Surface.cc

Go to the documentation of this file.

#include <esg/geometry/Surface.h>
#include <esg/mesh/PolygonalMesh.h>
#include <esg/mesh/SurfaceMesh.h>

using namespace esg;

bool Surface::_check_vertex()
{
    if (_primActVert == _primVertices) {
        // create new polygon
        if (_pRepository) {
            _Surface * pS;
            if (_havePlaneNormal)
                pS = new _Surface(_vertices,
                                  _normals,
                                  _uvCoords,
                                  _primVertices,
                                  _primVertIndices,
                                  _primNormIndices,
                                  _primUVIndices,
                                  _auxPlaneNormal,
                                  true);
            else
                pS = new _Surface(_vertices,
                                  _normals,
                                  _uvCoords,
                                  _primVertices,
                                  _primVertIndices,
                                  _primNormIndices,
                                  _primUVIndices);
            _pRepository->append(pS); // _Surface is also primitive
            _nSurfaces++;
        }

        // discard old plane normal
        _havePlaneNormal = false;
        
        // permutate vertices:
        switch (_vertOrder) {  
        case TRIANGLES:
        case QUADS:
            _primActVert = 0;
            break;
        case TRIANGLE_STRIP:
        case QUAD_STRIP:
            _primVertIndices[0] = _primVertIndices[_primVertices-1];
            _primVertIndices[1] = _primVertIndices[_primVertices-2];
            _primNormIndices[0] = _primNormIndices[_primVertices-1];
            _primNormIndices[1] = _primNormIndices[_primVertices-2];
            _primUVIndices[0]   = _primUVIndices[_primVertices-1];
            _primUVIndices[1]   = _primUVIndices[_primVertices-2];
            _primActVert = 2;
            break;
        case TRIANGLE_FAN:
            _primVertIndices[1] = _primVertIndices[_primVertices-1];
            _primNormIndices[1] = _primNormIndices[_primVertices-1];
            _primUVIndices[1]   = _primUVIndices[_primVertices-1];
            _primActVert = 2;
            break;
        }
    }

    return true;
}

Mesh* Surface::_mesh(int) const
{
    if (!_created)   return NULL;
    if (_fastMesh)   return new SurfaceMesh((Surface*)this);
    if (!_pIterator) return NULL;

    /* slow but precise polygonal mesh */
    PolygonalMesh * pMesh = new PolygonalMesh(_vertices, _nVert);

    _pIterator->initChildrenSearch();
    _Surface * pSurface = (_Surface*) _pIterator->firstChild();
    
    while (pSurface) {
        Vector3* normals;

        // get array of vertex normals if any
        if (pSurface->haveVertNormals()) {
            normals = new Vector3 [pSurface->numVertices()];
            for (unsigned i = 0; i < pSurface->numVertices(); i++)
                normals[i].set(pSurface->getVertNormal(i));
        } else
            normals = NULL;

        // append new polygon to mesh
        if (pSurface->haveFixedNormal())
            pMesh->addFacet(pSurface->_vindices,
                            normals,
                            pSurface->numVertices(),
                            pSurface->getFacetNormal());
        else
            pMesh->addFacet(pSurface->_vindices,
                            normals,
                            pSurface->numVertices());
        
        delete [] normals;
        
        pSurface = (_Surface*) _pIterator->nextChild();
    }
    
    return (Mesh*) pMesh;
}

void Surface::_duplicate_attributes(const Geometry& src)
{
    if (!((Surface&)src)._created) {
        fprintf(stderr,"Surface Error: can't duplicate attributes during creation process\n");
        return;
    }
    
    _created = true;

    _pPreviousHit = new HitPoint();

    _vertOrder = ((Surface&)src)._vertOrder;
    _fastMesh  = ((Surface&)src)._fastMesh;

    _nSurfaces  = ((Surface&)src)._nSurfaces;

    _pAutoVertices = ((Surface&)src)._pAutoVertices;
    if (_pAutoVertices) {
        _nVert    = ((Surface&)src)._nVert;
        _vertices = _pAutoVertices->origObject();
        _pAutoVertices->registerReferer(this);
    } else {
        _nVert    = 0;
        _vertices = NULL;
        fprintf(stderr,"Surface Error: No global array of vertices in source object\n");
    }

    _pAutoNormals = ((Surface&)src)._pAutoNormals;
    if (_pAutoNormals) {
        _nNorm   = ((Surface&)src)._nNorm;
        _normals = _pAutoNormals->origObject();
        _pAutoNormals->registerReferer(this);
    } else {
        _nVert    = 0;
        _vertices = NULL;
        fprintf(stderr,"Surface Error: No global array of vertex normals in source object\n");
    }

    _pAutoUVCoords = ((Surface&)src)._pAutoUVCoords;
    if (_pAutoUVCoords) {
        _nUVCoords = ((Surface&)src)._nUVCoords;
        _uvCoords  = _pAutoUVCoords->origObject();
        _pAutoUVCoords->registerReferer(this);
    } else {
        _nUVCoords = 0;
        _uvCoords  = NULL;
        fprintf(stderr,"Surface Error: No global array of vertex UV coordinates in source object\n");
    }

    _pAutoInter = ((Surface&)src)._pAutoInter;
    if (_pAutoInter) {
        _pIntersector = _pAutoInter->origObject();
        _pAutoInter->registerReferer(this);
    } else 
        _pIntersector = NULL;

    if (((Surface&)src)._pRepository) {
        _pRepository = (SDS*)((Surface&)src)._pRepository->clone();
        IteratorSDS * pIterator = (IteratorSDS*) ((Surface&)src)._pRepository->createIterator();
        pIterator->initChildrenSearch();
        _Surface * pObj = (_Surface*) pIterator->firstChild();
        while (pObj) {
            _pRepository->append(pObj->clone());
            pObj = (_Surface*) pIterator->nextChild();
        }
        _pRepository->build();
    } else
        _pRepository = NULL;

    if (_pRepository) {
        _pIterator     = (IteratorSDS*)_pRepository->createIterator();
    } else {
        _pIterator     = NULL;
    }
}

void Surface::_rotateX(float a)
{
    if (!_created || !_pIterator) return;

    Matrix3 trMat;
    trMat.rotX(a);
    
    for (register unsigned i = 0; i < _nVert; i++)
        trMat.transform(_vertices[i]);

    for (register unsigned i = 0; i < _nNorm; i++) 
        trMat.transform(_normals[i]);

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_rotate(trMat);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}

void Surface::_rotateY(float a)
{
    if (!_created || !_pIterator) return;

    Matrix3 trMat;
    trMat.rotY(a);
    
    for (register unsigned i = 0; i < _nVert; i++) 
        trMat.transform(_vertices[i]);

    for (register unsigned i = 0; i < _nNorm; i++) 
        trMat.transform(_normals[i]);

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_rotate(trMat);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}

void Surface::_rotateZ(float a)
{
    if (!_created || !_pIterator) return;

    Matrix3 trMat;
    trMat.rotZ(a);
    
    for (register unsigned i = 0; i < _nVert; i++) 
        trMat.transform(_vertices[i]);

    for (register unsigned i = 0; i < _nNorm; i++) 
        trMat.transform(_normals[i]);

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_rotate(trMat);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}

void Surface::_rotate(float a, const Vector3& axis)
{
    if (!_created || !_pIterator) return;

    Matrix4d trMat;
    Matrix3d rotMat;
    trMat.rotationGL(a, axis);
    trMat.get(rotMat);
    
    for (register unsigned i = 0; i < _nVert; i++) 
        trMat.transform(_vertices[i]);

    for (register unsigned i = 0; i < _nNorm; i++) 
        trMat.transform(_normals[i]);

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_transform(trMat);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}

void Surface::_rotate(const Matrix3& rotMat)
{
    if (!_created || !_pIterator) return;

    for (register unsigned i = 0; i < _nVert; i++) 
        rotMat.transform(_vertices[i]);

    for (register unsigned i = 0; i < _nNorm; i++) 
        rotMat.transform(_normals[i]);

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_rotate(rotMat);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}

void Surface::_translate(float x, float y, float z)
{
    if (!_created || !_pIterator) return;
    
    for (register unsigned i = 0; i < _nVert; i++) {
        _vertices[i].x += x;
        _vertices[i].y += y;
        _vertices[i].z += z;
    }

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_translate(x,y,z);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}

void Surface::_transform(const Matrix4& trMat)
{
    if (!_created || !_pIterator) return;

    for (register unsigned i = 0; i < _nVert; i++) 
        trMat.transform(_vertices[i]);

    for (register unsigned i = 0; i < _nNorm; i++) {
        Matrix3d rotMat;
        trMat.get(rotMat);
        rotMat.transform(_normals[i]);
    }

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_transform(trMat);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}

void Surface::_scale(float s)
{
    if (!_created || !_pIterator) return;

    for (register unsigned i = 0; i < _nVert; i++) _vertices[i].scale(s);

    _pIterator->initChildrenSearch();
    _Surface * pCand = (_Surface*) _pIterator->firstChild();
    while (pCand) {
        pCand->_scale(s);
        pCand = (_Surface*) _pIterator->nextChild();
    }
}



Surface::Surface(const SDS&            ss,
                 AutoArray<Vertex3>*   va,
                 unsigned              nv,
                 AutoArray<Vector3>*   na,
                 unsigned              nn,
                 AutoArray<Vector2>*   uva,
                 unsigned              uvn,
                 enum VertOrder        vo,
                 AutoPtr<Intersector>* it,
                 bool                  fm)
{
    _pRepository     = (SDS*) ss.clone();
    _havePlaneNormal = false;
    _vertOrder       = vo;
    _primActVert     = 0;
    _created         = false;
    _pPreviousHit    = new HitPoint();
    _fastMesh        = fm;
    _nSurfaces       = 0;

    if (va && nv) {
        _nVert         = nv;
        _pAutoVertices = va;
        _vertices      = _pAutoVertices->origObject();
        if (!_vertices)
            fprintf(stderr,"Surface Error: No global array of vertices defined\n");
        _pAutoVertices->registerReferer(this);
    } else {
        _nVert         = 0;
        _pAutoVertices = NULL;
        _vertices      = NULL;
        fprintf(stderr,"Surface Error: No global array of vertices defined\n");
    }

    if (na && nn) {
        _nNorm        = nn;
        _pAutoNormals = na;
        _normals      = _pAutoNormals->origObject();
        _pAutoNormals->registerReferer(this);
    } else {
        _nNorm        = 0;
        _pAutoNormals = NULL;
        _normals      = NULL;
    }

    if (uva && uvn) {
        _nUVCoords     = uvn;
        _pAutoUVCoords = uva;
        _uvCoords      = _pAutoUVCoords->origObject();
        _pAutoUVCoords->registerReferer(this);
    } else {
        _nUVCoords     = 0;
        _pAutoUVCoords = NULL;
        _uvCoords      = NULL;
    }

    if (it) {
        _pIntersector = it->origObject();
        _pAutoInter   = it;
        it->registerReferer(this);
    } else {
        _pIntersector = NULL;
        _pAutoInter   = NULL;
    }

    if (_pRepository) {
        _pIterator     = (IteratorSDS*)_pRepository->createIterator();
    } else {
        _pIterator     = NULL;
    }

    switch (vo) {
    case TRIANGLES:
    case TRIANGLE_STRIP:
    case TRIANGLE_FAN:
        _primVertices = 3;
        break;
    case QUADS:
    case QUAD_STRIP:
        _primVertices = 4;
        break;
    default:
        fprintf(stderr,"Surface Error: Unsupported vertices interpretation\n");
    }
}

Surface::~Surface()
{
    if (_pRepository) delete _pRepository;
    AutoPtr<Intersector>::destroy(_pAutoInter,  this);
    AutoArray<Vertex3>::destroy(_pAutoVertices, this);
    AutoArray<Vector3>::destroy(_pAutoNormals,  this);
    AutoArray<Vector2>::destroy(_pAutoUVCoords, this);
    if (_pPreviousHit) delete _pPreviousHit;
}

void Surface::normal(const Vector3& v)
{
    _auxPlaneNormal.set(v);
    _havePlaneNormal = true;
}

bool Surface::vertex(unsigned index)
{
    //fprintf(stderr,"%f %f %f\n",_vertices[index].x,_vertices[index].y,_vertices[index].z);
    if (index >= _nVert || _normals) return false;
    _primVertIndices[_primActVert++] = index;
    return _check_vertex();
}

bool Surface::vertex(unsigned vindex, unsigned nindex)
{
    if (vindex >= _nVert || nindex >= _nNorm || !_normals) return false;
    _primVertIndices[_primActVert]   = vindex;
    _primNormIndices[_primActVert++] = nindex;
    return _check_vertex();
}

bool Surface::vertex(unsigned vindex, unsigned nindex, unsigned uvindex)
{
    if (vindex >= _nVert || nindex >= _nNorm || uvindex >= _nUVCoords || !_normals || !_uvCoords) return false;
    _primVertIndices[_primActVert] = vindex;
    _primNormIndices[_primActVert] = nindex;
    _primUVIndices[_primActVert++] = uvindex;
    return _check_vertex();
}

bool Surface::vertexUV(unsigned vindex, unsigned uvindex)
{
    if (vindex >= _nVert || uvindex >= _nUVCoords || !_uvCoords) return false;
    _primVertIndices[_primActVert] = vindex;
    _primUVIndices[_primActVert++] = uvindex;
    return _check_vertex();
}

bool Surface::done(void)
{
    _created = true;
    return _pRepository->build();
}

const _Surface* Surface::firstPlane(void)
{
    if (!_pIterator) return NULL;
    _pIterator->initChildrenSearch();
    return (_Surface*) _pIterator->firstChild();
}

const _Surface* Surface::nextPlane(void)
{
    return ((_pIterator) ? (_Surface*) _pIterator->nextChild() : NULL);
}

unsigned Surface::numEdges(void) const
{
    if (!_pRepository) return 0;
    IteratorSDS * pIter = (IteratorSDS*) _pRepository->createIterator();
    if (!pIter) return 0;
    pIter->initChildrenSearch();

    unsigned counter = 0;
    _Surface * pS = (_Surface*) pIter->firstChild();
    while (pS) {
        counter += pS->numVertices();
        pS = (_Surface*) pIter->nextChild();
    }
    
    return counter;
}

void Surface::rayIntersection(PointEnv*      pEnv,
                              int            mask,
                              const Vector3& origin,
                              const Vector3& direction,
                              float          maxD)
{
        if (!pEnv) return;
    pEnv->mask = ENV_HAVE_NOTHING;
    if (!_created || !_pIterator || !_pIntersector) return;

    const void* pPrevLeaf = ((_pPreviousHit->pSDSLeaf &&
                              _pPreviousHit->point.equals(origin)) ?
                             _pPreviousHit->pSDSLeaf :
                             NULL);

    _pIntersector->init(mask, maxD);
    _pIterator->initRayIntersection(origin,direction,true,maxD,pPrevLeaf);

    if (mask & (ENV_WANT_INTERSECTION|ENV_WANT_NORMAL|ENV_WANT_DISTANCE)) {
        /*
         * We have to get the real closest point of intersection
         */
        const void* pNewLeaf = NULL;
        float dist;
        SceneGraphObject * pCandidate = _pIterator->firstChild();
        while (pCandidate) {
            if (_pIntersector->processCandidate(pCandidate,origin,direction)) {
                pNewLeaf = _pIterator->lastExploitedElement();
                dist = _pIntersector->getActDistance();
                if (dist < maxD) {
                    maxD = dist;
                    _pIterator->initRayIntersection(origin, direction, false,
                                                    maxD, pPrevLeaf);
                }
            }
            pCandidate = _pIterator->nextChild();
        }

        PointEnv * pAuxE = _pIntersector->adoptIntersection();
        if (!pAuxE) return;

        if (pAuxE->mask & ENV_HAVE_INTERFERENCE) 
        pEnv->mask |= ENV_HAVE_INTERFERENCE;

        if (pAuxE->mask & ENV_HAVE_INTERSECTION) {
            if (pNewLeaf) {
                _pPreviousHit->point.set(pAuxE->intersection);
                _pPreviousHit->pSDSLeaf = pNewLeaf;
            }
            pEnv->intersection.set(pAuxE->intersection);
            pEnv->mask |= ENV_HAVE_INTERSECTION|ENV_HAVE_INTERFERENCE;
        }
        if (pAuxE->mask & ENV_HAVE_NORMAL) {
            pEnv->normal.set(pAuxE->normal);
            pEnv->normalOrientation = pAuxE->normalOrientation;
            pEnv->mask |= ENV_HAVE_NORMAL;
        }
        if (pAuxE->mask & ENV_HAVE_DISTANCE) {
            pEnv->distance = pAuxE->distance;
            pEnv->mask |= ENV_HAVE_DISTANCE;
        }
        if (pAuxE->mask & ENV_HAVE_N_DOT_D) {
            pEnv->nd = pAuxE->nd;
            pEnv->mask |= ENV_HAVE_N_DOT_D;
        }
        if (pAuxE->mask & ENV_HAVE_N_DOT_O) {
            pEnv->no = pAuxE->no;
            pEnv->mask |= ENV_HAVE_N_DOT_O;
        }

        delete pAuxE;
    } else {
        /*
         * Only the more efficient interference test is enough.
         */
        SceneGraphObject * pCandidate = _pIterator->firstChild();
        while (pCandidate) {
            if (_pIntersector->processCandidate(pCandidate,origin,direction)) {
                pEnv->mask |= ENV_HAVE_INTERFERENCE;
                return;
            }
            pCandidate = _pIterator->nextChild();
        }
        return;
    }
}

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

void Surface::randomSample(int mask, PointEnv& pe, double* pdf)
{
    pe.mask = ENV_HAVE_NOTHING;

    if (!_pIterator) return;
    _pIterator->initChildrenSearch();
    _Surface* pSurface = (_Surface*) _pIterator->firstChild();
    for (unsigned i=(unsigned)((double)_nSurfaces*rand()/(RAND_MAX+1.));i;i--)
         pSurface = (_Surface*) _pIterator->nextChild();

    if (pSurface) pSurface->randomSample(mask, pe, pdf);
}

bool Surface::randomDirection(const Vector3& pov, Vector3& dir, double* pdf) 
{
    if (!_pIterator) return false;
    _pIterator->initChildrenSearch();
    _Surface* pSurface = (_Surface*) _pIterator->firstChild();
    for (unsigned i=(unsigned)((double)_nSurfaces*rand()/(RAND_MAX+1.));i;i--)
         pSurface = (_Surface*) _pIterator->nextChild();

    return ((pSurface) ? pSurface->randomDirection(pov, dir, pdf) : false);
}

Interval Surface::extent(const Vector3& direction) const
{
    Interval retInt;

    if (_created)
        for (unsigned i = 0; i < _nVert; i++) {
            float d = direction.dot(_vertices[i]);
            if (d < retInt.min) retInt.min = d;
            if (d > retInt.max) retInt.max = d;
        }

    return retInt;
}

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

Vector3 Surface::centroid() const
{
    Vector3 pog(0.0, 0.0, 0.0);
    if (_created) 
        for (register unsigned i = 0; i < _nVert; i++) {
            Vertex3 aux(_vertices[i]);
            aux.scale(1.0/_nVert);
            pog.add(aux);
        }
    return pog;
}

double Surface::radius(const Vector3& centroid) const
{
    register double r = - MAXDOUBLE;
    register double d;
    Vector3  aux;
    if (_created) 
        for (register unsigned i = 0; i < _nVert; i++) {
            aux.set(_vertices[i]);
            aux.sub(centroid);
            d = aux.length();
            if (d > r) r = d;
        }
    return r;
}

void Surface::dump(const char* intent, const char* tab)
{
    printf("%s geometry PolygonalSurface {\n", intent);
    printf("%s %s numPolygons        %d", intent, tab, _nSurfaces);
    printf("%s %s numVertices        %d", intent, tab, _nVert);
    printf("%s %s numNormals         %d", intent, tab, _nNorm);
    printf("%s %s numUVCoords        %d", intent, tab, _nUVCoords);
    printf("%s %s fastMeshGeneration %s", intent, tab, ((_fastMesh) ? "yes" : "no"));
    printf("%s %s interpretation ", intent, tab);
    switch (_vertOrder) {
    case TRIANGLES:      printf("TRIANGLES\n");      break;
    case TRIANGLE_STRIP: printf("TRIANGLE_STRIP\n"); break;
    case TRIANGLE_FAN:   printf("TRIANGLE_FAN\n");   break;
    case QUADS:          printf("QUADS\n");          break;
    case QUAD_STRIP:     printf("QUAD_STRIP\n");     break;
    default:             printf("UNKNOWN\n");
    }
    if (_vertices) {
        printf("%s %s vertices [\n", intent, tab);
        for (register unsigned i = 0; i < _nVert; i++) 
            printf("%s %s %s %f %f %f\n", intent, tab, tab, _vertices[i].x, _vertices[i].y, _vertices[i].z);
        printf("%s %s ]\n", intent, tab);
    }
    if (_normals) {
        printf("%s %s vertexNorals [\n", intent, tab);
        for (register unsigned i = 0; i < _nVert; i++) 
            printf("%s %s %s %f %f %f\n", intent, tab, tab, _normals[i].x, _normals[i].y, _normals[i].z);
        printf("%s %s ]\n", intent, tab);
    }
    if (_uvCoords) {
        printf("%s %s uvCoordinates [\n", intent, tab);
        for (register unsigned i = 0; i < _nVert; i++) 
            printf("%s %s %s %f %f\n", intent, tab, tab, _uvCoords[i].x, _uvCoords[i].y);
        printf("%s %s ]\n", intent, tab);
    }

    char* newIntent = new char [strlen(intent) + strlen(tab) + 2];
    newIntent = strcpy(newIntent, intent);
    newIntent = strcat(newIntent, " ");
    newIntent = strcat(newIntent, tab);
    if (_pRepository) _pRepository->dump(newIntent, tab);
    delete [] newIntent;
    
    printf("%s }\n", intent);
}

---