SoPolyhedron Class Reference

SoPolyhedron is an Inventor encapsulation of the HepPolyedron class written by E.Chernyaev. More...

#include <SoPolyhedron.h>

Inheritance diagram for SoPolyhedron:

Collaboration diagram for SoPolyhedron:

Classes
struct	Vertex

Public Member Functions
	SoPolyhedron ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
	SoPolyhedron (const SbPolyhedron &)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
	SoPolyhedron (const SbPolyhedron *)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
long	hasVertex (Vertex *vertices, long len, Vertex &v)
void	makeShape (SbPolyhedron *)
virtual void	generateAlternateRep ()
virtual void	clearAlternateRep ()

Static Public Member Functions
static void	initClass ()

Public Attributes
SoSFNode	alternateRep
Vertex *	m_vertices {nullptr}
long *	m_indices {nullptr}
long	m_vcount {0}
long	m_icount {0}

Protected Member Functions
virtual void	computeBBox (SoAction *, SbBox3f &, SbVec3f &)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
virtual void	generatePrimitives (SoAction *)
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//
virtual	~SoPolyhedron ()
	!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Private Member Functions
	SO_NODE_HEADER (SoPolyhedron)

Private Attributes
std::unique_ptr< SbPolyhedron >	m_polyhedron

Detailed Description

SoPolyhedron is an Inventor encapsulation of the HepPolyedron class written by E.Chernyaev.

In particular SoPolyhedron permits to represent boolean operations over solids. To avoid clashes with other libraries (Geant4) where the HepPolyhedron classes may be found, the HepPolyhedron (through usage of CPP macros) had been renamed SbPolyhedron in the HEPVis lib. The solids are modeled with SbPolyedron objects. The SbPolyhedron permits to produce a new SbPolyhedron according to the boolean operation done on them. The resulting SbPolyhedron is then given to an SoPolyhedron for rendering. Note that a boolean operation could be rendered in wire frame by drawing the contour of the resulting solid (not by drawing the wire frame of a triangulation). See the applications/Polyhedron example.

Definition at line 49 of file SoPolyhedron.h.

Constructor & Destructor Documentation

SoPolyhedron() [1/3]

SoPolyhedron::SoPolyhedron

(

)

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 56 of file SoPolyhedron.cxx.

{
  SO_NODE_CONSTRUCTOR(SoPolyhedron);
  //  SO_NODE_ADD_FIELD(solid,(TRUE));
  //  SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
  SO_NODE_ADD_FIELD(alternateRep,(NULL));
  setNodeType(EXTENSION);
}

SoPolyhedron() [2/3]

SoPolyhedron::SoPolyhedron

(

const SbPolyhedron &

aPolyhedron

)

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 68 of file SoPolyhedron.cxx.

{
  SO_NODE_CONSTRUCTOR(SoPolyhedron);
  //  SO_NODE_ADD_FIELD(solid,(TRUE));
  //  SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
  SO_NODE_ADD_FIELD(alternateRep,(NULL));
 
  m_polyhedron = std::make_unique<SbPolyhedron>(aPolyhedron);
  setNodeType(EXTENSION);
  makeShape(m_polyhedron.get());
}

SoPolyhedron() [3/3]

SoPolyhedron::SoPolyhedron

(

const SbPolyhedron *

aPolyhedron

)

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 84 of file SoPolyhedron.cxx.

{
  SO_NODE_CONSTRUCTOR(SoPolyhedron);
  //  SO_NODE_ADD_FIELD(solid,(TRUE));
  //  SO_NODE_ADD_FIELD(reducedWireFrame,(TRUE));
  SO_NODE_ADD_FIELD(alternateRep,(NULL));
 
  m_polyhedron = std::make_unique<SbPolyhedron>(*aPolyhedron);
  setNodeType(EXTENSION);
  makeShape(m_polyhedron.get());
}

~SoPolyhedron()

SoPolyhedron::~SoPolyhedron ( )

protectedvirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 100 of file SoPolyhedron.cxx.

{
  if(m_vertices)
   delete [] m_vertices;
  if(m_indices)
   delete [] m_indices;
}

Member Function Documentation

clearAlternateRep()

void SoPolyhedron::clearAlternateRep ( )

virtual

Definition at line 415 of file SoPolyhedron.cxx.

{
  alternateRep.setValue(NULL);
  //Hmm... no ref/unref??
}

computeBBox()

void SoPolyhedron::computeBBox ( SoAction * , SbBox3f & aBox, SbVec3f & aCenter )

protectedvirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

Definition at line 285 of file SoPolyhedron.cxx.

{
  if(!m_polyhedron) return;
  if(m_polyhedron->GetNoFacets()<=0) { // Abnormal polyhedron.
    SbVec3f vmin(-1,-1,-1);
    SbVec3f vmax( 1, 1, 1);
    aBox.setBounds(vmin,vmax);
    aCenter.setValue(0,0,0);
  } else {
    //    SbBool wireFrame = (solid.getValue()==TRUE ? FALSE : TRUE);
    //DONOTHING HEPVis::SbProjector projector(wireFrame?fProjection:SbProjectionNone);
    SbBool first = TRUE;
    float xmn = 0,ymn = 0,zmn = 0;
    float xmx = 0,ymx = 0,zmx = 0;
    float xct = 0,yct = 0,zct = 0;
    SbVec3f point;
    int count = 0;
    // Assume all facets are convex quadrilaterals :
    bool notLastFace;
    do {
      HVNormal3D unitNormal;
      notLastFace = m_polyhedron->GetNextUnitNormal(unitNormal);
      bool notLastEdge;
      do {
        HVPoint3D vertex;
        int edgeFlag = 1;
        notLastEdge = m_polyhedron->GetNextVertex(vertex,edgeFlag);
        point.setValue(vertex[0],vertex[1],vertex[2]);
        //DONOTHING projector.project(1,&point);
        if(first==TRUE) {
          xct = xmx = xmn = point[0];
          yct = ymx = ymn = point[1];
          zct = zmx = zmn = point[2];
          count++;
          first = FALSE;
        } else {
          xmn = SbMinimum(xmn,point[0]);
          ymn = SbMinimum(ymn,point[1]);
          zmn = SbMinimum(zmn,point[2]);
          //
          xmx = SbMaximum(xmx,point[0]);
          ymx = SbMaximum(ymx,point[1]);
          zmx = SbMaximum(zmx,point[2]);
          //
          xct += point[0];
          yct += point[1];
          zct += point[2];
          count++;
        }
        //
      } while (notLastEdge);
    } while (notLastFace);
    SbVec3f vmin(xmn,ymn,zmn);
    SbVec3f vmax(xmx,ymx,zmx);
    aBox.setBounds(vmin,vmax);
 
    if(count==0) {
        aCenter.setValue(0,0,0);
    }
    else {
        aCenter.setValue(xct/count,yct/count,zct/count);
    }
    //DEBUG
//    std::cout << "vmin: " << xmn << " " << ymn << " " << zmn << std::endl;
//    std::cout << "vmax: " << xmx << " " << ymx << " " << zmx << std::endl;
  }
 
 
}

generateAlternateRep()

void SoPolyhedron::generateAlternateRep ( )

virtual

Definition at line 373 of file SoPolyhedron.cxx.

{
 if (alternateRep.getValue())
  clearAlternateRep();
 if( m_polyhedron && ( m_polyhedron->GetNoFacets() > 0 ) ){
  //SoSeparator *sep = new SoSeparator;
  SoVertexProperty *vertices = new SoVertexProperty();
 
  //Retreive geometry from polyhedron
  int vno = m_polyhedron->GetNoVertices();
  for(int i = 0; i < vno; i++){
   HVPoint3D vertex;
   vertex = m_polyhedron->GetVertex(i + 1);
   vertices->vertex.set1Value (i, vertex[0], vertex[1], vertex[2]);
  }
 
  int  fno = m_polyhedron->GetNoFacets();
  int  fcr = 0;
  int* aface = new int[8 * fno];
  for(int i = 0; i < fno; i++){
      int n, inodes[4];
      //SbVec3d nr = m_polyhedron->GetNormal(i + 1); // not used, gives warning, commenting out:
      //---
      m_polyhedron->GetFacet(i + 1, n, inodes);
      aface[fcr] = (inodes[0] <= vno) ? (inodes[0] - 1) : (0); fcr++;
      aface[fcr] = (inodes[1] <= vno) ? (inodes[1] - 1) : (0); fcr++;
      aface[fcr] = (inodes[2] <= vno) ? (inodes[2] - 1) : (0); fcr++;
      if(n == 4) { aface[fcr] = (inodes[3] <= vno) ? (inodes[3] - 1) : (0); fcr++; }
      aface[fcr] = -1; fcr++;
  }
  SoIndexedFaceSet * faceset = new SoIndexedFaceSet;
  faceset->coordIndex.setValues(0, fcr, aface);
  delete [] aface;
  faceset->vertexProperty = vertices;
  //sep->addChild(faceset);
  alternateRep.setValue(faceset);
 }
}

generatePrimitives()

void SoPolyhedron::generatePrimitives ( SoAction * aAction )

protectedvirtual

!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!//

• Activate this comment if u gona return to old method

Definition at line 111 of file SoPolyhedron.cxx.

{
  if(!m_polyhedron) return;
  if(m_polyhedron->GetNoFacets()<=0) return; // Abnormal polyhedron.
 
  SoState *state = aAction->getState();
  if (!state)
    return;
  SbBool useTexFunction =
    (SoTextureCoordinateElement::getType(state) ==
     SoTextureCoordinateElement::FUNCTION);
  const SoTextureCoordinateElement *tce = NULL;
  SbVec4f texCoord;
  if (useTexFunction) {
    tce = SoTextureCoordinateElement::getInstance(state);
  } else {
    texCoord[2] = 0.0;
    texCoord[3] = 1.0;
  }
 
  //  if(solid.getValue()==TRUE) {
  if(true) {
    SoPrimitiveVertex pv;
    SbVec3f point, normal;
    //----------------------------------------
#define GEN_VERTEX(pv,x,y,z,s,t,nx,ny,nz)  \
  point.setValue(x,y,z);                   \
  normal.setValue(nx,ny,nz);               \
  if (useTexFunction) {                    \
    texCoord=tce->get(point,normal);       \
  } else {                                 \
    texCoord[0]=s;                         \
    texCoord[1]=t;                         \
  }                                        \
  pv.setPoint(point);                      \
  pv.setNormal(normal);                    \
  pv.setTextureCoords(texCoord);           \
  shapeVertex(&pv);
  //----------------------------------------
   // For pick action use old method, for for see selected lines
   if ( aAction->getTypeId().isDerivedFrom(SoPickAction::getClassTypeId()) ){  //comment this line to return on old method
    // Assume all facets are convex quadrilaterals :
    bool notLastFace;
    do {
      HVNormal3D unitNormal;
      notLastFace = m_polyhedron->GetNextUnitNormal(unitNormal);
 
      beginShape(aAction,POLYGON);
      bool notLastEdge;
      int edgeFlag = 1;
      do {
        HVPoint3D vertex;
        notLastEdge = m_polyhedron->GetNextVertex(vertex,edgeFlag);
        GEN_VERTEX(pv,
                   vertex[0],
                   vertex[1],
                   vertex[2],
                   0.0,0.0,
                   unitNormal[0],
                   unitNormal[1],
                   unitNormal[2]);
      } while (notLastEdge);
      endShape();
    } while (notLastFace);  
   }
   else
   {
    if(m_vertices){
     glEnableClientState(GL_VERTEX_ARRAY);
      glVertexPointer(3, GL_FLOAT, sizeof(Vertex), &m_vertices[0].pos);
     glEnableClientState(GL_NORMAL_ARRAY);
      glNormalPointer(GL_FLOAT,    sizeof(Vertex), &m_vertices[0].nor);
     //For I-Method. Comment it if u use II-Method
     //glDrawElements(GL_TRIANGLES, m_icount, GL_UNSIGNED_INT, m_indices);  //comment it if u use II-Method
     //For II-Method. Comment it if u use I-Method
     glDrawArrays(GL_TRIANGLES, 0, m_vcount);  //comment it if u use I-Method
     glDisableClientState(GL_VERTEX_ARRAY);
     glDisableClientState(GL_NORMAL_ARRAY);
    }
   }  //End of comment for return to old method */
  } else {//lala
//     SoPrimitiveVertex pvb,pve;
//     pve.setTextureCoords(texCoord);
//     pvb.setTextureCoords(texCoord);
 
// #ifdef __COIN__ // To bypass a bug in invokeLineSegment when picking.
//     beginShape(aAction,POLYGON);
//     endShape();
// #endif
 
//     SbVec3f point;
//     bool notLastFace;
//     do {
//       HVNormal3D unitNormal;
//       notLastFace = m_polyhedron->GetNextUnitNormal(unitNormal);
 
//       SbVec3f normal;
//       if( false ) {
//         normal.setValue(0,0,1);
//       } else {
//         normal.setValue(unitNormal[0],unitNormal[1],unitNormal[2]);
//       }
 
//       // Treat edges :
//       int edgeFlag = 1;
//       int prevEdgeFlag = edgeFlag;
//       bool notLastEdge;
//       SbBool firstEdge = TRUE;
//       do {
//         HVPoint3D vertex;
//         notLastEdge = m_polyhedron->GetNextVertex(vertex,edgeFlag);
//         if(reducedWireFrame.getValue()==FALSE) edgeFlag = 1;
//         if(firstEdge) {
//           if(edgeFlag) {
//             pvb.setNormal(normal);
//             point.setValue(vertex[0],vertex[1],vertex[2]);
//             //DONOTHING projector.project(1,&point);
//             pvb.setPoint(point);
//           } else {
//           }
//           firstEdge = FALSE;
//           prevEdgeFlag = edgeFlag;
//         } else {
//           if(edgeFlag!=prevEdgeFlag) {
//             if(edgeFlag) { // Pass to a visible edge :
//               pvb.setNormal(normal);
//               point.setValue(vertex[0],vertex[1],vertex[2]);
//               //DONOTHING projector.project(1,&point);
//               pvb.setPoint(point);
//             } else { // Pass to an invisible edge :
//               pve.setNormal(normal);
//               point.setValue(vertex[0],vertex[1],vertex[2]);
//               //DONOTHING projector.project(1,&point);
//               pve.setPoint(point);
//               invokeLineSegmentCallbacks(aAction,&pvb,&pve);
//             }
//             prevEdgeFlag = edgeFlag;
//           } else {
//             if(edgeFlag) {
//               pve.setNormal(normal);
//               point.setValue(vertex[0],vertex[1],vertex[2]);
//               //DONOTHING projector.project(1,&point);
//               pve.setPoint(point);
//               invokeLineSegmentCallbacks(aAction,&pvb,&pve);
//               pvb = pve;
//             } else {
//             }
//           }
//         }
//       } while (notLastEdge);
//       } while (notLastFace);
  }
 
  if (state&&state->isElementEnabled(SoGLCacheContextElement::getClassStackIndex())) {
    //Encourage auto caching
    SoGLCacheContextElement::shouldAutoCache(state, SoGLCacheContextElement::DO_AUTO_CACHE);
#if ((COIN_MAJOR_VERSION>=3)||((COIN_MAJOR_VERSION==2)&&(COIN_MINOR_VERSION>=5)))
    SoGLCacheContextElement::incNumShapes(state);
#endif
  }
}

hasVertex()

long SoPolyhedron::hasVertex ( Vertex * vertices, long len, Vertex & v )

inline

Definition at line 424 of file SoPolyhedron.cxx.

                                                                        {
 for(long i = 0; i < len; i++){
  if((v.pos[0] == vertices[i].pos[0]) && (v.pos[1] == vertices[i].pos[1]) && (v.pos[2] == vertices[i].pos[2]) &&
     (v.nor[0] == vertices[i].nor[0]) && (v.nor[1] == vertices[i].nor[1]) && (v.nor[2] == vertices[i].nor[2]))
   return i;
 }
 return -1;
}

initClass()

void SoPolyhedron::initClass ( )

static

Definition at line 47 of file SoPolyhedron.cxx.

{
  [[maybe_unused]] static const bool didInit = [&]() {
    SO_NODE_INIT_CLASS(SoPolyhedron,SoShape,"Shape");
    return true;
  }();
}

makeShape()

void SoPolyhedron::makeShape

(

SbPolyhedron *

sp

)

Definition at line 517 of file SoPolyhedron.cxx.

{
 if(!sp || (m_polyhedron->GetNoFacets() < 1))
  return;
 
 if(m_vertices){
  delete [] m_vertices;
  m_vertices = 0;
  m_vcount = 0;
 }
 
 if(m_indices){
  delete [] m_indices;
  m_indices = 0;
  m_icount = 0;
 }
 
 int   fno = m_polyhedron->GetNoFacets();
 long  faces = 0;   //this is primitive face(triangle)
 for(int i = 0; i < fno; i++){
  int n, inodes[4];
  m_polyhedron->GetFacet(i + 1, n, inodes);
  if(n == 3)
   faces += 1;
  else if(n == 4)
   faces += 2;
 }
 
 if(faces < 1)
  return;
 
 long fcr = 0;
 long vno = m_polyhedron->GetNoVertices();
 m_vcount = 3 * faces;
 m_vertices = new Vertex[m_vcount];
 for(int i = 0; i < fno; i++){
  int n, inodes[4];
  HVPoint3D  pos[4];
 
  // rbianchi
  //  SbVec3f nor = m_polyhedron->GetNormal(i + 1);
  HVNormal3D nor = m_polyhedron->GetNormal(i + 1);
  //---
  m_polyhedron->GetFacet(i + 1, n, inodes);
  pos[0] = (inodes[0] <= vno) ? (m_polyhedron->GetVertex(inodes[0])) : (m_polyhedron->GetVertex(1));
  pos[1] = (inodes[1] <= vno) ? (m_polyhedron->GetVertex(inodes[1])) : (m_polyhedron->GetVertex(1));
  pos[2] = (inodes[2] <= vno) ? (m_polyhedron->GetVertex(inodes[2])) : (m_polyhedron->GetVertex(1));
  if(n == 4)
   pos[3] = (inodes[3] <= vno) ? (m_polyhedron->GetVertex(inodes[3])) : (m_polyhedron->GetVertex(1));
 
  if(n >= 3){
   m_vertices[fcr].pos[0] = pos[0][0]; m_vertices[fcr].nor[0] = nor[0];
   m_vertices[fcr].pos[1] = pos[0][1]; m_vertices[fcr].nor[1] = nor[1];
   m_vertices[fcr].pos[2] = pos[0][2]; m_vertices[fcr].nor[2] = nor[2];
   fcr++;
   m_vertices[fcr].pos[0] = pos[1][0]; m_vertices[fcr].nor[0] = nor[0];
   m_vertices[fcr].pos[1] = pos[1][1]; m_vertices[fcr].nor[1] = nor[1];
   m_vertices[fcr].pos[2] = pos[1][2]; m_vertices[fcr].nor[2] = nor[2];
   fcr++;
   m_vertices[fcr].pos[0] = pos[2][0]; m_vertices[fcr].nor[0] = nor[0];
   m_vertices[fcr].pos[1] = pos[2][1]; m_vertices[fcr].nor[1] = nor[1];
   m_vertices[fcr].pos[2] = pos[2][2]; m_vertices[fcr].nor[2] = nor[2];
   fcr++;
   if(n == 4){
    m_vertices[fcr].pos[0] = pos[0][0]; m_vertices[fcr].nor[0] = nor[0];
    m_vertices[fcr].pos[1] = pos[0][1]; m_vertices[fcr].nor[1] = nor[1];
    m_vertices[fcr].pos[2] = pos[0][2]; m_vertices[fcr].nor[2] = nor[2];
    fcr++;
    m_vertices[fcr].pos[0] = pos[2][0]; m_vertices[fcr].nor[0] = nor[0];
    m_vertices[fcr].pos[1] = pos[2][1]; m_vertices[fcr].nor[1] = nor[1];
    m_vertices[fcr].pos[2] = pos[2][2]; m_vertices[fcr].nor[2] = nor[2];
    fcr++;
    m_vertices[fcr].pos[0] = pos[3][0]; m_vertices[fcr].nor[0] = nor[0];
    m_vertices[fcr].pos[1] = pos[3][1]; m_vertices[fcr].nor[1] = nor[1];
    m_vertices[fcr].pos[2] = pos[3][2]; m_vertices[fcr].nor[2] = nor[2];
    fcr++;
   }
  }
 }
}

SO_NODE_HEADER()

SoPolyhedron::SO_NODE_HEADER ( SoPolyhedron )

private

Member Data Documentation

alternateRep

SoSFNode SoPolyhedron::alternateRep

Definition at line 56 of file SoPolyhedron.h.

m_icount

long SoPolyhedron::m_icount {0}

Definition at line 83 of file SoPolyhedron.h.

{0};

m_indices

long* SoPolyhedron::m_indices {nullptr}

Definition at line 81 of file SoPolyhedron.h.

{nullptr};

m_polyhedron

std::unique_ptr<SbPolyhedron> SoPolyhedron::m_polyhedron

private

Definition at line 71 of file SoPolyhedron.h.

m_vcount

long SoPolyhedron::m_vcount {0}

Definition at line 82 of file SoPolyhedron.h.

{0};

m_vertices

Vertex* SoPolyhedron::m_vertices {nullptr}

Definition at line 80 of file SoPolyhedron.h.

{nullptr};

---

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

• SoPolyhedron.h
• SoPolyhedron.cxx