SurfaceToSoNode Class Reference

#include <SurfaceToSoNode.h>

Collaboration diagram for SurfaceToSoNode:

Public Member Functions
	SurfaceToSoNode ()
virtual	~SurfaceToSoNode ()
SoNode *	translateSurface (const Trk::Surface &sf, const bool &simple=false) const
SoNode *	translatePlaneSurface (const Trk::PlaneSurface &psf) const
SoNode *	translateCylinderSurface (const Trk::CylinderSurface &csf) const
SoNode *	translateDiscSurface (const Trk::DiscSurface &dsf) const
SoNode *	translateStraightLineSurface (const Trk::StraightLineSurface &slsf, const bool &simple=false) const
SoNode *	translatePerigeeSurface (const Trk::PerigeeSurface &persf) const

Static Public Attributes
static const double	surfaceThickness = 0.1

Detailed Description

Definition at line 30 of file SurfaceToSoNode.h.

Constructor & Destructor Documentation

SurfaceToSoNode()

SurfaceToSoNode::SurfaceToSoNode

(

)

Definition at line 49 of file SurfaceToSoNode.cxx.

{
  SoTubs::initClass();
  SoGenericBox::initClass();
}

~SurfaceToSoNode()

SurfaceToSoNode::~SurfaceToSoNode ( )

virtual

Definition at line 55 of file SurfaceToSoNode.cxx.

{}

Member Function Documentation

translateCylinderSurface()

SoNode * SurfaceToSoNode::translateCylinderSurface

(

const Trk::CylinderSurface &

csf

)

const

Definition at line 175 of file SurfaceToSoNode.cxx.

{
   //std::cout<<"translateCylinderSurface"<<std::endl;
 
  double radius  =  csf.bounds().r();
  double hlength =  csf.bounds().halflengthZ();
 
  SoTubs* cylinderSurface = new SoTubs();
  (*cylinderSurface).pRMin = radius-0.25;
  (*cylinderSurface).pRMax = radius+0.25;
  (*cylinderSurface).pDz   = hlength;
 
  return cylinderSurface;
 
}

translateDiscSurface()

SoNode * SurfaceToSoNode::translateDiscSurface

(

const Trk::DiscSurface &

dsf

)

const

Definition at line 191 of file SurfaceToSoNode.cxx.

{
   //std::cout<<"translateDiscSurface"<<std::endl;
  const Trk::DiscBounds* cdbo = dynamic_cast<const Trk::DiscBounds*>(&(dsf.bounds()));
  if (cdbo){
   double iradius    = cdbo->rMin();
   double oradius    = cdbo->rMax();
   double halfphisec = cdbo->halfPhiSector();
 
   SoTubs* discSurface = new SoTubs();
   (*discSurface).pRMin = iradius;
   (*discSurface).pRMax = oradius;
   (*discSurface).pDz   = 0.25;
 
   if (fabs(halfphisec-M_PI)>10e-5){
     // sweep back the rotation as the sweepangle starts from x-axis
     (*discSurface).pSPhi = -halfphisec;
     (*discSurface).pDPhi = 2.* halfphisec;
   }
 
   return discSurface;
  }
  return 0;
}

translatePerigeeSurface()

SoNode * SurfaceToSoNode::translatePerigeeSurface

(

const Trk::PerigeeSurface &

persf

)

const

Definition at line 243 of file SurfaceToSoNode.cxx.

{
  //TK: Why do we need depend on the input???? FIXME
   //std::cout<<"translatePerigeeSurface"<<std::endl;
   SoTubs* perigeeSurface = new SoTubs();
    (*perigeeSurface).pRMin = 0.;
    (*perigeeSurface).pRMax = 5.;
    (*perigeeSurface).pDz   = 4000.;
    return perigeeSurface;
}

translatePlaneSurface()

SoNode * SurfaceToSoNode::translatePlaneSurface

(

const Trk::PlaneSurface &

psf

)

const

Definition at line 101 of file SurfaceToSoNode.cxx.

{
   const Trk::RectangleBounds* crecbo = dynamic_cast<const Trk::RectangleBounds*>(&(psf.bounds()));
   if (crecbo){
    SoGenericBox * gb = new SoGenericBox;
    gb->setParametersForBox(crecbo->halflengthPhi(),crecbo->halflengthEta(),0.5*surfaceThickness);
    gb->drawEdgeLines.setValue(true);
     return gb;
   }
 
   const Trk::TrapezoidBounds* ctrabo = dynamic_cast<const Trk::TrapezoidBounds*>(&(psf.bounds()));
   if (ctrabo){
     SoGenericBox * gb = new SoGenericBox;
     const double hminphi = ctrabo->minHalflengthPhi();
     const double hmaxphi = ctrabo->maxHalflengthPhi();
     const double heta    = ctrabo->halflengthEta();
     gb->setParametersForTrapezoid( 0.5*surfaceThickness/*dz*/, 0/*theta*/, 0/*phi*/, heta/*dy1*/,
                    hminphi/*dx1*/, hmaxphi/*dx2*/, heta/*dy2*/, hminphi/*dx3*/,
                    hmaxphi/*dx4*/, 0/*alp1*/, 0/*alp2*/ );
     gb->drawEdgeLines.setValue(true);
     return gb;
   }
   const Trk::RotatedTrapezoidBounds* crottrabo = dynamic_cast<const Trk::RotatedTrapezoidBounds*>(&(psf.bounds()));
   if (crottrabo){
     SoGenericBox * gb = new SoGenericBox;
     const double hminphi = crottrabo->minHalflengthY();
     const double hmaxphi = crottrabo->maxHalflengthY();
     const double heta    = crottrabo->halflengthX();
     gb->setParametersForTrapezoid( 0.5*surfaceThickness/*dz*/, 0/*theta*/, 0/*phi*/, heta/*dy1*/,
                    hminphi/*dx1*/, hmaxphi/*dx2*/, heta/*dy2*/, hminphi/*dx3*/,
                    hmaxphi/*dx4*/, 0/*alp1*/, 0/*alp2*/ );
     gb->drawEdgeLines.setValue(true);
     return gb;
   }
   const Trk::DiamondBounds* cdiabo = dynamic_cast<const Trk::DiamondBounds*>(&(psf.bounds()));
   if (cdiabo){
     double dz=0.25;
     std::vector<double> x,y;
     x.push_back(cdiabo->minHalflengthX());y.push_back( -2*cdiabo->halflengthY1());
     x.push_back(cdiabo->medHalflengthX());y.push_back( 0.);
     if (cdiabo->halflengthY2()>0.) {
       x.push_back(cdiabo->maxHalflengthX()); y.push_back( 2*cdiabo->halflengthY2()); 
       x.push_back(-cdiabo->maxHalflengthX());y.push_back( 2*cdiabo->halflengthY2()); 
     }
     x.push_back(-cdiabo->medHalflengthX());y.push_back( 0.);
     x.push_back(-cdiabo->minHalflengthX());y.push_back( -2*cdiabo->halflengthY1());
 
     SbPolyhedronPolygonXSect sbPoly(x,y,dz);
     return new SoPolyhedron(sbPoly);
   }
   
   const Trk::AnnulusBounds* cannulus = dynamic_cast<const Trk::AnnulusBounds*>(&(psf.bounds()));
   if (cannulus){
     SoGenericBox * gb = new SoGenericBox;
     const double hminphi = 0.5*cannulus->minR()*cannulus->phi();
     const double hmaxphi = 0.5*cannulus->maxR()*cannulus->phi();
     const double heta    = 0.5 * (cannulus->maxR() - cannulus->minR());
     gb->setParametersForTrapezoid( 0.5*surfaceThickness/*dz*/, 0/*theta*/, 0/*phi*/, heta/*dy1*/,
                    hminphi/*dx1*/, hmaxphi/*dx2*/, heta/*dy2*/, hminphi/*dx3*/,
                    hmaxphi/*dx4*/, 0/*alp1*/, 0/*alp2*/ );
     gb->drawEdgeLines.setValue(true);
     return gb;
   }   
   const Trk::NoBounds* nobo = dynamic_cast<const Trk::NoBounds*>(&(psf.bounds()));
   if (nobo){
    SoGenericBox * gb = new SoGenericBox;
    gb->setParametersForBox(50.0,50.0,0.5*surfaceThickness); 
    gb->drawEdgeLines.setValue(false);
     return gb;
   }
   
   return 0;
}

translateStraightLineSurface()

SoNode * SurfaceToSoNode::translateStraightLineSurface	(	const Trk::StraightLineSurface &	slsf,
		const bool &	simple = false
	)		const

Definition at line 216 of file SurfaceToSoNode.cxx.

{
  //std::cout<<"translateStraightLineSurface"<<std::endl;
  const Trk::CylinderBounds* ccbo = dynamic_cast<const Trk::CylinderBounds*>(&(slsf.bounds()));
   if (ccbo){
    double hlength =  ccbo->halflengthZ();
    if ( simple )
    {
      SoVertexProperty * scatVtxProperty = new SoVertexProperty();
      scatVtxProperty->vertex.set1Value(0, 0.0,0.0,-hlength);
      scatVtxProperty->vertex.set1Value(1, 0.0,0.0, hlength);
      SoLineSet * lineSurface = new SoLineSet();
      lineSurface->numVertices = 2;
      lineSurface->vertexProperty = scatVtxProperty;
      return lineSurface;
    }
 
    double radius  =  ccbo->r();
    SoTubs* lineSurface = new SoTubs();
    (*lineSurface).pRMin = 0.;
    (*lineSurface).pRMax = radius;
    (*lineSurface).pDz   = hlength;
    return lineSurface;
  }
  return 0;
}

translateSurface()

SoNode * SurfaceToSoNode::translateSurface	(	const Trk::Surface &	sf,
		const bool &	simple = false
	)		const

Definition at line 57 of file SurfaceToSoNode.cxx.

{
 
  SoNode* sono =0;
    const Trk::CylinderSurface* ccsf = dynamic_cast<const Trk::CylinderSurface*>(&sf);
    if (ccsf) sono = this->translateCylinderSurface(*ccsf);
 
    const Trk::DiscSurface* cdsf = sono ? 0 : dynamic_cast<const Trk::DiscSurface*>(&sf);
    if (cdsf) sono = this->translateDiscSurface(*cdsf);
 
    const Trk::PlaneSurface* cpsf = sono ? 0 : dynamic_cast<const Trk::PlaneSurface*>(&sf);
    if (cpsf) sono = this->translatePlaneSurface(*cpsf);
 
    const Trk::StraightLineSurface* cssf = sono ? 0 : dynamic_cast<const Trk::StraightLineSurface*>(&sf);
    if (cssf) sono = this->translateStraightLineSurface(*cssf, simple);
 
    const Trk::PerigeeSurface* cpersf    = sono ? 0 : dynamic_cast<const Trk::PerigeeSurface*>(&sf);
    if (cpersf) sono = this->translatePerigeeSurface(*cpersf);
 
    if (!sono) {
      std::cout<<"ERROR! Surface unknown!"<<std::endl;
      return 0;
    }
 
    // place and transform them
    SoSeparator* sosep = new SoSeparator();
    
    // Horrible hack for ITK annulus bounds. What should really happen is we draw the surface where the bounds are. But this was never done before.
    Amg::Transform3D transform = sf.transform();
    if (cpsf) {
      const Trk::AnnulusBounds* cannulus = dynamic_cast<const Trk::AnnulusBounds*>(&(cpsf->bounds()));
      if (cannulus){
        Amg::Vector3D vec(0.0,0.5*(cannulus->maxR()+cannulus->minR()),0.0);
        transform.translate(vec);
      }
    }
  
    SoTransform* sotra = VP1LinAlgUtils::toSoTransform(transform);
    sosep->addChild(sotra);
    sosep->addChild(sono);
 
    return sosep;
}

Member Data Documentation

surfaceThickness

const double SurfaceToSoNode::surfaceThickness = 0.1

static

Definition at line 55 of file SurfaceToSoNode.h.

---

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

• SurfaceToSoNode.h
• SurfaceToSoNode.cxx