Trk::SimplePolygonBrepVolumeBounds Class Reference

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

#include <SimplePolygonBrepVolumeBounds.h>

Inheritance diagram for Trk::SimplePolygonBrepVolumeBounds:

Collaboration diagram for Trk::SimplePolygonBrepVolumeBounds:

Public Member Functions
	SimplePolygonBrepVolumeBounds ()
	Default Constructor.
	SimplePolygonBrepVolumeBounds (const std::vector< std::pair< float, float > > &xyvtx, float hlengthz)
	Constructor - generic case (from float)
	SimplePolygonBrepVolumeBounds (const std::vector< std::pair< double, double > > &xyvtx, double hlengthz)
	Constructor - generic case (from double)
	SimplePolygonBrepVolumeBounds (const SimplePolygonBrepVolumeBounds &bobo)
	Copy Constructor.
virtual	~SimplePolygonBrepVolumeBounds ()
	Destructor.
SimplePolygonBrepVolumeBounds &	operator= (const SimplePolygonBrepVolumeBounds &bobo)
	Assignment operator.
SimplePolygonBrepVolumeBounds *	clone () const override final
	Virtual constructor.
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.
virtual std::vector< std::unique_ptr< Trk::Surface > >	decomposeToSurfaces (const Amg::Transform3D &transform) override final
	Method to decompose the Bounds into Surfaces.
ObjectAccessor	boundarySurfaceAccessor (const Amg::Vector3D &gp, const Amg::Vector3D &dir, bool forceInside=false) const override final
	Provide accessor for BoundarySurfaces.
const std::vector< std::pair< double, double > > &	xyVertices () const
	This method returns the set of xy generating vertices.
double	halflengthZ () const
	This method returns the halflength in local z.
const Trk::Volume *	combinedVolume () const
	This method returns the transcript into combined volume.
const Trk::Volume *	envelope () const
	This method returns the volume envelope.
MsgStream &	dump (MsgStream &sl) const override
	Output Method for MsgStream.
std::ostream &	dump (std::ostream &sl) const override
	Output Method for std::ostream.

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
double	m_halfX
	halflength in x - to define enclosing rectangle
double	m_halfY
	halflength in y - to define enclosing rectangle
double	m_halfZ
	halflength in z
int	m_ordering
	-1 not set/ 1 anticlockwise / 0 clockwise
const Trk::Volume *	m_combinedVolume
	triangulated polygon
const Trk::Volume *	m_envelope
	simplified envelope
Trk::EightObjectsAccessor	m_objectAccessor
	There's only one single object Acessor for the moment has to be implemented if Cuboids are used more widely.

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)

Definition at line 42 of file SimplePolygonBrepVolumeBounds.cxx.

  : VolumeBounds()
  , m_halfX(0.)
  , m_halfY(0.)
  , m_halfZ(halez)
  , m_ordering(-1)
  , m_combinedVolume(nullptr)
  , m_envelope(nullptr)
  , m_objectAccessor()
{
  m_xyVtx.resize(xyVtx.size());
  double xmin = xyVtx[0].first;
  double xmax = xmin;
  double ymin = xyVtx[0].second;
  double ymax = ymin;
  for (unsigned int i = 0; i < xyVtx.size(); i++) {
    m_xyVtx[i] = xyVtx[i];
    if (xyVtx[i].first < xmin)
      xmin = xyVtx[i].first;
    if (xyVtx[i].first > xmax)
      xmax = xyVtx[i].first;
    if (xyVtx[i].second < ymin)
      ymin = xyVtx[i].second;
    if (xyVtx[i].second > ymax)
      ymax = xyVtx[i].second;
  }
  double ehalfX = 0.5 * (xmax - xmin);
  double ehalfY = 0.5 * (ymax - ymin);
  m_halfX = fmax(std::abs(xmax), fabs(xmin));
  m_halfY = fmax(std::abs(ymax), fabs(ymin));
  Amg::Transform3D transXY(
    Amg::Translation3D(Amg::Vector3D(0.5 * (xmin + xmax), 0., 0.)) *
    Amg::Translation3D(Amg::Vector3D(0., 0.5 * (ymin + ymax), 0.)));
  m_envelope = new Trk::Volume(
    std::make_unique<Amg::Transform3D>(transXY),
    std::make_shared<Trk::CuboidVolumeBounds>(ehalfX, ehalfY, m_halfZ));
 
  processSubVols();
}

SimplePolygonBrepVolumeBounds() [3/4]

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

Constructor - generic case (from double)

Definition at line 84 of file SimplePolygonBrepVolumeBounds.cxx.

  : VolumeBounds()
  , m_halfX(0.)
  , m_halfY(0.)
  , m_halfZ(halez)
  , m_ordering(-1)
  , m_combinedVolume(nullptr)
  , m_envelope(nullptr)
  , m_objectAccessor()
{
  m_xyVtx.resize(xyVtx.size());
  double xmin = xyVtx[0].first;
  double xmax = xmin;
  double ymin = xyVtx[0].second;
  double ymax = ymin;
  for (unsigned int i = 0; i < xyVtx.size(); i++) {
    m_xyVtx[i] = xyVtx[i];
    if (xyVtx[i].first < xmin)
      xmin = xyVtx[i].first;
    if (xyVtx[i].first > xmax)
      xmax = xyVtx[i].first;
    if (xyVtx[i].second < ymin)
      ymin = xyVtx[i].second;
    if (xyVtx[i].second > ymax)
      ymax = xyVtx[i].second;
  }
  double ehalfX = 0.5 * (xmax - xmin);
  double ehalfY = 0.5 * (ymax - ymin);
  m_halfX = fmax(std::abs(xmax), fabs(xmin));
  m_halfY = fmax(std::abs(ymax), fabs(ymin));
  Amg::Transform3D transXY(
    Amg::Translation3D(Amg::Vector3D(0.5 * (xmin + xmax), 0., 0.)) *
    Amg::Translation3D(Amg::Vector3D(0., 0.5 * (ymin + ymax), 0.)));
  m_envelope = new Trk::Volume(
    std::make_unique<Amg::Transform3D>(transXY),
    std::make_shared<Trk::CuboidVolumeBounds>(ehalfX, ehalfY, m_halfZ));
 
  processSubVols();
}

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:

• SimplePolygonBrepVolumeBounds.h
• SimplePolygonBrepVolumeBounds.cxx