G4TessellatedGeometryAlgorithms Class Reference

#include <G4TessellatedGeometryAlgorithms.hh>

Static Public Member Functions
static G4bool	IntersectLineAndTriangle2D (const G4TwoVector &p, const G4TwoVector &v, const G4TwoVector &p0, const G4TwoVector &e0, const G4TwoVector &e1, G4TwoVector location[2])
static G4int	IntersectLineAndLineSegment2D (const G4TwoVector &p0, const G4TwoVector &d0, const G4TwoVector &p1, const G4TwoVector &d1, G4TwoVector location[2])
static G4double	cross (const G4TwoVector &v1, const G4TwoVector &v2)

Detailed Description

Definition at line 69 of file G4TessellatedGeometryAlgorithms.hh.

Member Function Documentation

cross()

G4double G4TessellatedGeometryAlgorithms::cross ( const G4TwoVector & v1, const G4TwoVector & v2 )

static

Definition at line 236 of file G4TessellatedGeometryAlgorithms.cc.

{
  return v1.x()*v2.y() - v1.y()*v2.x();
}

Referenced by IntersectLineAndLineSegment2D().

IntersectLineAndLineSegment2D()

G4int G4TessellatedGeometryAlgorithms::IntersectLineAndLineSegment2D ( const G4TwoVector & p0, const G4TwoVector & d0, const G4TwoVector & p1, const G4TwoVector & d1, G4TwoVector location[2] )

static

Definition at line 163 of file G4TessellatedGeometryAlgorithms.cc.

{
  G4TwoVector e     = p1 - p0;
  G4double kross    = cross(d0,d1);
  G4double sqrKross = kross * kross;
  G4double sqrLen0  = d0.mag2();
  G4double sqrLen1  = d1.mag2();
  location[0]       = G4TwoVector(0.0,0.0);
  location[1]       = G4TwoVector(0.0,0.0);
 
  if (sqrKross > DBL_EPSILON * DBL_EPSILON * sqrLen0 * sqrLen1)
  {
    //
    // The line and line segment are not parallel. Determine if the intersection
    // is in positive s where r=p0 + s*d0, and for 0<=t<=1 where r=p1 + t*d1.
    //
    G4double ss = cross(e,d1)/kross;
    if (ss < 0)         return 0; // Intersection does not occur for positive ss
    G4double t = cross(e,d0)/kross;
    if (t < 0 || t > 1) return 0; // Intersection does not occur on line-segment
    //
    // Intersection of lines is a single point on the forward-propagating line
    // defined by r=p0 + ss*d0, and the line segment defined by  r=p1 + t*d1.
    //
    location[0] = p0 + ss*d0;
    return 1;
  }
  //
  // Line and line segment are parallel. Determine whether they overlap or not.
  //
  G4double sqrLenE = e.mag2();
  kross            = cross(e,d0);
  sqrKross         = kross * kross;
  if (sqrKross > DBL_EPSILON * DBL_EPSILON * sqrLen0 * sqrLenE)
  {
    return 0; //Lines are different.
  }
  //
  // Lines are the same.  Test for overlap.
  //
  G4double s0   = d0.dot(e)/sqrLen0;
  G4double s1   = s0 + d0.dot(d1)/sqrLen0;
  G4double smin = 0.0;
  G4double smax = 0.0;
 
  if (s0 < s1) {smin = s0; smax = s1;}
  else         {smin = s1; smax = s0;}
 
  if (smax < 0.0) return 0;
  else if (smin < 0.0)
  {
    location[0] = p0;
    location[1] = p0 + smax*d0;
    return 2;
  }
  else
  {
    location[0] = p0 + smin*d0;
    location[1] = p0 + smax*d0;
    return 2;
  }
}

Referenced by IntersectLineAndTriangle2D().

IntersectLineAndTriangle2D()

G4bool G4TessellatedGeometryAlgorithms::IntersectLineAndTriangle2D ( const G4TwoVector & p, const G4TwoVector & v, const G4TwoVector & p0, const G4TwoVector & e0, const G4TwoVector & e1, G4TwoVector location[2] )

static

Definition at line 55 of file G4TessellatedGeometryAlgorithms.cc.

{
  G4TwoVector loc0[2];
  G4int e0i = IntersectLineAndLineSegment2D (p,v,p0,e0,loc0);
  if (e0i == 2)
  {
    location[0] = loc0[0];
    location[1] = loc0[1];
    return true;
  }
 
  G4TwoVector loc1[2];
  G4int e1i = IntersectLineAndLineSegment2D (p,v,p0,e1,loc1);
  if (e1i == 2)
  {
    location[0] = loc1[0];
    location[1] = loc1[1];
    return true;
  }
 
  if ((e0i == 1) && (e1i == 1))
  {
    if ((loc0[0]-p).mag2() < (loc1[0]-p).mag2())
    {
      location[0] = loc0[0];
      location[1] = loc1[0];
    }
    else
    {
      location[0] = loc1[0];
      location[1] = loc0[0];
    }
    return true;
  }
 
  G4TwoVector p1 = p0 + e0;
  G4TwoVector DE = e1 - e0;
  G4TwoVector loc2[2];
  G4int e2i = IntersectLineAndLineSegment2D (p,v,p1,DE,loc2);
  if (e2i == 2)
  {
    location[0] = loc2[0];
    location[1] = loc2[1];
    return true;
  }
 
  if ((e0i == 0) && (e1i == 0) && (e2i == 0)) return false;
 
  if ((e0i == 1) && (e2i == 1))
  {
    if ((loc0[0]-p).mag2() < (loc2[0]-p).mag2())
    {
      location[0] = loc0[0];
      location[1] = loc2[0];
    }
    else
    {
      location[0] = loc2[0];
      location[1] = loc0[0];
    }
    return true;
  }
 
  if ((e1i == 1) && (e2i == 1))
  {
    if ((loc1[0]-p).mag2() < (loc2[0]-p).mag2())
    {
      location[0] = loc1[0];
      location[1] = loc2[0];
    }
    else
    {
      location[0] = loc2[0];
      location[1] = loc1[0];
    }
    return true;
  }
 
  return false;
}

Referenced by G4TriangularFacet::Intersect().

---

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

• G4TessellatedGeometryAlgorithms.hh
• G4TessellatedGeometryAlgorithms.cc