NurbsSurface.cc

Go to the documentation of this file.

#include <esg/geometry/NurbsSurface.h>
#include <esg/AutoArray.h>

using namespace esg;

void NurbsSurface::_triangulate_surface(const ON_NurbsSurface& surface,
                                        const SDS&             ss,
                                        AutoPtr<Intersector>*  pAutoInt)
{
    ON_3dPoint    ONPoint;
    ON_3dVector   ONNormal;
    const double* s_knots = surface.Knot(0);
    const double* t_knots = surface.Knot(1);
    int           sn      = surface.KnotCount(0);
    int           tn      = surface.KnotCount(1);
    int           sSize;
    int           tSize;
    int           i,j,k,l;

    // count points of non-empty intervals:
    sSize = (tSize = 0);
    i = 0; while (i < sn) { i += surface.KnotMultiplicity(0,i); sSize++; }
    i = 0; while (i < tn) { i += surface.KnotMultiplicity(1,i); tSize++; }

    //    fprintf(stderr,"s,t: %i %i\n",sSize, tSize);

    Vector3* vertices = new Vector3 [sSize * tSize];
    Vector3* normals  = new Vector3 [sSize * tSize];

    i = 0;
    k = 0;
    while (k < sSize) {
        i += surface.KnotMultiplicity(0,i) - 1;
        j = 0;
        l = 0;
        while (l < tSize) {
            j += surface.KnotMultiplicity(1,j) - 1;
            if (surface.EvNormal(s_knots[i],t_knots[j],ONPoint,ONNormal)) {
                //fprintf(stderr,"p,v: %i, %f %f %f\n",k*tSize+l,ONPoint.x,ONPoint.y,ONPoint.z);
                vertices[k*tSize+l].set(ONPoint.x,ONPoint.y,ONPoint.z);
                normals [k*tSize+l].set(ONNormal.x,ONNormal.y,ONNormal.z);
            } else {
                vertices[k*tSize+l].set(0,0,0);
                normals [k*tSize+l].set(0,0,0);
            }
            l++;
            j++;
        }
        k++;
        i++;
    }

    /*
     * Now we have 1D array of vertices and their nornals.
     * Then let's create new trianguleted surface.
     */
    _pSurface = new Surface(ss,
                            new AutoArray<Vertex3>(vertices),
                            sSize*tSize,
                            new AutoArray<Vertex3>(normals),
                            sSize*tSize,
                            NULL,  // to do: UV coordinates mapping from NURBS
                            0,
                            Surface::TRIANGLES,
                            pAutoInt,
                            true);
    if (!_pSurface) {
        fprintf(stderr, "NurbsSurface Error: Failed to create triangulated surface\n");
        return;
    }

    /*
     * Append all non-degenerated triangles into the mesh object.
     */
    unsigned indices [3];
    Vector3  normal;
    for (int i = 0; i < sSize-1; i++) {
        for (int j = 0; j < tSize-1; j++) {
            indices[0] = ( i    * tSize) + j;
            indices[1] = ((i+1) * tSize) + j;
            indices[2] = ((i+1) * tSize) + j+1;

            //indices[0] = ( i    * tSize) + j;
            //indices[1] = ( i    * tSize) + j+1;
            //indices[2] = ((i+1) * tSize) + j+1;

            if (vertices[indices[0]] != vertices[indices[1]] &&
                vertices[indices[0]] != vertices[indices[2]] &&
                vertices[indices[1]] != vertices[indices[2]])
            {
                normal.cross(vertices[indices[1]] - vertices[indices[0]],
                             vertices[indices[2]] - vertices[indices[0]]);
                if (normal.dot(normals[indices[0]]) < 0) normal.negate();
                _pSurface->normal(normal);
                _pSurface->vertex(indices[0], indices[0]);
                _pSurface->vertex(indices[1], indices[1]);
                _pSurface->vertex(indices[2], indices[2]);
            }

            indices[0] = ( i    * tSize) + j;
            indices[1] = ((i+1) * tSize) + j+1;
            indices[2] = ( i    * tSize) + j+1;
            
            //indices[0] = ( i    * tSize) + j;
            //indices[1] = ((i+1) * tSize) + j+1;
            //indices[2] = ((i+1) * tSize) + j;

            if (vertices[indices[0]] != vertices[indices[1]] &&
                vertices[indices[0]] != vertices[indices[2]] &&
                vertices[indices[1]] != vertices[indices[2]])
            {
                normal.cross(vertices[indices[1]] - vertices[indices[0]],
                             vertices[indices[2]] - vertices[indices[0]]);
                if (normal.dot(normals[indices[0]]) < 0) normal.negate();
                _pSurface->normal(normal);
                _pSurface->vertex(indices[0], indices[0]);
                _pSurface->vertex(indices[1], indices[1]);
                _pSurface->vertex(indices[2], indices[2]);
            }
        }
    }

    _pSurface->done();
}

Mesh* NurbsSurface::_mesh(int density) const
{
    if (!_pSurface) {
        fprintf(stderr, "NurbsSurface Error: No surface to create mesh\n");
        return NULL;
    } else 
        return _pSurface->mesh(density);
}

void NurbsSurface::_duplicate_attributes (const Geometry& src)
{
    Geometry::_duplicate_attributes(src);

    if (((NurbsSurface&)src)._pSurface)
        _pSurface = (Surface*) ((NurbsSurface&)src)._pSurface->clone(NULL);
    else
        _pSurface = NULL;
}

void NurbsSurface::_rotateX(float angle)
{
    if (_pSurface) _pSurface->_rotateX(angle);
}

void NurbsSurface::_rotateY(float angle)
{
    if (_pSurface) _pSurface->_rotateY(angle);
}

void NurbsSurface::_rotateZ(float angle)
{
    if (_pSurface) _pSurface->_rotateZ(angle);
}

void NurbsSurface::_rotate(float angle, const Vector3& axis)
{
    if (_pSurface) _pSurface->_rotate(angle, axis);
}

void NurbsSurface::_rotate(const Matrix3& mat)
{
    if (_pSurface) _pSurface->_rotate(mat);
}

void NurbsSurface::_translate(float x, float y, float z)
{
    if (_pSurface) _pSurface->_translate(x,y,z);
}

void NurbsSurface::_transform(const Matrix4& mat)
{
    if (_pSurface) _pSurface->_transform(mat);
}

void NurbsSurface::_scale(float s)
{
    if (_pSurface) _pSurface->_scale(s);
}



NurbsSurface::NurbsSurface(const SDS&            ss,
                           AutoPtr<Intersector>* it,
                           int                   dimension,
                           bool                  rational,
                           int                   order0, 
                           int                   order1,
                           int                   count0,
                           int                   count1)
{
#warning "TODO: Employing NURBS instead of polygonal surface"
    ON_NurbsSurface nurbsS(dimension,rational,order0,order1,count0,count1);
    _triangulate_surface(nurbsS, ss, it);
}

NurbsSurface::NurbsSurface(const SDS&             ss,
                           AutoPtr<Intersector>*  it,
                           const ON_NurbsSurface& sp)
{
    _triangulate_surface(sp, ss, it);
}

NurbsSurface::~NurbsSurface()
{
    if (_pSurface)    delete _pSurface;
}

void NurbsSurface::rayIntersection(PointEnv      * pEnv,
                                   int             mask,
                                   const Vector3 & origin,
                                   const Vector3 & direction, 
                                   float           maxD) 
{
    if (_pSurface)
        _pSurface->rayIntersection(pEnv, mask, origin, direction, maxD);
    else 
        if (pEnv) pEnv->mask = ENV_HAVE_NOTHING;
}

bool NurbsSurface::mapToUV(const Vector3& v, Vector2& uv)
{
    fprintf(stderr,"NurbsSurface::mapToUV(): Not implemented\n");
    return false;
}

Interval NurbsSurface::extent(const Vector3& dir) const
{
    if (_pSurface) return _pSurface->extent(dir);
    else {
        Interval interval;
        interval.min =  MAXFLOAT;
        interval.max = -MAXFLOAT;
        return interval;
    }
}

Geometry* NurbsSurface::clone(const Matrix4 * pTrMat) const
{
  NurbsSurface* pRet = new NurbsSurface();
  pRet->_duplicate_attributes(*this);
  if (pTrMat) pRet->_transform(*pTrMat);
  return pRet;
}

Vector3 NurbsSurface::centroid() const
{
    if (_pSurface) return _pSurface->centroid();
    else return Vector3(0,0,0);
}

double NurbsSurface::radius() const
{
    if (_pSurface) return _pSurface->radius();
    else return -MAXDOUBLE;
}

double NurbsSurface::radius(const Vector3& centroid) const
{
    if (_pSurface) return _pSurface->radius(centroid);
    else return -MAXDOUBLE;
}

void NurbsSurface::dump(const char* intent, const char* tab)
{
    printf("geometry NurbsSurface {\n");
    if (_pSurface) _pSurface->dump(intent, tab);
    printf("%s }\n", intent);
}

---