SbPolyhedrizeAction Class Reference

#include <SbPolyhedrizeAction.h>

Inheritance diagram for SbPolyhedrizeAction:

Collaboration diagram for SbPolyhedrizeAction:

Public Member Functions
	SbPolyhedrizeAction ()
virtual	~SbPolyhedrizeAction ()
virtual void	handleShift (const GeoShapeShift *shift)
virtual void	handleUnion (const GeoShapeUnion *unio)
virtual void	handleIntersection (const GeoShapeIntersection *isect)
virtual void	handleSubtraction (const GeoShapeSubtraction *subtract)
virtual void	handleBox (const GeoBox *box)
virtual void	handleCons (const GeoCons *cons)
virtual void	handlePara (const GeoPara *para)
virtual void	handlePcon (const GeoPcon *pcon)
virtual void	handlePgon (const GeoPgon *pgon)
virtual void	handleTrap (const GeoTrap *trap)
virtual void	handleTrd (const GeoTrd *trd)
virtual void	handleTube (const GeoTube *tube)
virtual void	handleTubs (const GeoTubs *tubs)
virtual void	handleSimplePolygonBrep (const GeoSimplePolygonBrep *brep)
virtual void	handleTessellatedSolid (const GeoTessellatedSolid *tessellated)
virtual void	handleGenericTrap (const GeoGenericTrap *gentrap)
SbPolyhedron *	getPolyhedron ()

Private Member Functions
	SbPolyhedrizeAction (const SbPolyhedrizeAction &right)
const SbPolyhedrizeAction &	operator= (const SbPolyhedrizeAction &right)

Private Attributes
std::unique_ptr< SbPolyhedron >	m_polyhedron

Detailed Description

Definition at line 17 of file SbPolyhedrizeAction.h.

Constructor & Destructor Documentation

SbPolyhedrizeAction() [1/2]

SbPolyhedrizeAction::SbPolyhedrizeAction

(

)

Definition at line 30 of file SbPolyhedrizeAction.cxx.

  : m_polyhedron(nullptr)
{
  setDepthLimit(0);
}

~SbPolyhedrizeAction()

SbPolyhedrizeAction::~SbPolyhedrizeAction ( )

virtual

Definition at line 37 of file SbPolyhedrizeAction.cxx.

{
  
}

SbPolyhedrizeAction() [2/2]

SbPolyhedrizeAction::SbPolyhedrizeAction ( const SbPolyhedrizeAction & right )

private

Member Function Documentation

getPolyhedron()

SbPolyhedron * SbPolyhedrizeAction::getPolyhedron

(

)

Definition at line 280 of file SbPolyhedrizeAction.cxx.

{
 //transfer ownership via raw ptr
  return m_polyhedron.release();
}

handleBox()

void SbPolyhedrizeAction::handleBox ( const GeoBox * box )

virtual

Definition at line 89 of file SbPolyhedrizeAction.cxx.

{
  m_polyhedron=std::make_unique<SbPolyhedronBox> (box->getXHalfLength(),
                   box->getYHalfLength(),
                   box->getZHalfLength());
}

handleCons()

void SbPolyhedrizeAction::handleCons ( const GeoCons * cons )

virtual

Definition at line 96 of file SbPolyhedrizeAction.cxx.

{
  m_polyhedron = std::make_unique<SbPolyhedronCons> (cons->getRMin1(),
                      cons->getRMax1(),
                      cons->getRMin2(),
                      cons->getRMax2(),
                      cons->getDZ(),
                      cons->getSPhi(),
                      cons->getDPhi());
}

handleGenericTrap()

void SbPolyhedrizeAction::handleGenericTrap ( const GeoGenericTrap * gentrap )

virtual

Definition at line 271 of file SbPolyhedrizeAction.cxx.

{
  std::vector<std::pair<double,double> > vertices;
  vertices.reserve(8);
  for(size_t i=0; i<8; ++i)
    vertices.push_back(std::pair<double,double>(gentrap->getVertices()[i].x(),gentrap->getVertices()[i].y()));
  m_polyhedron = std::make_unique<SbPolyhedronGenericTrap>(gentrap->getZHalfLength(),vertices);
}

handleIntersection()

void SbPolyhedrizeAction::handleIntersection ( const GeoShapeIntersection * isect )

virtual

Definition at line 73 of file SbPolyhedrizeAction.cxx.

{
  SbPolyhedrizeAction auxA,auxB;
  isect->getOpA()->exec(&auxA);
  isect->getOpB()->exec(&auxB);
  m_polyhedron=std::make_unique<SbPolyhedron>(auxA.getPolyhedron()->intersect(*auxB.getPolyhedron()));
}

handlePara()

void SbPolyhedrizeAction::handlePara ( const GeoPara * para )

virtual

Definition at line 107 of file SbPolyhedrizeAction.cxx.

{
  m_polyhedron=std::make_unique<SbPolyhedronPara>(para->getXHalfLength(),
                   para->getYHalfLength(),
                   para->getZHalfLength(),
                   para->getAlpha(),
                   para->getTheta(),
                   para->getPhi());
}

handlePcon()

void SbPolyhedrizeAction::handlePcon ( const GeoPcon * pcon )

virtual

Definition at line 117 of file SbPolyhedrizeAction.cxx.

{
  double *z = new double[pcon->getNPlanes ()];
  double *rmn = new double[pcon->getNPlanes ()];
  double *rmx = new double[pcon->getNPlanes ()];
 
  for (unsigned s = 0; s < pcon->getNPlanes (); s++) {
    z[s] = pcon->getZPlane (s);
    rmn[s] = pcon->getRMinPlane (s);
    rmx[s] = pcon->getRMaxPlane (s);
  }
  m_polyhedron = std::make_unique<SbPolyhedronPcon> (pcon->getSPhi(), pcon->getDPhi(), pcon->getNPlanes (), z, rmn, rmx);
  
  delete[]z;
  delete[]rmn;
  delete[]rmx;
}

handlePgon()

void SbPolyhedrizeAction::handlePgon ( const GeoPgon * pgon )

virtual

Definition at line 135 of file SbPolyhedrizeAction.cxx.

{
  double *z   = new double[pgon->getNPlanes ()];
  double *rmn = new double[pgon->getNPlanes ()];
  double *rmx = new double[pgon->getNPlanes ()];
 
  for (unsigned s = 0; s < pgon->getNPlanes (); s++) {
    z[s]   = pgon->getZPlane (s);
    rmn[s] = pgon->getRMinPlane (s);
    rmx[s] = pgon->getRMaxPlane (s);
  }
  m_polyhedron = std::make_unique<SbPolyhedronPgon> (pgon->getSPhi(), pgon->getDPhi(), pgon->getNSides(), pgon->getNPlanes (), z, rmn, rmx);
  
  delete[]z;
  delete[]rmn;
  delete[]rmx;
}

handleShift()

void SbPolyhedrizeAction::handleShift ( const GeoShapeShift * shift )

virtual

Definition at line 42 of file SbPolyhedrizeAction.cxx.

{
  shift->getOp()->exec(this);
  GeoTrf::RotationMatrix3D rotation=shift->getX().rotation();
  GeoTrf::Vector3D  translation = shift->getX().translation();
 
  // rbianchi - 14.12.2012
//  SbVec3f    trx(translation.x(),translation.y(),translation.z());
//  SbRotation rot(SbMatrix(rotation.xx(),rotation.yx(),rotation.zx(),0,
//            rotation.xy(),rotation.yy(),rotation.zy(),0,
//            rotation.xz(),rotation.yz(),rotation.zz(),0,
//            0,0,0,1));
  SbVec3d    trx(translation.x(),translation.y(),translation.z());
  #include <VP1HEPVis/SbRotation.h> //using doubles instead of floats.
  HEPVis::SbRotation rot(rotation(0,0),rotation(1,0),rotation(2,0),0,
             rotation(0,1),rotation(1,1),rotation(2,1),0,
             rotation(0,2),rotation(1,2),rotation(2,2),0,
              0,0,0,1);
  //---
 
  m_polyhedron->Transform (rot, trx);
}

handleSimplePolygonBrep()

void SbPolyhedrizeAction::handleSimplePolygonBrep ( const GeoSimplePolygonBrep * brep )

virtual

Definition at line 189 of file SbPolyhedrizeAction.cxx.

{
  double dz = brep->getDZ();
  std::vector<double> x, y;
  for(unsigned int i=0; i<brep->getNVertices(); i++)
  {
    x.push_back(brep->getXVertex(i));
    y.push_back(brep->getYVertex(i));
  }
 
  m_polyhedron = std::make_unique<SbPolyhedronPolygonXSect>(x,y,dz);
}

handleSubtraction()

void SbPolyhedrizeAction::handleSubtraction ( const GeoShapeSubtraction * subtract )

virtual

Definition at line 81 of file SbPolyhedrizeAction.cxx.

{
  SbPolyhedrizeAction auxA,auxB;
  subtract->getOpA()->exec(&auxA);
  subtract->getOpB()->exec(&auxB);
  m_polyhedron=std::make_unique<SbPolyhedron>(auxA.getPolyhedron()->subtract(*auxB.getPolyhedron()));
}

handleTessellatedSolid()

void SbPolyhedrizeAction::handleTessellatedSolid ( const GeoTessellatedSolid * tessellated )

virtual

Definition at line 202 of file SbPolyhedrizeAction.cxx.

{
  // ______ Perform actions a la SetSolidClosed ________
  double vertTolerance = 1E-15;  // kCarTolerance ??
  std::vector<GeoFacetVertex> vertexList;
  std::map<GeoFacet*,std::vector<size_t> > facetVertIndInSolid;  // Vacet vertex indices in the vertexList
 
  // Loop over facets in the solid
  for(size_t facetIndInSolid = 0; facetIndInSolid<tessellated->getNumberOfFacets(); ++facetIndInSolid) {
    GeoFacet* facet = tessellated->getFacet(facetIndInSolid);
 
    facetVertIndInSolid[facet] = std::vector<size_t>();
    std::vector<size_t>& current = facetVertIndInSolid[facet];
    if(facet->getNumberOfVertices()==3)
      current.resize(3,0);
    else
      current.resize(4,0);
 
    size_t vertexListSize = vertexList.size();
    GeoFacetVertex vertex(0.,0.,0.);
 
    // Loop over vertices in the current facet
    for(size_t vertexIndInFacet=0; vertexIndInFacet<facet->getNumberOfVertices(); ++vertexIndInFacet) {
      vertex = facet->getVertex(vertexIndInFacet);
 
      // Check if we already have this vertex in our vertexList
      bool found = false;
      size_t j=0;
      while(j<vertexListSize && !found) {
    GeoFacetVertex vertexToCheck = vertexList[j];
    found = (vertexToCheck-vertex).mag() < vertTolerance;
    if(!found) j++;
      }
 
      if(found) {
    current[vertexIndInFacet] = j;
      }
      else {
    vertexList.push_back(vertex);
    current[vertexIndInFacet] = vertexList.size()-1;
      }
    }
  }
 
  // ______ Create Polyhedron itself ______
  SbPolyhedronArbitrary* polyhedron=  new SbPolyhedronArbitrary(vertexList.size(),tessellated->getNumberOfFacets());
 
  // add vertices from the list
  for(size_t vertexInd=0;  vertexInd<vertexList.size(); ++vertexInd) {
    GeoFacetVertex vertex = vertexList[vertexInd];
    polyhedron->AddVertex(vertex.x(),vertex.y(),vertex.z());
  }
 
  // add facets
  for(size_t facetIndInSolid = 0; facetIndInSolid<tessellated->getNumberOfFacets(); ++facetIndInSolid) {
    GeoFacet* facet = tessellated->getFacet(facetIndInSolid);
    std::vector<size_t>& current = facetVertIndInSolid[facet];
 
    size_t v[4];
    for (size_t j=0; j<4; j++) 
      v[j] = (j<current.size() ? current[j]+1 : 0);
 
    polyhedron->AddFacet(v[0],v[1],v[2],v[3]);
  }
 
  polyhedron->Finalize();
  m_polyhedron.reset(polyhedron);
}

handleTrap()

void SbPolyhedrizeAction::handleTrap ( const GeoTrap * trap )

virtual

Definition at line 153 of file SbPolyhedrizeAction.cxx.

{
  m_polyhedron = std::make_unique<SbPolyhedronTrap> (trap->getZHalfLength(),
                      trap->getTheta(),
                      trap->getPhi(),
                      trap->getDydzn(),
                      trap->getDxdyndzn(),
                      trap->getDxdypdzn(), 0,
                      trap->getDydzp(),
                      trap->getDxdyndzp(),
                      trap->getDxdypdzp(),0);
}

handleTrd()

void SbPolyhedrizeAction::handleTrd ( const GeoTrd * trd )

virtual

Definition at line 166 of file SbPolyhedrizeAction.cxx.

{
  m_polyhedron = std::make_unique<SbPolyhedronTrd2> (trd->getXHalfLength1(),
                      trd->getXHalfLength2(),
                      trd->getYHalfLength1(),
                      trd->getYHalfLength2(),
                      trd->getZHalfLength());
}

handleTube()

void SbPolyhedrizeAction::handleTube ( const GeoTube * tube )

virtual

Definition at line 175 of file SbPolyhedrizeAction.cxx.

{
  m_polyhedron = std::make_unique<SbPolyhedronTube> (tube->getRMin(),tube->getRMax(),tube->getZHalfLength());
}

handleTubs()

void SbPolyhedrizeAction::handleTubs ( const GeoTubs * tubs )

virtual

Definition at line 180 of file SbPolyhedrizeAction.cxx.

{
  m_polyhedron= std::make_unique<SbPolyhedronTubs> (tubs->getRMin(),
                     tubs->getRMax(),
                     tubs->getZHalfLength(),
                     tubs->getSPhi(),
                     tubs->getDPhi());
}

handleUnion()

void SbPolyhedrizeAction::handleUnion ( const GeoShapeUnion * unio )

virtual

Definition at line 65 of file SbPolyhedrizeAction.cxx.

{
  SbPolyhedrizeAction auxA,auxB;
  unio->getOpA()->exec(&auxA);
  unio->getOpB()->exec(&auxB);
  m_polyhedron = std::make_unique<SbPolyhedron>(auxA.getPolyhedron()->add(*auxB.getPolyhedron()));
}

operator=()

const SbPolyhedrizeAction & SbPolyhedrizeAction::operator= ( const SbPolyhedrizeAction & right )

private

Member Data Documentation

m_polyhedron

std::unique_ptr<SbPolyhedron> SbPolyhedrizeAction::m_polyhedron

private

Definition at line 67 of file SbPolyhedrizeAction.h.

---

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

• SbPolyhedrizeAction.h
• SbPolyhedrizeAction.cxx