OSGGeoFunctions.cpp

Go to the documentation of this file.

/*---------------------------------------------------------------------------* \
 *                                OpenSG                                     *
 *                                                                           *
 *                                                                           *
 *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
 *                                                                           *
 *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                License                                    *
 *                                                                           *
 * This library is free software; you can redistribute it and/or modify it   *
 * under the terms of the GNU Library General Public License as published    *
 * by the Free Software Foundation, version 2.                               *
 *                                                                           *
 * This library is distributed in the hope that it will be useful, but       *
 * WITHOUT ANY WARRANTY; without even the implied warranty of                *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
 * Library General Public License for more details.                          *
 *                                                                           *
 * You should have received a copy of the GNU Library General Public         *
 * License along with this library; if not, write to the Free Software       *
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                Changes                                    *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
\*---------------------------------------------------------------------------*/
//---------------------------------------------------------------------------
//  Includes
//---------------------------------------------------------------------------
#include <stdlib.h>
#include <stdio.h>

#include <set>

#include "OSGConfig.h"

#include <OSGLog.h>

#include <OSGGLU.h>

#include "OSGGeometry.h"
#include "OSGGeoPropPtrs.h"
#include "OSGTriangleIterator.h"
#include "OSGGeoFunctions.h"
#include "OSGFaceIterator.h"

//#include "OSGNodeGraph.h"
#include "OSGHalfEdgeGraph.h"

OSG_USING_NAMESPACE

#if defined(OSG_WIN32_ICL) && !defined(OSG_CHECK_FIELDSETARG)
#pragma warning(disable : 383)
#endif
#ifdef __sgi
#pragma set woff 1209
#endif

/***************************************************************************\
 *                            Description                                  *
\***************************************************************************/

OSG_SYSTEMLIB_DLLMAPPING void OSG::calcVertexNormals(GeometryPtr geo)
/*

faster; but not well tested code

{
  //Vec3f vec0, vec1,vec2;
  GeoPositionsPtr positionPtr;
  GeoNormalsPtr   normalPtr;
  Int32 i, ni, pi, pN, p0, p1, p2, skipN = 0;
  TriangleIterator tI;
  Real32 x,y,z;
  std::vector<Vec3f> normalVec;

  if (geo != NullFC) {

    // get the pos bag and pos count
    positionPtr = geo->getPositions();
    pN = (positionPtr != NullFC) ? positionPtr->getSize() : 0;

    FNOTICE (("Create %d normal \n", pN ));

    if (pN) {

      // init the normal bag
      normalVec.resize(pN);
      for (i = 0; i < pN; ++i)
        normalVec[i].setValues(0,0,0);

      // fill the normal bag
      for (tI = geo->beginTriangles(); tI != geo->endTriangles(); ++tI) {

        if ((p0 == p1) || (p1 == p2) || (p2 == p0)) {
          skipN++;
        }
        else {

          // get the tri points
          p0 = tI.getPositionIndex(0);
          p1 = tI.getPositionIndex(1);
          p2 = tI.getPositionIndex(2);
          // get the points
          // TODO; use assign
          Vec3f vec0(tI.getPosition(0));
          Vec3f vec1(tI.getPosition(1));
          Vec3f vec2(tI.getPosition(2));

          // calc the face normal
          vec0 -= vec1;
          vec1 -= vec2;
          vec0.crossThis(vec1);
          vec0.normalize();

          // add the normal
          normalVec[p0] += vec0;
          normalVec[p1] += vec0;
          normalVec[p2] += vec0;
        }
      }

      // get/create/resize the normal bag
      normalPtr = geo->getNormals();
      if (normalPtr == NullFC) {
        normalPtr = GeoNormals3f::create();
        beginEditCP(geo);
        {
          geo->setNormals( normalPtr );
        }
        endEditCP(geo);
      }

      // get/create/resize the normal bag
      normalPtr = geo->getNormals();
      if (normalPtr == NullFC) {
        normalPtr = GeoNormals3f::create();
        beginEditCP(geo);
        {
          geo->setNormals( normalPtr );
        }
        endEditCP(geo);
      }

      // normalize and copy the result
      beginEditCP (normalPtr);
      {
        // resize the bag
        normalPtr->resize(pN);

        // normalize and copy the result
        for (i = 0; i < pN; ++i) {
          if (normalize)
            normalVec[i].normalize();
          normalPtr->setValue( normalVec[i], i );
        }
      }
      endEditCP (normalPtr);

      // adapting the indexMapping
      pi = geo->calcMappingIndex ( Geometry::MapPosition );
      ni = geo->calcMappingIndex ( Geometry::MapNormal   );
      if ((geo->getIndexMapping().size() > 1) && (pi >= 0) && (pi != ni)) {

        geo->getIndexMapping(ni) &= ~Geometry::MapNormal;
        if (geo->getIndexMapping(ni) == 0) {
          FFATAL (("Should delete normal entry; do impl !!!\n" ));
          geo->getIndexMapping(ni) = Geometry::MapEmpty;
        }
        else {
          FNOTICE (("Keep mindex mapping after createVertexNormal()\n"));
        }

        geo->getIndexMapping(pi) |= Geometry::MapNormal;
      }
      else {
        FNOTICE (("Keep single index mapping after createVertexNormal()\n"));
      }
    }
    else {
      FFATAL (("No valid points setting; can not create normal\n"));
    }
    if (skipN) {
      FNOTICE (( "Skip %d invalid triangles in createVertexNormal()\n",
                 skipN));
    }
  }
  else {
    FFATAL (("No valid geometry; can not create normal\n"));
  }

}

*/
{
    GeoNormalsPtr   norms;
    typedef std::set<UInt32> IndexSet;
    IndexSet used_indices;

    if(geo->getNormals() == NullFC)
    {
        norms = GeoNormals3f::create();
    }
    else
    {
        norms = geo->getNormals();
    }
    beginEditCP(norms);

    norms->resize(geo->getPositions()->getSize());

    // problem: not all of the points of the property might be used by this
    // geometry. If the property has more than 1 users, be careful.
    if(norms->getParents().size() > 1)
    {
        for(TriangleIterator t = geo->beginTriangles(); t != geo->endTriangles();
                    ++t)
        {
            used_indices.insert(t.getPositionIndex(0));
            used_indices.insert(t.getPositionIndex(1));
            used_indices.insert(t.getPositionIndex(2));
        }

        for (IndexSet::iterator i = used_indices.begin();
             i != used_indices.end();
             ++i)
        {
            norms->setValue(Vec3f(0, 0, 0), *i);
        }
    }
    else            // just one user, can clear all
    {
        for(unsigned i = 0; i < geo->getPositions()->getSize(); i++)
        {
            norms->setValue(Vec3f(0, 0, 0), i);
        }
    }

    for(TriangleIterator t = geo->beginTriangles(); t != geo->endTriangles();
            ++t)
    {
        Pnt3f p0 = t.getPosition(0);
        Pnt3f p1 = t.getPosition(1);
        Pnt3f p2 = t.getPosition(2);
        Plane p(p0, p1, p2);

        Int32 i0 = t.getPositionIndex(0);
        Int32 i1 = t.getPositionIndex(1);
        Int32 i2 = t.getPositionIndex(2);
        norms->setValue( norms->getValue(i0) + p.getNormal(), i0 );
        norms->setValue( norms->getValue(i1) + p.getNormal(), i1 );
        norms->setValue( norms->getValue(i2) + p.getNormal(), i2 );
    }
    if(norms->getParents().size() > 1)
    {
        std::set < UInt32 >::iterator i = used_indices.begin();
        std::set < UInt32 >::iterator end = used_indices.end();

        while(i != end)
        {
            Vec3f   n = norms->getValue(*i);
            n.normalize();
            norms->setValue(n, *i);

            ++i;
        }
    }
    else            // just one user, can clear all
    {
        for(unsigned i = 0; i < geo->getPositions()->getSize(); i++)
        {
            Vec3f   n = norms->getValue(i);
            n.normalize();
            norms->setValue(n, i);
        }
    }
    endEditCP(norms);

    beginEditCP(geo);
    {
        geo->setNormals(norms);

        MFUInt16    &im = geo->getIndexMapping();
        if(im.size() > 0)
        {
            Int16   pi, ni;
            pi = geo->calcMappingIndex(Geometry::MapPosition);
            ni = geo->calcMappingIndex(Geometry::MapNormal);

            if(ni >= 0)
            {
                im[ni] = im[ni] &~Geometry::MapNormal;
            }
            if(pi >= 0)
            {
                im[pi] = im[pi] | Geometry::MapNormal;
            }
        }
    }
    endEditCP(geo);
}
#ifdef __sgi
#pragma reset woff 1209
#endif

#if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)

template<class type>
struct vecless
{
    bool operator () (const type &a, const type &b) const
    {
        UInt32  i;
        bool    ret = false;

        for(i = 0; i < type::_iSize; i++)
        {
            if(osgabs(a[i] - b[i]) < Eps)
                continue;

            if(a[i] > b[i])
            {
                ret = false;
                break;
            }
            ret = true;
            break;
        }
        return ret;
    }
};

template<class type>
struct memless
{
    bool operator () (const type &a, const type &b) const
    {
        if(a.second && b.second)
        {
            if(a.second == b.second)
            {
                return (memcmp(a.first, b.first, a.second) < 0) ? true : false;
            }
            else
            {
                FFATAL(("a.memSize != b.memSize in memless::operator()\n"));
            }
        }
        else
        {
            FFATAL(("memSize is NULL in memless::operator()\n"));
        }
        return false;
    }
};
#endif  // remove from all but dev docs


OSG_SYSTEMLIB_DLLMAPPING void OSG::calcVertexNormals(GeometryPtr geo,
                                                     Real32 creaseAngle)
{
    GeoNormalsPtr   norms;
    GeoPositionsPtr positions;

    if(creaseAngle >= Pi)
    {
        calcVertexNormals(geo);
        return;
    }

    // Get the positions property
    if(geo->getPositions() == NullFC)
    {
        FINFO(("Geo without positions in calcVertexNormals()\n"));
        return;
    }
    else
    {
        positions = geo->getPositions();
    }

    if(positions->size() < 3)
    {
        FINFO(("Geo with less than 3 positions in calcVertexNormals()\n"));
        return;
    }

    // Get normal property, create if needed
    if(geo->getNormals() == NullFC)
    {
        norms = GeoNormals3f::create();
    }
    else
    {
        norms = geo->getNormals();
    }

    // need to set it early, is used below
    beginEditCP(geo);
    {
        geo->setNormals(norms);
    }

    endEditCP(geo);

    // Do the normals have their own index?
    MFUInt16        &im = geo->getIndexMapping();
    Int16           ni = geo->calcMappingIndex(Geometry::MapNormal);
    GeoIndicesPtr   ip = geo->getIndices();
    
    // HACK but without indices it crashes.
    if(ip == NullFC || ip->size() == 0)
    {
        FINFO(("Geo without indices in calcVertexNormals()\n"));
        return;
    }

    UInt32          nind = ip->size() / (im.size() ? im.size() : 1);
    int             imsize = 0;
    if(ni < 0 || im[ni] != Geometry::MapNormal)
    {
        // normals need their own index
        if(ni >= 0)
        {
            im[ni] = im[ni] &~Geometry::MapNormal;
        }

        // need to be multi-indexed?
        if(im.size() == 0)
        {
            UInt32  map = Geometry::MapPosition;

            if(geo->getTexCoords() != NullFC)
                map |= Geometry::MapTexCoords;

            if(geo->getColors() != NullFC)
                map |= Geometry::MapColor;

            im.push_back(map);
        }

        ni = im.size();
        im.push_back(Geometry::MapNormal);

        // add an entry to the indices for the normals
        imsize = im.size();

        beginEditCP(ip);
        ip->resize(nind * imsize);

        for(UInt32 i = nind - 1; i > 0; --i)
        {
            for(Int16 j = imsize - 2; j >= 0; --j)
            {
                UInt32  val;
                ip->getValue(val, i * (imsize - 1) + j);
                ip->setValue(val, i * imsize + j);
            }

            ip->setValue(i, i * imsize + imsize - 1);
        }

        ip->setValue(0, imsize - 1);
        endEditCP(ip);
    }
    else            // set the normal indices
    {
        imsize = im.size();
        beginEditCP(ip);
        for(UInt32 i = 0; i < nind; ++i)
        {
            ip->setValue(i, i * imsize + ni);
        }

        endEditCP(ip);
    }

    // now calc the normals
    // if creaseAngle is 0, it's simple: every face uses its own.
    if(creaseAngle == 0)
    {
        beginEditCP(norms);
        beginEditCP(ip);

        norms->resize(nind);

        for(TriangleIterator ti = geo->beginTriangles();
                    ti != geo->endTriangles(); ++ti)
        {
            Vec3f   d1 = ti.getPosition(1) - ti.getPosition(0);
            Vec3f   d2 = ti.getPosition(2) - ti.getPosition(0);
            d1.crossThis(d2);

            d1.normalize();

            norms->setValue(d1, ti.getNormalIndex(0));
            norms->setValue(d1, ti.getNormalIndex(1));
            norms->setValue(d1, ti.getNormalIndex(2));
        }

        endEditCP(norms);
        endEditCP(ip);
        return;
    }

    // creaseAngle > 0, need to calculate
#if 0
    // orig pngMap based code (written by dirk)
    // collect a map from points to faces using this point
    // collect the face normals in a separate vector
    std::vector < Vec3f > faceNormals;
    std::multimap<Pnt3f, UInt32, vecless<Pnt3f> > pntMap;

    TriangleIterator    ti;

    for(ti = geo->beginTriangles(); ti != geo->endTriangles(); ++ti)
    {
        Vec3f   d1 = ti.getPosition(1) - ti.getPosition(0);
        Vec3f   d2 = ti.getPosition(2) - ti.getPosition(0);
        d1.crossThis(d2);

        d1.normalize();
        faceNormals.push_back(d1);

        pntMap.insert(std::pair< Pnt3f, UInt32 > 
                        (ti.getPosition(0), faceNormals.size() - 1));
        pntMap.insert(std::pair< Pnt3f, UInt32 > 
                        (ti.getPosition(1), faceNormals.size() - 1));
        pntMap.insert(std::pair< Pnt3f, UInt32 > 
                        (ti.getPosition(2), faceNormals.size() - 1));
    }

    // now walk through the geometry again and calc the normals
    beginEditCP(norms);
    beginEditCP(ip);

    norms->resize(nind);

    Real32  cosCrease = osgcos(creaseAngle);

    for(ti = geo->beginTriangles(); ti != geo->endTriangles(); ++ti)
    {
        Int32   tind = ti.getIndex();
        Vec3f   mynorm = faceNormals[tind];

        std::multimap<Pnt3f, UInt32, vecless<Pnt3f> >::iterator st, en;

        for(UInt16 i = 0; i < 3; ++i)
        {
            // calculate the normal: average all different normals
            // that use a point. Simple addition or weighted addition
            // doesn't work, as it depends on the triangulation
            // of the object. :(
            std::set<Vec3f, vecless<Vec3f> > normset;

            st = pntMap.lower_bound(ti.getPosition(i));
            en = pntMap.upper_bound(ti.getPosition(i));

            for(; st != en; st++)
            {
                if(mynorm.dot(faceNormals[(*st).second]) > cosCrease)
                {
                    normset.insert(faceNormals[(*st).second]);
                }
            }

            Vec3f                                               norm(0, 0, 0);
            typedef std::set<Vec3f, vecless<Vec3f> >::iterator  NormSetIt;

            for(NormSetIt it = normset.begin(); it != normset.end(); ++it)
            {
                norm += (*it);
            }

            norm.normalize();
            norms->setValue(norm, ti.getNormalIndex(i));
        }
    }

    endEditCP(ip);
    endEditCP(norms);

#else
    // opt + normal share code (written by jbehr)
    // collect a map from points to faces using this point
    // collect the face normals in a separate vector
    //FLOG (("Run calcVertexNormals(%g)\n", creaseAngle));
    std::vector < Vec3f > faceNormals;
    std::vector < std::vector < UInt32 > > pntFaceDic;

    TriangleIterator ti;
    UInt32 i, pN = positions->size();

    pntFaceDic.resize(pN);
    for(ti = geo->beginTriangles(), i = 0; ti != geo->endTriangles(); ++ti, ++i)
    {
        Int32 v0 = ti.getPositionIndex(0);
        Int32 v1 = ti.getPositionIndex(1);
        Int32 v2 = ti.getPositionIndex(2);

        if(v0 != v1 && v0 != v2)
        {
            Vec3f d1 = ti.getPosition(1) - ti.getPosition(0);
            Vec3f d2 = ti.getPosition(2) - ti.getPosition(0);
            d1.crossThis(d2);

            if(d1.squareLength() >= 0)
            {
                d1.normalize();
                faceNormals.push_back(d1);

                pntFaceDic[ti.getPositionIndex(0)].push_back(i);
                pntFaceDic[ti.getPositionIndex(1)].push_back(i);
                pntFaceDic[ti.getPositionIndex(2)].push_back(i);
            }
            else
            {
                faceNormals.push_back(Vec3f(0, 0, 0));
            }
        }
        else
        {
            faceNormals.push_back(Vec3f(0, 0, 0));
        }
    }

    // now walk through the geometry again and calc the normals
    beginEditCP(norms);
    beginEditCP(ip);

    norms->clear();

    Real32 cosCrease = osgcos(creaseAngle);
    Vec3f norm;
    std::vector < UInt32 > normset;
    std::vector < std::map < std::vector < UInt32 > , UInt32 > > normDic;
    std::map < std::vector < UInt32 > , UInt32 >::iterator ndI;

    UInt32 normalIndex = 0;

    normDic.resize(pN);

    for(ti = geo->beginTriangles(); ti != geo->endTriangles(); ++ti)
    {
        Int32 tind = ti.getIndex();
        Vec3f faceNorm(faceNormals[tind]);

        if(faceNorm.squareLength() != 0.0)
        {
            for(UInt16 i = 0; i < 3; ++i)
            {
                // calculate the normal: average all different normals
                // that use a point. Simple addition or weighted addition
                // doesn't work, as it depends on the triangulation
                // of the object. :(
                UInt32 p = ti.getPositionIndex(i);
                UInt32 pf, f, fN = pntFaceDic[p].size();
                UInt32 n, nN;

                normset.clear();
                for(f = 0; f < fN; f++)
                {
                    if(((pf = pntFaceDic[p][f]) == tind) ||
                       (faceNorm.dot(faceNormals[pf]) > cosCrease))
                        normset.push_back(pf);
                }

                if((nN = normset.size()))
                {
                    // find normal
                    //std::sort ( normset.begin(), normset.end() );
                    ndI = normDic[p].find(normset);
                    if(ndI == normDic[p].end())
                    {
                        norm = faceNormals[normset[0]];
                        for(n = 1; n < nN; ++n)
                            norm += faceNormals[normset[n]];
                        norm.normalize();
                        normalIndex = norms->size();
                        norms->push_back(norm);
                        normDic[p][normset] = normalIndex;
                    }
                    else
                    {
                        normalIndex = ndI->second;
                    }
                }
                else
                {
                    // keep normalIndex
                    FWARNING(("Empty normset for %d faces pos %d: %f/%f/%f\n",
                               fN, i, ti.getPosition(i).x(),
                               ti.getPosition(i).y(), ti.getPosition(i).z()
                            ));
                }

                ip->setValue(normalIndex, ti.getIndexIndex(i) + ni);
            }
        }
        else
        {
            // keep normal for degenerated triangle

            normalIndex = norms->size();
            norms->push_back(norm);
            
            ip->setValue ( normalIndex, ti.getIndexIndex(0) + ni );
            ip->setValue ( normalIndex, ti.getIndexIndex(1) + ni );
            ip->setValue ( normalIndex, ti.getIndexIndex(2) + ni );
        }
    }

    endEditCP(ip);
    endEditCP(norms);
#endif
}

#ifdef __sgi
#pragma set woff 1209
#endif

OSG_SYSTEMLIB_DLLMAPPING void OSG::calcFaceNormals(GeometryPtr geo)
{
    GeoIndicesPtr newIndex = GeoIndicesUI32::create();
    GeoNormalsPtr newNormals = GeoNormals3f::create();
    Vec3f normal;

    FaceIterator faceIter = geo->beginFaces();
    GeoIndicesPtr oldIndex = geo->getIndices();

    if(oldIndex != NullFC)
    {
        //Indexed
        if(geo->getIndexMapping().size() > 0)
        {
            //MULTI INDEXED
            beginEditCP(newIndex);

            MFUInt16    &oldIndexMap = geo->getIndexMapping();
            UInt32 oldIMSize = oldIndexMap.size();
            for(UInt32 i = 0; i < oldIndex->getSize() / oldIMSize; ++i)
            {
                for(UInt32 k = 0; k < oldIMSize; ++k)
                {
                    newIndex->push_back(oldIndex->getValue(i * oldIMSize + k));
                }

                newIndex->push_back(0);                                 //placeholder for normal index
            }

            beginEditCP(newNormals);
            for(UInt32 faceCnt = 0; faceIter != geo->endFaces();
                            ++faceIter, ++faceCnt)
            {
                if(faceIter.getLength() == 3)
                {
                    //Face is a Triangle
                    normal =
                        (
                            faceIter.getPosition(1) -
                            faceIter.getPosition(0)
                        ).cross(faceIter.getPosition(2) - faceIter.getPosition(0));
                    normal.normalize();
                }
                else
                {
                    //Face must be a Quad then
                    normal =
                        (
                            faceIter.getPosition(1) -
                            faceIter.getPosition(0)
                        ).cross(faceIter.getPosition(2) - faceIter.getPosition(0));
                    if(normal.length() == 0)
                    {
                        //Quad is degenerate, choose different points for normal
                        normal =
                            (
                                faceIter.getPosition(1) -
                                faceIter.getPosition(2)
                            ).cross(faceIter.getPosition(3) -
                                                                faceIter.getPosition(2));
                    }

                    normal.normalize();
                }

                newNormals->push_back(normal);                          //put the normal into the storage
                UInt32 base;
                switch(faceIter.getType())
                {
                case GL_TRIANGLE_STRIP:
                    base = faceIter.getIndexIndex(2);                   //get last point's position in index field
                    newIndex->setValue(faceCnt, base + (base / oldIMSize) + oldIMSize);
                    break;
                case GL_TRIANGLE_FAN:
                    base = faceIter.getIndexIndex(2);                   //get last point's position in index field
                    newIndex->setValue(faceCnt, base + (base / oldIMSize) + oldIMSize);
                    break;
                case GL_QUAD_STRIP:
                    base = faceIter.getIndexIndex(3);                   //get last point's position in index field
                    newIndex->setValue(faceCnt, base + (base / oldIMSize) + oldIMSize);
                    break;
                default:
                    for(UInt32 i = 0; i < faceIter.getLength(); ++i)
                    {
                        base = faceIter.getIndexIndex(i);
                        newIndex->setValue(faceCnt,
                                                                   base + (base / oldIMSize) + oldIMSize);
                    }
                    break;
                }
            }

            endEditCP(newNormals);
            endEditCP(newIndex);

            beginEditCP(geo);

            Int16 ni;
            ni = geo->calcMappingIndex(Geometry::MapNormal);
            if(ni != -1)
            {
                oldIndexMap[ni] = oldIndexMap[ni] &~Geometry::MapNormal;
            }

            oldIndexMap.push_back(Geometry::MapNormal);
            geo->setNormals(newNormals);
            geo->setIndices(newIndex);
            endEditCP(geo);
            return;
        }
    }

    //SINGLE INDEXED or NON INDEXED
    //UInt32 pointCnt = 0;
    newNormals->resize(geo->getPositions()->getSize());
    for(; faceIter != geo->endFaces(); ++faceIter)
    {
        if(faceIter.getLength() == 3)
        {
            //Face is a Triangle
            normal = (faceIter.getPosition(1) - faceIter.getPosition(0)).cross(faceIter.getPosition(2) - faceIter.getPosition(0));
            normal.normalize();
        }
        else
        {
            //Face must be a Quad then
            normal = (faceIter.getPosition(1) - faceIter.getPosition(0)).cross(faceIter.getPosition(2) - faceIter.getPosition(0));
            if(normal.length() == 0)
            {
                //Quad is degenerate, choose different points for normal
                normal =
                    (
                        faceIter.getPosition(1) -
                        faceIter.getPosition(2)
                    ).cross(faceIter.getPosition(3) - faceIter.getPosition(2));
            }

            normal.normalize();
        }

        switch(faceIter.getType())
        {
        case GL_TRIANGLE_STRIP:
            newNormals->setValue(normal, faceIter.getPositionIndex(2));
            break;
        case GL_TRIANGLE_FAN:
            newNormals->setValue(normal, faceIter.getPositionIndex(2));
            break;
        case GL_QUAD_STRIP:
            newNormals->setValue(normal, faceIter.getPositionIndex(3));
            break;
        default:
            for(UInt32 i = 0; i < faceIter.getLength(); ++i)
            {
                newNormals->setValue(normal, faceIter.getPositionIndex(i));
            }
            break;
        }

        beginEditCP(geo);
        geo->setNormals(newNormals);
        endEditCP(geo);
    }
}

OSG_SYSTEMLIB_DLLMAPPING 
Int32 OSG::setIndexFromVRMLData(GeometryPtr geoPtr,
                                std::vector<Int32> &coordIndex,
                                std::vector<Int32> &normalIndex,
                                std::vector<Int32> &colorIndex,
                                std::vector<Int32> &texCoordIndex,
                                bool convex, 
                                bool ccw,
                                bool normalPerVertex, 
                                bool colorPerVertex,
                                bool createNormal, 
                                bool faceSet)
{
  Int32 primitiveType = faceSet ? GL_POLYGON : GL_LINE;

  return setIndexFromIndexedX3DData ( geoPtr,
                                      coordIndex,
                                      normalIndex,
                                      colorIndex,
                                      texCoordIndex,
                                      primitiveType,
                                      convex,
                                      ccw,
                                      normalPerVertex,
                                      colorPerVertex,
                                      createNormal );
}

OSG_SYSTEMLIB_DLLMAPPING 
Int32 OSG::setIndexFromIndexedX3DData ( GeometryPtr geoPtr,
                                        std::vector<Int32> &coordIndex,
                                        std::vector<Int32> &normalIndex,
                                        std::vector<Int32> &colorIndex,
                                        std::vector<Int32> &texCoordIndex,
                                        Int32 primitiveType, 
                                        bool OSG_CHECK_ARG(convex), 
                                        bool ccw,
                                        bool normalPerVertex, 
                                        bool colorPerVertex,
                                        bool OSG_CHECK_ARG(createNormal) )
{
    typedef std::vector<Int32>  *IndexBagP;

    enum IndexType
    {
        UNKNOWN_IT          = 0,
        EMPTY_IT,
        VERTEX_COORD_IT,
        VERTEX_IT,
        VERTEX_DUP_IT,
        VERTEX_CREATE_IT,
        PRIMITIVE_IT,
        PRIMITIVE_INDEX_IT,
        PRIMITIVE_CREATE_IT
    };

    static const char *indexTypeStr[] =
    {
        "UNKNOWN_IT",
        "EMPTY_IT",
        "VERTEX_COORD_IT",
        "VERTEX_IT",
        "VERTEX_DUP_IT",
        "VERTEX_CREATE_IT",
        "PRIMTIVE_IT",
        "PRIMITIVE_INDEX_IT",
        "PRIMITIVE_CREATE_IT"
    };
    OSG::GeoPositionsPtr posPtr;
    OSG::GeoNormalsPtr normalPtr;
    OSG::GeoColorsPtr colorPtr;
    OSG::GeoTexCoordsPtr texCoordsPtr;
    OSG::GeoPLengthsPtr lensPtr;
    OSG::GeoPTypesPtr geoTypePtr;
    OSG::GeoIndicesPtr indexPtr;

    //bool faceSet = (primitiveType == GL_POLYGON);
    Int32 index, i, pi, typei, mapi, primitiveN = 0, vN = 0;
    Int32 pType = 0, localPType;
    Int32 maxPType; //  = (faceSet ? 5 : 3);
    Int32 minPType; //  = (faceSet ? 3 : 2);
    Int32 beginIndex, endIndex, step, len, sysPType = 0;
    Int32 piN = 0, ciN = 0, niN = 0, tiN = 0;
    Int32 pN = 0, nN = 0, cN = 0, tN = 0, tN1 = 0, tN2 = 0, tN3 = 0;
    IndexType indexType[4];
    IndexType &coordIT = indexType[0];
    IndexType &normalIT = indexType[1];
    IndexType &colorIT = indexType[2];
    IndexType &textureIT = indexType[3];
    Int32 primitiveTypeCount[6];
    UInt32 triCount = 0;
    Int16 indexMap[4], indexMapID[4];
    UInt32 uiNumTextures = 0;

    IndexBagP indexBag[4] =
    {
        &coordIndex,
        &normalIndex,
        &colorIndex,
        &texCoordIndex
    };

    //----------------------------------------------------------------------
    // init
    coordIT = VERTEX_IT;
    indexMap[0] = Geometry::MapPosition;

    //----------------------------------------------------------------------
    // set maxPType and minPTypr from primitiveType
    switch (primitiveType) {
    case GL_POINTS:
      minPType = 1;
      maxPType = 1;
      break;
    case GL_LINES:
      minPType = 2;
      maxPType = 3;
      break;
    case GL_LINE_STRIP:
      minPType = 2;
      maxPType = 3;
      break;
    case GL_LINE_LOOP:
      minPType = 2;
      maxPType = 3;
      break;
    case GL_TRIANGLES:
      minPType = 3;
      maxPType = 3;
      break;
    case GL_TRIANGLE_STRIP:
      minPType = 3;
      maxPType = 3;
      break;
    case GL_TRIANGLE_FAN:
      minPType = 3;
      maxPType = 3;
      break;
    case GL_QUADS:
      minPType = 3;
      maxPType = 4;
      break;
    case GL_QUAD_STRIP:    
      minPType = 3;
      maxPType = 4;
      break;
    case GL_POLYGON:
      minPType = 3;
      maxPType = 5;
      break;
    default:
      FFATAL (( "Can not fill index; Invalid primitiveType: %d\n",
                primitiveType ));
      break;
    }
      

    //----------------------------------------------------------------------
    // get the property pointer and element count
    posPtr = geoPtr->getPositions();
    pN = ((posPtr == OSG::NullFC) ? 0 : posPtr->getSize());

    normalPtr = geoPtr->getNormals();
    nN = ((normalPtr == OSG::NullFC) ? 0 : normalPtr->getSize());

    colorPtr = geoPtr->getColors();
    cN = ((colorPtr == OSG::NullFC) ? 0 : colorPtr->getSize());

    texCoordsPtr = geoPtr->getTexCoords();
    tN = ((texCoordsPtr == OSG::NullFC) ? 0 : texCoordsPtr->getSize());

    texCoordsPtr = geoPtr->getTexCoords1();
    tN1 = ((texCoordsPtr == OSG::NullFC) ? 0 : texCoordsPtr->getSize());

    texCoordsPtr = geoPtr->getTexCoords2();
    tN2 = ((texCoordsPtr == OSG::NullFC) ? 0 : texCoordsPtr->getSize());

    texCoordsPtr = geoPtr->getTexCoords3();
    tN3 = ((texCoordsPtr == OSG::NullFC) ? 0 : texCoordsPtr->getSize());

    FDEBUG(("vertex attrib count P/N/C/T: %d/%d/%d/%d\n", pN, nN, cN, tN));

    //----------------------------------------------------------------------
    // check the vertex index and count the primitives
    primitiveN = index = 0;
    for(pType = 0; pType < 6; pType++)
        primitiveTypeCount[pType] = 0;

    if(!pN)
    {
        FINFO(("No points in OSG::setIndexFromVRMLData()\n"));
        return 0;
    }
    else
    {
        piN = coordIndex.size();
        if(piN)
        {
            for(i = 0; i <= piN; i++)
            {
                index = (i == piN) ? -1 : coordIndex[i];
                if((index < 0) && vN)
                {
                    primitiveTypeCount[(vN > maxPType) ? maxPType : vN]++;
                    primitiveN++;
                    vN = 0;
                }
                else
                {
                    if(index >= pN && i != piN)
                    {
                        FWARNING(("Point index (%d/%d) out of range", index, pN));
                        coordIndex[i] = 0;
                    }

                    vN++;
                }
            }
        }
        else
        {
            FWARNING(("No coordIndex in OSG::setIndexFromVRMLData()\n"));
            return 0;
        }
    }

    //----------------------------------------------------------------------
    // check the normal index
    normalIT = UNKNOWN_IT;
    niN = normalIndex.size();
    if(nN)
    {               // have normal elements
        if(normalPerVertex)
        {
            // normal per vertex
            if(niN >= piN)
            {
                // valid normal index number
                for(i = 0; i < piN; i++)
                {   // check if normal index equals the coord index
                    if(normalIndex[i] != coordIndex[i])
                    {
                        normalIT = VERTEX_IT;
                        break;
                    }
                }

                if(normalIT == UNKNOWN_IT)
                {
                    // if equal than delete unneeded normal index
                    normalIT = VERTEX_DUP_IT;
                }
            }
            else
            {
                // no or not enough normal index
                normalIT = VERTEX_COORD_IT;
                if(niN)
                {
                    FWARNING(("Not enough normal index (%d,%d)\n", normalIndex.
                                                     size(), piN));
                    normalIndex.clear();
                }
            }
        }
        else
        {
            // normal per primitive
            if(niN >= primitiveN)
            {
                // use one normal index per primitive
                normalIT = PRIMITIVE_INDEX_IT;
            }
            else
            {
                if(nN >= primitiveN)
                {
                    // use one normal per primitive
                    normalIT = PRIMITIVE_IT;
                }
                else
                {
                    FINFO(("not enough normal index (%d,%d)\n", nN, primitiveN));
                }
            }
        }
    }
    else
    {
        /* not yet !!!
if (createNormal)
  if (normalPerVertex)
    normalIT = VERTEX_CREATE_IT;
  else
    normalIT = PRIMITIVE_CREATE_IT;
else
*/
        normalIT = EMPTY_IT;
    }

    //----------------------------------------------------------------------
    // check the color index
    colorIT = UNKNOWN_IT;
    ciN = colorIndex.size();
    if(cN)
    {               // have color elements
        if(colorPerVertex)
        {
            // color per vertex
            if(ciN >= piN)
            {
                // valid color index number
                for(i = 0; i < piN; i++)
                {   // check if color index equals the coord index
                    if(colorIndex[i] != coordIndex[i])
                    {
                        colorIT = VERTEX_IT;
                        break;
                    }
                }

                if(colorIT == UNKNOWN_IT)
                {
                    // if equal than delete unneeded color index
                    colorIT = VERTEX_DUP_IT;
                }
            }
            else
            {
                // no or not enough color index
                colorIT = VERTEX_COORD_IT;
                if(ciN)
                {
                    FWARNING(("Not enough color index (%d,%d)\n", colorIndex.
                                                     size(), piN));
                    colorIndex.clear();
                }
            }
        }
        else
        {
            // color per primitive
            if(ciN >= primitiveN)
            {
                // use one color index per primitive
                colorIT = PRIMITIVE_INDEX_IT;
            }
            else
            {
                if(cN >= primitiveN)
                {
                    // use one color per primitive
                    colorIT = PRIMITIVE_IT;
                }
                else
                {
                    FINFO(("not enough color index (%d,%d)\n", cN, primitiveN));
                }
            }
        }
    }
    else
    {
        colorIT = EMPTY_IT;
    }

    //----------------------------------------------------------------------
    // check the texture index
    textureIT = UNKNOWN_IT;
    tiN = texCoordIndex.size();
    if(tN)
    {               // have texture elemnts
        if(tiN >= piN)
        {
            // valid texture index number
            for(i = 0; i < piN; i++)
            {       // check if texture index equals the coord index
                if(texCoordIndex[i] != coordIndex[i])
                {
                    textureIT = VERTEX_IT;
                    break;
                }
            }

            if(textureIT == UNKNOWN_IT)
            {
                // if equal than delete unneeded texture index
                textureIT = VERTEX_DUP_IT;
            }
        }
        else
        {
            // no or not enough texture index
            textureIT = VERTEX_COORD_IT;
            if(ciN)
            {
                FWARNING(("Not enough texCoord index (%d,%d)\n", texCoordIndex.
                                             size(), piN));
                texCoordIndex.clear();
            }
        }
    }
    else
    {
        textureIT = EMPTY_IT;
    }

    FNOTICE (( "primitiveN:  %d, %d, 0/%d 1/%d 2/%d 3/%d 4/%d 5/%d\n",
            primitiveType,
            primitiveN, primitiveTypeCount[0],
            primitiveTypeCount[1], primitiveTypeCount[2],
            primitiveTypeCount[3], primitiveTypeCount[4],
            primitiveTypeCount[5]));
    
    FNOTICE (( "IndexType: coord: %s, color: %s, normal: %s, texture: %s \n",
            indexTypeStr[coordIT], indexTypeStr[colorIT], 
            indexTypeStr[normalIT], indexTypeStr[textureIT]));

    //----------------------------------------------------------------------
    // check/create the indexPtr/lengthsPtr/geoTypePtr
    indexPtr = geoPtr->getIndices();
    if(indexPtr == OSG::NullFC)
    {
        indexPtr = OSG::GeoIndicesUI32::create();
    }
    else
    {
        OSG::beginEditCP(indexPtr);
        indexPtr->clear();
        OSG::endEditCP(indexPtr);
    }

    lensPtr = geoPtr->getLengths();
    if(lensPtr == OSG::NullFC)
    {
        lensPtr = OSG::GeoPLengthsUI32::create();
    }
    else
    {
        OSG::beginEditCP(lensPtr);
        lensPtr->clear();
        OSG::endEditCP(lensPtr);
    }

    geoTypePtr = geoPtr->getTypes();
    if(geoTypePtr == OSG::NullFC)
    {
        geoTypePtr = OSG::GeoPTypesUI8::create();
    }
    else
    {
        OSG::beginEditCP(geoTypePtr);
        geoTypePtr->clear();
        OSG::endEditCP(geoTypePtr);
    }

    //----------------------------------------------------------------------
    // create the index mapping
    indexMapID[0] = Geometry::MapPosition;
    indexMapID[1] = Geometry::MapNormal;
    indexMapID[2] = Geometry::MapColor;
    indexMapID[3] = Geometry::MapTexCoords;

    for(mapi = i = 1; i <= 3; i++)
    {
        indexMap[i] = 0;
        switch(indexType[i])
        {
        case UNKNOWN_IT:
        case EMPTY_IT:
            break;
        case VERTEX_COORD_IT:
        case VERTEX_DUP_IT:
            //case VERTEX_CREATE_IT:
            indexMap[0] |= indexMapID[i];
            break;
        case VERTEX_IT:
        case PRIMITIVE_IT:
        case PRIMITIVE_INDEX_IT:
            //case PRIMITIVE_CREATE_IT:
            indexMap[mapi++] = indexMapID[i];
            break;
        default:    //X_CREATE_IT
            break;
        }
    }

    //----------------------------------------------------------------------
    // set lens/geoType/index/mapping the index mapping
    OSG::beginEditCP(geoPtr);
    {
        geoPtr->setLengths(lensPtr);
        geoPtr->setTypes(geoTypePtr);
        geoPtr->setIndices(indexPtr);
        geoPtr->getIndexMapping().clear();

        // TODO: check for multiindex mapping ?
        // if (indexMap[1])
        for(i = 0; ((i <= 3) && indexMap[i]); i++)
        {
            if(i == 0)
            {
                if(indexMap[i] & Geometry::MapTexCoords)
                {
                    ++uiNumTextures;
                    
                    if(tN1 != 0)
                    {
                        indexMap[i] |= Geometry::MapTexCoords1;
                    }
                    
                    if(tN2 != 0)
                    {
                        indexMap[i] |= Geometry::MapTexCoords2;
                    }
                    
                    if(tN3 != 0)
                    {
                        indexMap[i] |= Geometry::MapTexCoords3;
                    }
                }

                geoPtr->getIndexMapping().push_back(indexMap[i]);
            }
            else
            {
                geoPtr->getIndexMapping().push_back(indexMap[i]);
                
                if(indexMap[i] & Geometry::MapTexCoords)
                {
                    ++uiNumTextures;
                    
                    if(tN1 != 0)
                    {
                        geoPtr->getIndexMapping().push_back(
                            Geometry::MapTexCoords1);
                        
                        ++uiNumTextures;
                    }
                    
                    if(tN2 != 0)
                    {
                        geoPtr->getIndexMapping().push_back(
                            Geometry::MapTexCoords2);
                        
                        ++uiNumTextures;
                    }
                    
                    if(tN3 != 0)
                    {
                        geoPtr->getIndexMapping().push_back(
                            Geometry::MapTexCoords3);
                        
                        ++uiNumTextures;
                    }
                }
            }
        }
    }
    OSG::endEditCP(geoPtr);

    //----------------------------------------------------------------------
    // create index face/line data
    OSG::beginEditCP(indexPtr);
    for(pType = minPType; pType <= maxPType; pType++)
    {
        // check for the pType count
        if(primitiveTypeCount[pType])
        {
            // calc len/sysPType
          
            if(pType < maxPType)
            {
                len = primitiveTypeCount[pType] * pType;
                switch (pType) 
                {
                  case 1: