Very minor fixes: Uncrustify a few files and rename a shadowed var.

polygon/poly2tri/common/shapes.h

@@ -56,7 +56,7 @@ struct Point
     std::vector<Edge*> edge_list;
 
     /// Construct using coordinates.
-    Point( double x, double y ) : x( x ), y( y ) {}
+    Point( double ax, double ay ) : x( ax ), y( ay ) {}
 
     /// Set this point to all zeros.
     void set_zero()

polygon/poly2tri/sweep/advancing_front.cc

@@ -31,7 +31,6 @@
 #include "advancing_front.h"
 
 namespace p2t {
-
 AdvancingFront::AdvancingFront( Node& head, Node& tail )
 {
     head_   = &head;
@@ -39,28 +38,38 @@ AdvancingFront::AdvancingFront(Node& head, Node& tail)
     search_node_ = &head;
 }
 
+
 Node* AdvancingFront::LocateNode( const double& x )
 {
     Node* node = search_node_;
 
-  if (x < node->value) {
+    if( x < node->value )
-    while ((node = node->prev) != NULL) {
+    {
-      if (x >= node->value) {
+        while( (node = node->prev) != NULL )
+        {
+            if( x >= node->value )
+            {
                 search_node_ = node;
                 return node;
             }
         }
-  } else {
+    }
-    while ((node = node->next) != NULL) {
+    else
-      if (x < node->value) {
+    {
+        while( (node = node->next) != NULL )
+        {
+            if( x < node->value )
+            {
                 search_node_ = node->prev;
                 return node->prev;
             }
         }
     }
+
     return NULL;
 }
 
+
 Node* AdvancingFront::FindSearchNode( const double& x )
 {
     (void) x; // suppress compiler warnings "unused parameter 'x'"
@@ -68,42 +77,59 @@ Node* AdvancingFront::FindSearchNode(const double& x)
     return search_node_;
 }
 
+
 Node* AdvancingFront::LocatePoint( const Point* point )
 {
     const double px = point->x;
     Node* node = FindSearchNode( px );
     const double nx = node->point->x;
 
-  if (px == nx) {
+    if( px == nx )
-    if (point != node->point) {
+    {
+        if( point != node->point )
+        {
             // We might have two nodes with same x value for a short time
-      if (point == node->prev->point) {
+            if( point == node->prev->point )
+            {
                 node = node->prev;
-      } else if (point == node->next->point) {
+            }
+            else if( point == node->next->point )
+            {
                 node = node->next;
-      } else {
+            }
+            else
+            {
                 assert( 0 );
             }
         }
-  } else if (px < nx) {
+    }
-    while ((node = node->prev) != NULL) {
+    else if( px < nx )
-      if (point == node->point) {
+    {
+        while( (node = node->prev) != NULL )
+        {
+            if( point == node->point )
+            {
                 break;
             }
         }
-  } else {
+    }
-    while ((node = node->next) != NULL) {
+    else
+    {
+        while( (node = node->next) != NULL )
+        {
             if( point == node->point )
                 break;
         }
     }
-  if(node) search_node_ = node;
+
+    if( node )
+        search_node_ = node;
+
     return node;
 }
 
+
 AdvancingFront::~AdvancingFront()
 {
 }
-
 }
-

polygon/poly2tri/sweep/advancing_front.h

@@ -35,11 +35,11 @@
 #include "../common/shapes.h"
 
 namespace p2t {
-
 struct Node;
 
 // Advancing front node
-struct Node {
+struct Node
+{
     Point* point;
     Triangle* triangle;
 
@@ -52,14 +52,15 @@ struct Node {
     {
     }
 
-  Node(Point& p, Triangle& t) : point(&p), triangle(&t), next(NULL), prev(NULL), value(p.x)
+    Node( Point& p, Triangle& t ) : point( &p ), triangle( &t ), next( NULL ), prev( NULL ), value(
+                p.x )
     {
     }
-
 };
 
 // Advancing front
-class AdvancingFront {
+class AdvancingFront
+{
 public:
 
     AdvancingFront( Node& head, Node& tail );
@@ -89,30 +90,36 @@ inline Node* AdvancingFront::head()
 {
     return head_;
 }
+
+
 inline void AdvancingFront::set_head( Node* node )
 {
     head_ = node;
 }
 
+
 inline Node* AdvancingFront::tail()
 {
     return tail_;
 }
+
+
 inline void AdvancingFront::set_tail( Node* node )
 {
     tail_ = node;
 }
 
+
 inline Node* AdvancingFront::search()
 {
     return search_node_;
 }
 
+
 inline void AdvancingFront::set_search( Node* node )
 {
     search_node_ = node;
 }
-
 }
 
 #endif

polygon/poly2tri/sweep/cdt.cc

@@ -31,42 +31,46 @@
 #include "cdt.h"
 
 namespace p2t {
-
 CDT::CDT( std::vector<Point*> polyline )
 {
     sweep_context_ = new SweepContext( polyline );
     sweep_ = new Sweep;
 }
 
+
 void CDT::AddHole( std::vector<Point*> polyline )
 {
     sweep_context_->AddHole( polyline );
 }
 
-void CDT::AddPoint(Point* point) {
+
+void CDT::AddPoint( Point* point )
+{
     sweep_context_->AddPoint( point );
 }
 
+
 void CDT::Triangulate()
 {
     sweep_->Triangulate( *sweep_context_ );
 }
 
+
 std::vector<p2t::Triangle*> CDT::GetTriangles()
 {
     return sweep_context_->GetTriangles();
 }
 
+
 std::list<p2t::Triangle*> CDT::GetMap()
 {
     return sweep_context_->GetMap();
 }
 
+
 CDT::~CDT()
 {
     delete sweep_context_;
     delete sweep_;
 }
-
 }
-

polygon/poly2tri/sweep/sweep.cc

@@ -35,7 +35,6 @@
 #include "../common/utils.h"
 
 namespace p2t {
-
 // Triangulate simple polygon with holes
 void Sweep::Triangulate( SweepContext& tcx )
 {
@@ -47,23 +46,30 @@ void Sweep::Triangulate(SweepContext& tcx)
     FinalizationPolygon( tcx );
 }
 
+
 void Sweep::SweepPoints( SweepContext& tcx )
 {
-  for (int i = 1; i < tcx.point_count(); i++) {
+    for( int jj = 1; jj < tcx.point_count(); jj++ )
-    Point& point = *tcx.GetPoint(i);
+    {
+        Point& point    = *tcx.GetPoint( jj );
         Node* node      = &PointEvent( tcx, point );
-    for (unsigned int i = 0; i < point.edge_list.size(); i++) {
+
+        for( unsigned int i = 0; i < point.edge_list.size(); i++ )
+        {
             EdgeEvent( tcx, point.edge_list[i], node );
         }
     }
 }
 
+
 void Sweep::FinalizationPolygon( SweepContext& tcx )
 {
     // Get an Internal triangle to start with
     Triangle* t = tcx.front()->head()->next->triangle;
     Point* p = tcx.front()->head()->next->point;
-  while (!t->GetConstrainedEdgeCW(*p)) {
+
+    while( !t->GetConstrainedEdgeCW( *p ) )
+    {
         t = t->NeighborCCW( *p );
     }
 
@@ -71,6 +77,7 @@ void Sweep::FinalizationPolygon(SweepContext& tcx)
     tcx.MeshClean( *t );
 }
 
+
 Node& Sweep::PointEvent( SweepContext& tcx, Point& point )
 {
     Node& node = tcx.LocateNode( point );
@@ -78,7 +85,8 @@ Node& Sweep::PointEvent(SweepContext& tcx, Point& point)
 
     // Only need to check +epsilon since point never have smaller
     // x value than node due to how we fetch nodes from the front
-  if (point.x <= node.point->x + EPSILON) {
+    if( point.x <= node.point->x + EPSILON )
+    {
         Fill( tcx, node );
     }
 
@@ -88,12 +96,14 @@ Node& Sweep::PointEvent(SweepContext& tcx, Point& point)
     return new_node;
 }
 
+
 void Sweep::EdgeEvent( SweepContext& tcx, Edge* edge, Node* node )
 {
     tcx.edge_event.constrained_edge = edge;
     tcx.edge_event.right = (edge->p->x > edge->q->x);
 
-  if (IsEdgeSideOfTriangle(*node->triangle, *edge->p, *edge->q)) {
+    if( IsEdgeSideOfTriangle( *node->triangle, *edge->p, *edge->q ) )
+    {
         return;
     }
 
@@ -104,76 +114,104 @@ void Sweep::EdgeEvent(SweepContext& tcx, Edge* edge, Node* node)
     EdgeEvent( tcx, *edge->p, *edge->q, node->triangle, *edge->q );
 }
 
+
 void Sweep::EdgeEvent( SweepContext& tcx, Point& ep, Point& eq, Triangle* triangle, Point& point )
 {
-  if (IsEdgeSideOfTriangle(*triangle, ep, eq)) {
+    if( IsEdgeSideOfTriangle( *triangle, ep, eq ) )
+    {
         return;
     }
 
     Point* p1 = triangle->PointCCW( point );
     Orientation o1 = Orient2d( eq, *p1, ep );
-  if (o1 == COLLINEAR) {
+
-    if( triangle->Contains(&eq, p1)) {
+    if( o1 == COLLINEAR )
+    {
+        if( triangle->Contains( &eq, p1 ) )
+        {
             triangle->MarkConstrainedEdge( &eq, p1 );
             // We are modifying the constraint maybe it would be better to
             // not change the given constraint and just keep a variable for the new constraint
             tcx.edge_event.constrained_edge->q = p1;
             triangle = &triangle->NeighborAcross( point );
             EdgeEvent( tcx, ep, *p1, triangle, *p1 );
-    } else {
+        }
+        else
+        {
             std::runtime_error( "EdgeEvent - collinear points not supported" );
             assert( 0 );
         }
+
         return;
     }
 
     Point* p2 = triangle->PointCW( point );
     Orientation o2 = Orient2d( eq, *p2, ep );
-  if (o2 == COLLINEAR) {
+
-    if( triangle->Contains(&eq, p2)) {
+    if( o2 == COLLINEAR )
+    {
+        if( triangle->Contains( &eq, p2 ) )
+        {
             triangle->MarkConstrainedEdge( &eq, p2 );
             // We are modifying the constraint maybe it would be better to
             // not change the given constraint and just keep a variable for the new constraint
             tcx.edge_event.constrained_edge->q = p2;
             triangle = &triangle->NeighborAcross( point );
             EdgeEvent( tcx, ep, *p2, triangle, *p2 );
-    } else {
+        }
+        else
+        {
             std::runtime_error( "EdgeEvent - collinear points not supported" );
             assert( 0 );
         }
+
         return;
     }
 
-  if (o1 == o2) {
+    if( o1 == o2 )
+    {
         // Need to decide if we are rotating CW or CCW to get to a triangle
         // that will cross edge
-    if (o1 == CW) {
+        if( o1 == CW )
+        {
             triangle = triangle->NeighborCCW( point );
-    }       else{
+        }
+        else
+        {
             triangle = triangle->NeighborCW( point );
         }
+
         EdgeEvent( tcx, ep, eq, triangle, point );
-  } else {
+    }
+    else
+    {
         // This triangle crosses constraint so lets flippin start!
         FlipEdgeEvent( tcx, ep, eq, triangle, point );
     }
 }
 
+
 bool Sweep::IsEdgeSideOfTriangle( Triangle& triangle, Point& ep, Point& eq )
 {
     int index = triangle.EdgeIndex( &ep, &eq );
 
-  if (index != -1) {
+    if( index != -1 )
+    {
         triangle.MarkConstrainedEdge( index );
         Triangle* t = triangle.GetNeighbor( index );
-    if (t) {
+
+        if( t )
+        {
             t->MarkConstrainedEdge( &ep, &eq );
         }
+
         return true;
     }
+
     return false;
 }
 
+
 Node& Sweep::NewFrontTriangle( SweepContext& tcx, Point& point, Node& node )
 {
     Triangle* triangle = new Triangle( point, *node.point, *node.next->point );
@@ -189,13 +227,15 @@ Node& Sweep::NewFrontTriangle(SweepContext& tcx, Point& point, Node& node)
     node.next->prev = new_node;
     node.next = new_node;
 
-  if (!Legalize(tcx, *triangle)) {
+    if( !Legalize( tcx, *triangle ) )
+    {
         tcx.MapTriangleToNodes( *triangle );
     }
 
     return *new_node;
 }
 
+
 void Sweep::Fill( SweepContext& tcx, Node& node )
 {
     Triangle* triangle = new Triangle( *node.prev->point, *node.point, *node.next->point );
@@ -212,21 +252,24 @@ void Sweep::Fill(SweepContext& tcx, Node& node)
     node.next->prev = node.prev;
 
     // If it was legalized the triangle has already been mapped
-  if (!Legalize(tcx, *triangle)) {
+    if( !Legalize( tcx, *triangle ) )
+    {
         tcx.MapTriangleToNodes( *triangle );
     }
-
 }
 
+
 void Sweep::FillAdvancingFront( SweepContext& tcx, Node& n )
 {
-
     // Fill right holes
     Node* node = n.next;
 
-  while (node->next) {
+    while( node->next )
+    {
         // if HoleAngle exceeds 90 degrees then break.
-    if (LargeHole_DontFill(node)) break;
+        if( LargeHole_DontFill( node ) )
+            break;
+
         Fill( tcx, *node );
         node = node->next;
     }
@@ -234,57 +277,79 @@ void Sweep::FillAdvancingFront(SweepContext& tcx, Node& n)
     // Fill left holes
     node = n.prev;
 
-  while (node->prev) {
+    while( node->prev )
+    {
         // if HoleAngle exceeds 90 degrees then break.
-    if (LargeHole_DontFill(node)) break;
+        if( LargeHole_DontFill( node ) )
+            break;
+
         Fill( tcx, *node );
         node = node->prev;
     }
 
     // Fill right basins
-  if (n.next && n.next->next) {
+    if( n.next && n.next->next )
+    {
         double angle = BasinAngle( n );
-    if (angle < PI_3div4) {
+
+        if( angle < PI_3div4 )
+        {
             FillBasin( tcx, n );
         }
     }
 }
 
-// True if HoleAngle exceeds 90 degrees.
-bool Sweep::LargeHole_DontFill(Node* node) {
 
+// True if HoleAngle exceeds 90 degrees.
+bool Sweep::LargeHole_DontFill( Node* node )
+{
     Node* nextNode = node->next;
     Node* prevNode = node->prev;
+
     if( !AngleExceeds90Degrees( node->point, nextNode->point, prevNode->point ) )
         return false;
 
     // Check additional points on front.
     Node* next2Node = nextNode->next;
+
     // "..Plus.." because only want angles on same side as point being added.
-  if ((next2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, next2Node->point, prevNode->point))
+    if( (next2Node != NULL)
+        && !AngleExceedsPlus90DegreesOrIsNegative( node->point, next2Node->point,
+                prevNode->point ) )
         return false;
 
     Node* prev2Node = prevNode->prev;
+
     // "..Plus.." because only want angles on same side as point being added.
-  if ((prev2Node != NULL) && !AngleExceedsPlus90DegreesOrIsNegative(node->point, nextNode->point, prev2Node->point))
+    if( (prev2Node != NULL)
+        && !AngleExceedsPlus90DegreesOrIsNegative( node->point, nextNode->point,
+                prev2Node->point ) )
         return false;
 
     return true;
 }
 
-bool Sweep::AngleExceeds90Degrees(Point* origin, Point* pa, Point* pb) {
+
+bool Sweep::AngleExceeds90Degrees( Point* origin, Point* pa, Point* pb )
+{
     double angle = Angle( *origin, *pa, *pb );
     bool exceeds90Degrees = ( (angle > PI_div2) || (angle < -PI_div2) );
+
     return exceeds90Degrees;
 }
 
-bool Sweep::AngleExceedsPlus90DegreesOrIsNegative(Point* origin, Point* pa, Point* pb) {
+
+bool Sweep::AngleExceedsPlus90DegreesOrIsNegative( Point* origin, Point* pa, Point* pb )
+{
     double angle = Angle( *origin, *pa, *pb );
     bool exceedsPlus90DegreesOrIsNegative = (angle > PI_div2) || (angle < 0);
+
     return exceedsPlus90DegreesOrIsNegative;
 }
 
-double Sweep::Angle(Point& origin, Point& pa, Point& pb) {
+
+double Sweep::Angle( Point& origin, Point& pa, Point& pb )
+{
     /* Complex plane
      * ab = cosA +i*sinA
      * ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx)
@@ -302,16 +367,20 @@ double Sweep::Angle(Point& origin, Point& pa, Point& pb) {
     double x    = ax * by - ay * bx;
     double y    = ax * bx + ay * by;
     double angle = atan2( x, y );
+
     return angle;
 }
 
+
 double Sweep::BasinAngle( Node& node )
 {
     double ax   = node.point->x - node.next->next->point->x;
     double ay   = node.point->y - node.next->next->point->y;
+
     return atan2( ay, ax );
 }
 
+
 double Sweep::HoleAngle( Node& node )
 {
     /* Complex plane
@@ -326,34 +395,40 @@ double Sweep::HoleAngle(Node& node)
     double ay   = node.next->point->y - node.point->y;
     double bx   = node.prev->point->x - node.point->x;
     double by   = node.prev->point->y - node.point->y;
+
     return atan2( ax * by - ay * bx, ax * bx + ay * by );
 }
 
+
 bool Sweep::Legalize( SweepContext& tcx, Triangle& t )
 {
     // To legalize a triangle we start by finding if any of the three edges
     // violate the Delaunay condition
-  for (int i = 0; i < 3; i++) {
+    for( int i = 0; i < 3; i++ )
+    {
         if( t.delaunay_edge[i] )
             continue;
 
         Triangle* ot = t.GetNeighbor( i );
 
-    if (ot) {
+        if( ot )
+        {
             Point* p = t.GetPoint( i );
             Point* op = ot->OppositePoint( t, *p );
             int oi = ot->Index( op );
 
             // If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
             // then we should not try to legalize
-      if (ot->constrained_edge[oi] || ot->delaunay_edge[oi]) {
+            if( ot->constrained_edge[oi] || ot->delaunay_edge[oi] )
+            {
                 t.constrained_edge[i] = ot->constrained_edge[oi];
                 continue;
             }
 
             bool inside = Incircle( *p, *t.PointCCW( *p ), *t.PointCW( *p ), *op );
 
-      if (inside) {
+            if( inside )
+            {
                 // Lets mark this shared edge as Delaunay
                 t.delaunay_edge[i] = true;
                 ot->delaunay_edge[oi] = true;
@@ -366,11 +441,14 @@ bool Sweep::Legalize(SweepContext& tcx, Triangle& t)
 
                 // Make sure that triangle to node mapping is done only one time for a specific triangle
                 bool not_legalized = !Legalize( tcx, t );
-        if (not_legalized) {
+
+                if( not_legalized )
+                {
                     tcx.MapTriangleToNodes( t );
                 }
 
                 not_legalized = !Legalize( tcx, *ot );
+
                 if( not_legalized )
                     tcx.MapTriangleToNodes( *ot );
 
@@ -387,9 +465,11 @@ bool Sweep::Legalize(SweepContext& tcx, Triangle& t)
             }
         }
     }
+
     return false;
 }
 
+
 bool Sweep::Incircle( Point& pa, Point& pb, Point& pc, Point& pd )
 {
     double adx  = pa.x - pd.x;
@@ -426,9 +506,11 @@ bool Sweep::Incircle(Point& pa, Point& pb, Point& pc, Point& pd)
     return det > 0;
 }
 
+
 void Sweep::RotateTrianglePair( Triangle& t, Point& p, Triangle& ot, Point& op )
 {
     Triangle* n1, * n2, * n3, * n4;
+
     n1  = t.NeighborCCW( p );
     n2  = t.NeighborCW( p );
     n3  = ot.NeighborCCW( op );
@@ -468,38 +550,59 @@ void Sweep::RotateTrianglePair(Triangle& t, Point& p, Triangle& ot, Point& op)
     // the right side.
     t.ClearNeighbors();
     ot.ClearNeighbors();
-  if (n1) ot.MarkNeighbor(*n1);
+
-  if (n2) t.MarkNeighbor(*n2);
+    if( n1 )
-  if (n3) t.MarkNeighbor(*n3);
+        ot.MarkNeighbor( *n1 );
-  if (n4) ot.MarkNeighbor(*n4);
+
+    if( n2 )
+        t.MarkNeighbor( *n2 );
+
+    if( n3 )
+        t.MarkNeighbor( *n3 );
+
+    if( n4 )
+        ot.MarkNeighbor( *n4 );
+
     t.MarkNeighbor( ot );
 }
 
+
 void Sweep::FillBasin( SweepContext& tcx, Node& node )
 {
-  if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
+    if( Orient2d( *node.point, *node.next->point, *node.next->next->point ) == CCW )
+    {
         tcx.basin.left_node = node.next->next;
-  } else {
+    }
+    else
+    {
         tcx.basin.left_node = node.next;
     }
 
     // Find the bottom and right node
     tcx.basin.bottom_node = tcx.basin.left_node;
+
     while( tcx.basin.bottom_node->next
-         && tcx.basin.bottom_node->point->y >= tcx.basin.bottom_node->next->point->y) {
+           && tcx.basin.bottom_node->point->y >= tcx.basin.bottom_node->next->point->y )
+    {
         tcx.basin.bottom_node = tcx.basin.bottom_node->next;
     }
-  if (tcx.basin.bottom_node == tcx.basin.left_node) {
+
+    if( tcx.basin.bottom_node == tcx.basin.left_node )
+    {
         // No valid basin
         return;
     }
 
     tcx.basin.right_node = tcx.basin.bottom_node;
+
     while( tcx.basin.right_node->next
-         && tcx.basin.right_node->point->y < tcx.basin.right_node->next->point->y) {
+           && tcx.basin.right_node->point->y < tcx.basin.right_node->next->point->y )
+    {
         tcx.basin.right_node = tcx.basin.right_node->next;
     }
-  if (tcx.basin.right_node == tcx.basin.bottom_node) {
+
+    if( tcx.basin.right_node == tcx.basin.bottom_node )
+    {
         // No valid basins
         return;
     }
@@ -510,34 +613,52 @@ void Sweep::FillBasin(SweepContext& tcx, Node& node)
     FillBasinReq( tcx, tcx.basin.bottom_node );
 }
 
+
 void Sweep::FillBasinReq( SweepContext& tcx, Node* node )
 {
     // if shallow stop filling
-  if (IsShallow(tcx, *node)) {
+    if( IsShallow( tcx, *node ) )
+    {
         return;
     }
 
     Fill( tcx, *node );
 
-  if (node->prev == tcx.basin.left_node && node->next == tcx.basin.right_node) {
+    if( node->prev == tcx.basin.left_node && node->next == tcx.basin.right_node )
+    {
         return;
-  } else if (node->prev == tcx.basin.left_node) {
+    }
+    else if( node->prev == tcx.basin.left_node )
+    {
         Orientation o = Orient2d( *node->point, *node->next->point, *node->next->next->point );
-    if (o == CW) {
+
+        if( o == CW )
+        {
             return;
         }
+
         node = node->next;
-  } else if (node->next == tcx.basin.right_node) {
+    }
+    else if( node->next == tcx.basin.right_node )
+    {
         Orientation o = Orient2d( *node->point, *node->prev->point, *node->prev->prev->point );
-    if (o == CCW) {
+
+        if( o == CCW )
+        {
             return;
         }
+
         node = node->prev;
-  } else {
+    }
+    else
+    {
         // Continue with the neighbor node with lowest Y value
-    if (node->prev->point->y < node->next->point->y) {
+        if( node->prev->point->y < node->next->point->y )
+        {
             node = node->prev;
-    } else {
+        }
+        else
+        {
             node = node->next;
         }
     }
@@ -545,51 +666,71 @@ void Sweep::FillBasinReq(SweepContext& tcx, Node* node)
     FillBasinReq( tcx, node );
 }
 
+
 bool Sweep::IsShallow( SweepContext& tcx, Node& node )
 {
     double height;
 
-  if (tcx.basin.left_highest) {
+    if( tcx.basin.left_highest )
+    {
         height = tcx.basin.left_node->point->y - node.point->y;
-  } else {
+    }
+    else
+    {
         height = tcx.basin.right_node->point->y - node.point->y;
     }
 
     // if shallow stop filling
-  if (tcx.basin.width > height) {
+    if( tcx.basin.width > height )
+    {
         return true;
     }
+
     return false;
 }
 
+
 void Sweep::FillEdgeEvent( SweepContext& tcx, Edge* edge, Node* node )
 {
-  if (tcx.edge_event.right) {
+    if( tcx.edge_event.right )
+    {
         FillRightAboveEdgeEvent( tcx, edge, node );
-  } else {
+    }
+    else
+    {
         FillLeftAboveEdgeEvent( tcx, edge, node );
     }
 }
 
+
 void Sweep::FillRightAboveEdgeEvent( SweepContext& tcx, Edge* edge, Node* node )
 {
-  while (node->next->point->x < edge->p->x) {
+    while( node->next->point->x < edge->p->x )
+    {
         // Check if next node is below the edge
-    if (Orient2d(*edge->q, *node->next->point, *edge->p) == CCW) {
+        if( Orient2d( *edge->q, *node->next->point, *edge->p ) == CCW )
+        {
             FillRightBelowEdgeEvent( tcx, edge, *node );
-    } else {
+        }
+        else
+        {
             node = node->next;
         }
     }
 }
 
+
 void Sweep::FillRightBelowEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
 {
-  if (node.point->x < edge->p->x) {
+    if( node.point->x < edge->p->x )
-    if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
+    {
+        if( Orient2d( *node.point, *node.next->point, *node.next->next->point ) == CCW )
+        {
             // Concave
             FillRightConcaveEdgeEvent( tcx, edge, node );
-    } else{
+        }
+        else
+        {
             // Convex
             FillRightConvexEdgeEvent( tcx, edge, node );
             // Retry this one
@@ -598,61 +739,85 @@ void Sweep::FillRightBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
     }
 }
 
+
 void Sweep::FillRightConcaveEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
 {
     Fill( tcx, *node.next );
-  if (node.next->point != edge->p) {
+
+    if( node.next->point != edge->p )
+    {
         // Next above or below edge?
-    if (Orient2d(*edge->q, *node.next->point, *edge->p) == CCW) {
+        if( Orient2d( *edge->q, *node.next->point, *edge->p ) == CCW )
+        {
             // Below
-      if (Orient2d(*node.point, *node.next->point, *node.next->next->point) == CCW) {
+            if( Orient2d( *node.point, *node.next->point, *node.next->next->point ) == CCW )
+            {
                 // Next is concave
                 FillRightConcaveEdgeEvent( tcx, edge, node );
-      } else {
+            }
+            else
+            {
                 // Next is convex
             }
         }
     }
-
 }
 
+
 void Sweep::FillRightConvexEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
 {
     // Next concave or convex?
-  if (Orient2d(*node.next->point, *node.next->next->point, *node.next->next->next->point) == CCW) {
+    if( Orient2d( *node.next->point, *node.next->next->point,
+                *node.next->next->next->point ) == CCW )
+    {
         // Concave
         FillRightConcaveEdgeEvent( tcx, edge, *node.next );
-  } else{
+    }
+    else
+    {
         // Convex
         // Next above or below edge?
-    if (Orient2d(*edge->q, *node.next->next->point, *edge->p) == CCW) {
+        if( Orient2d( *edge->q, *node.next->next->point, *edge->p ) == CCW )
+        {
             // Below
             FillRightConvexEdgeEvent( tcx, edge, *node.next );
-    } else{
+        }
+        else
+        {
             // Above
         }
     }
 }
 
+
 void Sweep::FillLeftAboveEdgeEvent( SweepContext& tcx, Edge* edge, Node* node )
 {
-  while (node->prev->point->x > edge->p->x) {
+    while( node->prev->point->x > edge->p->x )
+    {
         // Check if next node is below the edge
-    if (Orient2d(*edge->q, *node->prev->point, *edge->p) == CW) {
+        if( Orient2d( *edge->q, *node->prev->point, *edge->p ) == CW )
+        {
             FillLeftBelowEdgeEvent( tcx, edge, *node );
-    } else {
+        }
+        else
+        {
             node = node->prev;
         }
     }
 }
 
+
 void Sweep::FillLeftBelowEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
 {
-  if (node.point->x > edge->p->x) {
+    if( node.point->x > edge->p->x )
-    if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
+    {
+        if( Orient2d( *node.point, *node.prev->point, *node.prev->prev->point ) == CW )
+        {
             // Concave
             FillLeftConcaveEdgeEvent( tcx, edge, node );
-    } else {
+        }
+        else
+        {
             // Convex
             FillLeftConvexEdgeEvent( tcx, edge, node );
             // Retry this one
@@ -661,84 +826,117 @@ void Sweep::FillLeftBelowEdgeEvent(SweepContext& tcx, Edge* edge, Node& node)
     }
 }
 
+
 void Sweep::FillLeftConvexEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
 {
     // Next concave or convex?
-  if (Orient2d(*node.prev->point, *node.prev->prev->point, *node.prev->prev->prev->point) == CW) {
+    if( Orient2d( *node.prev->point, *node.prev->prev->point,
+                *node.prev->prev->prev->point ) == CW )
+    {
         // Concave
         FillLeftConcaveEdgeEvent( tcx, edge, *node.prev );
-  } else{
+    }
+    else
+    {
         // Convex
         // Next above or below edge?
-    if (Orient2d(*edge->q, *node.prev->prev->point, *edge->p) == CW) {
+        if( Orient2d( *edge->q, *node.prev->prev->point, *edge->p ) == CW )
+        {
             // Below
             FillLeftConvexEdgeEvent( tcx, edge, *node.prev );
-    } else{
+        }
+        else
+        {
             // Above
         }
     }
 }
 
+
 void Sweep::FillLeftConcaveEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
 {
     Fill( tcx, *node.prev );
-  if (node.prev->point != edge->p) {
+
+    if( node.prev->point != edge->p )
+    {
         // Next above or below edge?
-    if (Orient2d(*edge->q, *node.prev->point, *edge->p) == CW) {
+        if( Orient2d( *edge->q, *node.prev->point, *edge->p ) == CW )
+        {
             // Below
-      if (Orient2d(*node.point, *node.prev->point, *node.prev->prev->point) == CW) {
+            if( Orient2d( *node.point, *node.prev->point, *node.prev->prev->point ) == CW )
+            {
                 // Next is concave
                 FillLeftConcaveEdgeEvent( tcx, edge, node );
-      } else{
+            }
+            else
+            {
                 // Next is convex
             }
         }
     }
-
 }
 
+
 void Sweep::FlipEdgeEvent( SweepContext& tcx, Point& ep, Point& eq, Triangle* t, Point& p )
 {
     Triangle& ot = t->NeighborAcross( p );
     Point& op = *ot.OppositePoint( *t, p );
 
-  if (&ot == NULL) {
+    if( &ot == NULL )
+    {
         // If we want to integrate the fillEdgeEvent do it here
         // With current implementation we should never get here
         // throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
         assert( 0 );
     }
 
-  if (InScanArea(p, *t->PointCCW(p), *t->PointCW(p), op)) {
+    if( InScanArea( p, *t->PointCCW( p ), *t->PointCW( p ), op ) )
+    {
         // Lets rotate shared edge one vertex CW
         RotateTrianglePair( *t, p, ot, op );
         tcx.MapTriangleToNodes( *t );
         tcx.MapTriangleToNodes( ot );
 
-    if (p == eq && op == ep) {
+        if( p == eq && op == ep )
-      if (eq == *tcx.edge_event.constrained_edge->q && ep == *tcx.edge_event.constrained_edge->p) {
+        {
+            if( eq == *tcx.edge_event.constrained_edge->q
+                && ep == *tcx.edge_event.constrained_edge->p )
+            {
                 t->MarkConstrainedEdge( &ep, &eq );
                 ot.MarkConstrainedEdge( &ep, &eq );
                 Legalize( tcx, *t );
                 Legalize( tcx, ot );
-      } else {
+            }
+            else
+            {
                 // XXX: I think one of the triangles should be legalized here?
             }
-    } else {
+        }
+        else
+        {
             Orientation o = Orient2d( eq, op, ep );
             t = &NextFlipTriangle( tcx, (int) o, *t, ot, p, op );
             FlipEdgeEvent( tcx, ep, eq, t, p );
         }
-  } else {
+    }
+    else
+    {
         Point& newP = NextFlipPoint( ep, eq, ot, op );
         FlipScanEdgeEvent( tcx, ep, eq, *t, ot, newP );
         EdgeEvent( tcx, ep, eq, t, p );
     }
 }
 
-Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangle& ot, Point& p, Point& op)
+
+Triangle& Sweep::NextFlipTriangle( SweepContext& tcx,
+        int o,
+        Triangle& t,
+        Triangle& ot,
+        Point& p,
+        Point& op )
+{
+    if( o == CCW )
     {
-  if (o == CCW) {
         // ot is not crossing edge after flip
         int edge_index = ot.EdgeIndex( &p, &op );
         ot.delaunay_edge[edge_index] = true;
@@ -756,13 +954,18 @@ Triangle& Sweep::NextFlipTriangle(SweepContext& tcx, int o, Triangle& t, Triangl
     return ot;
 }
 
+
 Point& Sweep::NextFlipPoint( Point& ep, Point& eq, Triangle& ot, Point& op )
 {
     Orientation o2d = Orient2d( eq, op, ep );
-  if (o2d == CW) {
+
+    if( o2d == CW )
+    {
         // Right
         return *ot.PointCCW( op );
-  } else if (o2d == CCW) {
+    }
+    else if( o2d == CCW )
+    {
         // Left
         return *ot.PointCW( op );
     }
@@ -774,20 +977,23 @@ Point& Sweep::NextFlipPoint(Point& ep, Point& eq, Triangle& ot, Point& op)
     return ep;
 }
 
+
 void Sweep::FlipScanEdgeEvent( SweepContext& tcx, Point& ep, Point& eq, Triangle& flip_triangle,
         Triangle& t, Point& p )
 {
     Triangle& ot = t.NeighborAcross( p );
     Point& op = *ot.OppositePoint( t, p );
 
-  if (&t.NeighborAcross(p) == NULL) {
+    if( &t.NeighborAcross( p ) == NULL )
+    {
         // If we want to integrate the fillEdgeEvent do it here
         // With current implementation we should never get here
         // throw new RuntimeException( "[BUG:FIXME] FLIP failed due to missing triangle");
         assert( 0 );
     }
 
-  if (InScanArea(eq, *flip_triangle.PointCCW(eq), *flip_triangle.PointCW(eq), op)) {
+    if( InScanArea( eq, *flip_triangle.PointCCW( eq ), *flip_triangle.PointCW( eq ), op ) )
+    {
         // flip with new edge op->eq
         FlipEdgeEvent( tcx, eq, op, &ot, op );
         // TODO: Actually I just figured out that it should be possible to
@@ -797,21 +1003,21 @@ void Sweep::FlipScanEdgeEvent(SweepContext& tcx, Point& ep, Point& eq, Triangle&
         // also need to set a new flip_triangle first
         // Turns out at first glance that this is somewhat complicated
         // so it will have to wait.
-  } else{
+    }
+    else
+    {
         Point& newP = NextFlipPoint( ep, eq, ot, op );
         FlipScanEdgeEvent( tcx, ep, eq, flip_triangle, ot, newP );
     }
 }
 
-Sweep::~Sweep() {
 
+Sweep::~Sweep()
+{
     // Clean up memory
     for( unsigned i = 0; i < nodes_.size(); i++ )
     {
         delete nodes_[i];
     }
-
 }
-
 }
-

polygon/poly2tri/sweep/sweep_context.cc

@@ -33,7 +33,6 @@
 #include "advancing_front.h"
 
 namespace p2t {
-
 SweepContext::SweepContext( std::vector<Point*> polyline ) :
     front_( 0 ),
     head_( 0 ),
@@ -50,42 +49,55 @@ SweepContext::SweepContext(std::vector<Point*> polyline) :
     InitEdges( points_ );
 }
 
+
 void SweepContext::AddHole( std::vector<Point*> polyline )
 {
     InitEdges( polyline );
-  for(unsigned int i = 0; i < polyline.size(); i++) {
+
+    for( unsigned int i = 0; i < polyline.size(); i++ )
+    {
         points_.push_back( polyline[i] );
     }
 }
 
-void SweepContext::AddPoint(Point* point) {
+
+void SweepContext::AddPoint( Point* point )
+{
     points_.push_back( point );
 }
 
+
 std::vector<Triangle*> SweepContext::GetTriangles()
 {
     return triangles_;
 }
 
+
 std::list<Triangle*> SweepContext::GetMap()
 {
     return map_;
 }
 
+
 void SweepContext::InitTriangulation()
 {
     double  xmax( points_[0]->x ), xmin( points_[0]->x );
     double  ymax( points_[0]->y ), ymin( points_[0]->y );
 
     // Calculate bounds.
-  for (unsigned int i = 0; i < points_.size(); i++) {
+    for( unsigned int i = 0; i < points_.size(); i++ )
+    {
         Point& p = *points_[i];
+
         if( p.x > xmax )
             xmax = p.x;
+
         if( p.x < xmin )
             xmin = p.x;
+
         if( p.y > ymax )
             ymax = p.y;
+
         if( p.y < ymin )
             ymin = p.y;
     }
@@ -97,37 +109,42 @@ void SweepContext::InitTriangulation()
 
     // Sort points along y-axis
     std::sort( points_.begin(), points_.end(), cmp );
-
 }
 
+
 void SweepContext::InitEdges( std::vector<Point*> polyline )
 {
     int num_points = polyline.size();
-  for (int i = 0; i < num_points; i++) {
+
+    for( int i = 0; i < num_points; i++ )
+    {
         int j = i < num_points - 1 ? i + 1 : 0;
         edge_list.push_back( new Edge( *polyline[i], *polyline[j] ) );
     }
 }
 
+
 Point* SweepContext::GetPoint( const int& index )
 {
     return points_[index];
 }
 
+
 void SweepContext::AddToMap( Triangle* triangle )
 {
     map_.push_back( triangle );
 }
 
+
 Node& SweepContext::LocateNode( Point& point )
 {
     // TODO implement search tree
     return *front_->LocateNode( point.x );
 }
 
+
 void SweepContext::CreateAdvancingFront( std::vector<Node*> nodes )
 {
-
     (void) nodes;
     // Initial triangle
     Triangle* triangle = new Triangle( *points_[0], *tail_, *head_ );
@@ -147,40 +164,52 @@ void SweepContext::CreateAdvancingFront(std::vector<Node*> nodes)
     af_tail_->prev = af_middle_;
 }
 
+
 void SweepContext::RemoveNode( Node* node )
 {
     delete node;
 }
 
+
 void SweepContext::MapTriangleToNodes( Triangle& t )
 {
-  for (int i = 0; i < 3; i++) {
+    for( int i = 0; i < 3; i++ )
-    if (!t.GetNeighbor(i)) {
+    {
+        if( !t.GetNeighbor( i ) )
+        {
             Node* n = front_->LocatePoint( t.PointCW( *t.GetPoint( i ) ) );
+
             if( n )
                 n->triangle = &t;
         }
     }
 }
 
+
 void SweepContext::RemoveFromMap( Triangle* triangle )
 {
     map_.remove( triangle );
 }
 
+
 void SweepContext::MeshClean( Triangle& triangle )
 {
     std::vector<Triangle*> triangles;
+
     triangles.push_back( &triangle );
 
-  while(!triangles.empty()){
+    while( !triangles.empty() )
+    {
         Triangle* t = triangles.back();
         triangles.pop_back();
 
-    if (t != NULL && !t->IsInterior()) {
+        if( t != NULL && !t->IsInterior() )
+        {
             t->IsInterior( true );
             triangles_.push_back( t );
-      for (int i = 0; i < 3; i++) {
+
+            for( int i = 0; i < 3; i++ )
+            {
                 if( !t->constrained_edge[i] )
                     triangles.push_back( t->GetNeighbor( i ) );
             }
@@ -188,9 +217,9 @@ void SweepContext::MeshClean(Triangle& triangle)
     }
 }
 
+
 SweepContext::~SweepContext()
 {
-
     // Clean up memory
 
     delete head_;
@@ -202,15 +231,15 @@ SweepContext::~SweepContext()
 
     typedef std::list<Triangle*> type_list;
 
-    for(type_list::iterator iter = map_.begin(); iter != map_.end(); ++iter) {
+    for( type_list::iterator iter = map_.begin(); iter != map_.end(); ++iter )
+    {
         Triangle* ptr = *iter;
         delete ptr;
     }
 
-     for(unsigned int i = 0; i < edge_list.size(); i++) {
+    for( unsigned int i = 0; i < edge_list.size(); i++ )
+    {
         delete edge_list[i];
     }
-
 }
-
 }

polygon/poly2tri/sweep/sweep_context.h

@@ -37,7 +37,6 @@
 #include <cstddef>
 
 namespace p2t {
-
 // Inital triangle factor, seed triangle will extend 30% of
 // PointSet width to both left and right.
 const double kAlpha = 0.3;
@@ -48,7 +47,8 @@ struct Node;
 struct Edge;
 class AdvancingFront;
 
-class SweepContext {
+class SweepContext
+{
 public:
 
 /// Constructor
@@ -92,18 +92,21 @@ AdvancingFront* front();
     void MeshClean( Triangle& triangle );
 
     std::vector<Triangle*> GetTriangles();
+
     std::list<Triangle*> GetMap();
 
     std::vector<Edge*> edge_list;
 
-struct Basin {
+    struct Basin
+    {
         Node* left_node;
         Node* bottom_node;
         Node* right_node;
         double width;
         bool left_highest;
 
-  Basin() : left_node(NULL), bottom_node(NULL), right_node(NULL), width(0.0), left_highest(false)
+        Basin() : left_node( NULL ), bottom_node( NULL ), right_node( NULL ), width( 0.0 ),
+            left_highest( false )
         {
         }
 
@@ -117,7 +120,8 @@ struct Basin {
         }
     };
 
-struct EdgeEvent {
+    struct EdgeEvent
+    {
         Edge* constrained_edge;
         bool right;
 
@@ -148,7 +152,6 @@ Node *af_head_, *af_middle_, *af_tail_;
 
     void    InitTriangulation();
     void    InitEdges( std::vector<Point*> polyline );
-
 };
 
 inline AdvancingFront* SweepContext::front()
@@ -156,31 +159,35 @@ inline AdvancingFront* SweepContext::front()
     return front_;
 }
 
+
 inline int SweepContext::point_count()
 {
     return points_.size();
 }
 
+
 inline void SweepContext::set_head( Point* p1 )
 {
     head_ = p1;
 }
 
+
 inline Point* SweepContext::head()
 {
     return head_;
 }
 
+
 inline void SweepContext::set_tail( Point* p1 )
 {
     tail_ = p1;
 }
 
+
 inline Point* SweepContext::tail()
 {
     return tail_;
 }
-
 }
 
 #endif