osg::DVRClipper Class Reference

#include <OSGDVRClipper.h>

List of all members.

Public Member Functions
	DVRClipper (void)
	~DVRClipper (void)
void	clipSlice (DVRVolume *volume, DVRSlice &slice, const Vec3f &slicingNormal, Real32 dist2RefPlane, DVRRenderSlice &clippedSlice)
	clips the slice
void	initialize (DVRVolume *volume)
	initialize the clipper
void	reset (DVRVolume *volume)
	Reset objects state.
void	setReferencePlane (const Plane &refPlane)
const Plane &	getReferencePlane () const
bool	setNumAddPerVertexAttr (DVRVolume *volume, UInt32 additionalPerVertexAttributes)
	set the number of additional per vertex attributes
Private Attributes
bool	hasTesselatorSupport
	GLUtesselator available?
GLdouble *	sliceVertexData
Plane	refPlane
UInt32	numAddPerVertexAttr

---

Detailed Description

Definition at line 13 of file OSGDVRClipper.h.

---

Constructor & Destructor Documentation

DVRClipper::DVRClipper

(

void

)

Definition at line 28 of file OSGDVRClipper.cpp.

References GLdouble, hasTesselatorSupport, numAddPerVertexAttr, and sliceVertexData.

{
    myTess = NULL;
    // allocate temp. storage for 6 vertex positions and texture coordinates
    sliceVertexData = (GLdouble*)malloc(6*6*sizeof(GLdouble));

    numAddPerVertexAttr  = 0;
    hasTesselatorSupport = false;
}

DVRClipper::~DVRClipper

(

void

)

Definition at line 38 of file OSGDVRClipper.cpp.

References sliceVertexData.

{
    if(myTess)
        gluDeleteTess(myTess);

    free(sliceVertexData);
}

---

Member Function Documentation

void DVRClipper::clipSlice	(	DVRVolume *	volume,
		DVRSlice &	slice,
		const Vec3f &	slicingNormal,
		Real32	dist2RefPlane,
		DVRRenderSlice &	clippedSlice
	)

Definition at line 187 of file OSGDVRClipper.cpp.

References osg::DVRRenderSlice::clear(), osg::DVRTriangle::contourNeighbour, osg::DVRTriangle::cutPoint, osg::DVRClipObjects::Difference, DVRVOLUME_PARAMETER, osg::DVRSlice::getTextureScale(), osg::DVRSlice::getTextureTranslate(), osg::PointInterface< ValueTypeT, StorageInterfaceT >::getValues(), osg::DVRSlice::getVertex(), osg::DVRSlice::getVertexCount(), hasTesselatorSupport, osg::NullFC, numAddPerVertexAttr, osg::DVRClipObjects::Off, sliceVertexData, osg::DVRRenderSlicePrimitive::type, and osg::DVRRenderSlicePrimitive::vertices.

Referenced by osg::Brick::render2DSliceXY(), osg::Brick::render2DSliceXZ(), osg::Brick::render2DSliceYZ(), and osg::Brick::render3DSlices().

{
    const Vec3f &texScale     = unclippedSlice.getTextureScale    ();
    const Vec3f &texTranslate = unclippedSlice.getTextureTranslate();

    // get clip objects
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);

    // nothing to clip with?
    if(clipObjects == NullFC)
    {
        DVRRenderSlicePrimitive *newPrimitive =  new DVRRenderSlicePrimitive();

        newPrimitive->type = GL_TRIANGLE_FAN;

        for(UInt32 i = 0; i < unclippedSlice.getVertexCount(); i++)
        {
            UInt32 idx = (6+numAddPerVertexAttr)*i;
            sliceVertexData[idx    ] = 
                unclippedSlice.getVertex(i).getValues()[0];

            sliceVertexData[idx + 1] = 
                unclippedSlice.getVertex(i).getValues()[1];

            sliceVertexData[idx + 2] =
                unclippedSlice.getVertex(i).getValues()[2];


            // set (standard) texture coordinates
            sliceVertexData[idx + 3] = 
                texScale[0] * 
                unclippedSlice.getVertex(i).getValues()[0] + 
                texTranslate[0];

            sliceVertexData[idx + 4] = 
                texScale[1] * 
                unclippedSlice.getVertex(i).getValues()[1] + 
                texTranslate[1];

            sliceVertexData[idx + 5] = 
                texScale[2] * 
                unclippedSlice.getVertex(i).getValues()[2] + 
                texTranslate[2];      

            newPrimitive->vertices.push_back(&sliceVertexData[idx]);
        }

        clippedSlice.push_back(newPrimitive);
        
        return;
    }

    if(!hasTesselatorSupport)
        return;

    // render colored contours only (usefull for debugging)
    if(clipObjects->getDoContours())
    {
        glDisable(GL_TEXTURE   );
        glDisable(GL_LIGHTING  );

        glBegin  (GL_LINE_STRIP);  
        {
            int col = 0;
            
            for(UInt32 i = 0; i < unclippedSlice.getVertexCount(); i++)
            {      
                glColor3f(col % 3 == 0 ? 1.0f : 0.0f, 
                          col % 3 == 1 ? 1.0f : 0.0f, 
                          col % 3 == 2 ? 1.0f : 0.0f);
                
                col++;
                
                glVertex3fv(unclippedSlice.getVertex(i).getValues());
            }
        }
        glEnd();
   
        bool clipAwayOutside = 
            clipObjects->getClipMode() == DVRClipObjects::Difference;
    
        for(UInt32 i = 0; i < clipObjects->count(); i++)
        {
            // get i-th clip object
            DVRClipGeometryPtr clipObject = clipObjects->get(i);
      
            // compute the contours of the triangles intersecting the 
            // current slice

            const DVRTriangleList &contours = 
                clipObject->getContours(dist2RefPlane,
                                        !clipAwayOutside,
                                        slicingNormal);     
      
            if(!contours.empty())
            {
                DVRTriangle *current;
                DVRTriangle *contourStart;
    
                // iterate over all contours
                DVRTriangleList::const_iterator contoursIt;

                for(contoursIt  = contours.begin(); 
                    contoursIt != contours.end  (); 
                    contoursIt++)
                { 
                    contourStart = current = *contoursIt;    
      
                    glBegin(GL_LINE_STRIP);   
                    {
                        int col = 0;
                        
                        // iterate over all triangles in the current contour
                        do
                        {              
                            glColor3f(col % 3 == 0 ? 1.0f : 0.0f, 
                                      col % 3 == 1 ? 1.0f : 0.0f, 
                                      col % 3 == 2 ? 1.0f : 0.0f);

                            col++;

                            glVertex3dv(current->cutPoint);

                            current = current->contourNeighbour;

                        } while(current!= contourStart);
                    }
                    glEnd();
                }
            }
        }
        
        glEnable(GL_TEXTURE );
        glEnable(GL_LIGHTING);
        
    }
    else
    {
        // tesselate and render the clipped slices

        // set the slice normal for tesselation
        gluTessNormal(myTess, 
                      slicingNormal[0], 
                      slicingNormal[1], 
                      slicingNormal[2]);    
        
        clippedSlice.clear();
        
        gluTessBeginPolygon(myTess, &clippedSlice);
    
        // set the slice's base contour
        gluTessBeginContour(myTess);
        
        for(UInt32 i = 0; i < unclippedSlice.getVertexCount(); i++)
        {       
            UInt32 idx = (6 + numAddPerVertexAttr) * i;

            sliceVertexData[idx    ] = 
                unclippedSlice.getVertex(i).getValues()[0];

            sliceVertexData[idx + 1] = 
                unclippedSlice.getVertex(i).getValues()[1];

            sliceVertexData[idx + 2] = 
                unclippedSlice.getVertex(i).getValues()[2];

            // set (standard) texture coordinates
            sliceVertexData[idx + 3] = 
                texScale[0] *
                unclippedSlice.getVertex(i).getValues()[0] + 
                texTranslate[0];

            sliceVertexData[idx + 4] = 
                texScale[1] * 
                unclippedSlice.getVertex(i).getValues()[1] + 
                texTranslate[1];

            sliceVertexData[idx + 5] = 
                texScale[2] * 
                unclippedSlice.getVertex(i).getValues()[2] +
                texTranslate[2];

            gluTessVertex(myTess, 
                          &sliceVertexData[idx], 
                          &sliceVertexData[idx]);
        }
        
        gluTessEndContour(myTess);
        
        // set contours of clip objects
        if(clipObjects->getClipMode() != DVRClipObjects::Off)
        {
            // get clip mode
            bool clipAwayOutside = 
                clipObjects->getClipMode() == DVRClipObjects::Difference;
      
            // add the contours of the intersections of the clip geometries 
            // with the slice
            for(UInt32 i = 0; i < clipObjects->count(); i++)
            {
                // get i-th clip object
                DVRClipGeometryPtr clipObject = clipObjects->get(i);
    
                // compute the contours of the triangles intersecting 
                // the current slice

                const DVRTriangleList &contours = 
                    clipObject->getContours( dist2RefPlane,
                                            !clipAwayOutside,
                                             slicingNormal);       
    
                if(!contours.empty())
                {
                    DVRTriangle *current;
                    DVRTriangle *contourStart;
      
                    // iterate over all contours
                    DVRTriangleList::const_iterator contoursIt;

                    for(contoursIt  = contours.begin(); 
                        contoursIt != contours.end  (); 
                        contoursIt++)
                    { 
                        contourStart = current = *contoursIt;
                
                        // start new contour
                        gluTessBeginContour(myTess);
        
                        // iterate over all triangles in the current contour
                        do
                        {       
                            // set (standard) texture coordinates
                            current->cutPoint[3] = 
                                texScale[0] * 
                                current->cutPoint[0] + 
                                texTranslate[0];

                            current->cutPoint[4] = 
                                texScale[1] * 
                                current->cutPoint[1] + 
                                texTranslate[1];

                            current->cutPoint[5] = 
                                texScale[2] * 
                                current->cutPoint[2] + 
                                texTranslate[2];

                            if(!current->cutPoint)
                                std::cerr << "WTF: cutPoint is NULL"
                                          << std::endl;

                            gluTessVertex(myTess, 
                                          current->cutPoint, 
                                          current->cutPoint);

                            current = current->contourNeighbour;

                        } while(current != contourStart);
        
                        gluTessEndContour(myTess);
                    }
                }
            }
        }
        
        gluTessEndPolygon(myTess);
    }
}

void DVRClipper::initialize

(

DVRVolume *

volume

)

Definition at line 100 of file OSGDVRClipper.cpp.

References beginCallback(), DVRVOLUME_PARAMETER, endCallback(), errorCallback(), hasTesselatorSupport, osg::NullFC, vertexCallback(), and vertexCombineCallback().

Referenced by osg::DVRVolume::draw().

{
    if(volume == NULL)
        return;
 
    // get clip objects
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);
  
    if(clipObjects == NullFC)
        return;
  
    if(!hasTesselatorSupport)
    {
        // check for glu tesselator support
        hasTesselatorSupport = (atof((char*)gluGetString(GLU_VERSION)) >= 1.2);
        
        if(!hasTesselatorSupport)
            return;
    }

    if(myTess == NULL)
    {
        myTess = gluNewTess();

        // registering callback functions for glu tesselator...
        gluTessCallback(myTess, 
                        GLU_TESS_COMBINE_DATA, 
                        reinterpret_cast<OSGGLUfuncptr>(vertexCombineCallback));

        gluTessCallback(myTess, 
                        GLU_TESS_VERTEX_DATA, 
                        reinterpret_cast<OSGGLUfuncptr>(vertexCallback));

        gluTessCallback(myTess, 
                        GLU_TESS_BEGIN_DATA,
                        reinterpret_cast<OSGGLUfuncptr>(beginCallback));

        gluTessCallback(myTess, 
                        GLU_TESS_END_DATA, 
                        reinterpret_cast<OSGGLUfuncptr>(endCallback));

        gluTessCallback(myTess, 
                        GLU_TESS_ERROR, 
                        reinterpret_cast<OSGGLUfuncptr>(errorCallback));
    
    }
  
}

void DVRClipper::reset

(

DVRVolume *

volume

)

Definition at line 150 of file OSGDVRClipper.cpp.

References DVRVOLUME_PARAMETER, hasTesselatorSupport, osg::DVRClipObjects::Intersection, and osg::NullFC.

Referenced by osg::DVRVolume::draw(), and osg::Brick::render3DSlices().

{
    if(volume == NULL || !hasTesselatorSupport)
        return;
 
    // get clip objects
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);
  
    if(clipObjects == NullFC)
        return;
  
    // set tesselator properties according to clip mode
    if(clipObjects->getClipMode() == DVRClipObjects::Intersection)
    {
        gluTessProperty(myTess, 
                        GLU_TESS_WINDING_RULE, 
                        GLU_TESS_WINDING_ABS_GEQ_TWO);
    }
    else
    {
        gluTessProperty(myTess, 
                        GLU_TESS_WINDING_RULE, 
                        GLU_TESS_WINDING_POSITIVE);
    }
  
    // reset local data
    for(UInt32 i = 0; i < clipObjects->count(); i++)
    {    
        // reset i-th clip object
        DVRClipGeometryPtr clipObject = clipObjects->get(i);

        clipObject->resetLocalData     ();  
        clipObject->computeSeedVertices();
    }
}

void DVRClipper::setReferencePlane

(

const Plane &

refPlane

)

Definition at line 46 of file OSGDVRClipper.cpp.

References FDEBUG, osg::Plane::getDistanceFromOrigin(), osg::Plane::getNormal(), refPlane, and osg::Plane::set().

Referenced by osg::DVRVolume::initializeClipObjects().

{
    FDEBUG(("pre DVRVolume::setRefPlane - %f %f %f : %f\n",
            rP.getNormal()[0], 
            rP.getNormal()[1], 
            rP.getNormal()[2], 
            rP.getDistanceFromOrigin()));

    refPlane.set(rP.getNormal(), rP.getDistanceFromOrigin());
    
    FDEBUG(("post DVRVolume::setRefPlane - %f %f %f : %f\n",
            refPlane.getNormal()[0], 
            refPlane.getNormal()[1], 
            refPlane.getNormal()[2], 
            refPlane.getDistanceFromOrigin()));
}

const Plane & DVRClipper::getReferencePlane

(

)

const

Definition at line 63 of file OSGDVRClipper.cpp.

References refPlane.

Referenced by osg::Brick::render2DSliceXY(), osg::Brick::render2DSliceXZ(), and osg::Brick::render2DSliceYZ().

{
    return refPlane;
}

bool DVRClipper::setNumAddPerVertexAttr	(	DVRVolume *	volume,
		UInt32	additionalPerVertexAttributes
	)

basically there are two attributes available, the vertex position and a 3D texture coordinate. If one needs additional attributes, e.g. color, texture coordinates,.., the number of (double) values needed has to be set with this function.

Definition at line 69 of file OSGDVRClipper.cpp.

References DVRVOLUME_PARAMETER, GLdouble, osg::NullFC, numAddPerVertexAttr, and sliceVertexData.

{
    numAddPerVertexAttr = additionalPerVertexAttributes;

    sliceVertexData = (GLdouble*) realloc(
        sliceVertexData,
        6 * (6 + additionalPerVertexAttributes) * sizeof(GLdouble));
  
    if(!sliceVertexData)
        return false;

    // get clip objects
    DVRClipObjectsPtr clipObjects = DVRVOLUME_PARAMETER(volume, 
                                                        DVRClipObjects);
  
    if(clipObjects == NullFC)
        return true;

    for(UInt32 i = 0; i < clipObjects->count(); i++)
    {    
        DVRClipGeometryPtr clipObject = clipObjects->get(i);

        if(!clipObject->setNumAddPerVertexAttr(additionalPerVertexAttributes))
            return false;      
    }  
    return true;
}

---

Member Data Documentation

bool osg::DVRClipper::hasTesselatorSupport [private]

Definition at line 53 of file OSGDVRClipper.h.

Referenced by clipSlice(), DVRClipper(), initialize(), and reset().

GLdouble* osg::DVRClipper::sliceVertexData [private]

Definition at line 62 of file OSGDVRClipper.h.

Referenced by clipSlice(), DVRClipper(), setNumAddPerVertexAttr(), and ~DVRClipper().

Plane osg::DVRClipper::refPlane [private]

Definition at line 65 of file OSGDVRClipper.h.

Referenced by getReferencePlane(), and setReferencePlane().

UInt32 osg::DVRClipper::numAddPerVertexAttr [private]

Definition at line 68 of file OSGDVRClipper.h.

Referenced by clipSlice(), DVRClipper(), and setNumAddPerVertexAttr().

---

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

• OSGDVRClipper.h
• OSGDVRClipper.cpp