#include <UVCSGfaceted.hh>

Inheritance diagram for UVCSGfaceted:

Public Member Functions
	UVCSGfaceted (const std::string &name)

virtual	~UVCSGfaceted ()

	UVCSGfaceted (const UVCSGfaceted &source)

UVCSGfaceted &	operator= (const UVCSGfaceted &source)

VUSolid::EnumInside	InsideNoVoxels (const UVector3 &p) const

virtual VUSolid::EnumInside	Inside (const UVector3 &p) const

virtual bool	Normal (const UVector3 &p, UVector3 &n) const

double	DistanceToInNoVoxels (const UVector3 &p, const UVector3 &v) const

virtual double	DistanceToIn (const UVector3 &p, const UVector3 &v, double aPstep=UUtils::kInfinity) const

virtual double	SafetyFromOutside (const UVector3 &aPoint, bool aAccurate=false) const

double	DistanceTo (const UVector3 &p, const bool outgoing) const

double	DistanceToOutNoVoxels (const UVector3 &p, const UVector3 &v, UVector3 &n, bool &aConvex) const

virtual double	DistanceToOut (const UVector3 &p, const UVector3 &v, UVector3 &n, bool &aConvex, double aPstep=UUtils::kInfinity) const

virtual double	SafetyFromInside (const UVector3 &aPoint, bool aAccurate=false) const

virtual double	SafetyFromInsideNoVoxels (const UVector3 &aPoint, bool aAccurate=false) const

virtual UGeometryType	GetEntityType () const

virtual std::ostream &	StreamInfo (std::ostream &os) const

int	GetCubVolStatistics () const

double	GetCubVolEpsilon () const

void	SetCubVolStatistics (int st)

void	SetCubVolEpsilon (double ep)

int	GetAreaStatistics () const

double	GetAreaAccuracy () const

void	SetAreaStatistics (int st)

void	SetAreaAccuracy (double ep)

virtual double	Capacity ()

virtual double	SurfaceArea ()

Public Member Functions inherited from VUSolid
	VUSolid ()

	VUSolid (const std::string &name)

virtual	~VUSolid ()

double	GetCarTolerance () const

double	GetRadTolerance () const

double	GetAngTolerance () const

void	SetCarTolerance (double eps)

void	SetRadTolerance (double eps)

void	SetAngTolerance (double eps)

virtual void	ExtentAxis (EAxisType aAxis, double &aMin, double &aMax) const

virtual void	Extent (UVector3 &aMin, UVector3 &aMax) const =0

const std::string &	GetName () const

void	SetName (const std::string &aName)

virtual void	SamplePointsInside (int, UVector3 *) const

virtual void	SamplePointsOnSurface (int, UVector3 *) const

virtual void	SamplePointsOnEdge (int, UVector3 *) const

virtual void	GetParametersList (int aNumber, double *aArray) const =0

virtual VUSolid *	Clone () const =0

virtual UVector3	GetPointOnSurface () const =0

double	EstimateCubicVolume (int nStat, double epsilon) const

double	EstimateSurfaceArea (int nStat, double ell) const

Protected Member Functions
double	SafetyFromInsideSection (int index, const UVector3 &p, UBits &bits) const

int	GetSection (double z) const

UVector3	GetPointOnSurfaceGeneric () const

void	CopyStuff (const UVCSGfaceted &source)

void	DeleteStuff ()

void	FindCandidates (double z, std::vector< int > &candidates, bool sides=false)

void	InitVoxels (UReduciblePolygon &z, double radius)

Protected Member Functions inherited from VUSolid
virtual void	ComputeBBox (UBBox *aBox, bool aStore=false)=0

Protected Attributes
int	numFace

UVCSGface **	faces

double	fCubicVolume

double	fSurfaceArea

std::vector< double >	fZs

std::vector< std::vector< int > >	fCandidates

int	fMaxSection

UBox	fBox

double	fBoxShift

bool	fNoVoxels

Additional Inherited Members
Public Types inherited from VUSolid
enum	EnumInside { eInside =0, eSurface =1, eOutside =2 }

enum	EAxisType { eXaxis =0, eYaxis =1, eZaxis =2 }

Static Public Member Functions inherited from VUSolid
static double	Tolerance ()

Static Protected Attributes inherited from VUSolid
static double	fgTolerance = 1.0E-9

static double	frTolerance = 1.0E-9

static double	faTolerance = 1.0E-9

Detailed Description

Definition at line 33 of file UVCSGfaceted.hh.

Constructor & Destructor Documentation

UVCSGfaceted::UVCSGfaceted ( const std::string & name )

Definition at line 31 of file UVCSGfaceted.cc.

   : VUSolid(name),
     numFace(0), faces(0), fCubicVolume(0.), fSurfaceArea(0.),
     fMaxSection(0),fBoxShift(0.), fNoVoxels(true),fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.)
 {
 }

UVCSGfaceted::~UVCSGfaceted ( )

virtual

Definition at line 41 of file UVCSGfaceted.cc.

References DeleteStuff().

 {
   DeleteStuff();
 }

UVCSGfaceted::UVCSGfaceted ( const UVCSGfaceted & source )

Definition at line 49 of file UVCSGfaceted.cc.

References CopyStuff().

   : VUSolid(source)
 {
   fStatistics = source.fStatistics;
   fCubVolEpsilon = source.fCubVolEpsilon;
   fAreaAccuracy = source.fAreaAccuracy;
 
   CopyStuff(source);
 }

Member Function Documentation

double UVCSGfaceted::Capacity ( )

virtual

Implements VUSolid.

Definition at line 519 of file UVCSGfaceted.cc.

References VUSolid::EstimateCubicVolume(), and fCubicVolume.

 {
   if (fCubicVolume != 0.)
   {
     ;
   }
   else
   {
     fCubicVolume = EstimateCubicVolume(fStatistics, fCubVolEpsilon);
   }
   return fCubicVolume;
 }

void UVCSGfaceted::CopyStuff ( const UVCSGfaceted & source )

protected

Definition at line 91 of file UVCSGfaceted.cc.

References UVCSGface::Clone(), faces, fBox, fBoxShift, fCubicVolume, fMaxSection, fNoVoxels, fSurfaceArea, fZs, and numFace.

Referenced by operator=(), and UVCSGfaceted().

 {
   numFace = source.numFace;
   if (numFace == 0)
   {
     return;  // odd, but permissable?
   }
 
   faces = new UVCSGface*[numFace];
 
   UVCSGface** face = faces,
               **sourceFace = source.faces;
   do
   {
     *face = (*sourceFace)->Clone();
   }
   while (++sourceFace, ++face < faces + numFace);
   fCubicVolume = source.fCubicVolume;
   fSurfaceArea = source.fSurfaceArea;
 
   fMaxSection = source.fMaxSection;
   fNoVoxels = source.fNoVoxels;
   fZs = source.fZs;
   fBox = source.fBox;
   fBoxShift = source.fBoxShift;
 }

void UVCSGfaceted::DeleteStuff ( )

protected

Definition at line 124 of file UVCSGfaceted.cc.

References faces, and numFace.

Referenced by UPolyhedra::Reset(), and ~UVCSGfaceted().

 {
   if (numFace)
   {
     UVCSGface** face = faces;
     do
     {
       delete *face;
     }
     while (++face < faces + numFace);
 
     delete [] faces;
   }
 }

double UVCSGfaceted::DistanceTo	(	const UVector3 &	p,
		const bool	outgoing
	)		const

Definition at line 399 of file UVCSGfaceted.cc.

References faces, VUSolid::fgTolerance, and numFace.

Referenced by SafetyFromInsideNoVoxels(), and SafetyFromOutside().

 {
   UVCSGface** face = faces;
   double best = UUtils::kInfinity;
   do
   {
     double distance = (*face)->Safety(p, outgoing);
     if (distance < best)  best = distance;
   }
   while (++face < faces + numFace);
 
   return (best < 0.5 * fgTolerance) ? 0 : best;
 }

double UVCSGfaceted::DistanceToIn	(	const UVector3 &	p,
		const UVector3 &	v,
		double	aPstep = `UUtils::kInfinity`
	)		const

virtual

Implements VUSolid.

Reimplemented in UPolyhedra, and UGenericPolycone.

Definition at line 670 of file UVCSGfaceted.cc.

References UVCSGface::Distance(), UBox::DistanceToIn(), DistanceToInNoVoxels(), faces, fBox, fBoxShift, fCandidates, VUSolid::fgTolerance, fMaxSection, fNoVoxels, fZs, GetSection(), numFace, UVCSGface::Safety(), UBits::SetBitNumber(), UVector3::x, UVector3::y, z, and UVector3::z.

Referenced by UGenericPolycone::DistanceToIn(), and UPolyhedra::DistanceToIn().

 {
   if (fNoVoxels) return DistanceToInNoVoxels(p, v);
 
   UVector3 pb(p.x, p.y, p.z - fBoxShift);
 
   double idistance, shift;
   idistance = fBox.DistanceToIn(pb, v); // using only box, this appears
   // to be faster than: idistance = enclosingCylinder->DistanceTo(pb, v);
   if (idistance >= UUtils::kInfinity) return idistance;
 
   // this line can be here or not. not a big difference in performance
   // TODO: fix enclosingCylinder for polyhedra!!! - the current radius appears to be too small
   //  if (enclosingCylinder->ShouldMiss(p, v)) return UUtils::kInfinity;
 
   // this just takes too much time
   //  idistance = enclosingCylinder->DistanceTo(pb, v);
   //  if (idistance == UUtils::kInfinity) return idistance;
 
   double z = p.z + idistance * v.z;
   int index = GetSection(z);
   int increment = (v.z > 0) ? 1 : -1;
   if (std::fabs(v.z) < fgTolerance) increment = 0;
 
   double distance = UUtils::kInfinity;
   double distFromSurface = UUtils::kInfinity;
   UVCSGface* bestFace = 0;
   UBits bits(numFace);
   UVector3 faceNormal;
 
   do
   {
     const vector<int>& candidates = fCandidates[index];
     int size = candidates.size();
     for (int i = 0; i < size; ++i)
     {
       int candidate = candidates[i];
       if (!bits[candidate])
       {
         bits.SetBitNumber(candidate);
         UVCSGface& face = *faces[candidate];
 
         double   faceDistance,
                  faceDistFromSurface;
         bool    faceAllBehind;
         if (face.Distance(p, v, false, fgTolerance * 0.5,
                           faceDistance, faceDistFromSurface,
                           faceNormal, faceAllBehind))
         {
           // Intersecting face
           if (faceDistance < distance)
           {
             distance = faceDistance;
             distFromSurface = faceDistFromSurface;
             bestFace = &face;
             if (distFromSurface <= 0) return 0;
           }
         }
       }
     }
 
     if (!increment)
       break;
 
     index += increment;
     if (index < 0 || index > fMaxSection)
       break;
     int newz = increment > 0 ? index  : index + 1;
     shift = (fZs[newz] - z) / v.z;
   }
   while (idistance + shift < distance);
 
   if (distance < UUtils::kInfinity && distFromSurface < fgTolerance / 2)
   {
     if (bestFace->Safety(p, false) < fgTolerance / 2)
     {
       distance = 0;
     }
   }
 
   return distance;
 }

double UVCSGfaceted::DistanceToInNoVoxels	(	const UVector3 &	p,
		const UVector3 &	v
	)		const

inline

Definition at line 272 of file UVCSGfaceted.cc.

References faces, VUSolid::fgTolerance, numFace, and UVCSGface::Safety().

Referenced by DistanceToIn().

 {
   double distance = UUtils::kInfinity;
   double distFromSurface = UUtils::kInfinity;
   UVCSGface** face = faces;
   UVCSGface* bestFace = *face;
   static double htol = fgTolerance * 0.5;
   UVector3 faceNormal;
 
   do
   {
     double   faceDistance, faceDistFromSurface;
     bool    faceAllBehind;
     if ((*face)->Distance(p, v, false, htol,
                           faceDistance, faceDistFromSurface,
                           faceNormal, faceAllBehind))
     {
       //
       // Intersecting face
       //
       if (faceDistance < distance)
       {
         distance = faceDistance;
         distFromSurface = faceDistFromSurface;
         bestFace = *face;
         if (distFromSurface <= 0)
         {
           return 0;
         }
       }
     }
   }
   while (++face < faces + numFace);
 
   if (distance < UUtils::kInfinity && distFromSurface < htol)
   {
     if (bestFace->Safety(p, false) < htol)
     {
       distance = 0;
     }
   }
 
   return distance;
 }

double UVCSGfaceted::DistanceToOut	(	const UVector3 &	p,
		const UVector3 &	v,
		UVector3 &	n,
		bool &	aConvex,
		double	aPstep = `UUtils::kInfinity`
	)		const

virtual

Implements VUSolid.

Definition at line 755 of file UVCSGfaceted.cc.

References UVCSGface::Distance(), DistanceToOutNoVoxels(), VUSolid::eSurface, faces, fCandidates, VUSolid::fgTolerance, fMaxSection, fNoVoxels, fZs, GetSection(), Inside(), numFace, UVCSGface::Safety(), UBits::SetBitNumber(), and UVector3::z.

 {
   if (fNoVoxels) return DistanceToOutNoVoxels(p, v, n, aConvex);
 
   int index =  GetSection(p.z);
   int increment = (v.z > 0) ? 1 : -1;
 
   bool allBehind = true;
   double distance = UUtils::kInfinity;
   double distFromSurface = UUtils::kInfinity;
   UVector3 normal, faceNormal;
   double shift;
 
   UVCSGface* bestFace = 0;
   UBits bits(numFace);
 
   do
   {
     const vector<int>& candidates = fCandidates[index];
     int size = candidates.size();
     for (int i = 0; i < size; ++i)
     {
       int candidate = candidates[i];
       if (!bits[candidate])
       {
         bits.SetBitNumber(candidate);
         UVCSGface& face = *faces[candidate];
 
         double faceDistance, faceDistFromSurface;
         bool faceAllBehind;
         if ((face.Distance(p, v, true, fgTolerance * 0.5, faceDistance, faceDistFromSurface,
                            faceNormal, faceAllBehind)))
         {
           // Intersecting face
           if ((distance < UUtils::kInfinity) || (!faceAllBehind))
           {
             allBehind = false;
           }
           if (faceDistance < distance)
           {
             distance = faceDistance;
             distFromSurface = faceDistFromSurface;
             normal = faceNormal;
             bestFace = &face;
             if (distFromSurface <= 0) break;
           }
         }
       }
     }
 
     if (distFromSurface <= 0) break;
     if (!increment) break;
 
     index += increment;
     if (index < 0 || index > fMaxSection)
       break;
     int newz = increment > 0 ? index  : index + 1;
     shift = (fZs[newz] - p.z) / v.z;
   }
   while (shift < distance);
 
   if (distance < UUtils::kInfinity)
   {
     if (distFromSurface <= 0)
     {
       distance = 0;
     }
     else if (distFromSurface < fgTolerance / 2)
     {
       if (bestFace->Safety(p, true) < fgTolerance * 0.5)
       {
         distance = 0;
       }
     }
 
     aConvex = allBehind;
     n = normal;
   }
   else
   {
     if (Inside(p) == eSurface)
     {
       distance = 0;
     }
     aConvex = false;
   }
 
   return distance;
 }

double UVCSGfaceted::DistanceToOutNoVoxels	(	const UVector3 &	p,
		const UVector3 &	v,
		UVector3 &	n,
		bool &	aConvex
	)		const

inline

Definition at line 325 of file UVCSGfaceted.cc.

References VUSolid::eSurface, faces, VUSolid::fgTolerance, Inside(), numFace, and UVCSGface::Safety().

Referenced by DistanceToOut().

 {
   bool allBehind = true;
   double distance = UUtils::kInfinity;
   double distFromSurface = UUtils::kInfinity;
   UVector3 normal, faceNormal;
 
   UVCSGface** face = faces;
   UVCSGface* bestFace = *face;
   do
   {
     double faceDistance, faceDistFromSurface;
     bool faceAllBehind;
     if ((*face)->Distance(p, v, true, fgTolerance / 2,
                           faceDistance, faceDistFromSurface,
                           faceNormal, faceAllBehind))
     {
       // Intersecting face
       if ((distance < UUtils::kInfinity) || (!faceAllBehind))
       {
         allBehind = false;
       }
       if (faceDistance < distance)
       {
         distance = faceDistance;
         distFromSurface = faceDistFromSurface;
         normal = faceNormal;
         bestFace = *face;
         if (distFromSurface <= 0)
         {
           break;
         }
       }
     }
   }
   while (++face < faces + numFace);
 
   if (distance < UUtils::kInfinity)
   {
     if (distFromSurface <= 0)
     {
       distance = 0;
     }
     else if (distFromSurface < fgTolerance / 2)
     {
       if (bestFace->Safety(p, true) < fgTolerance / 2)
       {
         distance = 0;
       }
     }
 
     aConvex = allBehind;
     n = normal;
   }
   else
   {
     if (Inside(p) == eSurface)
     {
       distance = 0;
     }
     aConvex = false;
   }
 
   return distance;
 }

void UVCSGfaceted::FindCandidates	(	double	z,
		std::vector< int > &	candidates,
		bool	sides = `false`
	)

protected

Definition at line 653 of file UVCSGfaceted.cc.

References UVCSGface::Extent(), faces, VUSolid::fgTolerance, and numFace.

Referenced by InitVoxels().

 {
   for (int j = 0; j < numFace; j++)
   {
     UVCSGface* face = faces[j];
     double minZ = -face->Extent(UVector3(0, 0, -1)) ;
     double maxZ = face->Extent(UVector3(0, 0, 1));
     if (z >= minZ - fgTolerance * 10 && z <= maxZ  + fgTolerance * 10)
     {
       if (!sides || std::fabs(minZ - maxZ) < fgTolerance * 10)
         if (std::find(candidates.begin(), candidates.end(), j) == candidates.end())
           candidates.push_back(j);
     }
   }
 }

double UVCSGfaceted::GetAreaAccuracy ( ) const

Definition at line 490 of file UVCSGfaceted.cc.

 {
   return fAreaAccuracy;
 }

int UVCSGfaceted::GetAreaStatistics ( ) const

Definition at line 481 of file UVCSGfaceted.cc.

 {
   return fStatistics;
 }

double UVCSGfaceted::GetCubVolEpsilon ( ) const

Definition at line 452 of file UVCSGfaceted.cc.

 {
   return fCubVolEpsilon;
 }

int UVCSGfaceted::GetCubVolStatistics ( ) const

Definition at line 443 of file UVCSGfaceted.cc.

 {
   return fStatistics;
 }

UGeometryType UVCSGfaceted::GetEntityType ( ) const

virtual

Implements VUSolid.

Reimplemented in UPolyhedra, and UGenericPolycone.

Definition at line 417 of file UVCSGfaceted.cc.

 {
   return std::string("UCSGfaceted");
 }

UVector3 UVCSGfaceted::GetPointOnSurfaceGeneric ( ) const

protected

Definition at line 553 of file UVCSGfaceted.cc.

References faces, numFace, UUtils::Random(), and UVCSGface::SurfaceArea().

Referenced by UGenericPolycone::GetPointOnSurface(), and UPolyhedra::GetPointOnSurface().

 {
   // Preparing variables
   //
   UVector3 answer = UVector3(0., 0., 0.);
   UVCSGface** face = faces;
   double area = 0;
   int i;
   std::vector<double> areas;
 
   // First step: calculate surface areas
   //
   do
   {
     double result = (*face)->SurfaceArea();
     areas.push_back(result);
     area = area + result;
   }
   while (++face < faces + numFace);
 
   // Second Step: choose randomly one surface
   //
   UVCSGface** face1 = faces;
   double chose = area * UUtils::Random();
   double Achose1, Achose2;
   Achose1 = 0;
   Achose2 = 0.;
   i = 0;
 
   do
   {
     Achose2 += areas[i];
     if (chose >= Achose1 && chose < Achose2)
     {
       UVector3 point;
       point = (*face1)->GetPointOnFace();
       return point;
     }
     i++;
     Achose1 = Achose2;
   }
   while (++face1 < faces + numFace);
 
   return answer;
 }

int UVCSGfaceted::GetSection ( double z ) const

inlineprotected

Definition at line 104 of file UVCSGfaceted.hh.

References UVoxelizer::BinarySearch(), fMaxSection, and fZs.

Referenced by DistanceToIn(), DistanceToOut(), Inside(), and Normal().

     {
       int section = UVoxelizer::BinarySearch(fZs, z);
       if (section < 0) section = 0;
       else if (section > fMaxSection) section = fMaxSection;
       return section;
     }

void UVCSGfaceted::InitVoxels	(	UReduciblePolygon &	z,
		double	radius
	)

protected

Definition at line 615 of file UVCSGfaceted.cc.

References UReduciblePolygon::CopyVertices(), fBox, fBoxShift, fCandidates, FindCandidates(), fMaxSection, fZs, UBox::GetZHalfLength(), left, UReduciblePolygon::NumVertices(), right, UBox::Set(), sort(), test::v, and z.

Referenced by UGenericPolycone::Create(), and UPolyhedra::Create().

 {
   int size = rz.NumVertices() + 1;
   vector<double> r(size), z(size), zs;
   rz.CopyVertices(&r[0], &z[0]);
 
   fZs.clear();
   for (int i = 0; i < size; ++i)
   {
     double v = z[i];
     if (std::find(fZs.begin(), fZs.end(), v) == fZs.end())
     {
       fZs.push_back(v);
     }
     std::sort(fZs.begin(), fZs.end());
   }
 
   size = fZs.size();
   fMaxSection = size - 2;
 
   for (int i = 0; i <= fMaxSection; ++i)
   {
     vector<int> candidates;
 
     double left = fZs[i], right = fZs[i + 1];
     double middle = (left + right) / 2;
     FindCandidates(middle, candidates);
 
     FindCandidates(left, candidates, true);
     FindCandidates(right, candidates, true);
 
     fCandidates.push_back(candidates);
   }
 
   fBox.Set(radius, radius, (fZs.back() - fZs.front()) / 2);
   fBoxShift = fZs[0] + fBox.GetZHalfLength();
 }

VUSolid::EnumInside UVCSGfaceted::Inside ( const UVector3 & p ) const

virtual

Implements VUSolid.

Reimplemented in UPolyhedra, and UGenericPolycone.

Definition at line 846 of file UVCSGfaceted.cc.

References VUSolid::eOutside, VUSolid::eSurface, faces, fCandidates, VUSolid::fgTolerance, fMaxSection, fNoVoxels, fZs, GetSection(), UVCSGface::Inside(), InsideNoVoxels(), numFace, UBits::SetBitNumber(), and UVector3::z.

Referenced by DistanceToOut(), DistanceToOutNoVoxels(), UGenericPolycone::Inside(), and UPolyhedra::Inside().

 {
   if (fNoVoxels) return InsideNoVoxels(p);
 
 //  if (fEnclosingCylinder->MustBeOutside(p)) return eOutside;
 
   int index =  GetSection(p.z);
   double shift;
 
   UBits bits(numFace);
   double best = UUtils::kInfinity;
   VUSolid::EnumInside answer = eOutside;
   int middle = index;
 
   do
   {
     const vector<int>& candidates = fCandidates[index];
     int size = candidates.size();
     for (int i = 0; i < size; ++i)
     {
       int candidate = candidates[i];
       if (!bits[candidate])
       {
         UVCSGface& face = *faces[candidate];
 
         double distance;
         VUSolid::EnumInside result = face.Inside(p, fgTolerance * 0.5, &distance);
         if (result == eSurface) return eSurface;
         if (distance < best)
         {
           best = distance;
           answer = result;
         }
         bits.SetBitNumber(candidate);
       }
     }
 
     if (index <= middle)
     {
       if (--index >= 0)
       {
         shift = fZs[index + 1] - p.z;
         if (shift < best) continue;
       }
       index = middle;
     }
     if (++index > fMaxSection) break;
     shift = p.z - fZs[index];
   }
   while (shift > best);
 
   return answer;
 }

VUSolid::EnumInside UVCSGfaceted::InsideNoVoxels ( const UVector3 & p ) const

inline

Definition at line 179 of file UVCSGfaceted.cc.

References VUSolid::eOutside, VUSolid::eSurface, faces, VUSolid::fgTolerance, and numFace.

Referenced by Inside().

 {
   VUSolid::EnumInside answer = eOutside;
   UVCSGface** face = faces;
   double best = UUtils::kInfinity;
   do
   {
     double distance;
     VUSolid::EnumInside result = (*face)->Inside(p, fgTolerance * 0.5, &distance);
     if (result == eSurface)
     {
       return eSurface;
     }
     if (distance < best)
     {
       best = distance;
       answer = result;
     }
   }
   while (++face < faces + numFace);
 
   return answer;
 }

bool UVCSGfaceted::Normal	(	const UVector3 &	p,
		UVector3 &	n
	)		const

virtual

Implements VUSolid.

Definition at line 209 of file UVCSGfaceted.cc.

References faces, fCandidates, VUSolid::fgTolerance, GetSection(), UVCSGface::Normal(), numFace, UBits::SetBitNumber(), and UVector3::z.

 {
   UVector3 answer;
   double best = UUtils::kInfinity;
   UVector3 normal;
 
   UBits bits(numFace);
 
   int index = GetSection(p.z);
   const vector<int>& candidates = fCandidates[index];
   int size = candidates.size();
   for (int i = 0; i < size; ++i)
   {
     int candidate = candidates[i];
     if (!bits[candidate])
     {
       bits.SetBitNumber(candidate);
       UVCSGface& face = *faces[candidate];
       double distance;
       normal = face.Normal(p, &distance);
       if (distance < best)
       {
         best = distance;
         answer = normal;
         if (distance < fgTolerance)
           break;
       }
     }
   }
   n = answer;
   return true;
 }

UVCSGfaceted & UVCSGfaceted::operator= ( const UVCSGfaceted & source )

Definition at line 63 of file UVCSGfaceted.cc.

References CopyStuff().

Referenced by UGenericPolycone::operator=(), and UPolyhedra::operator=().

 {
   if (&source == this)
   {
     return *this;
   }
 
   // Copy base class data
   //
   VUSolid::operator=(source);
 
   // Copy data
   //
   fStatistics = source.fStatistics;
   fCubVolEpsilon = source.fCubVolEpsilon;
   fAreaAccuracy = source.fAreaAccuracy;
 
   CopyStuff(source);
 
   return *this;
 }

double UVCSGfaceted::SafetyFromInside	(	const UVector3 &	aPoint,
		bool	aAccurate = `false`
	)		const

virtual

Implements VUSolid.

Definition at line 921 of file UVCSGfaceted.cc.

References UVoxelizer::BinarySearch(), VUSolid::fgTolerance, fMaxSection, fNoVoxels, fZs, numFace, SafetyFromInsideNoVoxels(), SafetyFromInsideSection(), and UVector3::z.

 {
   if (fNoVoxels) return SafetyFromInsideNoVoxels(p);
 
   int index = UVoxelizer::BinarySearch(fZs, p.z);
   if (index < 0 || index > fMaxSection) return 0;
 
   UBits bits(numFace);
   double minSafety = SafetyFromInsideSection(index, p, bits);
 
   if (minSafety > UUtils::kInfinity) return 0;
   if (minSafety < 1e-6) return 0;
 
   double zbase = fZs[index + 1];
   for (int i = index + 1; i <= fMaxSection; ++i)
   {
     double dz = fZs[i] - zbase;
     if (dz >= minSafety) break;
     double safety = SafetyFromInsideSection(i, p, bits);
     if (safety < minSafety) minSafety = safety;
   }
 
   if (index > 0)
   {
     zbase = fZs[index - 1];
     for (int i = index - 1; i >= 0; --i)
     {
       double dz = zbase - fZs[i];
       if (dz >= minSafety) break;
       double safety = SafetyFromInsideSection(i, p, bits);
       if (safety < minSafety) minSafety = safety;
     }
   }
   return (minSafety < 0.5 * fgTolerance) ? 0 : minSafety;
 }

double UVCSGfaceted::SafetyFromInsideNoVoxels	(	const UVector3 &	aPoint,
		bool	aAccurate = `false`
	)		const

virtual

Definition at line 609 of file UVCSGfaceted.cc.

References DistanceTo().

Referenced by SafetyFromInside().

 {
   return DistanceTo(p, true);
 }

double UVCSGfaceted::SafetyFromInsideSection	(	int	index,
		const UVector3 &	p,
		UBits &	bits
	)		const

protected

Definition at line 900 of file UVCSGfaceted.cc.

References faces, fCandidates, UVCSGface::Safety(), and UBits::SetBitNumber().

Referenced by SafetyFromInside().

 {
   double best = UUtils::kInfinity;
 
   const vector<int>& candidates = fCandidates[index];
   int size = candidates.size();
   for (int i = 0; i < size; ++i)
   {
     int candidate = candidates[i];
     if (!bits[candidate])
     {
       bits.SetBitNumber(candidate);
       UVCSGface& face = *faces[candidate];
 
       double distance = face.Safety(p, true);
       if (distance < best)  best = distance;
     }
   }
   return best;
 }

double UVCSGfaceted::SafetyFromOutside	(	const UVector3 &	aPoint,
		bool	aAccurate = `false`
	)		const

virtual

Implements VUSolid.

Reimplemented in UPolyhedra.

Definition at line 599 of file UVCSGfaceted.cc.

References DistanceTo(), fBox, fBoxShift, UBox::SafetyFromOutside(), UVector3::x, UVector3::y, and UVector3::z.

Referenced by UPolyhedra::SafetyFromOutside().

 {
   if (!accurate)
   {
     UVector3 pb(p.x, p.y, p.z - fBoxShift);
     return fBox.SafetyFromOutside(pb);
   }
   return DistanceTo(p, false);
 }

void UVCSGfaceted::SetAreaAccuracy ( double ep )

Definition at line 509 of file UVCSGfaceted.cc.

References fSurfaceArea.

 {
   fSurfaceArea = 0.;
   fAreaAccuracy = ep;
 }

void UVCSGfaceted::SetAreaStatistics ( int st )

Definition at line 499 of file UVCSGfaceted.cc.

References fSurfaceArea.

 {
   fSurfaceArea = 0.;
   fStatistics = st;
 }

void UVCSGfaceted::SetCubVolEpsilon ( double ep )

Definition at line 471 of file UVCSGfaceted.cc.

References fCubicVolume.

 {
   fCubicVolume = 0.;
   fCubVolEpsilon = ep;
 }

void UVCSGfaceted::SetCubVolStatistics ( int st )

Definition at line 461 of file UVCSGfaceted.cc.

References fCubicVolume.

 {
   fCubicVolume = 0.;
   fStatistics = st;
 }

std::ostream & UVCSGfaceted::StreamInfo ( std::ostream & os ) const

virtual

Implements VUSolid.

Reimplemented in UPolyhedra, and UGenericPolycone.

Definition at line 426 of file UVCSGfaceted.cc.

References VUSolid::GetName(), and numFace.

 {
   os << "-----------------------------------------------------------\n"
      << "       *** Dump for solid - " << GetName() << " ***\n"
      << "       ===================================================\n"
      << " Solid type: UVCSGfaceted\n"
      << " Parameters: \n"
      << "       number of faces: " << numFace << "\n"
      << "-----------------------------------------------------------\n";
 
   return os;
 }

double UVCSGfaceted::SurfaceArea ( )

virtual

Implements VUSolid.

Definition at line 536 of file UVCSGfaceted.cc.

References VUSolid::EstimateSurfaceArea(), and fSurfaceArea.

 {
   if (fSurfaceArea != 0.)
   {
     ;
   }
   else
   {
     fSurfaceArea = EstimateSurfaceArea(fStatistics, fAreaAccuracy);
   }
   return fSurfaceArea;
 }