G4GeomTools.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
// $Id: $
//
//
// class G4GeomTools Implementation
//
// Author: evgueni.tcherniaev@cern.ch
//
// 10.10.2016 E.Tcherniaev: initial version.
// --------------------------------------------------------------------

#include "G4GeomTools.hh"

#include "geomdefs.hh"
#include "G4SystemOfUnits.hh"
#include "G4GeometryTolerance.hh"

//
// Calculate area of a triangle in 2D

G4double G4GeomTools::TriangleArea(G4double Ax, G4double Ay,
                                   G4double Bx, G4double By,
                                   G4double Cx, G4double Cy)
{
  return ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax))*0.5;
}

//
// Calculate area of a triangle in 2D

G4double G4GeomTools::TriangleArea(const G4TwoVector& A,
                                   const G4TwoVector& B,
                                   const G4TwoVector& C)
{
  G4double Ax = A.x(), Ay = A.y(); 
  return ((B.x()-Ax)*(C.y()-Ay) - (B.y()-Ay)*(C.x()-Ax))*0.5;
}

//
// Calculate area of a quadrilateral in 2D

G4double G4GeomTools::QuadArea(const G4TwoVector& A,
                               const G4TwoVector& B,
                               const G4TwoVector& C,
                               const G4TwoVector& D)
{
  return ((C.x()-A.x())*(D.y()-B.y()) - (C.y()-A.y())*(D.x()-B.x()))*0.5;
}

//
// Calculate area of a polygon in 2D

G4double G4GeomTools::PolygonArea(const G4TwoVectorList& p)
{
  G4double area = 0.0;
  G4int n = p.size();
  for(G4int i=0,k=n-1; i<n; k=i,++i)
  {
    area += p[k].x()*p[i].y() - p[i].x()*p[k].y();
  }
  return area*0.5;
}

//
// Point inside 2D triangle

G4bool G4GeomTools::PointInTriangle(G4double Ax, G4double Ay,
                                    G4double Bx, G4double By,
                                    G4double Cx, G4double Cy,
                                    G4double Px, G4double Py)

{
  if ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax) > 0.)
  {
    if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) < 0.) return false;
    if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) < 0.) return false;
    if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) < 0.) return false;
  }
  else
  {
    if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) > 0.) return false;
    if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) > 0.) return false;
    if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) > 0.) return false;
  }
  return true;
}

//
// Point inside 2D triangle

G4bool G4GeomTools::PointInTriangle(const G4TwoVector& A,
                                    const G4TwoVector& B,
                                    const G4TwoVector& C,
                                    const G4TwoVector& P)
{
  G4double Ax = A.x(), Ay = A.y();
  G4double Bx = B.x(), By = B.y();
  G4double Cx = C.x(), Cy = C.y();
  G4double Px = P.x(), Py = P.y();
  if ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax) > 0.)
  {
    if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) < 0.) return false;
    if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) < 0.) return false;
    if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) < 0.) return false;
  }
  else
  {
    if ((Ax-Cx)*(Py-Cy) - (Ay-Cy)*(Px-Cx) > 0.) return false;
    if ((Bx-Ax)*(Py-Ay) - (By-Ay)*(Px-Ax) > 0.) return false;
    if ((Cx-Bx)*(Py-By) - (Cy-By)*(Px-Bx) > 0.) return false;
  }
  return true;
}

//
// Detemine whether 2D polygon is convex or not

G4bool G4GeomTools::IsConvex(const G4TwoVectorList& polygon)
{
  static const G4double kCarTolerance =
         G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();

  G4bool gotNegative = false;
  G4bool gotPositive = false;
  G4int n = polygon.size();
  if (n <= 0) return false;
  for (G4int icur=0; icur<n; ++icur)
  {
    G4int iprev = (icur ==   0) ? n-1 : icur-1;
    G4int inext = (icur == n-1) ?   0 : icur+1;
    G4TwoVector e1 = polygon[icur]  - polygon[iprev];
    G4TwoVector e2 = polygon[inext] - polygon[icur];
    G4double cross = e1.x()*e2.y() - e1.y()*e2.x();
    if (std::abs(cross) < kCarTolerance) return false;
    if (cross <  0) gotNegative = true;
    if (cross >  0) gotPositive = true;
    if (gotNegative && gotPositive) return false;
  }
  return true;
}

//
// Triangulate simple polygon

G4bool G4GeomTools::TriangulatePolygon(const G4TwoVectorList& polygon,
                                             G4TwoVectorList& result)
{
  result.resize(0);
  std::vector<G4int> triangles;
  G4bool reply = TriangulatePolygon(polygon,triangles);

  G4int n = triangles.size();
  for (G4int i=0; i<n; ++i) result.push_back(polygon[triangles[i]]);
  return reply;
}

//
// Triangulation of a simple polygon by "ear clipping"

G4bool G4GeomTools::TriangulatePolygon(const G4TwoVectorList& polygon,
                             std::vector<G4int>& result)
{
  result.resize(0);

  // allocate and initialize list of Vertices in polygon
  //
  G4int n = polygon.size();
  if (n < 3) return false;

  // we want a counter-clockwise polygon in V
  // 
  G4double area = G4GeomTools::PolygonArea(polygon);
  G4int* V = new G4int[n];
  if (area > 0.)
    for (G4int i=0; i<n; ++i) V[i] = i;
  else
    for (G4int i=0; i<n; ++i) V[i] = (n-1)-i;

  //  Triangulation: remove nv-2 Vertices, creating 1 triangle every time
  // 
  G4int nv = n;
  G4int count = 2*nv; // error detection counter
  for(G4int b=nv-1; nv>2; )
  {
    // ERROR: if we loop, it is probably a non-simple polygon
    if ((count--) <= 0)
    {
      delete[] V;
      if (area < 0.) std::reverse(result.begin(),result.end());
      return false; 
    }

    // three consecutive vertices in current polygon, <a,b,c>
    G4int a = (b   < nv) ? b   : 0; // previous
          b = (a+1 < nv) ? a+1 : 0; // current
    G4int c = (b+1 < nv) ? b+1 : 0; // next

    if (CheckSnip(polygon, a,b,c, nv,V))
    {
      // output Triangle
      result.push_back(V[a]);
      result.push_back(V[b]);
      result.push_back(V[c]);

      // remove vertex b from remaining polygon
      nv--;
      for(G4int i=b; i<nv; ++i) V[i] = V[i+1];

      count = 2*nv; // resest error detection counter
    }
  }
  delete[] V;
  if (area < 0.) std::reverse(result.begin(),result.end());
  return true;
}

//
// Helper function for "ear clipping" polygon triangulation.
// Check for a valid snip

G4bool G4GeomTools::CheckSnip(const G4TwoVectorList& contour,
                              G4int a, G4int b, G4int c,
                              G4int n, const G4int* V)
{
  static const G4double kCarTolerance =
         G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();

  // check orientation of Triangle
  G4double Ax = contour[V[a]].x(), Ay = contour[V[a]].y();
  G4double Bx = contour[V[b]].x(), By = contour[V[b]].y();
  G4double Cx = contour[V[c]].x(), Cy = contour[V[c]].y();
  if ((Bx-Ax)*(Cy-Ay) - (By-Ay)*(Cx-Ax) < kCarTolerance) return false;
  
  // check that there is no point inside Triangle
  G4double xmin = std::min(std::min(Ax,Bx),Cx);
  G4double xmax = std::max(std::max(Ax,Bx),Cx);
  G4double ymin = std::min(std::min(Ay,By),Cy);
  G4double ymax = std::max(std::max(Ay,By),Cy);
  for (G4int i=0; i<n; ++i)
  {
    if((i == a) || (i == b) || (i == c)) continue;
    G4double Px = contour[V[i]].x();
    if (Px < xmin || Px > xmax) continue;
    G4double Py = contour[V[i]].y();
    if (Py < ymin || Py > ymax) continue;
    if (PointInTriangle(Ax,Ay,Bx,By,Cx,Cy,Px,Py)) return false;
  }
  return true;
}




//
// Remove collinear and coincident points from 2D polygon

void G4GeomTools::RemoveRedundantVertices(G4TwoVectorList& polygon,
                                          std::vector<G4int>& iout,
                                          G4double tolerance) 
{
  iout.resize(0);
  // set tolerance squared
  G4double delta = tolerance*tolerance;
  // set special value to mark vertices for removal
  G4double removeIt = kInfinity;

  G4int nv = polygon.size();

  // Main loop: check every three consecutive points, if the points
  // are collinear then mark middle point for removal
  //
  G4int icur = 0, iprev = 0, inext = 0, nout = 0; 
  for (G4int i=0; i<nv; ++i)
  {
    icur = i;                    // index of current point

    for (G4int k=1; k<nv+1; ++k) // set index of previous point
    {
      iprev = icur - k;
      if (iprev < 0) iprev += nv;
      if (polygon[iprev].x() != removeIt) break;
    }

    for (G4int k=1; k<nv+1; ++k) // set index of next point
    {
      inext = icur + k;
      if (inext >= nv) inext -= nv;
      if (polygon[inext].x() != removeIt) break;
    }

    if (iprev == inext) break;   // degenerate polygon, stop

    // Calculate parameters of triangle (iprev->icur->inext),
    // if triangle is too small or too narrow then mark current
    // point for removal
    G4TwoVector e1 = polygon[iprev] - polygon[icur];
    G4TwoVector e2 = polygon[inext] - polygon[icur];

    // Check length of edges, then check height of the triangle 
    G4double leng1 = e1.mag2();
    G4double leng2 = e2.mag2();
    G4double leng3 = (e2-e1).mag2();
    if (leng1 <= delta || leng2 <= delta || leng3 <= delta)
    {
      polygon[icur].setX(removeIt); nout++;
    }
    else
    {
      G4double lmax = std::max(std::max(leng1,leng2),leng3);
      G4double area = std::abs(e1.x()*e2.y()-e1.y()*e2.x())*0.5;
      if (area/std::sqrt(lmax) <= std::abs(tolerance))
      {
    polygon[icur].setX(removeIt); nout++;
      }
    }
  }

  // Remove marked points
  //
  icur = 0;
  if (nv - nout < 3)           // degenerate polygon, remove all points
  {
    for (G4int i=0; i<nv; ++i) iout.push_back(i);
    polygon.resize(0);
    nv = 0;
  }
  for (G4int i=0; i<nv; ++i) // move points, if required
  {
    if (polygon[i].x() != removeIt)
      polygon[icur++] = polygon[i];
    else
      iout.push_back(i);
  }
  if (icur < nv) polygon.resize(icur);
  return;
}

//
// Find bounding box of a disk sector

G4bool G4GeomTools::DiskExtent(G4double rmin, G4double rmax,
                               G4double startPhi, G4double delPhi,
                               G4TwoVector& pmin, G4TwoVector& pmax)
{
  static const G4double kCarTolerance =
         G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();

  // check parameters
  //
  pmin.set(0,0);
  pmax.set(0,0);
  if (rmin   <  0)                    return false;
  if (rmax   <= rmin + kCarTolerance) return false;
  if (delPhi <= 0    + kCarTolerance) return false;

  // calculate extent
  //
  pmin.set(-rmax,-rmax);
  pmax.set( rmax, rmax);
  if (delPhi >= CLHEP::twopi) return true;

  DiskExtent(rmin,rmax,
             std::sin(startPhi),std::cos(startPhi),
             std::sin(startPhi+delPhi),std::cos(startPhi+delPhi),
             pmin,pmax);
  return true;
}

//
// Find bounding box of a disk sector, fast version.
// No check of parameters !!!

void G4GeomTools::DiskExtent(G4double rmin, G4double rmax,
                             G4double sinStart, G4double cosStart,
                             G4double sinEnd, G4double cosEnd,
                             G4TwoVector& pmin, G4TwoVector& pmax)
{
  static const G4double kCarTolerance =
         G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();

  // check if 360 degrees
  //
  pmin.set(-rmax,-rmax);
  pmax.set( rmax, rmax);

  if (std::abs(sinEnd-sinStart) < kCarTolerance && 
      std::abs(cosEnd-cosStart) < kCarTolerance) return;

  // get start and end quadrants
  //
  //      1 | 0
  //     ---+--- 
  //      3 | 2
  //
  G4int icase = (cosEnd < 0) ? 1 : 0;
  if (sinEnd   < 0) icase += 2;
  if (cosStart < 0) icase += 4;
  if (sinStart < 0) icase += 8;

  switch (icase)
  {
  // start quadrant 0
  case  0:                                 // start->end : 0->0
    if (sinEnd < sinStart) break;
    pmin.set(rmin*cosEnd,rmin*sinStart);
    pmax.set(rmax*cosStart,rmax*sinEnd  );
    break;
  case  1:                                 // start->end : 0->1
    pmin.set(rmax*cosEnd,std::min(rmin*sinStart,rmin*sinEnd));
    pmax.set(rmax*cosStart,rmax  );
    break;
  case  2:                                 // start->end : 0->2
    pmin.set(-rmax,-rmax);
    pmax.set(std::max(rmax*cosStart,rmax*cosEnd),rmax);
    break;
  case  3:                                 // start->end : 0->3
    pmin.set(-rmax,rmax*sinEnd);
    pmax.set(rmax*cosStart,rmax);
    break;
  // start quadrant 1
  case  4:                                 // start->end : 1->0
    pmin.set(-rmax,-rmax);
    pmax.set(rmax,std::max(rmax*sinStart,rmax*sinEnd));
    break;
  case  5:                                 // start->end : 1->1
    if (sinEnd > sinStart) break;
    pmin.set(rmax*cosEnd,rmin*sinEnd  );
    pmax.set(rmin*cosStart,rmax*sinStart);
    break;
  case  6:                                 // start->end : 1->2
    pmin.set(-rmax,-rmax);
    pmax.set(rmax*cosEnd,rmax*sinStart);
    break;
  case  7:                                 // start->end : 1->3
    pmin.set(-rmax,rmax*sinEnd);
    pmax.set(std::max(rmin*cosStart,rmin*cosEnd),rmax*sinStart);
    break;
  // start quadrant 2
  case  8:                                 // start->end : 2->0
    pmin.set(std::min(rmin*cosStart,rmin*cosEnd),rmax*sinStart);
    pmax.set(rmax,rmax*sinEnd);
    break;
  case  9:                                 // start->end : 2->1
    pmin.set(rmax*cosEnd,rmax*sinStart);
    pmax.set(rmax,rmax);
    break;
  case 10:                                 // start->end : 2->2
    if (sinEnd < sinStart) break;
    pmin.set(rmin*cosStart,rmax*sinStart);
    pmax.set(rmax*cosEnd,rmin*sinEnd  );
    break;
  case 11:                                 // start->end : 2->3
    pmin.set(-rmax,std::min(rmax*sinStart,rmax*sinEnd));
    pmax.set(rmax,rmax);
    break;
  // start quadrant 3
  case 12:                                 // start->end : 3->0
    pmin.set(rmax*cosStart,-rmax);
    pmax.set(rmax,rmax*sinEnd);
    break;
  case 13:                                 // start->end : 3->1
    pmin.set(std::min(rmax*cosStart,rmax*cosEnd),-rmax);
    pmax.set(rmax,rmax);
    break;
  case 14:                                 // start->end : 3->2
    pmin.set(rmax*cosStart,-rmax);
    pmax.set(rmax*cosEnd,std::max(rmin*sinStart,rmin*sinEnd));
    break;
  case 15:                                 // start->end : 3->3
    if (sinEnd > sinStart) break;
    pmin.set(rmax*cosStart,rmax*sinEnd);
    pmax.set(rmin*cosEnd,rmin*sinStart);
    break;
  }
  return;
}

//
// Calculate distance between point P and line segment AB in 3D

G4double G4GeomTools::DistancePointSegment(G4ThreeVector P,
                                           G4ThreeVector A,
                                           G4ThreeVector B)
{
  G4ThreeVector AP = P - A;
  G4ThreeVector AB = B - A;

  G4double u = AP.dot(AB);
  if (u <= 0) return AP.mag();       // closest point is A

  G4double len2 = AB.mag2();
  if (u >= len2) return (B-P).mag(); // closest point is B

  return ((u/len2)*AB - AP).mag();   // distance to line
}


//
// Calculate bounding box of a spherical sector

G4bool
G4GeomTools::SphereExtent(G4double rmin, G4double rmax,
                          G4double startTheta, G4double delTheta,
                          G4double startPhi, G4double delPhi,
                          G4ThreeVector& pmin, G4ThreeVector& pmax)
{
  static const G4double kCarTolerance =
         G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();

  // check parameters
  //
  pmin.set(0,0,0);
  pmax.set(0,0,0);
  if (rmin     <  0)                    return false;
  if (rmax     <= rmin + kCarTolerance) return false;
  if (delTheta <= 0    + kCarTolerance) return false;
  if (delPhi   <= 0    + kCarTolerance) return false;

  G4double stheta = startTheta;
  G4double dtheta = delTheta;
  if (stheta < 0 && stheta > CLHEP::pi) return false;
  if (stheta + dtheta > CLHEP::pi)      dtheta = CLHEP::pi - stheta;
  if (dtheta <= 0 + kCarTolerance)      return false;

  // calculate extent
  //
  pmin.set(-rmax,-rmax,-rmax);
  pmax.set( rmax, rmax, rmax);
  if (dtheta >= CLHEP::pi && delPhi >= CLHEP::twopi) return true;

  G4double etheta   = stheta + dtheta;
  G4double sinStart = std::sin(stheta);
  G4double cosStart = std::cos(stheta);
  G4double sinEnd   = std::sin(etheta);
  G4double cosEnd   = std::cos(etheta);

  G4double rhomin = rmin*std::min(sinStart,sinEnd);
  G4double rhomax = rmax;
  if (stheta > CLHEP::halfpi) rhomax = rmax*sinStart;
  if (etheta < CLHEP::halfpi) rhomax = rmax*sinEnd;

  G4TwoVector xymin,xymax;
  DiskExtent(rhomin,rhomax,
             std::sin(startPhi),std::cos(startPhi),
             std::sin(startPhi+delPhi),std::cos(startPhi+delPhi),
             xymin,xymax);

  G4double zmin = std::min(rmin*cosEnd,rmax*cosEnd);
  G4double zmax = std::max(rmin*cosStart,rmax*cosStart);
  pmin.set(xymin.x(),xymin.y(),zmin);
  pmax.set(xymax.x(),xymax.y(),zmax);
  return true;
}