G4ClippablePolygon Class Reference

#include <G4ClippablePolygon.hh>

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
std::size_t	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 47 of file G4ClippablePolygon.hh.

Constructor & Destructor Documentation

G4ClippablePolygon()

G4ClippablePolygon::G4ClippablePolygon

(

)

Definition at line 38 of file G4ClippablePolygon.cc.

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

~G4ClippablePolygon()

G4ClippablePolygon::~G4ClippablePolygon ( )

virtual

Definition at line 46 of file G4ClippablePolygon.cc.

{
}

Member Function Documentation

AddVertexInOrder()

void G4ClippablePolygon::AddVertexInOrder ( const G4ThreeVector  vertex )

virtual

Definition at line 52 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

virtual

Definition at line 270 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 ( )

virtual

Definition at line 59 of file G4ClippablePolygon.cc.

{
  vertices.clear();
}

Referenced by G4PolyconeSide::CalculateExtent().

Clip()

G4bool G4ClippablePolygon::Clip ( const G4VoxelLimits &  voxelLimit )

virtual

Definition at line 66 of file G4ClippablePolygon.cc.

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

ClipAlongOneAxis()

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

virtual

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

Referenced by Clip(), and PartialClip().

ClipToSimpleLimits()

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

protected

Definition at line 416 of file G4ClippablePolygon.cc.

{
  std::size_t noVertices = pPolygon.size();
  G4ThreeVector vEnd,vStart;
 
  outputPolygon.clear();
    
  for (std::size_t 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
      {
      }
    }
  }
}

Referenced by ClipAlongOneAxis().

Empty()

G4bool G4ClippablePolygon::Empty ( ) const

inline

Referenced by BehindOf(), G4SolidExtentList::GetExtent(), and InFrontOf().

GetExtent()

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

virtual

Definition at line 97 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(), and G4SolidExtentList::GetExtent().

GetMaxPoint()

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

virtual

Definition at line 166 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

virtual

Definition at line 136 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

Referenced by BehindOf(), G4SolidExtentList::GetExtent(), and InFrontOf().

GetNumVertices()

std::size_t G4ClippablePolygon::GetNumVertices ( ) const

inline

GetPlanerExtent()

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

virtual

Definition at line 333 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

virtual

Definition at line 206 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  )

virtual

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

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

Member Data Documentation

kCarTolerance

G4double G4ClippablePolygon::kCarTolerance

protected

Definition at line 115 of file G4ClippablePolygon.hh.

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

normal

G4ThreeVector G4ClippablePolygon::normal

protected

Definition at line 114 of file G4ClippablePolygon.hh.

Referenced by BehindOf(), and InFrontOf().

vertices

G4ThreeVectorList G4ClippablePolygon::vertices

protected

Definition at line 113 of file G4ClippablePolygon.hh.

Referenced by AddVertexInOrder(), BehindOf(), ClearAllVertices(), Clip(), ClipAlongOneAxis(), GetExtent(), GetMaxPoint(), GetMinPoint(), GetPlanerExtent(), InFrontOf(), and PartialClip().

---

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

• G4ClippablePolygon.hh
• G4ClippablePolygon.cc