#include <SimplePolygonBrepVolumeBounds.h>

Inheritance diagram for Trk::SimplePolygonBrepVolumeBounds:

Collaboration diagram for Trk::SimplePolygonBrepVolumeBounds:

Public Member Functions
	SimplePolygonBrepVolumeBounds ()
	Default Constructor. More...

	SimplePolygonBrepVolumeBounds (const std::vector< std::pair< float, float > > &xyvtx, float hlengthz)
	Constructor - generic case (from float) More...

	SimplePolygonBrepVolumeBounds (const std::vector< std::pair< double, double > > &xyvtx, double hlengthz)
	Constructor - generic case (from double) More...

	SimplePolygonBrepVolumeBounds (const SimplePolygonBrepVolumeBounds &bobo)
	Copy Constructor. More...

virtual	~SimplePolygonBrepVolumeBounds ()
	Destructor. More...

SimplePolygonBrepVolumeBounds &	operator= (const SimplePolygonBrepVolumeBounds &bobo)
	Assignment operator. More...

SimplePolygonBrepVolumeBounds *	clone () const override final
	Virtual constructor. More...

bool	inside (const Amg::Vector3D &, double tol=0.) const override final
	This method checks if position in the 3D volume frame is inside the volume. More...

virtual std::vector< std::unique_ptr< Trk::Surface > >	decomposeToSurfaces (const Amg::Transform3D &transform) override final
	Method to decompose the Bounds into Surfaces. More...

ObjectAccessor	boundarySurfaceAccessor (const Amg::Vector3D &gp, const Amg::Vector3D &dir, bool forceInside=false) const override final
	Provide accessor for BoundarySurfaces. More...

const std::vector< std::pair< double, double > > &	xyVertices () const
	This method returns the set of xy generating vertices. More...

double	halflengthZ () const
	This method returns the halflength in local z. More...

const Trk::Volume *	combinedVolume () const
	This method returns the transcript into combined volume. More...

const Trk::Volume *	envelope () const
	This method returns the volume envelope. More...

MsgStream &	dump (MsgStream &sl) const override
	Output Method for MsgStream. More...

std::ostream &	dump (std::ostream &sl) const override
	Output Method for std::ostream. More...

Private Member Functions
void	processSubVols ()

std::unique_ptr< Trk::PlaneSurface >	sideSurf (const Amg::Transform3D &, unsigned int, unsigned int) const

bool	Left (std::pair< double, double > a, std::pair< double, double > b, std::pair< double, double > c) const

bool	Intersect (std::pair< double, double > a, std::pair< double, double > b, std::pair< double, double > c, std::pair< double, double > d) const

bool	InCone (int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const

bool	Diagonalie (int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const

bool	Diagonal (int i, int j, const std::vector< std::pair< double, double > > &inputVertices) const

std::vector< std::pair< double, double > >	TriangulatePolygon (const std::vector< std::pair< double, double > > &Vertices) const

std::vector< std::pair< double, double > >	TriangulatePolygonCheck (const std::vector< std::pair< double, double > > &Vertices)

Static Private Member Functions
static bool	Xor (bool x, bool y)

Private Attributes
std::vector< std::pair< double, double > >	m_xyVtx
	generating xy vertices More...

double	m_halfX
	halflength in x - to define enclosing rectangle More...

double	m_halfY
	halflength in y - to define enclosing rectangle More...

double	m_halfZ
	halflength in z More...

int	m_ordering
	-1 not set/ 1 anticlockwise / 0 clockwise More...

const Trk::Volume *	m_combinedVolume
	triangulated polygon More...

const Trk::Volume *	m_envelope
	simplified envelope More...

Trk::EightObjectsAccessor	m_objectAccessor
	There's only one single object Acessor for the moment has to be implemented if Cuboids are used more widely. More...

Detailed Description

Bounds for the exact transcript of the GeoSimplePolygonBrep; volume defined by combination of symm.trapezoids

BoundarySurfaceFace [index]:

- negativeFaceXY     [0] : Trk::SubtractedPlaneSurface,
                           parallel to \f$ xy \f$ plane at negative \f$ z

\( - positiveFaceXY [1] : Trk::SubtractedPlaneSurface, parallel to \) xy \( plane at positive \) z

Definition at line 44 of file SimplePolygonBrepVolumeBounds.h.

Constructor & Destructor Documentation

◆ SimplePolygonBrepVolumeBounds() [1/4]

Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds ( )

Default Constructor.

Definition at line 28 of file SimplePolygonBrepVolumeBounds.cxx.

   : VolumeBounds()
   , m_halfX(0.)
   , m_halfY(0.)
   , m_halfZ(0.)
   , m_ordering(-1)
   , m_combinedVolume(nullptr)
   , m_envelope(nullptr)
   , m_objectAccessor()
 {
   //@TODO an object created by the default constructor cannot be copied or
   //assigned.
 }

◆ SimplePolygonBrepVolumeBounds() [2/4]

Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds	(	const std::vector< std::pair< float, float > > &	xyvtx,
		float	hlengthz
	)

Constructor - generic case (from float)

◆ SimplePolygonBrepVolumeBounds() [3/4]

Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds	(	const std::vector< std::pair< double, double > > &	xyvtx,
		double	hlengthz
	)

Constructor - generic case (from double)

◆ SimplePolygonBrepVolumeBounds() [4/4]

Trk::SimplePolygonBrepVolumeBounds::SimplePolygonBrepVolumeBounds ( const SimplePolygonBrepVolumeBounds & bobo )

Copy Constructor.

Definition at line 126 of file SimplePolygonBrepVolumeBounds.cxx.

   : VolumeBounds()
   , m_halfX(trabo.m_halfX)
   , m_halfY(trabo.m_halfY)
   , m_halfZ(trabo.m_halfZ)
   , m_ordering(trabo.m_ordering)
   , m_combinedVolume(trabo.m_combinedVolume->clone())
   , m_envelope(trabo.m_envelope->clone())
   , m_objectAccessor(trabo.m_objectAccessor)
 {
   m_xyVtx.resize(trabo.m_xyVtx.size());
   for (unsigned int i = 0; i < m_xyVtx.size(); i++)
     m_xyVtx[i] = trabo.m_xyVtx[i];
 }

◆ ~SimplePolygonBrepVolumeBounds()

Trk::SimplePolygonBrepVolumeBounds::~SimplePolygonBrepVolumeBounds ( )

virtual

Destructor.

Definition at line 142 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   delete m_combinedVolume;
   delete m_envelope;
 }

Member Function Documentation

◆ boundarySurfaceAccessor()

ObjectAccessor Trk::SimplePolygonBrepVolumeBounds::boundarySurfaceAccessor	(	const Amg::Vector3D &	gp,
		const Amg::Vector3D &	dir,
		bool	forceInside = `false`
	)		const

inlinefinaloverridevirtual

Provide accessor for BoundarySurfaces.

Implements Trk::VolumeBounds.

Definition at line 164 of file SimplePolygonBrepVolumeBounds.h.

                                                         {
   return Trk::ObjectAccessor(m_objectAccessor);
 }

◆ clone()

SimplePolygonBrepVolumeBounds * Trk::SimplePolygonBrepVolumeBounds::clone ( ) const

inlinefinaloverridevirtual

Virtual constructor.

Implements Trk::VolumeBounds.

Definition at line 142 of file SimplePolygonBrepVolumeBounds.h.

           {
   return new SimplePolygonBrepVolumeBounds(*this);
 }

◆ combinedVolume()

const Trk::Volume * Trk::SimplePolygonBrepVolumeBounds::combinedVolume ( ) const

inline

This method returns the transcript into combined volume.

Definition at line 155 of file SimplePolygonBrepVolumeBounds.h.

           {
   return m_combinedVolume;
 }

◆ decomposeToSurfaces()

std::vector< std::unique_ptr< Trk::Surface > > Trk::SimplePolygonBrepVolumeBounds::decomposeToSurfaces ( const Amg::Transform3D & transform )

finaloverridevirtual

Method to decompose the Bounds into Surfaces.

Implements Trk::VolumeBounds.

Definition at line 170 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   auto retsf = std::vector<std::unique_ptr<Trk::Surface>>();
  
   // face surfaces xy
   //  (1) - at negative local z
   Trk::PlaneSurface xymPlane(
       Amg::Transform3D(transform *
                        Amg::Translation3D(Amg::Vector3D(0., 0., -m_halfZ))),
       std::make_shared<Trk::RectangleBounds>(m_halfX, m_halfY));
   auto volExcl =
       std::make_shared<const Trk::VolumeExcluder>(
         std::make_unique<Trk::Volume>(
           *m_combinedVolume,
           Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., -m_halfZ)))
           )
         );
  
   retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(xymPlane, std::move(volExcl), true));
   //  (2) - at positive local z
   Trk::PlaneSurface xyPlane(
       Amg::Transform3D(transform *Amg::Translation3D(Amg::Vector3D(0., 0., m_halfZ))),
       std::make_shared<Trk::RectangleBounds>(m_halfX, m_halfY)
       );
  
   volExcl = std::make_shared<const Trk::VolumeExcluder>(
     std::make_unique<Trk::Volume>(*m_combinedVolume,
       Amg::Transform3D(Amg::Translation3D(Amg::Vector3D(0., 0., m_halfZ)))
       )
     );
   retsf.push_back(std::make_unique<Trk::SubtractedPlaneSurface>(xyPlane, std::move(volExcl), true));
   // loop over xy vertices
   //  (3)
   for (unsigned int iv = 0; iv < m_xyVtx.size(); iv++) {
     if (iv != m_xyVtx.size() - 1)
       retsf.push_back(sideSurf(transform, iv, iv + 1));
     else
       retsf.push_back(sideSurf(transform, iv, 0));
   }
  
   return retsf;
 }

◆ Diagonal()

bool Trk::SimplePolygonBrepVolumeBounds::Diagonal	(	int	i,
		int	j,
		const std::vector< std::pair< double, double > > &	inputVertices
	)		const

private

Definition at line 418 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   // std::cout<<"MW Diagonal "<<i<<" "<<j<<" "<<InCone(i,j, inputVertices)<<"
   // "<<Diagonalie(i,j, inputVertices)<<std::endl;
   return InCone(i, j, inputVertices) && Diagonalie(i, j, inputVertices);
 }

◆ Diagonalie()

bool Trk::SimplePolygonBrepVolumeBounds::Diagonalie	(	int	i,
		int	j,
		const std::vector< std::pair< double, double > > &	inputVertices
	)		const

private

Definition at line 392 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   // Returns TRUE iff (v_i, v_j) is a proper internal *or* external diagonal of
   // this polygon, *ignoring edges incident to v_i and v_j*.
  
   /* For each edge (k,k+1) of P */
   for (int k = 0; k < (int)inputVertices.size(); k++) {
  
     int kPlus1 = (k + 1) % inputVertices.size();
  
     /* Skip edges incident to i or j */
     if ((k != i) && (kPlus1 != i) && (k != j) && (kPlus1 != j))
       if (Intersect(
             inputVertices[i],
             inputVertices[j],
             inputVertices[k],
             inputVertices[kPlus1]))
         return false;
   }
   return true;
 }

◆ dump() [1/2]

MsgStream & Trk::SimplePolygonBrepVolumeBounds::dump ( MsgStream & sl ) const

overridevirtual

Output Method for MsgStream.

Implements Trk::VolumeBounds.

Definition at line 294 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   std::stringstream temp_sl;
   temp_sl << std::setiosflags(std::ios::fixed);
   temp_sl << std::setprecision(7);
   temp_sl << "Trk::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
   temp_sl << "( " << m_halfZ << ")";
   for (const auto & xyVtx : m_xyVtx)
     temp_sl << "(" << xyVtx.first << "," << xyVtx.second << ")";
   sl << temp_sl.str();
   return sl;
 }

◆ dump() [2/2]

std::ostream & Trk::SimplePolygonBrepVolumeBounds::dump ( std::ostream & sl ) const

overridevirtual

Output Method for std::ostream.

Implements Trk::VolumeBounds.

Definition at line 308 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   std::stringstream temp_sl;
   temp_sl << std::setiosflags(std::ios::fixed);
   temp_sl << std::setprecision(7);
   temp_sl << "Trk::SimplePolygonBrepVolumeBounds: (halfZ, xy vertices) = ";
   temp_sl << "( " << m_halfZ << ")";
   for (const auto & myVtx : m_xyVtx)
     temp_sl << "(" << myVtx.first << "," << myVtx.second << ")";
   sl << temp_sl.str();
   return sl;
 }

◆ envelope()

const Trk::Volume * Trk::SimplePolygonBrepVolumeBounds::envelope ( ) const

inline

This method returns the volume envelope.

Definition at line 160 of file SimplePolygonBrepVolumeBounds.h.

                                                                       {
   return m_envelope;
 }

◆ halflengthZ()

double Trk::SimplePolygonBrepVolumeBounds::halflengthZ ( ) const

inline

This method returns the halflength in local z.

Definition at line 151 of file SimplePolygonBrepVolumeBounds.h.

                                                                {
   return m_halfZ;
 }

◆ InCone()

bool Trk::SimplePolygonBrepVolumeBounds::InCone	(	int	i,
		int	j,
		const std::vector< std::pair< double, double > > &	inputVertices
	)		const

private

Definition at line 368 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   int iPlus1 = (i + 1) % inputVertices.size();
   int iMinus1 = (i + inputVertices.size() - 1) % inputVertices.size();
  
   /* If P[i] is a convex vertex [ i+1 left or on (i-1,i) ]. */
   if (Left(inputVertices[iMinus1], inputVertices[i], inputVertices[iPlus1]))
     return Left(inputVertices[i], inputVertices[j], inputVertices[iMinus1]) &&
            Left(inputVertices[j], inputVertices[i], inputVertices[iPlus1]);
  
   /* Assume (i-1,i,i+1) not collinear. */
   /* else v_i is reflex. */
   else
     return !(
       Left(inputVertices[i], inputVertices[j], inputVertices[iPlus1]) &&
       Left(inputVertices[j], inputVertices[i], inputVertices[iMinus1]));
 }

◆ inside()

bool Trk::SimplePolygonBrepVolumeBounds::inside	(	const Amg::Vector3D &	pos,
		double	tol = `0.`
	)		const

finaloverridevirtual

This method checks if position in the 3D volume frame is inside the volume.

Implements Trk::VolumeBounds.

Definition at line 261 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   return (m_combinedVolume->inside(pos, tol));
 }

◆ Intersect()

bool Trk::SimplePolygonBrepVolumeBounds::Intersect	(	std::pair< double, double >	a,
		std::pair< double, double >	b,
		std::pair< double, double >	c,
		std::pair< double, double >	d
	)		const

private

Definition at line 356 of file SimplePolygonBrepVolumeBounds.cxx.

 {
  
   return Xor(Left(a, b, c), Left(a, b, d)) && Xor(Left(c, d, a), Left(c, d, b));
 }

◆ Left()

bool Trk::SimplePolygonBrepVolumeBounds::Left	(	std::pair< double, double >	a,
		std::pair< double, double >	b,
		std::pair< double, double >	c
	)		const

private

Definition at line 339 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   double CrossZ = (b.first - a.first) * (c.second - a.second) -
                   (c.first - a.first) * (b.second - a.second);
   if (m_ordering == 1)
     return (CrossZ >= 0.);
   if (m_ordering == 0)
     return (CrossZ < 0.);
   return false;
 }

◆ operator=()

Trk::SimplePolygonBrepVolumeBounds & Trk::SimplePolygonBrepVolumeBounds::operator= ( const SimplePolygonBrepVolumeBounds & bobo )

Assignment operator.

Definition at line 149 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   if (this != &trabo) {
     m_halfX = trabo.m_halfX;
     m_halfY = trabo.m_halfY;
     m_halfZ = trabo.m_halfZ;
     m_objectAccessor = trabo.m_objectAccessor;
     m_xyVtx.resize(trabo.m_xyVtx.size());
     for (unsigned int i = 0; i < m_xyVtx.size(); i++)
       m_xyVtx[i] = trabo.m_xyVtx[i];
     delete m_combinedVolume;
     delete m_envelope;
     m_combinedVolume = trabo.m_combinedVolume->clone();
     m_envelope = trabo.m_envelope->clone();
     m_ordering = trabo.m_ordering;
   }
   return *this;
 }

◆ processSubVols()

void Trk::SimplePolygonBrepVolumeBounds::processSubVols ( )

private

Definition at line 268 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   // translate into prisms (triangulate)
   std::unique_ptr<Trk::Volume> cVol;
   std::vector<std::pair<double, double>> triangles = TriangulatePolygonCheck(m_xyVtx);
   std::vector<std::pair<double, double>> vertices;
   for (unsigned int i = 0; i < triangles.size(); i = i + 3) {
     vertices.push_back(triangles[i]);
     vertices.push_back(triangles[i + 1]);
     vertices.push_back(triangles[i + 2]);
     auto newVol = std::make_unique<Trk::Volume>(nullptr, std::make_shared<Trk::PrismVolumeBounds>(vertices, m_halfZ));
     if (cVol){
       cVol = std::make_unique<Trk::Volume>(nullptr, std::make_shared<Trk::CombinedVolumeBounds>(std::move(cVol),
                                                                                                 std::move(newVol),
                                                                                                 false));
     }
     else{
       cVol = std::move(newVol);
     }
     vertices.clear();
   }
   m_combinedVolume = cVol.release();
 }

◆ sideSurf()

std::unique_ptr< Trk::PlaneSurface > Trk::SimplePolygonBrepVolumeBounds::sideSurf	(	const Amg::Transform3D &	transform,
		unsigned int	iv1,
		unsigned int	iv2
	)		const

private

Definition at line 216 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   std::unique_ptr<Trk::PlaneSurface> plane = nullptr;
  
   double xdif = m_xyVtx[iv2].first - m_xyVtx[iv1].first;
   double ydif = m_xyVtx[iv2].second - m_xyVtx[iv1].second;
   double xsize = sqrt(xdif * xdif + ydif * ydif);
  
   double ori = m_ordering > 0 ? -1. : 1.;
  
   Amg::Vector3D pos(
     0.5 * (m_xyVtx[iv1].first + m_xyVtx[iv2].first),
     0.5 * (m_xyVtx[iv1].second + m_xyVtx[iv2].second),
     0.);
   double phi = ori * ydif < 0 ? M_PI / 2 : -M_PI / 2;
   if (ori > 0 && ydif > 0)
     phi = M_PI / 2;
   if (std::abs(xdif) > 1e-6) {
     phi = std::atan(ydif / xdif);
     if (xdif < 0)
       phi += M_PI;
   }
  
   Amg::Transform3D tr(
     transform * Amg::Translation3D(pos) *
     Amg::AngleAxis3D(phi, Amg::Vector3D(0., 0., 1.)) *
     Amg::AngleAxis3D(-ori * 90 * Gaudi::Units::deg, Amg::Vector3D(1., 0., 0.)));
   plane = std::make_unique<Trk::PlaneSurface>(tr, std::make_shared<Trk::RectangleBounds>(0.5 * xsize, m_halfZ));
  
   // verify position of vertices - uncomment for debugging
   // if
   // (!plane->isOnSurface(Trk::GlobalPosition(m_xyVtx[iv1].first,m_xyVtx[iv1].second,m_halfZ),true,0.001,0.001)
   //  ||
   //  !plane->isOnSurface(Trk::GlobalPosition(m_xyVtx[iv2].first,m_xyVtx[iv2].second,-m_halfZ),true,0.001,0.001)
   //  )
   // std::cout << "ERROR in SIMPLEPGONBREP side boundary:vertices out of
   // plane"<< std::endl;
  
   return plane;
 }

◆ TriangulatePolygon()

std::vector< std::pair< double, double > > Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygon ( const std::vector< std::pair< double, double > > & Vertices ) const

private

Definition at line 430 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   // Subtracting ears method
   //
   // One way to triangulate a simple polygon is by using the assertion that any
   // simple polygon without holes
   //  has at least two so called 'ears'. An ear is a triangle with two sides on
   //  the edge of the polygon and the other one completely inside it. The
   //  algorithm then consists of finding such an ear, removing it from the
   //  polygon (which results in a new polygon that still meets the conditions)
   //  and repeating until there is only one triangle left.
   //
  
   int NSize = Vertices.size();
   std::vector<std::pair<double, double>> outTriangles;
   std::vector<std::pair<double, double>> inputVertices;
   inputVertices.reserve(NSize);
   for (int i = 0; i < NSize; i++)
     inputVertices.push_back((Vertices)[i]);
  
   // for (int i; i<NSize;i++) std::cout<<"MW input vertices:
   // "<<inputVertices[i].first<<" "<<inputVertices[i].second<<std::endl;
   // Triangulates this polygon and saves triangle edges in TriPoly.
   // Triangles are stored CCW, with each set of 3 consecutive points in TriPoly
   // representing 1 triangle.
   // Assumes this polygon is closed.
  
   if (NSize < 4)
     return inputVertices;
  
   // Start triangulating
   int VerticesLeft = NSize;
   while (VerticesLeft > 3) {
     // std::cout<<"MW vertices left "<<VerticesLeft<<std::endl;
     bool bCornerCut = false;
     for (int i = 0; i < VerticesLeft; i++) {
  
       int iPlus1 = i + 1;
       if (iPlus1 == VerticesLeft)
         iPlus1 = 0;
       int iPlus2 = (iPlus1 + 1);
       if (iPlus2 == VerticesLeft)
         iPlus2 = 0;
  
       if (Diagonal(i, iPlus2, inputVertices)) {
  
         outTriangles.push_back(inputVertices[i]);
         outTriangles.push_back(inputVertices[iPlus1]);
         outTriangles.push_back(inputVertices[iPlus2]);
  
         inputVertices.erase(inputVertices.begin() + iPlus1);
         VerticesLeft--;
         bCornerCut = true;
         break;
       }
     }
     if (!bCornerCut) { // Error - bad poly
       // std::cout<<"MW     Error - bad poly"<<std::endl;
       std::vector<std::pair<double, double>> out;
       return out;
     }
   }
  
   if (VerticesLeft == 3) {
     outTriangles.push_back(inputVertices[0]);
     outTriangles.push_back(inputVertices[1]);
     outTriangles.push_back(inputVertices[2]);
     inputVertices.erase(inputVertices.begin() + 1);
     VerticesLeft--;
   }
  
   return outTriangles;
 }

◆ TriangulatePolygonCheck()

std::vector< std::pair< double, double > > Trk::SimplePolygonBrepVolumeBounds::TriangulatePolygonCheck ( const std::vector< std::pair< double, double > > & Vertices )

private

Definition at line 506 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   // Perform triangulation. Check the orientation of the verices in the polygon
   // m_ordering   = -1    not set
   // m_ordering   =  1    anticlockwise
   // m_ordering   =  0    clockwise
  
   if (m_ordering == -1)
     m_ordering = 1;
   std::vector<std::pair<double, double>> outTriangles =
     TriangulatePolygon(Vertices);
   if (outTriangles.empty()) {
     m_ordering = -m_ordering + 1;
     outTriangles = TriangulatePolygon(Vertices);
   }
  
   return outTriangles;
 }

◆ Xor()

bool Trk::SimplePolygonBrepVolumeBounds::Xor	(	bool	x,
		bool	y
	)

staticprivate

Definition at line 327 of file SimplePolygonBrepVolumeBounds.cxx.

 {
   return !x ^ !y;
 }

◆ xyVertices()

const std::vector< std::pair< double, double > > & Trk::SimplePolygonBrepVolumeBounds::xyVertices ( ) const

inline

This method returns the set of xy generating vertices.

Definition at line 147 of file SimplePolygonBrepVolumeBounds.h.

                                                 {
   return m_xyVtx;
 }

Member Data Documentation

◆ m_combinedVolume

const Trk::Volume* Trk::SimplePolygonBrepVolumeBounds::m_combinedVolume

private

triangulated polygon

Definition at line 134 of file SimplePolygonBrepVolumeBounds.h.

◆ m_envelope

const Trk::Volume* Trk::SimplePolygonBrepVolumeBounds::m_envelope

private

simplified envelope

Definition at line 135 of file SimplePolygonBrepVolumeBounds.h.

◆ m_halfX

double Trk::SimplePolygonBrepVolumeBounds::m_halfX

private

halflength in x - to define enclosing rectangle

Definition at line 129 of file SimplePolygonBrepVolumeBounds.h.

◆ m_halfY

double Trk::SimplePolygonBrepVolumeBounds::m_halfY

private

halflength in y - to define enclosing rectangle

Definition at line 130 of file SimplePolygonBrepVolumeBounds.h.

◆ m_halfZ

double Trk::SimplePolygonBrepVolumeBounds::m_halfZ

private

halflength in z

Definition at line 131 of file SimplePolygonBrepVolumeBounds.h.

◆ m_objectAccessor

Trk::EightObjectsAccessor Trk::SimplePolygonBrepVolumeBounds::m_objectAccessor

private

There's only one single object Acessor for the moment has to be implemented if Cuboids are used more widely.

can we get rid of this ?

Definition at line 139 of file SimplePolygonBrepVolumeBounds.h.

◆ m_ordering

int Trk::SimplePolygonBrepVolumeBounds::m_ordering

private

-1 not set/ 1 anticlockwise / 0 clockwise

Definition at line 133 of file SimplePolygonBrepVolumeBounds.h.

◆ m_xyVtx

std::vector<std::pair<double, double> > Trk::SimplePolygonBrepVolumeBounds::m_xyVtx

private

generating xy vertices

Definition at line 128 of file SimplePolygonBrepVolumeBounds.h.

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

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ SimplePolygonBrepVolumeBounds() [1/4]

◆ SimplePolygonBrepVolumeBounds() [2/4]

◆ SimplePolygonBrepVolumeBounds() [3/4]

◆ SimplePolygonBrepVolumeBounds() [4/4]

◆ ~SimplePolygonBrepVolumeBounds()

Member Function Documentation

◆ boundarySurfaceAccessor()

◆ clone()

◆ combinedVolume()

◆ decomposeToSurfaces()

◆ Diagonal()

◆ Diagonalie()

◆ dump() [1/2]

◆ dump() [2/2]

◆ envelope()

◆ halflengthZ()

◆ InCone()

◆ inside()

◆ Intersect()

◆ Left()

◆ operator=()

◆ processSubVols()

◆ sideSurf()

◆ TriangulatePolygon()

◆ TriangulatePolygonCheck()

◆ Xor()

◆ xyVertices()

Member Data Documentation

◆ m_combinedVolume

◆ m_envelope

◆ m_halfX

◆ m_halfY

◆ m_halfZ

◆ m_objectAccessor

◆ m_ordering

◆ m_xyVtx