G4ClippablePolygon Class Reference

G4ClippablePolygon in a utility class defining a polygon that can be clipped by a voxel. More...

#include <G4ClippablePolygon.hh>

Public Member Functions
	G4ClippablePolygon ()
	~G4ClippablePolygon ()=default
void	AddVertexInOrder (const G4ThreeVector &vertex)
void	ClearAllVertices ()
const G4ThreeVector	GetNormal () const
void	SetNormal (const G4ThreeVector &newNormal)
G4bool	Clip (const G4VoxelLimits &voxelLimit)
G4bool	PartialClip (const G4VoxelLimits &voxelLimit, const EAxis IgnoreMe)
void	ClipAlongOneAxis (const G4VoxelLimits &voxelLimit, const EAxis axis)
G4bool	GetExtent (const EAxis axis, G4double &min, G4double &max) const
const G4ThreeVector *	GetMinPoint (const EAxis axis) const
const G4ThreeVector *	GetMaxPoint (const EAxis axis) const
std::size_t	GetNumVertices () const
G4bool	Empty () const
G4bool	InFrontOf (const G4ClippablePolygon &other, EAxis axis) const
G4bool	BehindOf (const G4ClippablePolygon &other, EAxis axis) const
G4bool	GetPlanerExtent (const G4ThreeVector &pointOnPlane, const G4ThreeVector &planeNormal, G4double &min, G4double &max) const

Detailed Description

G4ClippablePolygon in a utility class defining a polygon that can be clipped by a voxel.

Definition at line 51 of file G4ClippablePolygon.hh.

Constructor & Destructor Documentation

G4ClippablePolygon()

G4ClippablePolygon::G4ClippablePolygon

(

)

Default Constructor and Destructor.

Definition at line 38 of file G4ClippablePolygon.cc.

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

Referenced by BehindOf(), Empty(), and InFrontOf().

~G4ClippablePolygon()

G4ClippablePolygon::~G4ClippablePolygon ( )

default

Member Function Documentation

AddVertexInOrder()

void G4ClippablePolygon::AddVertexInOrder

(

const G4ThreeVector &

vertex

)

Adds a vertex to collection.

Definition at line 46 of file G4ClippablePolygon.cc.

{
  vertices.push_back( vertex );
}

Referenced by G4PolyconeSide::CalculateExtent(), G4PolyhedraSide::CalculateExtent(), and G4PolyPhiFace::CalculateExtent().

BehindOf()

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

Decides if this polygon is behind another. Remarks in previous method are valid here too.

Definition at line 268 of file G4ClippablePolygon.cc.

{
  //
  // If things are empty, do something semi-sensible
  //
  std::size_t 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;
}

Referenced by G4SolidExtentList::AddSurface().

ClearAllVertices()

void G4ClippablePolygon::ClearAllVertices

(

)

Clears the collection of vertices.

Definition at line 53 of file G4ClippablePolygon.cc.

{
  vertices.clear();
}

Referenced by G4PolyconeSide::CalculateExtent().

Clip()

G4bool G4ClippablePolygon::Clip

(

const G4VoxelLimits &

voxelLimit

)

Clips the polygon along the Cartesian axes, as specified in 'voxelLimit'.

Returns

true if the collection of vertices is not empty.

Definition at line 60 of file G4ClippablePolygon.cc.

{
  if (voxelLimit.IsLimited())
  {
    ClipAlongOneAxis( voxelLimit, kXAxis );
    ClipAlongOneAxis( voxelLimit, kYAxis );
    ClipAlongOneAxis( voxelLimit, kZAxis );
  }
  
  return (!vertices.empty());
}

ClipAlongOneAxis()

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

Clips the polygon along just one axis, as specified in 'voxelLimit'.

Definition at line 374 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.empty())
  {
    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.empty()) { return; }
}

Referenced by Clip(), and PartialClip().

Empty()

G4bool G4ClippablePolygon::Empty ( ) const

inline

Returns true if collection of vertices is empty.

Referenced by BehindOf(), and InFrontOf().

GetExtent()

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

Computes the polygon extent along the specified 'axis'.

Parameters

[in]	axis	The Cartesian axis along which computing the extent.
[out]	min	The minimum extent value.
[out]	max	The maximum extent value.

Returns

false if invalid polygon (no vertices).

Definition at line 91 of file G4ClippablePolygon.cc.

{
  //
  // Okay, how many entries do we have?
  //
  std::size_t 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
  //
  for( std::size_t i=1; i<noLeft; ++i )
  {
    G4double component = vertices[i].operator()( axis );
    if (component < min )
    {
      min = component;
    }
    else if (component > max )
    {
      max = component;
    }
  }
  
  return true;
}

Referenced by G4SolidExtentList::AddSurface().

GetMaxPoint()

const G4ThreeVector * G4ClippablePolygon::GetMaxPoint

(

const EAxis

axis

)

const

Definition at line 164 of file G4ClippablePolygon.cc.

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

Referenced by BehindOf().

GetMinPoint()

const G4ThreeVector * G4ClippablePolygon::GetMinPoint

(

const EAxis

axis

)

const

Returns a pointer to the minimum or maximum point along specified 'axis'. Take care! Do not use pointer after destroying parent polygon.

Definition at line 134 of file G4ClippablePolygon.cc.

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

Referenced by InFrontOf().

GetNormal()

const G4ThreeVector G4ClippablePolygon::GetNormal ( ) const

inline

Accessor and setter for normal vector.

Referenced by BehindOf(), and InFrontOf().

GetNumVertices()

std::size_t G4ClippablePolygon::GetNumVertices ( ) const

inline

Returns the number of vertices in the polygon.

GetPlanerExtent()

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

Gets min/max vertices distance in or out of a plane.

Parameters

[in]	pointOnPlane	The point on the plane.
[in]	planeNormal	The normal vector to the plane.
[out]	min	The minimum distance from the plane.
[out]	max	The maximum distance from the plane.

Returns

false if invalid polygon (no vertices).

Definition at line 331 of file G4ClippablePolygon.cc.

{
  //
  // Okay, how many entries do we have?
  //
  std::size_t 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
  //
  for( std::size_t 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;
}

Referenced by BehindOf(), and InFrontOf().

InFrontOf()

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

Decides if the polygon is in "front" of another when viewed along the specified 'axis'. For our purposes here, it is sufficient to use the minimum extent of the polygon along the axis to determine this.

Definition at line 204 of file G4ClippablePolygon.cc.

{
  //
  // If things are empty, do something semi-sensible
  //
  std::size_t 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;
}

Referenced by G4SolidExtentList::AddSurface().

PartialClip()

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

Clips the polygon while ignoring the indicated axis.

Returns

true if the collection of vertices is not empty.

Definition at line 76 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.empty());
}

Referenced by G4PolyconeSide::CalculateExtent(), G4PolyhedraSide::CalculateExtent(), and G4PolyPhiFace::CalculateExtent().

SetNormal()

void G4ClippablePolygon::SetNormal ( const G4ThreeVector & newNormal )

inline

Referenced by G4PolyconeSide::CalculateExtent(), G4PolyhedraSide::CalculateExtent(), and G4PolyPhiFace::CalculateExtent().

---

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

• G4ClippablePolygon.hh
• G4ClippablePolygon.cc