#include <UReduciblePolygon.hh>

Data Structures
struct	ABVertex

Public Member Functions
	UReduciblePolygon (const double a[], const double b[], int n)

	UReduciblePolygon (const double rmin[], const double rmax[], const double z[], int n)

virtual	~UReduciblePolygon ()

int	NumVertices () const

double	Amin () const

double	Amax () const

double	Bmin () const

double	Bmax () const

void	CopyVertices (double a[], double b[]) const

void	ScaleA (double scale)

void	ScaleB (double scale)

bool	RemoveDuplicateVertices (double tolerance)

bool	RemoveRedundantVertices (double tolerance)

void	ReverseOrder ()

void	StartWithZMin ()

double	Area ()

bool	CrossesItself (double tolerance)

bool	BisectedBy (double a1, double b1, double a2, double b2, double tolerance)

void	Print ()

Protected Member Functions
void	Create (const double a[], const double b[], int n)

void	CalculateMaxMin ()

Protected Attributes
double	aMin

double	aMax

double	bMin

double	bMax

int	numVertices

ABVertex *	vertexHead

Friends
class	UReduciblePolygonIterator

struct	ABVertex

Detailed Description

Definition at line 39 of file UReduciblePolygon.hh.

Constructor & Destructor Documentation

UReduciblePolygon::UReduciblePolygon	(	const double	a[],
		const double	b[],
		int	n
	)

Definition at line 28 of file UReduciblePolygon.cc.

References Create().

   : aMin(0.), aMax(0.), bMin(0.), bMax(0.),
     vertexHead(0)
 {
   //
   // Do all of the real work in Create
   //
   Create(a, b, n);
 }

UReduciblePolygon::UReduciblePolygon	(	const double	rmin[],
		const double	rmax[],
		const double	z[],
		int	n
	)

Definition at line 44 of file UReduciblePolygon.cc.

References test::a, test::b, Create(), and n.

   : aMin(0.), aMax(0.), bMin(0.), bMax(0.),
     vertexHead(0)
 {
   //
   // Translate
   //
   double* a = new double[n * 2];
   double* b = new double[n * 2];
 
   double* rOut = a + n,
           *zOut = b + n,
            *rIn = rOut - 1,
             *zIn = zOut - 1;
 
   int i;
   for (i = 0; i < n; i++, rOut++, zOut++, rIn--, zIn--)
   {
     *rOut = rmax[i];
     *rIn  = rmin[i];
     *zOut = *zIn = z[i];
   }
 
   Create(a, b, n * 2);
 
   delete [] a;
   delete [] b;
 }

UReduciblePolygon::~UReduciblePolygon ( )

virtual

Definition at line 121 of file UReduciblePolygon.cc.

References curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

 {
   ABVertex* curr = vertexHead;
   while (curr)
   {
     ABVertex* toDelete = curr;
     curr = curr->next;
     delete toDelete;
   }
 }

Member Function Documentation

double UReduciblePolygon::Amax ( ) const

inline

Definition at line 71 of file UReduciblePolygon.hh.

References aMax.

Referenced by UGenericPolycone::Create(), UPolyhedra::Create(), UPolycone::Init(), and UPolyPhiFace::UPolyPhiFace().

     {
       return aMax;
     }

double UReduciblePolygon::Amin ( ) const

inline

Definition at line 67 of file UReduciblePolygon.hh.

References aMin.

Referenced by UGenericPolycone::Create(), UPolyhedra::Create(), UPolycone::Init(), and UPolyPhiFace::UPolyPhiFace().

     {
       return aMin;
     }

double UReduciblePolygon::Area ( )

Definition at line 537 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, UReduciblePolygon::ABVertex::b, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by UGenericPolycone::Create(), and UPolyhedra::Create().

 {
   double answer = 0;
 
   ABVertex* curr = vertexHead, *next;
   do
   {
     next = curr->next;
     if (next == 0) next = vertexHead;
 
     answer += curr->a * next->b - curr->b * next->a;
     curr = curr->next;
   }
   while (curr);
 
   return 0.5 * answer;
 }

bool UReduciblePolygon::BisectedBy	(	double	a1,
		double	b1,
		double	a2,
		double	b2,
		double	tolerance
	)

Definition at line 490 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, UReduciblePolygon::ABVertex::b, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by UGenericPolycone::Create().

 {
   int nNeg = 0, nPos = 0;
 
   double a12 = a2 - a1, b12 = b2 - b1;
   double len12 = std::sqrt(a12 * a12 + b12 * b12);
   a12 /= len12;
   b12 /= len12;
 
   ABVertex* curr = vertexHead;
   do
   {
     double av = curr->a - a1,
            bv = curr->b - b1;
 
     double Cross = av * b12 - bv * a12;
 
     if (Cross < -tolerance)
     {
       if (nPos) return true;
       nNeg++;
     }
     else if (Cross > tolerance)
     {
       if (nNeg) return true;
       nPos++;
     }
     curr = curr->next;
   }
   while (curr);
 
   return false;
 }

double UReduciblePolygon::Bmax ( ) const

inline

Definition at line 79 of file UReduciblePolygon.hh.

References bMax.

Referenced by UGenericPolycone::Create(), UPolyhedra::Create(), UPolycone::Init(), UPolycone::SetOriginalParameters(), and UPolyPhiFace::UPolyPhiFace().

     {
       return bMax;
     }

double UReduciblePolygon::Bmin ( ) const

inline

Definition at line 75 of file UReduciblePolygon.hh.

References bMin.

Referenced by UGenericPolycone::Create(), UPolyhedra::Create(), UPolycone::Init(), and UPolyPhiFace::UPolyPhiFace().

     {
       return bMin;
     }

void UReduciblePolygon::CalculateMaxMin ( )

protected

Definition at line 577 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, aMax, aMin, UReduciblePolygon::ABVertex::b, bMax, bMin, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by Create(), RemoveDuplicateVertices(), and RemoveRedundantVertices().

 {
   ABVertex* curr = vertexHead;
   aMin = aMax = curr->a;
   bMin = bMax = curr->b;
   curr = curr->next;
   while (curr)
   {
     if (curr->a < aMin)
       aMin = curr->a;
     else if (curr->a > aMax)
       aMax = curr->a;
 
     if (curr->b < bMin)
       bMin = curr->b;
     else if (curr->b > bMax)
       bMax = curr->b;
 
     curr = curr->next;
   }
 }

void UReduciblePolygon::CopyVertices	(	double	a[],
		double	b[]
	)		const

Definition at line 140 of file UReduciblePolygon.cc.

References test::a, UReduciblePolygon::ABVertex::a, test::b, UReduciblePolygon::ABVertex::b, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by UVCSGfaceted::InitVoxels().

 {
   double* anext = a, *bnext = b;
   ABVertex* curr = vertexHead;
   while (curr)
   {
     *anext++ = curr->a;
     *bnext++ = curr->b;
     curr = curr->next;
   }
 }

void UReduciblePolygon::Create	(	const double	a[],
		const double	b[],
		int	n
	)

protected

Definition at line 82 of file UReduciblePolygon.cc.

References test::a, UReduciblePolygon::ABVertex::a, ABVertex, test::b, UReduciblePolygon::ABVertex::b, CalculateMaxMin(), UUtils::Exception(), FatalErrorInArguments, n, UReduciblePolygon::ABVertex::next, numVertices, and vertexHead.

Referenced by UReduciblePolygon().

 {
   if (n < 3)
     UUtils::Exception("UReduciblePolygon::Create()", "GeomSolids0002",
                       FatalErrorInArguments, 1, "Less than 3 vertices specified.");
 
   const double* anext = a, *bnext = b;
 
   ABVertex* prev = 0;
   do
   {
     ABVertex* newVertex = new ABVertex;
     newVertex->a = *anext;
     newVertex->b = *bnext;
     newVertex->next = 0;
     if (prev == 0)
     {
       vertexHead = newVertex;
     }
     else
     {
       prev->next = newVertex;
     }
 
     prev = newVertex;
   }
   while (++anext, ++bnext < b + n);
 
   numVertices = n;
 
   CalculateMaxMin();
 }

bool UReduciblePolygon::CrossesItself ( double tolerance )

Definition at line 432 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, UReduciblePolygon::ABVertex::b, UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by UGenericPolycone::Create(), and UPolyhedra::Create().

 {
   double tolerance2 = tolerance * tolerance;
   double one  = 1.0 - tolerance,
          zero = tolerance;
   //
   // Top loop over line segments. By the time we finish
   // with the second to last segment, we're done.
   //
   ABVertex* curr1 = vertexHead, *next1 = 0;
   while (curr1->next)
   {
     next1 = curr1->next;
     double da1 = next1->a - curr1->a,
            db1 = next1->b - curr1->b;
 
     //
     // Inner loop over subsequent line segments
     //
     ABVertex* curr2 = next1->next;
     while (curr2)
     {
       ABVertex* next2 = curr2->next;
       if (next2 == 0) next2 = vertexHead;
       double da2 = next2->a - curr2->a,
              db2 = next2->b - curr2->b;
       double a12 = curr2->a - curr1->a,
              b12 = curr2->b - curr1->b;
 
       //
       // Calculate intersection of the two lines
       //
       double deter = da1 * db2 - db1 * da2;
       if (std::fabs(deter) > tolerance2)
       {
         double s1, s2;
         s1 = (a12 * db2 - b12 * da2) / deter;
 
         if (s1 >= zero && s1 < one)
         {
           s2 = -(da1 * b12 - db1 * a12) / deter;
           if (s2 >= zero && s2 < one) return true;
         }
       }
       curr2 = curr2->next;
     }
     curr1 = next1;
   }
   return false;
 }

int UReduciblePolygon::NumVertices ( ) const

inline

Definition at line 62 of file UReduciblePolygon.hh.

References numVertices.

Referenced by UGenericPolycone::Create(), UPolyhedra::Create(), UVCSGfaceted::InitVoxels(), and UPolyPhiFace::UPolyPhiFace().

     {
       return numVertices;
     }

void UReduciblePolygon::Print ( void )

Definition at line 559 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, UReduciblePolygon::ABVertex::b, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

 {
   ABVertex* curr = vertexHead;
   do
   {
     std::cerr << curr->a << " " << curr->b << std::endl;
     curr = curr->next;
   }
   while (curr);
 }

bool UReduciblePolygon::RemoveDuplicateVertices ( double tolerance )

Definition at line 191 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, UReduciblePolygon::ABVertex::b, CalculateMaxMin(), curr(), UReduciblePolygon::ABVertex::next, numVertices, and vertexHead.

Referenced by UGenericPolycone::Create(), and UPolyhedra::Create().

 {
   ABVertex* curr = vertexHead,
             *prev = 0, *next = 0;
   while (curr)
   {
     next = curr->next;
     if (next == 0) next = vertexHead;
 
     if (std::fabs(curr->a - next->a) < tolerance &&
         std::fabs(curr->b - next->b) < tolerance)
     {
       //
       // Duplicate found: do we have > 3 vertices?
       //
       if (numVertices <= 3)
       {
         CalculateMaxMin();
         return false;
       }
 
       //
       // Delete
       //
       ABVertex* toDelete = curr;
       curr = curr->next;
       delete toDelete;
 
       numVertices--;
 
       if (prev) prev->next = curr;
       else vertexHead = curr;
     }
     else
     {
       prev = curr;
       curr = curr->next;
     }
   }
 
   //
   // In principle, this is not needed, but why not just play it safe?
   //
   CalculateMaxMin();
 
   return true;
 }

bool UReduciblePolygon::RemoveRedundantVertices ( double tolerance )

Definition at line 246 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, UReduciblePolygon::ABVertex::b, CalculateMaxMin(), curr(), UReduciblePolygon::ABVertex::next, numVertices, mcscore::test(), and vertexHead.

Referenced by UGenericPolycone::Create(), and UPolyhedra::Create().

 {
   //
   // Under these circumstances, we can quit now!
   //
   if (numVertices <= 2) return false;
 
   double tolerance2 = tolerance * tolerance;
 
   //
   // Loop over all vertices
   //
   ABVertex* curr = vertexHead, *next = 0;
   while (curr)
   {
     next = curr->next;
     if (next == 0) next = vertexHead;
 
     double da = next->a - curr->a,
            db = next->b - curr->b;
 
     //
     // Loop over all subsequent vertices, up to curr
     //
     for (;;)
     {
       //
       // Get vertex after next
       //
       ABVertex* test = next->next;
       if (test == 0) test = vertexHead;
 
       //
       // If we are back to the original vertex, stop
       //
       if (test == curr) break;
 
       //
       // Test for parallel line segments
       //
       double dat = test->a - curr->a,
              dbt = test->b - curr->b;
 
       if (std::fabs(dat * db - dbt * da) > tolerance2) break;
 
       //
       // Redundant vertex found: do we have > 3 vertices?
       //
       if (numVertices <= 3)
       {
         CalculateMaxMin();
         return false;
       }
 
       //
       // Delete vertex pointed to by next. Carefully!
       //
       if (curr->next)
       {
         // next is not head
         if (next->next)
           curr->next = test;  // next is not tail
         else
           curr->next = 0;   // New tail
       }
       else
         vertexHead = test;  // New head
 
       if ((curr != next) && (next != test)) delete next;
 
       numVertices--;
 
       //
       // Replace next by the vertex we just tested,
       // and keep on going...
       //
       next = test;
       da = dat;
       db = dbt;
     }
     curr = curr->next;
   }
 
   //
   // In principle, this is not needed, but why not just play it safe?
   //
   CalculateMaxMin();
 
   return true;
 }

void UReduciblePolygon::ReverseOrder ( )

Definition at line 343 of file UReduciblePolygon.cc.

References curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by UGenericPolycone::Create(), and UPolyhedra::Create().

 {
   //
   // Loop over all vertices
   //
   ABVertex* prev = vertexHead;
   if (prev == 0) return;  // No vertices
 
   ABVertex* curr = prev->next;
   if (curr == 0) return;  // Just one vertex
 
   //
   // Our new tail
   //
   vertexHead->next = 0;
 
   for (;;)
   {
     //
     // Save pointer to next vertex (in original order)
     //
     ABVertex* save = curr->next;
 
     //
     // Replace it with a pointer to the previous one
     // (in original order)
     //
     curr->next = prev;
 
     //
     // Last vertex?
     //
     if (save == 0) break;
 
     //
     // Next vertex
     //
     prev = curr;
     curr = save;
   }
 
   //
   // Our new head
   //
   vertexHead = curr;
 }

void UReduciblePolygon::ScaleA ( double scale )

Definition at line 158 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::a, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by UPolyhedra::Init().

 {
   ABVertex* curr = vertexHead;
   while (curr)
   {
     curr->a *= scale;
     curr = curr->next;
   }
 }

void UReduciblePolygon::ScaleB ( double scale )

Definition at line 174 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::b, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

 {
   ABVertex* curr = vertexHead;
   while (curr)
   {
     curr->b *= scale;
     curr = curr->next;
   }
 }

void UReduciblePolygon::StartWithZMin ( )

Definition at line 395 of file UReduciblePolygon.cc.

References UReduciblePolygon::ABVertex::b, curr(), UReduciblePolygon::ABVertex::next, and vertexHead.

Referenced by UPolycone::SetOriginalParameters().

 {
   ABVertex* curr = vertexHead;
   double bcurr = curr->b;
   ABVertex* prev = curr;
   while (curr)
   {
     if (curr->b < bcurr)
     {
       bcurr = curr->b;
       ABVertex* curr1 = curr;
       while (curr1)
       {
         if (curr1->next == 0)
         {
           curr1->next = vertexHead;
           break;
         }
         curr1 = curr1->next;
       }
       vertexHead = curr;
       prev->next = 0;
     }
     prev = curr;
     curr = curr->next;
   }
 }