G4BoundingEnvelope Class Reference

#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 ()
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

Definition at line 65 of file G4BoundingEnvelope.hh.

Constructor & Destructor Documentation

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

Definition at line 51 of file G4BoundingEnvelope.cc.

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

G4BoundingEnvelope::G4BoundingEnvelope

(

const std::vector< const G4ThreeVectorList * > &

polygons

)

Definition at line 65 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;
  std::vector<const G4ThreeVectorList*>::const_iterator ibase;
  for (ibase = fPolygons->begin(); ibase != fPolygons->end(); ibase++)
  { 
    std::vector<G4ThreeVector>::const_iterator ipoint;
    for (ipoint = (*ibase)->begin(); ipoint != (*ibase)->end(); ipoint++)
    {
      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();
}

Here is the call graph for this function:

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

Definition at line 106 of file G4BoundingEnvelope.cc.

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

G4BoundingEnvelope::~G4BoundingEnvelope

(

)

Definition at line 121 of file G4BoundingEnvelope.cc.

{
}

Member Function Documentation

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

Definition at line 198 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 283 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 == 0)
    {
      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 == 0)
    {
      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
    {
      std::vector<const G4ThreeVectorList*>::const_iterator ibase;
      for (ibase = fPolygons->begin(); ibase != fPolygons->end(); ibase++)
      { 
        G4ThreeVectorList::const_iterator ipoint;
        for (ipoint = (*ibase)->begin(); ipoint != (*ibase)->end(); ipoint++)
        {
          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;

  // Allocate memory for transformed polygons
  //
  G4int nbases = (fPolygons == 0) ? 2 : fPolygons->size();
  std::vector<G4Polygon3D*> bases(nbases);
  if (fPolygons == 0)
  {
    bases[0] = new G4Polygon3D(4); 
    bases[1] = new G4Polygon3D(4);
  }
  else
  {
    for (G4int i=0; i<nbases; ++i)
    { 
      bases[i] = new G4Polygon3D((*fPolygons)[i]->size());
    }
  }

  //  Transform vertices 
  //
  TransformVertices(pTransform3D, bases);

  // Create adjusted G4VoxelLimits box. New limits are extended by 
  // delta, kCarTolerance multiplied by max scale factor of
  // the transformation
  //
  EAxis axis[] = { kXAxis,kYAxis,kZAxis };
  G4VoxelLimits limits; // default is unlimited 
  for (G4int i=0; i<3; ++i)
  {
    if (pVoxelLimits.IsLimited(axis[i]))
    {
      G4double emin = pVoxelLimits.GetMinExtent(axis[i]) - delta;
      G4double emax = pVoxelLimits.GetMaxExtent(axis[i]) + delta;
      limits.AddLimit(axis[i], emin, emax);
    }
  }

  // Main loop along the set of prisms
  //
  G4Segment3D extent;
  extent.first  = G4Point3D( kInfinity, kInfinity, kInfinity);
  extent.second = G4Point3D(-kInfinity,-kInfinity,-kInfinity);
  for (G4int k=0; k<nbases-1; ++k)
  {
    // Find bounding box of current prism
    G4Polygon3D* baseA = bases[k];
    G4Polygon3D* baseB = bases[k+1];
    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

  // Free memory
  //
  for (G4int i=0; i<nbases; ++i) { delete bases[i]; bases[i] = 0; }

  // 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• source/geant4.10.03.p03/source/geometry/management/include/G4BoundingEnvelope.hh
• source/geant4.10.03.p03/source/geometry/management/src/G4BoundingEnvelope.cc