#include <G4ClippablePolygon.hh>

Collaboration diagram for G4ClippablePolygon:

Public Member Functions
	G4ClippablePolygon ()

virtual	~G4ClippablePolygon ()

virtual void	AddVertexInOrder (const G4ThreeVector vertex)

virtual void	ClearAllVertices ()

void	SetNormal (const G4ThreeVector &newNormal)

const G4ThreeVector	GetNormal () const

virtual G4bool	Clip (const G4VoxelLimits &voxelLimit)

virtual G4bool	PartialClip (const G4VoxelLimits &voxelLimit, const EAxis IgnoreMe)

virtual void	ClipAlongOneAxis (const G4VoxelLimits &voxelLimit, const EAxis axis)

virtual G4bool	GetExtent (const EAxis axis, G4double &min, G4double &max) const

virtual const G4ThreeVector *	GetMinPoint (const EAxis axis) const

virtual const G4ThreeVector *	GetMaxPoint (const EAxis axis) const

G4int	GetNumVertices () const

G4bool	Empty () const

virtual G4bool	InFrontOf (const G4ClippablePolygon &other, EAxis axis) const

virtual G4bool	BehindOf (const G4ClippablePolygon &other, EAxis axis) const

virtual G4bool	GetPlanerExtent (const G4ThreeVector &pointOnPlane, const G4ThreeVector &planeNormal, G4double &min, G4double &max) const

Protected Member Functions
void	ClipToSimpleLimits (G4ThreeVectorList &pPolygon, G4ThreeVectorList &outputPolygon, const G4VoxelLimits &pVoxelLimit)

Protected Attributes
G4ThreeVectorList	vertices

G4ThreeVector	normal

G4double	kCarTolerance

Detailed Description

Definition at line 55 of file G4ClippablePolygon.hh.

Constructor & Destructor Documentation

G4ClippablePolygon::G4ClippablePolygon ( )

Definition at line 48 of file G4ClippablePolygon.cc.

   : normal(0.,0.,0.)
 {
   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 }

Here is the call graph for this function:

G4ClippablePolygon::~G4ClippablePolygon ( )

virtual

Definition at line 58 of file G4ClippablePolygon.cc.

59 {

60 }

Member Function Documentation

void G4ClippablePolygon::AddVertexInOrder ( const G4ThreeVector vertex )

virtual

Definition at line 66 of file G4ClippablePolygon.cc.

 {
   vertices.push_back( vertex );
 }

Here is the caller graph for this function:

G4bool G4ClippablePolygon::BehindOf	(	const G4ClippablePolygon &	other,
		EAxis	axis
	)		const

virtual

Definition at line 296 of file G4ClippablePolygon.cc.

 {
   //
   // If things are empty, do something semi-sensible
   //
   G4int noLeft = vertices.size();
   if (noLeft==0) return false;
   
   if (other.Empty()) return true;
 
   //
   // Get minimum of other polygon
   //
   const G4ThreeVector *maxPointOther = other.GetMaxPoint( axis );
   const G4double maxOther = maxPointOther->operator()(axis);
   
   //
   // Get minimum of this polygon
   //
   const G4ThreeVector *maxPoint = GetMaxPoint( axis );
   const G4double max = maxPoint->operator()(axis);
   
   //
   // Easy decision
   //
   if (max > maxOther+kCarTolerance) return true;    // Clear winner
   
   if (maxOther > max+kCarTolerance) return false;    // Clear loser
   
   //
   // We have a tie (this will not be all that rare since our
   // polygons are connected)
   //
   // Check to see if there is a vertex in the other polygon
   // that is in front of this one (or vice versa)
   //
   G4bool answer;
   G4ThreeVector normalOther = other.GetNormal();
   
   if (std::fabs(normalOther(axis)) > std::fabs(normal(axis)))
   {
     G4double minP, maxP;
     GetPlanerExtent( *maxPointOther, normalOther, minP, maxP );
     
     answer = (normalOther(axis) > 0) ? (maxP > +kCarTolerance)
                                      : (minP < -kCarTolerance);
   }
   else
   {
     G4double minP, maxP;
     other.GetPlanerExtent( *maxPoint, normal, minP, maxP );
     
     answer = (normal(axis) > 0) ? (minP < -kCarTolerance)
                                 : (maxP > +kCarTolerance);
   }
   return answer;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ClippablePolygon::ClearAllVertices ( )

virtual

Definition at line 75 of file G4ClippablePolygon.cc.

 {
   vertices.clear();
 }

Here is the caller graph for this function:

G4bool G4ClippablePolygon::Clip ( const G4VoxelLimits & voxelLimit )

virtual

Definition at line 84 of file G4ClippablePolygon.cc.

 {
   if (voxelLimit.IsLimited()) {
     ClipAlongOneAxis( voxelLimit, kXAxis );
     ClipAlongOneAxis( voxelLimit, kYAxis );
     ClipAlongOneAxis( voxelLimit, kZAxis );
   }
   
   return (vertices.size() > 0);
 }

Here is the call graph for this function:

void G4ClippablePolygon::ClipAlongOneAxis	(	const G4VoxelLimits &	voxelLimit,
		const EAxis	axis
	)

virtual

Definition at line 401 of file G4ClippablePolygon.cc.

 {    
   if (!voxelLimit.IsLimited(axis)) return;
   
   G4ThreeVectorList tempPolygon;
 
   //
   // Build a "simple" voxelLimit that includes only the min extent
   // and apply this to our vertices, producing result in tempPolygon
   //
   G4VoxelLimits simpleLimit1;
   simpleLimit1.AddLimit( axis, voxelLimit.GetMinExtent(axis), kInfinity );
   ClipToSimpleLimits( vertices, tempPolygon, simpleLimit1 );
 
   //
   // If nothing is left from the above clip, we might as well return now
   // (but with an empty vertices)
   //
   if (tempPolygon.size() == 0)
   {
     vertices.clear();
     return;
   }
 
   //
   // Now do the same, but using a "simple" limit that includes only the max
   // extent. Apply this to out tempPolygon, producing result in vertices.
   //
   G4VoxelLimits simpleLimit2;
   simpleLimit2.AddLimit( axis, -kInfinity, voxelLimit.GetMaxExtent(axis) );
   ClipToSimpleLimits( tempPolygon, vertices, simpleLimit2 );
 
   //
   // If nothing is left, return now
   //
   if (vertices.size() == 0) return;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ClippablePolygon::ClipToSimpleLimits	(	G4ThreeVectorList &	pPolygon,
		G4ThreeVectorList &	outputPolygon,
		const G4VoxelLimits &	pVoxelLimit
	)

protected

Definition at line 445 of file G4ClippablePolygon.cc.

 {
   G4int i;
   G4int noVertices=pPolygon.size();
   G4ThreeVector vEnd,vStart;
 
   outputPolygon.clear();
     
   for (i=0;i<noVertices;i++)
   {
     vStart=pPolygon[i];
     if (i==noVertices-1)
     {
       vEnd=pPolygon[0];
     }
     else
     {
       vEnd=pPolygon[i+1];
     }
 
     if (pVoxelLimit.Inside(vStart))
     {
       if (pVoxelLimit.Inside(vEnd))
       {
         // vStart and vEnd inside -> output end point
         //
         outputPolygon.push_back(vEnd);
       }
       else
       {
         // vStart inside, vEnd outside -> output crossing point
         //
         pVoxelLimit.ClipToLimits(vStart,vEnd);
         outputPolygon.push_back(vEnd);
       }
     }
     else
     {
       if (pVoxelLimit.Inside(vEnd))
       {
         // vStart outside, vEnd inside -> output inside section
         //
         pVoxelLimit.ClipToLimits(vStart,vEnd);
         outputPolygon.push_back(vStart);
         outputPolygon.push_back(vEnd);
       }
       else    // Both point outside -> no output
       {
       }
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4ClippablePolygon::Empty ( ) const

inline

Here is the caller graph for this function:

G4bool G4ClippablePolygon::GetExtent	(	const EAxis	axis,
		G4double &	min,
		G4double &	max
	)		const

virtual

Definition at line 117 of file G4ClippablePolygon.cc.

 {
   //
   // Okay, how many entries do we have?
   //
   G4int noLeft = vertices.size();
   
   //
   // Return false if nothing is left
   //
   if (noLeft == 0) return false;
   
   //
   // Initialize min and max to our first vertex
   //
   min = max = vertices[0].operator()( axis );
   
   //
   // Compare to the rest
   //
   G4int i;
   for( i=1; i<noLeft; i++ )
   {
     G4double component = vertices[i].operator()( axis );
     if (component < min )
       min = component;
     else if (component > max )
       max = component;
   }
   
   return true;
 }

Here is the caller graph for this function:

const G4ThreeVector * G4ClippablePolygon::GetMaxPoint ( const EAxis axis ) const

virtual

Definition at line 190 of file G4ClippablePolygon.cc.

 {
   G4int noLeft = vertices.size();
   if (noLeft==0)
     G4Exception("G4ClippablePolygon::GetMaxPoint()",
                 "GeomSolids0002", FatalException, "Empty polygon.");
   
   const G4ThreeVector *answer = &(vertices[0]);
   G4double max = answer->operator()(axis);
 
   G4int i;
   for( i=1; i<noLeft; i++ )
   {
     G4double component = vertices[i].operator()( axis );
     if (component > max)
     {
       answer = &(vertices[i]);
       max = component;
     }
   }
   
   return answer;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4ThreeVector * G4ClippablePolygon::GetMinPoint ( const EAxis axis ) const

virtual

Definition at line 159 of file G4ClippablePolygon.cc.

 {
   G4int noLeft = vertices.size();
   if (noLeft==0)
     G4Exception("G4ClippablePolygon::GetMinPoint()",
                 "GeomSolids0002", FatalException, "Empty polygon.");
   
   const G4ThreeVector *answer = &(vertices[0]);
   G4double min = answer->operator()(axis);
 
   G4int i;
   for( i=1; i<noLeft; i++ )
   {
     G4double component = vertices[i].operator()( axis );
     if (component < min)
     {
       answer = &(vertices[i]);
       min = component;
     }
   }
   
   return answer;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4ThreeVector G4ClippablePolygon::GetNormal ( ) const

inline

Here is the caller graph for this function:

G4int G4ClippablePolygon::GetNumVertices ( ) const

inline

G4bool G4ClippablePolygon::GetPlanerExtent	(	const G4ThreeVector &	pointOnPlane,
		const G4ThreeVector &	planeNormal,
		G4double &	min,
		G4double &	max
	)		const

virtual

Definition at line 361 of file G4ClippablePolygon.cc.

 {
   //
   // Okay, how many entries do we have?
   //
   G4int noLeft = vertices.size();
   
   //
   // Return false if nothing is left
   //
   if (noLeft == 0) return false;
   
   //
   // Initialize min and max to our first vertex
   //
   min = max = planeNormal.dot(vertices[0]-pointOnPlane);
   
   //
   // Compare to the rest
   //
   G4int i;
   for( i=1; i<noLeft; i++ )
   {
     G4double component = planeNormal.dot(vertices[i] - pointOnPlane);
     if (component < min )
       min = component;
     else if (component > max )
       max = component;
   }
   
   return true;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4ClippablePolygon::InFrontOf	(	const G4ClippablePolygon &	other,
		EAxis	axis
	)		const

virtual

Definition at line 231 of file G4ClippablePolygon.cc.

 {
   //
   // If things are empty, do something semi-sensible
   //
   G4int noLeft = vertices.size();
   if (noLeft==0) return false;
   
   if (other.Empty()) return true;
 
   //
   // Get minimum of other polygon
   //
   const G4ThreeVector *minPointOther = other.GetMinPoint( axis );
   const G4double minOther = minPointOther->operator()(axis);
   
   //
   // Get minimum of this polygon
   //
   const G4ThreeVector *minPoint = GetMinPoint( axis );
   const G4double min = minPoint->operator()(axis);
   
   //
   // Easy decision
   //
   if (min < minOther-kCarTolerance) return true;    // Clear winner
   
   if (minOther < min-kCarTolerance) return false;    // Clear loser
   
   //
   // We have a tie (this will not be all that rare since our
   // polygons are connected)
   //
   // Check to see if there is a vertex in the other polygon
   // that is behind this one (or vice versa)
   //
   G4bool answer;
   G4ThreeVector normalOther = other.GetNormal();
   
   if (std::fabs(normalOther(axis)) > std::fabs(normal(axis)))
   {
     G4double minP, maxP;
     GetPlanerExtent( *minPointOther, normalOther, minP, maxP );
     
     answer = (normalOther(axis) > 0) ? (minP < -kCarTolerance)
                                      : (maxP > +kCarTolerance);
   }
   else
   {
     G4double minP, maxP;
     other.GetPlanerExtent( *minPoint, normal, minP, maxP );
     
     answer = (normal(axis) > 0) ? (maxP > +kCarTolerance)
                                 : (minP < -kCarTolerance);
   }
   return answer;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4ClippablePolygon::PartialClip	(	const G4VoxelLimits &	voxelLimit,
		const EAxis	IgnoreMe
	)

virtual

Definition at line 101 of file G4ClippablePolygon.cc.

 {
   if (voxelLimit.IsLimited()) {
     if (IgnoreMe != kXAxis) ClipAlongOneAxis( voxelLimit, kXAxis );
     if (IgnoreMe != kYAxis) ClipAlongOneAxis( voxelLimit, kYAxis );
     if (IgnoreMe != kZAxis) ClipAlongOneAxis( voxelLimit, kZAxis );
   }
   
   return (vertices.size() > 0);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ClippablePolygon::SetNormal ( const G4ThreeVector & newNormal )

inline

Here is the caller graph for this function:

Member Data Documentation

G4double G4ClippablePolygon::kCarTolerance

protected

Definition at line 123 of file G4ClippablePolygon.hh.

G4ThreeVector G4ClippablePolygon::normal

protected

Definition at line 122 of file G4ClippablePolygon.hh.

G4ThreeVectorList G4ClippablePolygon::vertices

protected

Definition at line 121 of file G4ClippablePolygon.hh.

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

geant4.10.03.p01/source/geometry/solids/specific/include/G4ClippablePolygon.hh
geant4.10.03.p01/source/geometry/solids/specific/src/G4ClippablePolygon.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation