osg::ExtrusionSurface Class Reference

Encapsulates the data of an X3D extrusion surface Not intended to be directly used. Use construction functions makeExtrusion and makeExtrusionGeo instead.

#include <OSGExtrusionGeometry.h>

List of all members.

Public Member Functions
Constructors
	ExtrusionSurface (const std::vector< Pnt2f > &crossSection, const std::vector< Quaternion > &orientation, const std::vector< Vec2f > &scale, const std::vector< Pnt3f > &spine, Real32 creaseAngle=0.f, bool beginCap=true, bool endCap=true, bool ccw=true, bool convex=true, bool buildNormal=true, bool buildTexCoord=true)
	Constructor initializing an extrusion surface.
Access
GeometryPtr	createGeometry (UInt32 nSubDivisions)
	Creates a multi-indexed Geometry representing the extrusion surface Invoked by the construction function makeExtrusionGeo and makeExtrusion.
Private Types
typedef std::vector< Pnt3f > ::const_iterator	Pnt3fConstIt
typedef std::vector< Matrix > ::const_iterator	MatrixConstIt
typedef std::pair < Pnt3fConstIt, Pnt3fConstIt >	Pnt3fConstItPair
typedef std::vector < std::vector< Vertex > >	VertexGrid
typedef std::map< Pnt3f, UInt32, vecless< Pnt3f > >	PositionMap
typedef std::map< Vec3f, UInt32, vecless< Vec3f > >	NormalMap
typedef std::map< Vec2f, UInt32, vecless< Vec2f > >	TexCoordMap
Private Member Functions
	ExtrusionSurface (const ExtrusionSurface &source)
	prohibit default function (move to 'public' if needed)
void	operator= (const ExtrusionSurface &source)
	prohibit default function (move to 'public' if needed)
void	calcXAxes (void)
void	calcYAxes (void)
void	calcZAxes (void)
void	calcTransforms (void)
void	calcSweepSurfacePositions (void)
void	calcSweepSurfaceFaceNormals (void)
void	calcSweepSurfaceTexCoords (void)
void	determineTopology (void)
void	initGrid (void)
bool	verifyInput (void)
void	refineCrossSection (UInt32 nTimes)
void	refineOrientation (UInt32 nTimes)
void	refineScale (UInt32 nTimes)
void	refineSpine (UInt32 nTimes)
void	storeConvexCap (UInt32 spineIndex, bool invertNormal, GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeSweepSurfaceWithNormals (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeSweepSurfaceWithoutNormals (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeMaps (GeoPositions3fPtr positionsPtr, GeoNormals3fPtr normalsPtr, GeoTexCoords2fPtr texCoordsPtr)
void	storeVertex (const Vertex &vertex, GeoIndicesUI32Ptr indicesPtr)
void	storePrimitive (GLenum type, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
template<typename PType>
UInt32	store (PType property, std::map< PType, UInt32, vecless< PType > > &propertyIndexMap)
template<typename PType>
void	store (const PType property, std::map< PType, UInt32, vecless< PType > > &propertyIndexMap, GeoIndicesUI32Ptr indicesPtr)
Pnt3fConstItPair	getPrevAndNextIt (const Pnt3fConstIt &pIt)
Vec3f	calcNonUnitYAxis (const Pnt3fConstIt &pIt)
Vec3f	calcNonUnitZAxis (const Pnt3fConstIt &pIt)
Vec3f	calcXAxis (const MatrixConstIt &pIt)
Vec3f	calcTriangleFaceNormal (const Pnt3f &a, const Pnt3f &b, const Pnt3f &c)
Vec3f	calcQuadFaceNormal (const Pnt3f &a, const Pnt3f &b, const Pnt3f &c, const Pnt3f &d)
void	calcVertexNormal (Vertex *vertexPtr, UInt32 faceIndex)
bool	isLeft (const Pnt2f &a, const Pnt2f &b)
Real32	computeMinYAbs (const std::vector< Pnt2f > &contour, Real32 alpha)
Real32	calcBetterRotationAngle (const std::vector< Pnt2f > &contour, UInt32 nAngles)
bool	calcOptimizedContour (const std::vector< Pnt2f > &contour, const Pnt2f &point, std::vector< Pnt2f > *optimizedContour)
Int32	calcWindingNumber (const std::vector< Pnt2f > &contour, const Pnt2f &point)
void	storeFaceNormalGeo (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeVertexNormalGeo (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
Constructors
	ExtrusionSurface (void)
	prohibit default function (move to 'public' if needed)
Private Attributes
std::vector< Pnt2f >	_crossSection
std::vector< Quaternion >	_orientation
std::vector< Vec2f >	_scale
std::vector< Pnt3f >	_spine
Real32	_creaseAngle
bool	_beginCap
bool	_endCap
bool	_ccw
bool	_convex
bool	_crossSectionClosed
bool	_spineClosed
bool	_spineCollinear
bool	_revolutionSurface
bool	_createNormals
bool	_createTexCoords
std::vector< Matrix >	_transform
VertexGrid	_grid
PositionMap	_posMap
NormalMap	_normalMap
TexCoordMap	_texCoordMap
UInt32	_vertexCount
UInt32	_totalVertexCount
UInt32	_primitiveCount
Classes
struct	vecless
struct	Vertex

---

Detailed Description

Definition at line 140 of file OSGExtrusionGeometry.h.

---

Member Typedef Documentation

typedef std::vector<Pnt3f>::const_iterator osg::ExtrusionSurface::Pnt3fConstIt [private]

Definition at line 249 of file OSGExtrusionGeometry.h.

typedef std::vector<Matrix>::const_iterator osg::ExtrusionSurface::MatrixConstIt [private]

Definition at line 250 of file OSGExtrusionGeometry.h.

typedef std::pair<Pnt3fConstIt, Pnt3fConstIt> osg::ExtrusionSurface::Pnt3fConstItPair [private]

Definition at line 251 of file OSGExtrusionGeometry.h.

typedef std::vector< std::vector< Vertex > > osg::ExtrusionSurface::VertexGrid [private]

Definition at line 253 of file OSGExtrusionGeometry.h.

typedef std::map<Pnt3f, UInt32, vecless<Pnt3f> > osg::ExtrusionSurface::PositionMap [private]

Definition at line 255 of file OSGExtrusionGeometry.h.

typedef std::map<Vec3f, UInt32, vecless<Vec3f> > osg::ExtrusionSurface::NormalMap [private]

Definition at line 256 of file OSGExtrusionGeometry.h.

typedef std::map<Vec2f, UInt32, vecless<Vec2f> > osg::ExtrusionSurface::TexCoordMap [private]

Definition at line 257 of file OSGExtrusionGeometry.h.

---

Constructor & Destructor Documentation

ExtrusionSurface::ExtrusionSurface	(	const std::vector< Pnt2f > &	crossSection,
		const std::vector< Quaternion > &	orientation,
		const std::vector< Vec2f > &	scale,
		const std::vector< Pnt3f > &	spine,
		Real32	creaseAngle = 0.f,
		bool	beginCap = true,
		bool	endCap = true,
		bool	ccw = true,
		bool	convex = true,
		bool	buildNormal = true,
		bool	buildTexCoord = true
	)

Parameters:

	crossSection	The cross-section of the sweep surface
	orientation	The orientation rotating the cross-section out of the XZ-plane
	scale	The scale values scaling the cross-section
	spine	The spine curve along which the cross-section is extruded
	creaseAngle	Determines when normals are smoothed between adjacent quads
	beginCap	Determines whether a begin cap is to created
	endCap	Determines whether an end cap is to be created
	ccw	Determines the ordering of the primitive vertices with respect to the generated normals
	convex	Determines whether the cross-section is convex
	buildNormal	Determines whether normals are calculated
	buildTexCoord	Determines whether texture coordinates are created

Definition at line 125 of file OSGExtrusionGeometry.cpp.

References _crossSection, _orientation, _scale, _spine, osg::DEF_CROSS_SECTION, osg::DEF_N_CROSS_SECTION_POINTS, osg::DEF_N_ORIENTATION_PARAMS, osg::DEF_N_SCALE_PARAMS, osg::DEF_N_SPINE_POINTS, osg::DEF_ORIENTATION, osg::DEF_SCALE, osg::DEF_SPINE, and FDEBUG.

                                                       :

    _creaseAngle(creaseAngle),
    _beginCap(beginCap),
    _endCap(endCap),
    _ccw(ccw),
    _convex(convex),
    _createNormals(buildNormal),
    _createTexCoords(buildTexCoord),
    _primitiveCount(0),
    _vertexCount(0),
    _totalVertexCount(0)
{
    // initialize cross section
    if(!crossSection.empty()) 
    {
        // copy argument
        _crossSection.assign(crossSection.begin(), crossSection.end());
    }
    else
    {
        // copy default
        FDEBUG(("OSGExtrusion: Empty cross section. Using default.\n"));
        for(UInt32 i = 0; i < DEF_N_CROSS_SECTION_POINTS; i++)
            _crossSection.push_back(Pnt2f(DEF_CROSS_SECTION[i]));
    }

    // initialize orientations
    if(!orientation.empty())
    {
        // copy argument
        _orientation.assign(orientation.begin(), orientation.end());
    }
    else
    {
        // copy default
        FDEBUG(("OSGExtrusion: Empty orientation. Using default.\n"));
        for(UInt32 i = 0; i < DEF_N_ORIENTATION_PARAMS; i++)
            _orientation.push_back(Quaternion(Vec3f(DEF_ORIENTATION[i]),
                                              DEF_ORIENTATION[i][3]));
    }
    
    // initialize scale parameters
    if(!scale.empty())
    {
        // copy argument
        _scale.assign(scale.begin(), scale.end());
    }
    else
    {
        // copy default
        FDEBUG(("OSGExtrusion: Empty scale parameter. Using default.\n"));
        for(UInt32 i = 0; i < DEF_N_SCALE_PARAMS; i++)
            _scale.push_back(Vec2f(DEF_SCALE[i]));
    }


    // initialize spine
    if(!spine.empty())
    {
        // copy argument
        _spine.assign(spine.begin(), spine.end());
    }
    else
    {
        // copy default
        FDEBUG(("OSGExtrusion: Empty spine. Using default.\n"));
        for(UInt32 i = 0; i < DEF_N_SPINE_POINTS; i++)
            _spine.push_back(Pnt3f(DEF_SPINE[i]));
    }
}

osg::ExtrusionSurface::ExtrusionSurface

(

void

)

[private]

osg::ExtrusionSurface::ExtrusionSurface

(

const ExtrusionSurface &

source

)

[private]

---

Member Function Documentation

GeometryPtr ExtrusionSurface::createGeometry

(

UInt32

nSubDivisions

)

Parameters:

nSubDivisions

The number of subdivisions to apply

Returns:

A pointer to a newly created geometry containing the surface

Definition at line 1477 of file OSGExtrusionGeometry.cpp.

References _beginCap, _convex, _createNormals, _createTexCoords, _endCap, _normalMap, _orientation, _posMap, _primitiveCount, _spine, _texCoordMap, _totalVertexCount, osg::beginEditCP(), calcSweepSurfacePositions(), calcSweepSurfaceTexCoords(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), determineTopology(), osg::endEditCP(), FDEBUG, FFATAL, FINFO, FWARNING, osg::GeoProperty< GeoPropertyDesc >::GeoPropDataFieldMask, osg::GeometryBase::IndexMappingFieldMask, osg::GeometryBase::IndicesFieldMask, initGrid(), osg::GeometryBase::LengthsFieldMask, osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::GeometryBase::NormalsFieldMask, osg::NullFC, osg::GeometryBase::PositionsFieldMask, refineCrossSection(), refineScale(), refineSpine(), SINFO, storeConvexCap(), storeFaceNormalGeo(), storeMaps(), storeSweepSurfaceWithNormals(), storeSweepSurfaceWithoutNormals(), storeVertexNormalGeo(), osg::GeometryBase::TexCoordsFieldMask, osg::GeometryBase::TypesFieldMask, and verifyInput().

Referenced by osg::makeExtrusionGeo().

{
    // do some sanity checks on and determines the topology
    // of the _spine and _crossSection member fields
    if(!verifyInput())
    {
        FWARNING(("OSGExtrusion:createGeometry: Invalid input. Returning NullFC\n"));
        return NullFC;
    }

    // initialize topology flags (i.e spine/_crossSection closure)
    determineTopology();
    
    // optionally subdivide input data
    if(nSubdivs > 0)
    {
        refineCrossSection(nSubdivs);

        if(_orientation.size() == 1)
        {
            refineSpine(nSubdivs);
            refineScale(nSubdivs);
        }
        else // more than 1 orientation
        {
            // It'd be necessary to refine the orientations in order to get
            // a consistent result, but this is not implemented yet.
            FINFO(("OSGExtrusion:createGeometry: Too many orientations. Not refining along spine\n"));
        }
    }

    // allocate vertex grid structure
    initGrid();
    calcSweepSurfacePositions();

    if(_createTexCoords)
    {
        calcSweepSurfaceTexCoords();
    }

    // create opensg geometry field containers
    GeoPositions3fPtr  posPtr     = GeoPositions3f::create();
    GeoPLengthsUI32Ptr lensPtr    = GeoPLengthsUI32::create();
    GeoIndicesUI32Ptr  indicesPtr = GeoIndicesUI32::create();
    GeoPTypesUI8Ptr    typesPtr   = GeoPTypesUI8::create();
    GeoNormals3fPtr    normalsPtr = NullFC;
    GeoTexCoords2fPtr  texPtr     = NullFC;

    if(_createNormals)
        normalsPtr = GeoNormals3f::create();

    if(_createTexCoords)
        texPtr = GeoTexCoords2f::create();

    beginEditCP(indicesPtr, GeoIndicesUI32::GeoPropDataFieldMask);
    beginEditCP(lensPtr,    GeoPLengthsUI32::GeoPropDataFieldMask);
    beginEditCP(typesPtr,   GeoPTypesUI8::GeoPropDataFieldMask);

    if(_createNormals)
    {
        // store sweep surface as triangle strips with vertex normals
        storeSweepSurfaceWithNormals(indicesPtr, lensPtr, typesPtr);
    }
    else
    {
        // store sweep surface as triangle strips without vertex normals
        storeSweepSurfaceWithoutNormals(indicesPtr, lensPtr, typesPtr);
    }

    if(_convex)
    {
        // calculate and store caps as triangle fans
        if(_beginCap)
        {
            FDEBUG(("OSGExtrusion:createGeometry: Creating begin cap\n"));
            storeConvexCap(0,           // spine section 0 
                           true,        // flip normal
                           indicesPtr, 
                           lensPtr, 
                           typesPtr);
        }
        
        if(_endCap)
        {
            FDEBUG(("OSGExtrusion:createGeometry: Creating end cap\n"));
            storeConvexCap(_spine.size() - 1,  // last spine section
                           false,              // don't flip normal
                           indicesPtr,
                           lensPtr, 
                           typesPtr);
        }
    }
    else // non-convex case
    {
        FFATAL(("OSGExtrusion:createGeometry: Support for non-convex caps not implemented\n"));
    }
    
#ifdef DEBUG_VERTEX_NORMALS
    // add surface normals for debugging purposes
    storeVertexNormalGeo(indicesPtr, lensPtr, typesPtr);
#endif

#ifdef DEBUG_FACE_NORMALS
    // add sweep surface face normals for debugging purposes
    storeFaceNormalGeo(indicesPtr, lensPtr, typesPtr);
#endif    

    endEditCP(indicesPtr, GeoIndicesUI32::GeoPropDataFieldMask);
    endEditCP(lensPtr,    GeoPLengthsUI32::GeoPropDataFieldMask);
    endEditCP(typesPtr,   GeoPTypesUI8::GeoPropDataFieldMask);

    // store the shared vertex data into the vertex data field containers
    storeMaps(posPtr, normalsPtr, texPtr);

    // create a new OpenSG geometry
    GeometryPtr geoPtr = Geometry::create();

    beginEditCP(geoPtr, Geometry::TypesFieldMask  |
                Geometry::LengthsFieldMask        |
                Geometry::IndicesFieldMask        |
                Geometry::IndexMappingFieldMask   |
                Geometry::PositionsFieldMask      |
                Geometry::NormalsFieldMask        |
                Geometry::TexCoordsFieldMask      );

    // The interleaved multi-index blocks have one of the following 
    // layouts (depending on _createNormals and _createTexCoords):
    //
    // 1. (Position)                  
    // 2. (Position, Normal)
    // 3. (Position, TexCoord)        
    // 4. (Position, Normal, TexCoord)
    geoPtr->getIndexMapping().push_back(Geometry::MapPosition);
    if(_createNormals)
        geoPtr->getIndexMapping().push_back(Geometry::MapNormal);
    if(_createTexCoords)
        geoPtr->getIndexMapping().push_back(Geometry::MapTexCoords);

    // set primitive data field containers
    geoPtr->setLengths(lensPtr);
    geoPtr->setIndices(indicesPtr);
    geoPtr->setTypes(typesPtr);
   
    // set vertex data field containers
    geoPtr->setPositions(posPtr);
    geoPtr->setNormals(normalsPtr);
    geoPtr->setTexCoords(texPtr);
   
    endEditCP(geoPtr, Geometry::TypesFieldMask  |
              Geometry::LengthsFieldMask        |
              Geometry::IndicesFieldMask        |
              Geometry::IndexMappingFieldMask   |
              Geometry::PositionsFieldMask      |
              Geometry::NormalsFieldMask        |
              Geometry::TexCoordsFieldMask      );


    SINFO << "OSGExtrusion:createGeometry: Stats: ("
          << _primitiveCount     << '/'
          << _totalVertexCount   << '/'
          << _posMap.size() << '/'
          << _normalMap.size()   << '/'
          << _texCoordMap.size() << ')'
          << "(Prims/Verts/Pos/Norms/TexCoords)"
          << std::endl; 
        
    return geoPtr;
}

void osg::ExtrusionSurface::operator=

(

const ExtrusionSurface &

source

)

[private]

void ExtrusionSurface::calcXAxes

(

void

)

[inline, private]

Calculates the X-Axes of the CP to SCP transforms

Definition at line 331 of file OSGExtrusionGeometry.cpp.

References _revolutionSurface, _spineCollinear, _transform, and calcXAxis().

Referenced by calcTransforms().

{
    std::vector<Matrix>::iterator tIt = _transform.begin();

    // Either of the two cases below implies the cross product of
    // the y- and the z-axis vanish (and so do all x-axes)
    if(!_spineCollinear && !_revolutionSurface)
    {
        for(; tIt != _transform.end(); ++tIt)
        {
            Vec3f xAxis = calcXAxis(tIt);
            (*tIt)[0].setValue(xAxis);
        }
    }
    else
    {
        (*tIt)[0].setValue(Vec3f(0.f, 0.f, 0.f));
    }
}

void ExtrusionSurface::calcYAxes

(

void

)

[inline, private]

Calculates the Y-Axes of the CP to SCP transforms

Definition at line 361 of file OSGExtrusionGeometry.cpp.

References _revolutionSurface, _spine, _transform, calcNonUnitYAxis(), osg::Eps, FDEBUG, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

Referenced by calcTransforms().

{
    bool yAxisDefined = false;

    std::vector<Pnt3f>::const_iterator  spineIt = _spine.begin();
    std::vector<Matrix>::iterator tIt = _transform.begin();
    for(; spineIt != _spine.end(); ++spineIt, ++tIt)
    {
        Vec3f yAxis = calcNonUnitYAxis(spineIt);
        if(yAxis.length() > Eps) // we have found a valid tangent
        {
            yAxis.normalize();
            if(!yAxisDefined)
            {
                FDEBUG(("OSGExtrusion:calcYAxes: yAxis is defined\n"));
                yAxisDefined = true;

                // assign found y-axis to all transforms
                // up to and including the current one
                std::vector<Matrix>::iterator yIt;
                for(yIt = _transform.begin(); yIt != (tIt + 1); ++yIt)
                    (*yIt)[1].setValue(yAxis);
            }
            else 
            {
                // assign found y-axis to the current transform only
                (*tIt)[1].setValue(yAxis);
            }
        }
        else if(yAxisDefined)
        {
            // reuse y-axis determined during last step
            (*tIt)[1] = (*(tIt - 1))[1];
        }
    }

    // all spine points coincided => surface of revolution
    _revolutionSurface = !yAxisDefined;
}

void ExtrusionSurface::calcZAxes

(

void

)

[inline, private]

Calculates the Z-Axes of the CP to SCP transforms

Definition at line 410 of file OSGExtrusionGeometry.cpp.

References _spine, _spineCollinear, _transform, calcNonUnitZAxis(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), osg::Eps, FDEBUG, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length(), osg::PointInterface< ValueTypeT, StorageInterfaceT >::negate(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

Referenced by calcTransforms().

{
    bool zAxisDefined = false;
    
    std::vector<Pnt3f>::const_iterator  spineIt = _spine.begin();
    std::vector<Matrix>::iterator tIt = _transform.begin();
    for(; spineIt != _spine.end(); ++spineIt, ++tIt)
    {
        Vec3f zAxis = calcNonUnitZAxis(spineIt);
        if(zAxis.length() > Eps)
        {
            zAxis.normalize();
            if(!zAxisDefined)
            {
                FDEBUG(("OSGExtrusion:calcZAxes: zAxis is defined\n"));
                zAxisDefined = true;
                
                // set the current z-Axis for the current transform
                (*tIt)[2].setValue(zAxis);

                // assign found z-axis to all previous transforms
                std::vector<Matrix>::iterator zIt;
                for(zIt = _transform.begin(); zIt != tIt; ++zIt)
                {
                    (*zIt)[2].setValue(zAxis);
                }
            }
            else // assign found z-axis to this basis _only_
            {
                (*tIt)[2].setValue(zAxis);

                // as the zAxis is defined tIt - 1 contains a valid value 
                Vec3f prevZAxis((*(tIt - 1))[2][0],
                                (*(tIt - 1))[2][1],
                                (*(tIt - 1))[2][2]);

                // check whether the z-axis needs to be flipped
                if(prevZAxis.dot(zAxis) + Eps < 0.f)
                {
                    FDEBUG(("OSGExtrusion:calcZAxes: Flipping z-axis\n"));
                    zAxis.negate();
                }

                // assign zAxis to current transform
                (*tIt)[2].setValue(zAxis);
            }
        }
        else if(zAxisDefined)
        {
            // reuse previous value
            (*tIt)[2] = (*(tIt - 1))[2];
        }
    } // end for

    // All cross products vanished => spine has no non-collinear part
    // and is thus composed of collinear parts and revolutions only
    _spineCollinear = !zAxisDefined;
}

void ExtrusionSurface::calcTransforms

(

void

)

[private]

Calculates the affine transformations from CP to SCP

Definition at line 480 of file OSGExtrusionGeometry.cpp.

References _orientation, _revolutionSurface, _scale, _spine, _spineCollinear, _transform, calcXAxes(), calcYAxes(), calcZAxes(), FDEBUG, osg::QuaternionBase< ValueTypeT >::getValue(), osg::TransformationMatrix< ValueTypeT >::multLeft(), and osg::QuaternionBase< ValueTypeT >::setValue().

Referenced by calcSweepSurfacePositions().

{
    _transform.clear();

    // initialize the transformations with Id
    _transform.resize(_spine.size());

    /* X3D Spec:
     * The SCP is computed by first computing its Y-axis and Z-axis, then 
     * taking the cross product of these to determine the X-axis. These three 
     * axes are then used to determine the rotation value needed to rotate the
     * Y=0 plane to the SCP. This results in a plane that is the approximate 
     * tangent of the spine at each point, as shown in Figure 13.5.
     */
    calcZAxes(); // sets bool _spineCollinear
    calcYAxes(); // sets bool _revolutionSurface

    // We need to make a difference between surfaces having at least
    // one non-trivial collinear part in their spine and surfaces created
    // by pure revolution of the crossection.
    if(_revolutionSurface)
    {
        _spineCollinear = false;
    }
    calcXAxes(); // uses _spineCollinear and _revolutionSurface

    /* X3D Spec:
     *
     * If the entire spine is collinear, the SCP is computed by finding the 
     * rotation of a vector along the positive Y-axis (v1) to the vector formed
     * by the spine points (v2). The Y=0 plane is then rotated by this value.
     *
     * If two points are coincident, they both have the same SCP. If each point
     * has a different orientation value, then the surface is constructed by 
     * connecting edges of the cross-sections as normal. This is useful in 
     * creating revolved surfaces.
     */
    Matrix rotation; // m = Id and thus ok for revolution case
    if(_spineCollinear && !_revolutionSurface)
    {
        // calculate the rotation that rotates the y unit vector to the
        // direction of the spine.
        Vec3f v1(0.f, 1.f, 0.f);
        Vec3f v2(_transform[0][1]);
            
        Quaternion q;
        q.setValue(v1, v2);
        q.getValue(rotation);
    }

    std::vector<Matrix>::iterator tIt             = _transform.begin();
    std::vector<Pnt3f>::const_iterator spineIt    = _spine.begin();
    std::vector<Vec2f>::const_iterator scaleIt    = _scale.begin(); 
    std::vector<Quaternion>::const_iterator rotIt = _orientation.begin();

    // calculate an affine transformation for the cross-section at
    // each spine point
    for(; spineIt != _spine.end(); ++spineIt, ++tIt)
    {
        // special cases
        if(_spineCollinear || _revolutionSurface)
        {
            // defines the x,y and z-axes in this case
            *tIt = rotation;
        }        

        // setup transform of the CP
        Matrix cSPlaneTransform;

        // Scale the x- and z-axes
        cSPlaneTransform[0] *= (*scaleIt)[0];
        cSPlaneTransform[2] *= (*scaleIt)[1];

        // apply orientation
        Matrix orientationMatrix;
        rotIt->getValue(orientationMatrix);
        cSPlaneTransform.multLeft(orientationMatrix);

        tIt->mult(cSPlaneTransform);

        // affine translation to the spine point
        tIt->setTranslate(*spineIt);
        
        // The affine transformation *tIt should now
        //
        //   1. scale the CP
        //   2. apply the orientation to the CP        
        //   2. translate the origin to spine[i]
        //
        // in exactly this order.

        /* X3D Spec quotation:
         *
         * If the number of scale or orientation values is greater than the
         * number of spine points, the excess values are ignored. If they 
         * contain one value, it is applied at all spine points. The 
         * results are undefined if the number of scale or orientation 
         * values is greater than one but less than the number of spine 
         * points. The scale values shall be positive.
         */
        
        // always use last available value
        if(rotIt + 1   != _orientation.end()) { ++rotIt;   }
        if(scaleIt + 1 != _scale.end())       { ++scaleIt; }
    }

    FDEBUG(("OSGExtrusion:calcTransforms: spine collinear: %s\n", 
            (_spineCollinear ? "true" : "false")));

    FDEBUG(("OSGExtrusion:calcTransforms: revolution surface: %s\n",
            (_revolutionSurface ? "true" : "false")));
}

void ExtrusionSurface::calcSweepSurfacePositions

(

void

)

[private]

Calculates the positions of the sweep surface and stores them in the _grid

Definition at line 624 of file OSGExtrusionGeometry.cpp.

References _crossSection, _grid, _posMap, _spine, _transform, calcTransforms(), osg::Eps, FDEBUG, FFATAL, FWARNING, initGrid(), p, and SWARNING.

Referenced by createGeometry().

{
    FDEBUG(("OSGExtrusion:calcSweepSurfacePositions: Calculation vertex positions\n"));

    if(_grid.size() < _spine.size())
    {
        FFATAL(("OSGExtrusion:calcSweepSurfacePositions: Grid not initialized\n"));
        return;
    }

    _posMap.clear();

    // compute transformation matrices
    calcTransforms();

    if(_grid.size() < _spine.size()) // grid not yet or incorrectly initialized
    {
        initGrid();
    }

    std::vector<Matrix>::iterator transIt = _transform.begin();
    VertexGrid::iterator gridRowIt = _grid.begin();

    // iterate over the spine points
    for(Int32 i = 0; i < _spine.size(); i++, ++gridRowIt)
    {
        if(transIt->det3() < Eps) // degenerate transform
        {
            FWARNING(("OSGExtrusion:calcSurfacePositions: Degenerate transformation matrix\n"));
            SWARNING << "Degenerate transform[" << i << "]:\n "
                     << *transIt << std::endl;
        }

        std::vector<Vertex>::iterator gridColIt = gridRowIt->begin();
        std::vector<Pnt2f>::iterator crossIt;

        // iterate over the cross-section curve
        for(crossIt = _crossSection.begin(); crossIt != _crossSection.end();
            ++crossIt, ++gridColIt)
        {
            Pnt3f p = Pnt3f((*crossIt)[0], 0.f, (*crossIt)[1]);

            // apply "CP to SCP"-transform
            transIt->multMatrixPnt(p, gridColIt->position);
        }

        // always use last defined transformation matrix
        if(transIt + 1 != _transform.end()) { ++transIt; }
    }
}

void ExtrusionSurface::calcSweepSurfaceFaceNormals

(

void

)

[private]

Calculates the face normals of the sweep surface and stores them in the _grid

Definition at line 748 of file OSGExtrusionGeometry.cpp.

References _crossSection, _crossSectionClosed, _grid, _spine, _spineClosed, calcQuadFaceNormal(), FDEBUG, and FFATAL.

{
    FDEBUG(("OSGExtrusion:calcSweepSurfaceFaceNormals: Calculating sweep surface face normals\n"));

    if(_grid.size() < _spine.size())
    {
        FFATAL(("OSGExtrusion:calcSweepSurfaceFaceNormals: Grid not initialized\n"));
        return;
    }
    
    // calculate face normals
    for(UInt32 i = 0; i < _spine.size(); ++i)
    {
        UInt32 iPrev, iNext;

        // determine adjacent row indices
        if(_spineClosed)
        {
            // first point == last point
            iPrev = (i != 0) ? i - 1 : _spine.size() - 2;
            iNext = (i != _spine.size() - 1) ? i + 1 : 1;
        }
        else
        {
            iPrev = (i != 0) ? i - 1 : 0;
            iNext = (i != _spine.size() - 1) ? i + 1 : i;
        }

        for(UInt32 j = 0; j < _crossSection.size(); ++j)
        {
            Vec3f n;
            UInt32 jPrev, jNext;

            // determine adjacent column indices
            if(_crossSectionClosed)
            {
                // first point == last point
                jPrev = (j != 0) ? j - 1 : _crossSection.size() - 2;
                jNext = (j != _crossSection.size() - 1) ? j + 1 : 1;
            }
            else
            {
                jPrev = (j != 0) ? j - 1 : 0;
                jNext = (j != _crossSection.size() - 1) ? j + 1 : j;
            }

            // upper right face normal (1st quadrant)
            _grid[i][j].adjFaceNormals[0] =
                calcQuadFaceNormal(_grid[i][j].position,
                                   _grid[i][jNext].position,
                                   _grid[iNext][jNext].position,
                                   _grid[iNext][j].position);


            // upper left face normal (2nd quadrant)
            _grid[i][j].adjFaceNormals[1] = 
                calcQuadFaceNormal(_grid[i][j].position,
                                   _grid[iNext][j].position,
                                   _grid[iNext][jPrev].position,
                                   _grid[i][jPrev].position);


            // lower left face normal (3nd quadrant)
            _grid[i][j].adjFaceNormals[2] = 
                calcQuadFaceNormal(_grid[i][j].position,
                                   _grid[i][jPrev].position,
                                   _grid[iPrev][jPrev].position,
                                   _grid[iPrev][j].position);


            // lower right face normal (4th quadrant)
            _grid[i][j].adjFaceNormals[3] = 
                calcQuadFaceNormal(_grid[i][j].position,
                                   _grid[iPrev][j].position,
                                   _grid[iPrev][jNext].position,
                                   _grid[i][jNext].position);
        }
    }
}

void ExtrusionSurface::calcSweepSurfaceTexCoords

(

void

)

[private]

Definition at line 686 of file OSGExtrusionGeometry.cpp.

References _crossSection, _grid, _spine, _texCoordMap, osg::Eps, FDEBUG, and FFATAL.

Referenced by createGeometry().

{
    FDEBUG(("OSGExtrusion:calcSweepSurfaceTexCoords: Calculating texture coordinates\n"));
    if(_grid.size() < _spine.size())
    {
        FFATAL(("OSGExtrusion:calcSweepSurfaceTexCoords: Grid not initialized\n"));
        return;
    }
    _texCoordMap.clear();
    
    /* X3D Spec:
     *
     *  Textures are mapped so that the coordinates range in the U direction 
     *  from 0 to 1 along the crossSection curve (with 0 corresponding to the 
     *  first point in crossSection and 1 to the last) and in the V direction
     *  from 0 to 1 along the spine curve (with 0 corresponding to the first 
     *  listed spine point and 1 to the last) 
     */

    // accumulate distances along u and v directions
    for(UInt32 i = 0; i < _spine.size(); ++i)
    {
        for(UInt32 j = 0; j < _crossSection.size(); ++j)
        {
            Real32 u,v;
            UInt32 iPrev = (i == 0) ? 0 : i - 1;
            UInt32 jPrev = (j == 0) ? 0 : j - 1;

            // contains length of i-th column curve up to the (j-1)-th point
            u = _grid[i][jPrev].texCoord[0];
            // add distance to j-th point
            u += _grid[i][j].position.dist(_grid[i][jPrev].position);

            // contains length of j-th row curve up to the (i-1)-th point
            v = _grid[iPrev][j].texCoord[1];
            // add distance to i-th point
            v += _grid[i][j].position.dist(_grid[iPrev][j].position);

            _grid[i][j].texCoord[0] = u;
            _grid[i][j].texCoord[1] = v;
        }
    }

    // renormalize distances to [0,1]x[0,1]
    for(UInt32 i = 0; i < _spine.size(); ++i)
    {
        for(UInt32 j = 0; j < _crossSection.size(); ++j)
        {
            // length is maximal in the row/column curve end points
            Real32 uMax = _grid[i][_crossSection.size() - 1].texCoord[0];
            Real32 vMax = _grid[_spine.size() - 1][j].texCoord[1];

            if(uMax > Eps)
                _grid[i][j].texCoord[0] /= uMax;

            if(vMax > Eps)
                _grid[i][j].texCoord[1] /= vMax;
        }
    }
}

void ExtrusionSurface::determineTopology

(

void

)

[private]

Initializes the topology flags of the extrusion surface

Definition at line 238 of file OSGExtrusionGeometry.cpp.

References _crossSection, _crossSectionClosed, _spine, _spineClosed, osg::Eps, FDEBUG, and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length().

Referenced by createGeometry().

{
    // compute vector differences between start and end points
    Vec3f sDiff = _spine.back() - _spine.front();
    Vec2f cDiff = _crossSection.back() - _crossSection.front();

    // determine whether the curves are closed
    _spineClosed = (sDiff.length() < Eps) ? true : false;
    _crossSectionClosed = (cDiff.length() < Eps) ? true : false;
    
    FDEBUG(("OSGExtrusion:checkInput: Topology: (Spine: %s / Cross-section: %s)\n", 
            (_spineClosed ? "Closed" : "Open"),
            (_crossSectionClosed ? "Closed" : "Open")));
}

void ExtrusionSurface::initGrid

(

void

)

[private]

Initializes the _grid data structure

Definition at line 600 of file OSGExtrusionGeometry.cpp.

References _crossSection, _grid, _spine, and FDEBUG.

Referenced by calcSweepSurfacePositions(), and createGeometry().

{
    FDEBUG(("OSGExtrusion:initGrid: Initializing vertex grid\n"));
    
    _grid.clear();
    _grid.resize(_spine.size());

    VertexGrid::iterator gridRowIt = _grid.begin();
    for(Int32 i = 0; i < _spine.size(); i++, ++gridRowIt)
    {
        gridRowIt->resize(_crossSection.size());
    }
}

bool ExtrusionSurface::verifyInput

(

void

)

[private]

Returns true if an extrusion surface can be generated from the supplied data.

Definition at line 214 of file OSGExtrusionGeometry.cpp.

References _crossSection, _spine, and FWARNING.

Referenced by createGeometry().

{
    if(_crossSection.size() < 2)
    {
        FWARNING(("OSGExtrusion:checkInput: Cross section is degenerate\n"));
        return false;
    }

    if(_spine.size() < 2)
    {
        FWARNING(("OSGExtrusion:checkInput: spine is degenerate\n"));
        return false;
    }

    return true;
}

void ExtrusionSurface::refineCrossSection

(

UInt32

nTimes

)

[private]

Definition at line 259 of file OSGExtrusionGeometry.cpp.

References _crossSection, _crossSectionClosed, FDEBUG, and subdivide().

Referenced by createGeometry().

{
    FDEBUG(("OSGExtrusion:refineCrossSection: Refinining %d times\n",nTimes));
    std::vector<Vec2f> output;

    // cast <Pnt2f> to <Vec2f> because we need the vector interface
    std::vector<Vec2f> & csVec2f ((std::vector<Vec2f>&)(_crossSection));
    subdivide(csVec2f, &output, nTimes, _crossSectionClosed);

    // swap output data into _crossSection
    output.swap(csVec2f);
}

void ExtrusionSurface::refineOrientation

(

UInt32

nTimes

)

[private]

Subdivides the _orientation vector n-times

Definition at line 316 of file OSGExtrusionGeometry.cpp.

References FFATAL.

{
    FFATAL(("OSGExtrusion:refineOrientation: Not Implemented\n"));
}

void ExtrusionSurface::refineScale

(

UInt32

nTimes

)

[private]

Subdivides the scale parameters vector n-times

Definition at line 297 of file OSGExtrusionGeometry.cpp.

References _scale, _spineClosed, and FDEBUG.

Referenced by createGeometry().

{
    FDEBUG(("OSGExtrusion:refineScale: Refinining %d times\n",nTimes));

    std::vector<Vec2f> output;
    subdivide<Vec2f>(_scale, &output, nTimes, _spineClosed);

    // swap output data into _scale
    output.swap(_scale);
}

void ExtrusionSurface::refineSpine

(

UInt32

nTimes

)

[private]

Subdivides the spine n-times

Definition at line 277 of file OSGExtrusionGeometry.cpp.

References _spine, _spineClosed, and FDEBUG.

Referenced by createGeometry().

{
    FDEBUG(("OSGExtrusion:refineSpine: Refinining %d times\n",nTimes));

    std::vector<Vec3f> output;

    // cast <Pnt3f> to <Vec3f> because we need the vector interface    
    std::vector<Vec3f> & spVec3f ((std::vector<Vec3f>&)(_spine));
    subdivide<Vec3f>(spVec3f, &output, nTimes, _spineClosed);

    // swap output data into _spine
    output.swap(spVec3f);
}

void osg::ExtrusionSurface::storeConvexCap	(	UInt32	spineIndex,
		bool	invertNormal,
		GeoIndicesUI32Ptr	indicesPtr,
		GeoPLengthsUI32Ptr	lensPtr,
		GeoPTypesUI8Ptr	typesPtr
	)			[private]

Stores a convex cap surface in the supplied field containers

Parameters:

	spineIndex	The spine point at which the cap is to be created
	invertNormal	If true the cap normal is reversed

Referenced by createGeometry().

void osg::ExtrusionSurface::storeSweepSurfaceWithNormals	(	GeoIndicesUI32Ptr	indicesPtr,
		GeoPLengthsUI32Ptr	lensPtr,
		GeoPTypesUI8Ptr	typesPtr
	)			[private]

Stores the sweep surface obtained by extruding the cross-section along the spine into the supplied field containers. The surface normals are also generated. The _creaseAngle is respected during primitive generation.

Referenced by createGeometry().

void osg::ExtrusionSurface::storeSweepSurfaceWithoutNormals	(	GeoIndicesUI32Ptr	indicesPtr,
		GeoPLengthsUI32Ptr	lensPtr,
		GeoPTypesUI8Ptr	typesPtr
	)			[private]

Stores the sweep surface obtained by extruding the cross-section along the spine into the supplied field containers. Normals are not generated.

Referenced by createGeometry().

void osg::ExtrusionSurface::storeMaps	(	GeoPositions3fPtr	positionsPtr,
		GeoNormals3fPtr	normalsPtr,
		GeoTexCoords2fPtr	texCoordsPtr
	)			[private]

Stores the accumulated property data in the supplied field containers

Referenced by createGeometry().

void osg::ExtrusionSurface::storeVertex	(	const Vertex &	vertex,
		GeoIndicesUI32Ptr	indicesPtr
	)			[inline, private]

Stores a property index in the supplied field container and the property itself into an internal map

Definition at line 404 of file OSGExtrusionGeometry.inl.

References _createNormals, _createTexCoords, _normalMap, _posMap, _texCoordMap, _totalVertexCount, _vertexCount, osg::ExtrusionSurface::Vertex::normal, osg::NullFC, osg::ExtrusionSurface::Vertex::position, SLOG, store(), and osg::ExtrusionSurface::Vertex::texCoord.

{
    assert(indicesPtr != NullFC);

#ifdef DEBUG_VERTEX_STORE
    std::ostringstream strout;
    strout << "OSGExtrusion:storeVertex:Storing:" << std::endl;
    strout << "\t[ (Pos: " << vertex.position << ")" << std::endl;
#endif
    
    // store position
    store(vertex.position, _posMap, indicesPtr);

    if(_createNormals)
    {
#ifdef DEBUG_VERTEX_STORE        
        strout << "\t  (Normal:" << vertex.normal << ")" << std::endl;
#endif
        // store normal
        store(vertex.normal, _normalMap, indicesPtr);
    }
    
    if(_createTexCoords)
    {
#ifdef DEBUG_VERTEX_STORE        
        strout << "\t  (TexCoord:" << vertex.texCoord << ")" << std::endl;
#endif
        // store texture coordinate
        store(vertex.texCoord, _texCoordMap, indicesPtr);
    }
    
    // increase the vertex count of the current primitive
    _vertexCount++;
    
#ifdef DEBUG_VERTEX_STORE        
    strout << "\t  (vc:" << _vertexCount << "/tvc:" << _totalVertexCount << ")]";
    SLOG << strout.str() << std::endl;
#endif
}

void osg::ExtrusionSurface::storePrimitive	(	GLenum	type,
		GeoPLengthsUI32Ptr	lensPtr,
		GeoPTypesUI8Ptr	typesPtr
	)			[inline, private]

Stores the _vertexCount into the lengths field container and the supplied primivite type into the types field container. The _vertexCount is reset to 0.

Definition at line 452 of file OSGExtrusionGeometry.inl.

References _primitiveCount, _totalVertexCount, _vertexCount, FFATAL, and osg::NullFC.

{
    assert(lensPtr != NullFC);
    assert(typesPtr != NullFC);

#ifdef DEBUG_PRIMITIVE_STORE
    switch(type)
    {
        case GL_TRIANGLE_STRIP:
            assert(_vertexCount > 2);
            assert(_vertexCount % 2 == 0);
            break;

        case GL_TRIANGLE_FAN:
            assert(_vertexCount > 2);
            break;
            
        case GL_QUADS:
            assert(_vertexCount == 4);
            break;
            
        case GL_LINES:
            assert(_vertexCount == 2);
            break;
    };
#endif
    
    if(_vertexCount != 0)
    {
        lensPtr->push_back(_vertexCount);
        typesPtr->push_back(type);
        _totalVertexCount += _vertexCount;

        // reset vertex count
        _vertexCount = 0;

        // increment primitive count (for stats only)
        _primitiveCount++;
    }
    else
    {
        FFATAL(("OSGExtrusion::storePrimitive: Tried to store empty primitive\n"));
    }
}

template<typename PType>

UInt32 osg::ExtrusionSurface::store	(	PType	property,
		std::map< PType, UInt32, vecless< PType > > &	propertyIndexMap
	)			[inline, private]

Returns a new index for the supplied property and stores it the given map

Definition at line 510 of file OSGExtrusionGeometry.inl.

References SLOG.

Referenced by store(), and storeVertex().

{
    typedef typename std::map<PType, 
                              UInt32,
                              vecless<PType> >::iterator   PTypeMapIterator;
    typedef typename std::map<PType, 
                              UInt32,
                              vecless<PType> >::value_type PTypeMapValueType;
    
    UInt32 newIndex = pIndexMap.size();
    const std::pair<PTypeMapIterator, bool>& result
        = pIndexMap.insert(PTypeMapValueType(property, newIndex));

#ifdef DEBUG_PROPERTY_STORE
    std::ostringstream strout;
    strout << "OSGExtrusion:store: Storing property:" << std::endl;
    strout << "\t"
           << result.first->first << " -> " << result.first->second
           << " (new insert: " << (result.second ? "TRUE" : "FALSE") << ")";
    SLOG << strout.str() << std::endl;
#endif

    // return index of property
    return result.first->second;
}

template<typename PType>

void osg::ExtrusionSurface::store	(	const PType	property,
		std::map< PType, UInt32, vecless< PType > > &	propertyIndexMap,
		GeoIndicesUI32Ptr	indicesPtr
	)			[inline, private]

Returns a new index for the supplied property, stores it as (property -> index) in the given map. The obtained index is directly stored in the supplied field container

Definition at line 546 of file OSGExtrusionGeometry.inl.

References osg::NullFC, and store().

{
    assert(indicesPtr != NullFC);
    indicesPtr->push_back(store(property, propertyIndexMap));
}

ExtrusionSurface::Pnt3fConstItPair osg::ExtrusionSurface::getPrevAndNextIt

(

const Pnt3fConstIt &

pIt

)

[inline, private]

Returns a pair of iterators pointing to the previous and the next spine point. The iterators are wrapped around at the ends if the spine is closed and saturated otherwise

Definition at line 100 of file OSGExtrusionGeometry.inl.

References _spine, and _spineClosed.

Referenced by calcNonUnitYAxis(), and calcNonUnitZAxis().

{
    Pnt3fConstIt prevIt, nextIt;
    bool firstPoint = (pIt == _spine.begin()) ? true : false;
    bool lastPoint  = (pIt == _spine.end() - 1) ? true : false;

    if(!firstPoint && !lastPoint)   // it's an interior point
    {
        prevIt = pIt - 1;
        nextIt = pIt + 1;
    }
    else // either it's the first or the last point
    {
        if(_spineClosed)
        {
            prevIt = _spine.end() - 2;
            nextIt = _spine.begin() + 1;
        }
        else // spine is open
        {
            if(firstPoint)
            {
                prevIt = _spine.begin();
                nextIt = _spine.begin() + 1;
            }
            else // last point
            {
                prevIt = _spine.end() - 2;
                nextIt = _spine.end() - 1;
            }
        }
    }
    return Pnt3fConstItPair(prevIt, nextIt);
}

Vec3f osg::ExtrusionSurface::calcNonUnitYAxis

(

const Pnt3fConstIt &

pIt

)

[inline, private]

Returns the non-normalized Y-Axis at pIt

Definition at line 140 of file OSGExtrusionGeometry.inl.

References getPrevAndNextIt().

Referenced by calcYAxes().

{
    /* X3D Spec:
     *
     * a. For all points other than the first or last: The Y-axis for spine[i]
     *    is found by normalizing the vector defined by
     *    (spine[i+1] - spine[i-1]). 
     * b. If the spine curve is closed: The SCP for the first and last points
     *    is the same and is found using (spine[1] - spine[n-2]) to compute
     *    the Y-axis.
     * c. If the spine curve is not closed: The Y-axis used for the first point
     *    is the vector from spine[0] to spine[1], and for the last it is the 
     *    vector from spine[n-2] to spine[n-1].
     */

    Pnt3fConstItPair prevAndNextIt = getPrevAndNextIt(pIt);
    Vec3f yAxis = *(prevAndNextIt.second) - *(prevAndNextIt.first);
    return yAxis;
}

Vec3f osg::ExtrusionSurface::calcNonUnitZAxis

(

const Pnt3fConstIt &

pIt

)

[inline, private]

Returns the non-normalized Z-Axis at pIt

Definition at line 165 of file OSGExtrusionGeometry.inl.

References osg::VectorInterface< ValueTypeT, StorageInterfaceT >::cross(), and getPrevAndNextIt().

Referenced by calcZAxes().

{
    /* X3D Spec:
     *
     * The Z-axis is determined as follows:
     *
     * d.  For all points other than the first or last: Take the following 
     *     cross-product: Z = (spine[i+1] - spine[i]) x (spine[i-1] - spine[i])
     * e.  If the spine curve is closed: The SCP for the first and last points 
     *     is the same and is found by taking the following cross-product: 
     *     Z = (spine[1] - spine[0]) x (spine[n-2] - spine[0]) 
     * f.  If the spine curve is not closed: The Z-axis used for the first
     *     spine point is the same as the Z-axis for spine[1]. The Z-axis
     *     used for the last spine point is the same as the Z-axis for
     *     spine[n-2].
     * g.  After determining the Z-axis, its dot product with the Z-axis of
     *     the previous spine point is computed. If this value is negative,
     *     the Z-axis is flipped (multiplied by -1). In most cases,
     *     this prevents small changes in the spine segment angles from
     *     flipping the cross-section 180 degrees.
     */

    Pnt3fConstItPair prevAndNextIt = getPrevAndNextIt(pIt);
    Vec3f pToNext, pToPrev;
    pToNext = *(prevAndNextIt.second) - *pIt;
    pToPrev = *(prevAndNextIt.first) - *pIt;

    // If pIt points to the first or the last point the cross-product below
    // is zero because either pToNext or pToPrev is zero in this case.
    Vec3f zAxis = pToNext.cross(pToPrev);
    return zAxis;
}

Vec3f osg::ExtrusionSurface::calcXAxis

(

const MatrixConstIt &

pIt

)

[inline, private]

Returns the normalized X-Axis at pIt

Definition at line 205 of file OSGExtrusionGeometry.inl.

References osg::VectorInterface< ValueTypeT, StorageInterfaceT >::cross(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

Referenced by calcXAxes().

{
    Vec3f yAxis((*mIt)[1]);
    Vec3f zAxis((*mIt)[2]);

    Vec3f xAxis = yAxis.cross(zAxis);
    xAxis.normalize();

    return xAxis;
}

Vec3f osg::ExtrusionSurface::calcTriangleFaceNormal	(	const Pnt3f &	a,
		const Pnt3f &	b,
		const Pnt3f &	c
	)			[inline, private]

Returns the non-normalized right handed face normal of the three points a,b,c, if _ccw is true and the negated otherwise

Definition at line 292 of file OSGExtrusionGeometry.inl.

References _ccw, and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::cross().

Referenced by calcQuadFaceNormal().

{
    Vec3f d1 = b - a;
    Vec3f d2 = c - a;
    Vec3f faceNormal = _ccw ? d1.cross(d2) : d2.cross(d1);

    return faceNormal;
}

Vec3f osg::ExtrusionSurface::calcQuadFaceNormal	(	const Pnt3f &	a,
		const Pnt3f &	b,
		const Pnt3f &	c,
		const Pnt3f &	d
	)			[inline, private]

Returns the normalized right handed face normal of the quad given by the four points a,b,c, if _ccw is true and the negated face normal otherwise

Definition at line 310 of file OSGExtrusionGeometry.inl.

References calcTriangleFaceNormal(), osg::Eps, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

Referenced by calcSweepSurfaceFaceNormals().

{
    Vec3f faceNormal = calcTriangleFaceNormal(a, b, d);
    if(faceNormal.length() > Eps)
    {
        faceNormal.normalize();
        return faceNormal;
    }

    faceNormal = calcTriangleFaceNormal(b, c, a);
    if(faceNormal.length() > Eps)
    {
        faceNormal.normalize();
        return faceNormal;
    }

    faceNormal = calcTriangleFaceNormal(c, d, b);
    if(faceNormal.length() > Eps)
    {
        faceNormal.normalize();
        return faceNormal;
    }

    // if we get here, the quad is completely degenerate and has no normal
    return Vec3f(0.f, 0.f, 0.f);
}

void osg::ExtrusionSurface::calcVertexNormal	(	Vertex *	vertexPtr,
		UInt32	faceIndex
	)			[inline, private]

Returns the normalized vertex normal obtained by averaging all face normals of adjacent faces enclosing an angle less than _creaseAngle with the face normal given by vertexPtr->adjFaceNormals[faceIndex]

Definition at line 354 of file OSGExtrusionGeometry.inl.

References _creaseAngle, osg::ExtrusionSurface::Vertex::adjFaceNormals, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::enclosedAngle(), osg::Eps, osg::ExtrusionSurface::Vertex::normal, and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

{
    assert(quadrant < 4);
    
    Vec3f refFN = vPtr->adjFaceNormals[quadrant];

    // set the vertex normal to the reference face normal
    vPtr->normal = refFN;    

    if(_creaseAngle < Eps)
    {   
        // we don't need to smooth across faces
        return;
    }

    // we need to smooth the normals
    for(UInt32 k = 0; k < 4; k++)
    {
        if(k != quadrant) // check the other 3 adjacent faces of the vertex 
        {
            Vec3f fN = vPtr->adjFaceNormals[k];
            if(refFN.enclosedAngle(fN) - Eps < _creaseAngle + Eps)
            {
                vPtr->normal += fN;
            }
        }
    }

    vPtr->normal.normalize();
}

bool ExtrusionSurface::isLeft	(	const Pnt2f &	a,
		const Pnt2f &	b
	)			[inline, private]

Definition at line 996 of file OSGExtrusionGeometry.cpp.

References osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize().

Referenced by calcWindingNumber().

{
    Vec2f d = b - a;
    d.normalize();
    // compute the normal pointing into the _right_ half plane of the oriented
    // line
    Vec2f n = Vec2f(d.y(), -d.x());
    // the dot product is >0 when two vectors point into the same direction
    return n.dot(a) > 0.f;
}

Real32 ExtrusionSurface::computeMinYAbs	(	const std::vector< Pnt2f > &	contour,
		Real32	alpha
	)			[private]

Definition at line 1013 of file OSGExtrusionGeometry.cpp.

References osg::osgabs(), osg::osgcos(), and osg::osgsin().

Referenced by calcBetterRotationAngle().

{
    const Real32 sinAlpha = osgsin(alpha);
    const Real32 cosAlpha = osgcos(alpha);

    Real32 minYAbs = 1.f;
    for(std::vector<Pnt2f>::const_iterator it = contour.begin();
        it != contour.end(); ++it)
    {
        Real32 y = sinAlpha * it->x() + cosAlpha * it->y();
        if(osgabs(y) < minYAbs)
            minYAbs = y;
    }

    return minYAbs;
}

Real32 ExtrusionSurface::calcBetterRotationAngle	(	const std::vector< Pnt2f > &	contour,
		UInt32	nAngles
	)			[private]

Definition at line 1038 of file OSGExtrusionGeometry.cpp.

References computeMinYAbs(), and osg::Pi.

Referenced by calcOptimizedContour().

{
    Real32 maxMinY = 0.f;
    Real32 bestAlpha = 0.f;

    Real32 alphaInc = 2 * Pi / nAngles;
    for(Real32 alpha = 0.f; alpha < 2 * Pi; alpha += alphaInc)
    {
        Real32 minYAlpha = computeMinYAbs(contour, alpha);
        if(minYAlpha > maxMinY)
        {
            maxMinY = minYAlpha;
            bestAlpha = alpha;
        }
    }

    return bestAlpha;
}

bool ExtrusionSurface::calcOptimizedContour	(	const std::vector< Pnt2f > &	contour,
		const Pnt2f &	point,
		std::vector< Pnt2f > *	optimizedContour
	)			[private]

Definition at line 1065 of file OSGExtrusionGeometry.cpp.

References calcBetterRotationAngle(), osg::Eps, FDEBUG, FWARNING, osg::osgabs(), osg::osgcos(), osg::osgsin(), and p.

Referenced by calcWindingNumber().

{
    // copy the input
    std::vector<Pnt2f> coords(contour);

    // translate the reference point to the origin
    // and compute a scale factor
    Real32 maxLen = std::numeric_limits<Real32>::min();
    Real32 minLen = std::numeric_limits<Real32>::max();

    for(std::vector<Pnt2f>::iterator it = coords.begin();
            it != coords.end(); ++it)
    {
        // translate the problem to the origin
        *it -= Vec2f(point);
        Real32 len = Vec2f(*it).length();

        if(len > maxLen)  maxLen = len;
        if(len < minLen)  minLen = len;
    }

    if(maxLen < Eps)
    {
        FWARNING(("OSGExtrusion:calcOptimizedContour: Contour completely degenerate\n"));
        return false;
    }

    if(minLen < Eps)
    {
        FWARNING(("OSGExtrusion:calcOptimizedContour: Reference point on curve\n"));
        return false;
    }

    // rescale the contour to the unit disk and determine the minimal
    // absolute y coordinate
    Real32 minAbsY = 1.f;
    for(std::vector<Pnt2f>::iterator it = coords.begin();
            it != coords.end(); ++it)
    {
        *it /= maxLen;
        // osgabs(it->y()) <= 1.f after rescale
        if(osgabs(it->y()) < minAbsY)
            minAbsY = osgabs(it->y());
    }

    optimizedContour->clear();
    optimizedContour->reserve(coords.size());
    
    if(minAbsY > Eps) // we can probably determine all crossings
    {
        optimizedContour->assign(coords.begin(), coords.end());
    }
    else // try to rotate the contour
    {
        // we need to rotate the contour to get a reasonable result
        FDEBUG(("OSGExtrusion:calcOptimizedContour: Contour needs rotation\n"));
        // compute the best rotation angle for 64 equal partitions 
        // of the circle
        Real32 alpha = calcBetterRotationAngle(contour, 64);
        FDEBUG(("OSGExtrusion:calcOptimizedContour: Rotation angle is: %f\n",
                alpha));

        Real32 sinAlpha = osgsin(alpha);
        Real32 cosAlpha = osgcos(alpha);

        // rotate the contour and copy it into the output vector
        for(std::vector<Pnt2f>::iterator it = coords.begin();
            it != coords.end(); ++it)
        {
            Pnt2f p;
            p[0] = cosAlpha * it->x() - sinAlpha * it->y();
            p[1] = sinAlpha * it->x() + cosAlpha * it->y();

            optimizedContour->push_back(p);
        }
    }

    // optimization successful
    return true;
}

Int32 ExtrusionSurface::calcWindingNumber	(	const std::vector< Pnt2f > &	contour,
		const Pnt2f &	point
	)			[private]

Definition at line 1156 of file OSGExtrusionGeometry.cpp.

References calcOptimizedContour(), and isLeft().

{
    Int32 windingNumber = 0;
    std::vector<Pnt2f> coords;

    // translate contour to origin and rotate it to a better position
    calcOptimizedContour(contour, point, &coords);

    const Pnt2f *prevPoint = &(coords[coords.size() - 1]);
    for(UInt32 i = 0; i < coords.size(); ++i)
    {
        const Pnt2f *curPoint = &(coords[i]);
        if(prevPoint->y() < 0.f)
        {
            // upward crossing
            if(curPoint->y() > 0.f)
            {
                if(isLeft(*prevPoint, *curPoint) == true)
                    windingNumber++;
            }
        }
        else // prevPoint->y() > 0.f
        {
            // downward crossing
            if(curPoint->y() < 0.f)
            {
                if(isLeft(*prevPoint, *curPoint) == false)
                    windingNumber--;
            }
        }
        prevPoint = curPoint;
    }

    return windingNumber;
}

void osg::ExtrusionSurface::storeFaceNormalGeo	(	GeoIndicesUI32Ptr	indicesPtr,
		GeoPLengthsUI32Ptr	lensPtr,
		GeoPTypesUI8Ptr	typesPtr
	)			[private]

Referenced by createGeometry().

void osg::ExtrusionSurface::storeVertexNormalGeo	(	GeoIndicesUI32Ptr	indicesPtr,
		GeoPLengthsUI32Ptr	lensPtr,
		GeoPTypesUI8Ptr	typesPtr
	)			[private]

Referenced by createGeometry().

---

Member Data Documentation

std::vector<Pnt2f> osg::ExtrusionSurface::_crossSection [private]

The cross section of the extrusion surface

Definition at line 265 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfaceFaceNormals(), calcSweepSurfacePositions(), calcSweepSurfaceTexCoords(), determineTopology(), ExtrusionSurface(), initGrid(), refineCrossSection(), and verifyInput().

std::vector<Quaternion> osg::ExtrusionSurface::_orientation [private]

The orientation values rotating the cross section plane (CP) in R^3

Definition at line 268 of file OSGExtrusionGeometry.h.

Referenced by calcTransforms(), createGeometry(), and ExtrusionSurface().

std::vector<Vec2f> osg::ExtrusionSurface::_scale [private]

The cross-section scale parameters of the extrusion surface

Definition at line 271 of file OSGExtrusionGeometry.h.

Referenced by calcTransforms(), ExtrusionSurface(), and refineScale().

std::vector<Pnt3f> osg::ExtrusionSurface::_spine [private]

The spine of the extrusion surface

Definition at line 274 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfaceFaceNormals(), calcSweepSurfacePositions(), calcSweepSurfaceTexCoords(), calcTransforms(), calcYAxes(), calcZAxes(), createGeometry(), determineTopology(), ExtrusionSurface(), getPrevAndNextIt(), initGrid(), refineSpine(), and verifyInput().

Real32 osg::ExtrusionSurface::_creaseAngle [private]

The crease angle of the extrusion surface

Definition at line 277 of file OSGExtrusionGeometry.h.

Referenced by calcVertexNormal().

bool osg::ExtrusionSurface::_beginCap [private]

If true, a begin cap is to be generated

Definition at line 280 of file OSGExtrusionGeometry.h.

Referenced by createGeometry().

bool osg::ExtrusionSurface::_endCap [private]

If true, an end cap is to be generated

Definition at line 283 of file OSGExtrusionGeometry.h.

Referenced by createGeometry().

bool osg::ExtrusionSurface::_ccw [private]

If true, the ordering of the generated primitives is ccw w.r.t. the generated normals

Definition at line 288 of file OSGExtrusionGeometry.h.

Referenced by calcTriangleFaceNormal().

bool osg::ExtrusionSurface::_convex [private]

If true, the cross section is assumed to be convex

Definition at line 291 of file OSGExtrusionGeometry.h.

Referenced by createGeometry().

bool osg::ExtrusionSurface::_crossSectionClosed [private]

If true, the cross section of the extrusion surface is assumend to be closed

Definition at line 297 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfaceFaceNormals(), determineTopology(), and refineCrossSection().

bool osg::ExtrusionSurface::_spineClosed [private]

If true, the spine of the extrusion surface is assumed to be closed

Definition at line 300 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfaceFaceNormals(), determineTopology(), getPrevAndNextIt(), refineScale(), and refineSpine().

bool osg::ExtrusionSurface::_spineCollinear [private]

If true, the spine contains at least one non-trivial collinear segment and all other parts consist of coinciding points

Definition at line 305 of file OSGExtrusionGeometry.h.

Referenced by calcTransforms(), calcXAxes(), and calcZAxes().

bool osg::ExtrusionSurface::_revolutionSurface [private]

If true, all points of the spine coincide

Definition at line 308 of file OSGExtrusionGeometry.h.

Referenced by calcTransforms(), calcXAxes(), and calcYAxes().

bool osg::ExtrusionSurface::_createNormals [private]

If true, normals are generated

Definition at line 311 of file OSGExtrusionGeometry.h.

Referenced by createGeometry(), and storeVertex().

bool osg::ExtrusionSurface::_createTexCoords [private]

If true, texture coordinates are generated

Definition at line 314 of file OSGExtrusionGeometry.h.

Referenced by createGeometry(), and storeVertex().

std::vector<Matrix> osg::ExtrusionSurface::_transform [private]

The affine transformations from the crossection plane to the spine aligned crossection planes

Definition at line 320 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfacePositions(), calcTransforms(), calcXAxes(), calcYAxes(), and calcZAxes().

VertexGrid osg::ExtrusionSurface::_grid [private]

The grid data structure containing the generated vertex data

Definition at line 323 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfaceFaceNormals(), calcSweepSurfacePositions(), calcSweepSurfaceTexCoords(), and initGrid().

PositionMap osg::ExtrusionSurface::_posMap [private]

The map containing (position, index) pairs for the extrusion surface

Definition at line 326 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfacePositions(), createGeometry(), and storeVertex().

NormalMap osg::ExtrusionSurface::_normalMap [private]

The map containing (vertex normal, index) pairs for the extrusion surface

Definition at line 331 of file OSGExtrusionGeometry.h.

Referenced by createGeometry(), and storeVertex().

TexCoordMap osg::ExtrusionSurface::_texCoordMap [private]

The map containing (tex coord, index) pairs for the extrusion surface

Definition at line 336 of file OSGExtrusionGeometry.h.

Referenced by calcSweepSurfaceTexCoords(), createGeometry(), and storeVertex().

UInt32 osg::ExtrusionSurface::_vertexCount [private]

The number of vertices stored in the current primitive

Definition at line 339 of file OSGExtrusionGeometry.h.

Referenced by storePrimitive(), and storeVertex().

UInt32 osg::ExtrusionSurface::_totalVertexCount [private]

The total number of vertices which have been stored until now

Definition at line 342 of file OSGExtrusionGeometry.h.

Referenced by createGeometry(), storePrimitive(), and storeVertex().

UInt32 osg::ExtrusionSurface::_primitiveCount [private]

The total number of primitives stored in the geometry

Definition at line 345 of file OSGExtrusionGeometry.h.

Referenced by createGeometry(), and storePrimitive().

---

The documentation for this class was generated from the following files:

• OSGExtrusionGeometry.h
• OSGExtrusionGeometry.cpp
• OSGExtrusionGeometry.inl