G4BoundingEnvelope Class Reference

G4BoundingEnvelope is a helper class to facilitate calculation of the extent of a solid within the limits defined by a G4VoxelLimits object. Calculation of the extent takes into account scaling and reflection, if any. More...

#include <G4BoundingEnvelope.hh>

Public Member Functions
	G4BoundingEnvelope (const G4ThreeVector &pMin, const G4ThreeVector &pMax)
	G4BoundingEnvelope (const std::vector< const G4ThreeVectorList * > &polygons)
	G4BoundingEnvelope (const G4ThreeVector &pMin, const G4ThreeVector &pMax, const std::vector< const G4ThreeVectorList * > &polygons)
	~G4BoundingEnvelope ()=default
G4bool	BoundingBoxVsVoxelLimits (const EAxis pAxis, const G4VoxelLimits &pVoxelLimits, const G4Transform3D &pTransform3D, G4double &pMin, G4double &pMax) const
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimits, const G4Transform3D &pTransform3D, G4double &pMin, G4double &pMax) const

Detailed Description

G4BoundingEnvelope is a helper class to facilitate calculation of the extent of a solid within the limits defined by a G4VoxelLimits object. Calculation of the extent takes into account scaling and reflection, if any.

Definition at line 64 of file G4BoundingEnvelope.hh.

Constructor & Destructor Documentation

G4BoundingEnvelope() [1/3]

G4BoundingEnvelope::G4BoundingEnvelope	(	const G4ThreeVector &	pMin,
		const G4ThreeVector &	pMax )

Constructor from an axis aligned bounding box (AABB).

Parameters

[in]	pMin	Lower boundary point.
[in]	pMax	Higher boundary point.

Definition at line 45 of file G4BoundingEnvelope.cc.

  : fMin(pMin), fMax(pMax)
{
  // Check correctness of bounding box
  //
  CheckBoundingBox();
}

G4BoundingEnvelope() [2/3]

G4BoundingEnvelope::G4BoundingEnvelope

(

const std::vector< const G4ThreeVectorList * > &

polygons

)

Constructor from a sequence of convex polygons, the polygons should have equal numbers of vertices except first and last polygons which may consist of a single vertex.

Parameters

[in]

polygons

The list of polygons.

Definition at line 58 of file G4BoundingEnvelope.cc.

  : fPolygons(&polygons)
{
  // Check correctness of polygons
  //
  CheckBoundingPolygons();
 
  // Set bounding box
  //
  G4double xmin =  kInfinity, ymin =  kInfinity, zmin =  kInfinity;
  G4double xmax = -kInfinity, ymax = -kInfinity, zmax = -kInfinity;
  for (const auto & polygon : *fPolygons)
  {
    for (const auto & ipoint : *polygon)
    {
      G4double x = ipoint.x();
      if (x < xmin) { xmin = x; }
      if (x > xmax) { xmax = x; }
      G4double y = ipoint.y();
      if (y < ymin) { ymin = y; }
      if (y > ymax) { ymax = y; }
      G4double z = ipoint.z();
      if (z < zmin) { zmin = z; }
      if (z > zmax) { zmax = z; }
    }
  }
  fMin.set(xmin,ymin,zmin);
  fMax.set(xmax,ymax,zmax);
 
  // Check correctness of bounding box
  //
  CheckBoundingBox();
}

G4BoundingEnvelope() [3/3]

G4BoundingEnvelope::G4BoundingEnvelope	(	const G4ThreeVector &	pMin,
		const G4ThreeVector &	pMax,
		const std::vector< const G4ThreeVectorList * > &	polygons )

Constructor from AABB and a sequence of polygons.

Parameters

[in]	pMin	Lower boundary point.
[in]	pMax	Higher boundary point.
[in]	polygons	The list of polygons.

Definition at line 97 of file G4BoundingEnvelope.cc.

  : fMin(pMin), fMax(pMax), fPolygons(&polygons)
{
  // Check correctness of bounding box and polygons
  //
  CheckBoundingBox();
  CheckBoundingPolygons();
}

~G4BoundingEnvelope()

G4BoundingEnvelope::~G4BoundingEnvelope ( )

default

Default Destructor.

Member Function Documentation

BoundingBoxVsVoxelLimits()

G4bool G4BoundingEnvelope::BoundingBoxVsVoxelLimits	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimits,
		const G4Transform3D &	pTransform3D,
		G4double &	pMin,
		G4double &	pMax ) const

Analyses the position of the bounding box relative to the voxel. It returns "true" in the case where the value of the extent can be figured out directly from the dimensions of the bounding box, or it is clear that the bounding box and the voxel do not intersect. The reply "false" means that further calculations are needed.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimits	The limiting space dictated by voxels.
[in]	pTransform3D	Internal transformation applied to the envelope.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns

True if the envelope is intersected by the extent region.

Definition at line 181 of file G4BoundingEnvelope.cc.

{
  pMin =  kInfinity;
  pMax = -kInfinity;
  G4double xminlim = pVoxelLimits.GetMinXExtent();
  G4double xmaxlim = pVoxelLimits.GetMaxXExtent();
  G4double yminlim = pVoxelLimits.GetMinYExtent();
  G4double ymaxlim = pVoxelLimits.GetMaxYExtent();
  G4double zminlim = pVoxelLimits.GetMinZExtent();
  G4double zmaxlim = pVoxelLimits.GetMaxZExtent();
 
  // Special case of pure translation
  //
  if (pTransform3D.xx()==1 && pTransform3D.yy()==1 && pTransform3D.zz()==1)
  {
    G4double xmin = fMin.x() + pTransform3D.dx();
    G4double xmax = fMax.x() + pTransform3D.dx();
    G4double ymin = fMin.y() + pTransform3D.dy();
    G4double ymax = fMax.y() + pTransform3D.dy();
    G4double zmin = fMin.z() + pTransform3D.dz();
    G4double zmax = fMax.z() + pTransform3D.dz();
 
    if (xmin-kCarTolerance > xmaxlim) { return true; }
    if (xmax+kCarTolerance < xminlim) { return true; }
    if (ymin-kCarTolerance > ymaxlim) { return true; }
    if (ymax+kCarTolerance < yminlim) { return true; }
    if (zmin-kCarTolerance > zmaxlim) { return true; }
    if (zmax+kCarTolerance < zminlim) { return true; }
 
    if (xmin >= xminlim && xmax <= xmaxlim &&
        ymin >= yminlim && ymax <= ymaxlim &&
        zmin >= zminlim && zmax <= zmaxlim)
    {
      if (pAxis == kXAxis)
      {
        pMin = (xmin-kCarTolerance < xminlim) ? xminlim : xmin;
        pMax = (xmax+kCarTolerance > xmaxlim) ? xmaxlim : xmax;
      }
      else if (pAxis == kYAxis)
      {
        pMin = (ymin-kCarTolerance < yminlim) ? yminlim : ymin;
        pMax = (ymax+kCarTolerance > ymaxlim) ? ymaxlim : ymax;
      }
      else if (pAxis == kZAxis)
      {
        pMin = (zmin-kCarTolerance < zminlim) ? zminlim : zmin;
        pMax = (zmax+kCarTolerance > zmaxlim) ? zmaxlim : zmax;
      }
      pMin -= kCarTolerance;
      pMax += kCarTolerance;
      return true;
    }
  }
 
  // Find max scale factor of the transformation, set delta
  // equal to kCarTolerance multiplied by the scale factor
  //
  G4double scale = FindScaleFactor(pTransform3D);
  G4double delta = kCarTolerance*scale;
 
  // Set the sphere surrounding the bounding box
  //
  G4Point3D center = pTransform3D*G4Point3D(0.5*(fMin+fMax));
  G4double  radius = 0.5*scale*(fMax-fMin).mag() + delta;
 
  // Check if the sphere surrounding the bounding box is outside
  // the voxel limits
  //
  if (center.x()-radius > xmaxlim) { return true; }
  if (center.y()-radius > ymaxlim) { return true; }
  if (center.z()-radius > zmaxlim) { return true; }
  if (center.x()+radius < xminlim) { return true; }
  if (center.y()+radius < yminlim) { return true; }
  if (center.z()+radius < zminlim) { return true; }
  return false;
}

Referenced by G4Cons::CalculateExtent(), G4CutTubs::CalculateExtent(), G4EllipticalCone::CalculateExtent(), G4EllipticalTube::CalculateExtent(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), G4GenericTrap::CalculateExtent(), G4Orb::CalculateExtent(), G4Para::CalculateExtent(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4TessellatedSolid::CalculateExtent(), G4Tet::CalculateExtent(), G4Torus::CalculateExtent(), G4Trap::CalculateExtent(), G4Trd::CalculateExtent(), and G4Tubs::CalculateExtent().

CalculateExtent()

G4bool G4BoundingEnvelope::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimits,
		const G4Transform3D &	pTransform3D,
		G4double &	pMin,
		G4double &	pMax ) const

Calculates the minimum and maximum extent of the bounding envelope, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimits	The limiting space dictated by voxels.
[in]	pTransform3D	Internal transformation applied to the envelope.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns

True if the envelope is intersected by the extent region.

Definition at line 267 of file G4BoundingEnvelope.cc.

{
  pMin =  kInfinity;
  pMax = -kInfinity;
  G4double xminlim = pVoxelLimits.GetMinXExtent();
  G4double xmaxlim = pVoxelLimits.GetMaxXExtent();
  G4double yminlim = pVoxelLimits.GetMinYExtent();
  G4double ymaxlim = pVoxelLimits.GetMaxYExtent();
  G4double zminlim = pVoxelLimits.GetMinZExtent();
  G4double zmaxlim = pVoxelLimits.GetMaxZExtent();
 
  // Special case of pure translation
  //
  if (pTransform3D.xx()==1 && pTransform3D.yy()==1 && pTransform3D.zz()==1)
  {
    G4double xmin = fMin.x() + pTransform3D.dx();
    G4double xmax = fMax.x() + pTransform3D.dx();
    G4double ymin = fMin.y() + pTransform3D.dy();
    G4double ymax = fMax.y() + pTransform3D.dy();
    G4double zmin = fMin.z() + pTransform3D.dz();
    G4double zmax = fMax.z() + pTransform3D.dz();
 
    if (xmin-kCarTolerance > xmaxlim) { return false; }
    if (xmax+kCarTolerance < xminlim) { return false; }
    if (ymin-kCarTolerance > ymaxlim) { return false; }
    if (ymax+kCarTolerance < yminlim) { return false; }
    if (zmin-kCarTolerance > zmaxlim) { return false; }
    if (zmax+kCarTolerance < zminlim) { return false; }
 
    if (fPolygons == nullptr)
    {
      if (pAxis == kXAxis)
      {
        pMin = (xmin-kCarTolerance < xminlim) ? xminlim : xmin;
        pMax = (xmax+kCarTolerance > xmaxlim) ? xmaxlim : xmax;
      }
      else if (pAxis == kYAxis)
      {
        pMin = (ymin-kCarTolerance < yminlim) ? yminlim : ymin;
        pMax = (ymax+kCarTolerance > ymaxlim) ? ymaxlim : ymax;
      }
      else if (pAxis == kZAxis)
      {
        pMin = (zmin-kCarTolerance < zminlim) ? zminlim : zmin;
        pMax = (zmax+kCarTolerance > zmaxlim) ? zmaxlim : zmax;
      }
      pMin -= kCarTolerance;
      pMax += kCarTolerance;
      return true;
    }
  }
 
  // Find max scale factor of the transformation, set delta
  // equal to kCarTolerance multiplied by the scale factor
  //
  G4double scale = FindScaleFactor(pTransform3D);
  G4double delta = kCarTolerance*scale;
 
  // Set the sphere surrounding the bounding box
  //
  G4Point3D center = pTransform3D*G4Point3D(0.5*(fMin+fMax));
  G4double  radius = 0.5*scale*(fMax-fMin).mag() + delta;
 
  // Check if the sphere surrounding the bounding box is within
  // the voxel limits, if so then transform only one coordinate
  //
  if (center.x()-radius >= xminlim && center.x()+radius <= xmaxlim &&
      center.y()-radius >= yminlim && center.y()+radius <= ymaxlim &&
      center.z()-radius >= zminlim && center.z()+radius <= zmaxlim )
  {
    G4double cx, cy, cz, cd;
    if (pAxis == kXAxis)
    {
      cx = pTransform3D.xx();
      cy = pTransform3D.xy();
      cz = pTransform3D.xz();
      cd = pTransform3D.dx();
    }
    else if (pAxis == kYAxis)
    {
      cx = pTransform3D.yx();
      cy = pTransform3D.yy();
      cz = pTransform3D.yz();
      cd = pTransform3D.dy();
    }
    else if (pAxis == kZAxis)
    {
      cx = pTransform3D.zx();
      cy = pTransform3D.zy();
      cz = pTransform3D.zz();
      cd = pTransform3D.dz();
    }
    else
    {
      cx = cy = cz = cd = kInfinity;
    }
    G4double emin = kInfinity, emax = -kInfinity;
    if (fPolygons == nullptr)
    {
      G4double coor;
      coor = cx*fMin.x() + cy*fMin.y() + cz*fMin.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
      coor = cx*fMax.x() + cy*fMin.y() + cz*fMin.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
      coor = cx*fMax.x() + cy*fMax.y() + cz*fMin.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
      coor = cx*fMin.x() + cy*fMax.y() + cz*fMin.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
      coor = cx*fMin.x() + cy*fMin.y() + cz*fMax.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
      coor = cx*fMax.x() + cy*fMin.y() + cz*fMax.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
      coor = cx*fMax.x() + cy*fMax.y() + cz*fMax.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
      coor = cx*fMin.x() + cy*fMax.y() + cz*fMax.z() + cd;
      if (coor < emin) { emin = coor; }
      if (coor > emax) { emax = coor; }
    }
    else
    {
      for (const auto & polygon : *fPolygons)
      {
        for (const auto & ipoint : *polygon)
        {
          G4double coor = ipoint.x()*cx + ipoint.y()*cy + ipoint.z()*cz + cd;
          if (coor < emin) { emin = coor; }
          if (coor > emax) { emax = coor; }
        }
      }
    }
    pMin = emin - delta;
    pMax = emax + delta;
    return true;
  }
 
  // Check if the sphere surrounding the bounding box is outside
  // the voxel limits
  //
  if (center.x()-radius > xmaxlim) { return false; }
  if (center.y()-radius > ymaxlim) { return false; }
  if (center.z()-radius > zmaxlim) { return false; }
  if (center.x()+radius < xminlim) { return false; }
  if (center.y()+radius < yminlim) { return false; }
  if (center.z()+radius < zminlim) { return false; }
 
  // Transform polygons
  //
  std::vector<G4Point3D> vertices;
  std::vector<std::pair<G4int, G4int>> bases;
  TransformVertices(pTransform3D, vertices, bases);
  std::size_t nbases = bases.size();
 
  // Create adjusted G4VoxelLimits box. New limits are extended by
  // delta, kCarTolerance multiplied by max scale factor of
  // the transformation
  //
  EAxis axes[] = { kXAxis, kYAxis, kZAxis };
  G4VoxelLimits limits; // default is unlimited
  for (const auto & iAxis : axes)
  {
    if (pVoxelLimits.IsLimited(iAxis))
    {
      G4double emin = pVoxelLimits.GetMinExtent(iAxis) - delta;
      G4double emax = pVoxelLimits.GetMaxExtent(iAxis) + delta;
      limits.AddLimit(iAxis, emin, emax);
    }
  }
 
  // Main loop along the set of prisms
  //
  G4Polygon3D baseA, baseB;
  G4Segment3D extent;
  extent.first  = G4Point3D( kInfinity, kInfinity, kInfinity);
  extent.second = G4Point3D(-kInfinity,-kInfinity,-kInfinity);
  for (std::size_t k=0; k<nbases-1; ++k)
  {
    baseA.resize(bases[k].second);
    for (G4int i = 0; i < bases[k].second; ++i)
    {
      baseA[i] = vertices[bases[k].first + i];
    }
 
    baseB.resize(bases[k+1].second);
    for (G4int i = 0; i < bases[k+1].second; ++i)
    {
      baseB[i] = vertices[bases[k+1].first + i];
    }
 
    // Find bounding box of current prism
    G4Segment3D  prismAABB;
    GetPrismAABB(baseA, baseB, prismAABB);
 
    // Check if prismAABB is completely within the voxel limits
    if (prismAABB.first.x() >= limits.GetMinXExtent() &&
        prismAABB.first.y() >= limits.GetMinYExtent() &&
        prismAABB.first.z() >= limits.GetMinZExtent() &&
        prismAABB.second.x()<= limits.GetMaxXExtent() &&
        prismAABB.second.y()<= limits.GetMaxYExtent() &&
        prismAABB.second.z()<= limits.GetMaxZExtent())
    {
      if (extent.first.x()  > prismAABB.first.x())
      {
        extent.first.setX( prismAABB.first.x() );
      }
      if (extent.first.y()  > prismAABB.first.y())
      {
        extent.first.setY( prismAABB.first.y() );
      }
      if (extent.first.z()  > prismAABB.first.z())
      {
        extent.first.setZ( prismAABB.first.z() );
      }
      if (extent.second.x() < prismAABB.second.x())
      {
        extent.second.setX(prismAABB.second.x());
      }
      if (extent.second.y() < prismAABB.second.y())
      {
        extent.second.setY(prismAABB.second.y());
      }
      if (extent.second.z() < prismAABB.second.z())
      {
        extent.second.setZ(prismAABB.second.z());
      }
      continue;
    }
 
    // Check if prismAABB is outside the voxel limits
    if (prismAABB.first.x()  > limits.GetMaxXExtent()) { continue; }
    if (prismAABB.first.y()  > limits.GetMaxYExtent()) { continue; }
    if (prismAABB.first.z()  > limits.GetMaxZExtent()) { continue; }
    if (prismAABB.second.x() < limits.GetMinXExtent()) { continue; }
    if (prismAABB.second.y() < limits.GetMinYExtent()) { continue; }
    if (prismAABB.second.z() < limits.GetMinZExtent()) { continue; }
 
    // Clip edges of the prism by adjusted G4VoxelLimits box
    std::vector<G4Segment3D> vecEdges;
    CreateListOfEdges(baseA, baseB, vecEdges);
    if (ClipEdgesByVoxel(vecEdges, limits, extent)) { continue; }
 
    // Some edges of the prism are completely outside of the voxel
    // limits, clip selected edges (see bits) of adjusted G4VoxelLimits
    // by the prism
    G4int bits = 0x000;
    if (limits.GetMinXExtent() < prismAABB.first.x())
    {
      bits |= 0x988; // 1001 1000 1000
    }
    if (limits.GetMaxXExtent() > prismAABB.second.x())
    {
      bits |= 0x622; // 0110 0010 0010
    }
 
    if (limits.GetMinYExtent() < prismAABB.first.y())
    {
      bits |= 0x311; // 0011 0001 0001
    }
    if (limits.GetMaxYExtent() > prismAABB.second.y())
    {
      bits |= 0xC44; // 1100 0100 0100
    }
 
    if (limits.GetMinZExtent() < prismAABB.first.z())
    {
      bits |= 0x00F; // 0000 0000 1111
    }
    if (limits.GetMaxZExtent() > prismAABB.second.z())
    {
      bits |= 0x0F0; // 0000 1111 0000
    }
    if (bits == 0xFFF) { continue; }
 
    std::vector<G4Plane3D> vecPlanes;
    CreateListOfPlanes(baseA, baseB, vecPlanes);
    ClipVoxelByPlanes(bits, limits, vecPlanes, prismAABB, extent);
  } // End of the main loop
 
  // Final adjustment of the extent
  //
  G4double emin = 0, emax = 0;
  if (pAxis == kXAxis) { emin = extent.first.x(); emax = extent.second.x(); }
  if (pAxis == kYAxis) { emin = extent.first.y(); emax = extent.second.y(); }
  if (pAxis == kZAxis) { emin = extent.first.z(); emax = extent.second.z(); }
 
  if (emin > emax) { return false; }
  emin -= delta;
  emax += delta;
  G4double minlim = pVoxelLimits.GetMinExtent(pAxis);
  G4double maxlim = pVoxelLimits.GetMaxExtent(pAxis);
  pMin = (emin < minlim) ? minlim-kCarTolerance : emin;
  pMax = (emax > maxlim) ? maxlim+kCarTolerance : emax;
  return true;
}

Referenced by G4Box::CalculateExtent(), G4Cons::CalculateExtent(), G4CutTubs::CalculateExtent(), G4Ellipsoid::CalculateExtent(), G4EllipticalCone::CalculateExtent(), G4EllipticalTube::CalculateExtent(), G4ExtrudedSolid::CalculateExtent(), G4GenericPolycone::CalculateExtent(), G4GenericTrap::CalculateExtent(), G4Hype::CalculateExtent(), G4MultiUnion::CalculateExtent(), G4Orb::CalculateExtent(), G4Para::CalculateExtent(), G4Paraboloid::CalculateExtent(), G4Polycone::CalculateExtent(), G4Polyhedra::CalculateExtent(), G4ScaledSolid::CalculateExtent(), G4Sphere::CalculateExtent(), G4TessellatedSolid::CalculateExtent(), G4Tet::CalculateExtent(), G4Torus::CalculateExtent(), G4Trap::CalculateExtent(), G4Trd::CalculateExtent(), G4Tubs::CalculateExtent(), G4TwistedTubs::CalculateExtent(), and G4VTwistedFaceted::CalculateExtent().

---

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

• G4BoundingEnvelope.hh
• G4BoundingEnvelope.cc