Gabriele Cosmo
222 lines
7.7 KiB
C++
222 lines
7.7 KiB
C++
//
|
|
// ********************************************************************
|
|
// * This Software is part of the AIDA Unified Solids Library package *
|
|
// * See: https://aidasoft.web.cern.ch/USolids *
|
|
// ********************************************************************
|
|
//
|
|
// $Id:$
|
|
//
|
|
// --------------------------------------------------------------------
|
|
//
|
|
// UPolyPhiFace
|
|
//
|
|
// Class description:
|
|
//
|
|
// Definition of a face that bounds a polycone or polyhedra when
|
|
// it has a phi opening:
|
|
//
|
|
// UPolyPhiFace( const UReduciblePolygon *rz,
|
|
// double phi,
|
|
// double deltaPhi,
|
|
// double phiOther )
|
|
//
|
|
// Specifically: a face that lies on a plane that passes through
|
|
// the z axis. It has boundaries that are straight lines of arbitrary
|
|
// length and direction, but with corners aways on the same side of
|
|
// the z axis.
|
|
//
|
|
// 19.10.12 Marek Gayer
|
|
// Created from original implementation in Geant4
|
|
// --------------------------------------------------------------------
|
|
|
|
#ifndef UPolyPhiFace_hh
|
|
#define UPolyPhiFace_hh
|
|
|
|
#include "UVCSGface.hh"
|
|
#include "UVector2.hh"
|
|
|
|
class UReduciblePolygon;
|
|
|
|
struct UPolyPhiFaceVertex
|
|
{
|
|
double x, y, r, z; // position
|
|
double rNorm,
|
|
zNorm; // r/z normal
|
|
UVector3 norm3D; // 3D normal
|
|
|
|
// Needed for Triangulation Algorithm
|
|
//
|
|
bool ear;
|
|
UPolyPhiFaceVertex* next, *prev;
|
|
};
|
|
|
|
struct UPolyPhiFaceEdge
|
|
{
|
|
UPolyPhiFaceEdge(): v0(0), v1(0), tr(.0), tz(0.), length(0.) {}
|
|
UPolyPhiFaceVertex* v0, *v1; // Corners
|
|
double tr, tz, // Unit vector along edge
|
|
length; // Length of edge
|
|
UVector3 norm3D; // 3D edge normal vector
|
|
};
|
|
|
|
class UPolyPhiFace : public UVCSGface
|
|
{
|
|
|
|
public: // with description
|
|
|
|
UPolyPhiFace(const UReduciblePolygon* rz,
|
|
double phi, double deltaPhi, double phiOther);
|
|
// Constructor.
|
|
// Points r,z should be supplied in clockwise order in r,z.
|
|
// For example:
|
|
// [1]---------[2] ^ R
|
|
// | | |
|
|
// | | +--> z
|
|
// [0]---------[3]
|
|
|
|
virtual ~UPolyPhiFace();
|
|
// Destructor. Removes edges and corners.
|
|
|
|
UPolyPhiFace(const UPolyPhiFace& source);
|
|
UPolyPhiFace& operator=(const UPolyPhiFace& source);
|
|
// Copy constructor and assgnment operator.
|
|
|
|
bool Distance(const UVector3& p, const UVector3& v,
|
|
bool outgoing, double surfTolerance,
|
|
double& distance, double& distFromSurface,
|
|
UVector3& normal, bool& allBehind);
|
|
|
|
double Safety(const UVector3& p, bool outgoing);
|
|
|
|
VUSolid::EnumInside Inside(const UVector3& p, double tolerance,
|
|
double* bestDistance);
|
|
|
|
UVector3 Normal(const UVector3& p, double* bestDistance);
|
|
|
|
double Extent(const UVector3 axis);
|
|
|
|
/*
|
|
void CalculateExtent( const EAxisType axis,
|
|
const UVoxelLimits &voxelLimit,
|
|
const UAffineTransform &tranform,
|
|
USolidExtentList &extentList );
|
|
*/
|
|
|
|
inline UVCSGface* Clone();
|
|
// Allocates on the heap a clone of this face.
|
|
|
|
double SurfaceArea();
|
|
double SurfaceTriangle(UVector3 p1, UVector3 p2,
|
|
UVector3 p3, UVector3* p4);
|
|
UVector3 GetPointOnFace();
|
|
// Auxiliary methods for determination of points on surface.
|
|
|
|
public: // without description
|
|
|
|
UPolyPhiFace(__void__&);
|
|
// Fake default constructor for usage restricted to direct object
|
|
// persistency for clients requiring preallocation of memory for
|
|
// persistifiable objects.
|
|
|
|
void Diagnose(VUSolid* solid);
|
|
// Throw an exception if something is found inconsistent with
|
|
// the solid. For debugging purposes only
|
|
|
|
protected:
|
|
|
|
bool InsideEdgesExact(double r, double z, double normSign,
|
|
const UVector3& p, const UVector3& v);
|
|
// Decide if the point in r,z is inside the edges of our face,
|
|
// **but** do so consistently with other faces.
|
|
|
|
bool InsideEdges(double r, double z);
|
|
bool InsideEdges(double r, double z, double* distRZ2,
|
|
UPolyPhiFaceVertex** base3Dnorm = 0,
|
|
UVector3** head3Dnorm = 0);
|
|
// Decide if the point in r,z is inside the edges of our face.
|
|
|
|
inline double ExactZOrder(double z,
|
|
double qx, double qy, double qz,
|
|
const UVector3& v,
|
|
double normSign,
|
|
const UPolyPhiFaceVertex* vert) const;
|
|
// Decide precisely whether a trajectory passes to the left, right,
|
|
// or exactly passes through the z position of a vertex point in face.
|
|
|
|
void CopyStuff(const UPolyPhiFace& source);
|
|
|
|
protected:
|
|
|
|
// Functions used for Triangulation in Case of generic Polygone.
|
|
// The triangulation is used for GetPointOnFace()
|
|
|
|
double Area2(UVector2 a, UVector2 b, UVector2 c);
|
|
// Calculation of 2*Area of Triangle with Sign
|
|
|
|
bool Left(UVector2 a, UVector2 b, UVector2 c);
|
|
bool LeftOn(UVector2 a, UVector2 b, UVector2 c);
|
|
bool Collinear(UVector2 a, UVector2 b, UVector2 c);
|
|
// Boolean functions for sign of Surface
|
|
|
|
bool IntersectProp(UVector2 a, UVector2 b,
|
|
UVector2 c, UVector2 d);
|
|
// Boolean function for finding proper intersection of two
|
|
// line segments (a,b) and (c,d).
|
|
|
|
bool Between(UVector2 a, UVector2 b, UVector2 c);
|
|
// Boolean function for determining if point c is between a and b
|
|
// where the three points (a,b,c) are on the same line.
|
|
|
|
bool Intersect(UVector2 a, UVector2 b,
|
|
UVector2 c, UVector2 d);
|
|
// Boolean function for finding proper intersection or not
|
|
// of two line segments (a,b) and (c,d).
|
|
|
|
bool Diagonalie(UPolyPhiFaceVertex* a, UPolyPhiFaceVertex* b);
|
|
// Boolean Diagonalie help to determine if diagonal s
|
|
// of segment (a,b) is convex or reflex.
|
|
|
|
bool InCone(UPolyPhiFaceVertex* a, UPolyPhiFaceVertex* b);
|
|
// Boolean function for determining if b is inside the cone (a0,a,a1)
|
|
// where a is the center of the cone.
|
|
|
|
bool Diagonal(UPolyPhiFaceVertex* a, UPolyPhiFaceVertex* b);
|
|
// Boolean function for determining if Diagonal is possible
|
|
// inside Polycone or PolyHedra.
|
|
|
|
void EarInit();
|
|
// Initialisation for Triangulisation by ear tips.
|
|
// For details see "Computational Geometry in C" by Joseph O'Rourke.
|
|
|
|
void Triangulate();
|
|
// Triangularisation by ear tips for Polycone or Polyhedra.
|
|
// For details see "Computational Geometry in C" by Joseph O'Rourke.
|
|
// NOTE: a copy of the shape is made and this copy is reordered in
|
|
// order to have a list of triangles. This list is used by the
|
|
// method GetPointOnFace().
|
|
|
|
protected:
|
|
|
|
int numEdges; // Number of edges
|
|
UPolyPhiFaceEdge* edges; // The edges of the face
|
|
UPolyPhiFaceVertex* corners; // And the corners
|
|
UVector3 normal; // Normal Unit vector
|
|
UVector3 radial; // Unit vector along radial direction
|
|
UVector3 surface; // Point on surface
|
|
UVector3 surface_point; // Auxiliary point on surface used for
|
|
// method GetPointOnFace()
|
|
double rMin, rMax, // Extent in r
|
|
zMin, zMax; // Extent in z
|
|
bool allBehind; // True if the polycone/polyhedra
|
|
// is behind the place of this face
|
|
double fTolerance;// Surface thickness
|
|
double fSurfaceArea; // Surface Area of PolyPhiFace
|
|
UPolyPhiFaceVertex* triangles; // Auxiliary pointer to 'corners' used for
|
|
// triangulation. Copy structure, changing
|
|
// the structure of 'corners' (ear removal)
|
|
};
|
|
|
|
#include "UPolyPhiFace.icc"
|
|
|
|
#endif
|