1008 lines
26 KiB
C++
1008 lines
26 KiB
C++
/*
|
|
* Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
|
|
* http://code.google.com/p/poly2tri/
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* * Neither the name of Poly2Tri nor the names of its contributors may be
|
|
* used to endorse or promote products derived from this software without specific
|
|
* prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
#include <stdexcept>
|
|
#include "sweep.h"
|
|
#include "sweep_context.h"
|
|
#include "advancing_front.h"
|
|
#include "../common/utils.h"
|
|
|
|
namespace p2t {
|
|
// Triangulate simple polygon with holes
|
|
void Sweep::Triangulate( SweepContext& tcx )
|
|
{
|
|
tcx.InitTriangulation();
|
|
tcx.CreateAdvancingFront( nodes_ );
|
|
// Sweep points; build mesh
|
|
SweepPoints( tcx );
|
|
// Clean up
|
|
FinalizationPolygon( tcx );
|
|
}
|
|
|
|
|
|
void Sweep::SweepPoints( SweepContext& tcx )
|
|
{
|
|
for( int jj = 1; jj < tcx.point_count(); jj++ )
|
|
{
|
|
Point& point = *tcx.GetPoint( jj );
|
|
Node* node = &PointEvent( tcx, point );
|
|
|
|
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 ) )
|
|
{
|
|
t = t->NeighborCCW( *p );
|
|
}
|
|
|
|
// Collect interior triangles constrained by edges
|
|
tcx.MeshClean( *t );
|
|
}
|
|
|
|
|
|
Node& Sweep::PointEvent( SweepContext& tcx, Point& point )
|
|
{
|
|
Node& node = tcx.LocateNode( point );
|
|
Node& new_node = NewFrontTriangle( tcx, point, node );
|
|
|
|
// 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 )
|
|
{
|
|
Fill( tcx, node );
|
|
}
|
|
|
|
// tcx.AddNode(new_node);
|
|
|
|
FillAdvancingFront( tcx, new_node );
|
|
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 ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// For now we will do all needed filling
|
|
// TODO: integrate with flip process might give some better performance
|
|
// but for now this avoid the issue with cases that needs both flips and fills
|
|
FillEdgeEvent( tcx, edge, 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 ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
Point* p1 = triangle->PointCCW( point );
|
|
Orientation o1 = Orient2d( eq, *p1, ep );
|
|
|
|
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
|
|
{
|
|
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 ) )
|
|
{
|
|
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
|
|
{
|
|
std::runtime_error( "EdgeEvent - collinear points not supported" );
|
|
assert( 0 );
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
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 )
|
|
{
|
|
triangle = triangle->NeighborCCW( point );
|
|
}
|
|
else
|
|
{
|
|
triangle = triangle->NeighborCW( point );
|
|
}
|
|
|
|
EdgeEvent( tcx, ep, eq, triangle, point );
|
|
}
|
|
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 )
|
|
{
|
|
triangle.MarkConstrainedEdge( index );
|
|
Triangle* t = triangle.GetNeighbor( index );
|
|
|
|
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 );
|
|
|
|
triangle->MarkNeighbor( *node.triangle );
|
|
tcx.AddToMap( triangle );
|
|
|
|
Node* new_node = new Node( point );
|
|
nodes_.push_back( new_node );
|
|
|
|
new_node->next = node.next;
|
|
new_node->prev = &node;
|
|
node.next->prev = new_node;
|
|
node.next = new_node;
|
|
|
|
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 );
|
|
|
|
// TODO: should copy the constrained_edge value from neighbor triangles
|
|
// for now constrained_edge values are copied during the legalize
|
|
triangle->MarkNeighbor( *node.prev->triangle );
|
|
triangle->MarkNeighbor( *node.triangle );
|
|
|
|
tcx.AddToMap( triangle );
|
|
|
|
// Update the advancing front
|
|
node.prev->next = node.next;
|
|
node.next->prev = node.prev;
|
|
|
|
// If it was legalized the triangle has already been mapped
|
|
if( !Legalize( tcx, *triangle ) )
|
|
{
|
|
tcx.MapTriangleToNodes( *triangle );
|
|
}
|
|
}
|
|
|
|
|
|
void Sweep::FillAdvancingFront( SweepContext& tcx, Node& n )
|
|
{
|
|
// Fill right holes
|
|
Node* node = n.next;
|
|
|
|
while( node->next )
|
|
{
|
|
// if HoleAngle exceeds 90 degrees then break.
|
|
if( LargeHole_DontFill( node ) )
|
|
break;
|
|
|
|
Fill( tcx, *node );
|
|
node = node->next;
|
|
}
|
|
|
|
// Fill left holes
|
|
node = n.prev;
|
|
|
|
while( node->prev )
|
|
{
|
|
// if HoleAngle exceeds 90 degrees then break.
|
|
if( LargeHole_DontFill( node ) )
|
|
break;
|
|
|
|
Fill( tcx, *node );
|
|
node = node->prev;
|
|
}
|
|
|
|
// Fill right basins
|
|
if( n.next && n.next->next )
|
|
{
|
|
double angle = BasinAngle( n );
|
|
|
|
if( angle < PI_3div4 )
|
|
{
|
|
FillBasin( tcx, n );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// 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 ) )
|
|
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 ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
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 )
|
|
{
|
|
double angle = Angle( *origin, *pa, *pb );
|
|
bool exceedsPlus90DegreesOrIsNegative = (angle > PI_div2) || (angle < 0);
|
|
|
|
return exceedsPlus90DegreesOrIsNegative;
|
|
}
|
|
|
|
|
|
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)
|
|
* atan2(y,x) computes the principal value of the argument function
|
|
* applied to the complex number x+iy
|
|
* Where x = ax*bx + ay*by
|
|
* y = ax*by - ay*bx
|
|
*/
|
|
double px = origin.x;
|
|
double py = origin.y;
|
|
double ax = pa.x - px;
|
|
double ay = pa.y - py;
|
|
double bx = pb.x - px;
|
|
double by = pb.y - py;
|
|
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
|
|
* ab = cosA +i*sinA
|
|
* ab = (ax + ay*i)(bx + by*i) = (ax*bx + ay*by) + i(ax*by-ay*bx)
|
|
* atan2(y,x) computes the principal value of the argument function
|
|
* applied to the complex number x+iy
|
|
* Where x = ax*bx + ay*by
|
|
* y = ax*by - ay*bx
|
|
*/
|
|
double ax = node.next->point->x - node.point->x;
|
|
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++ )
|
|
{
|
|
if( t.delaunay_edge[i] )
|
|
continue;
|
|
|
|
Triangle* ot = t.GetNeighbor( i );
|
|
|
|
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] )
|
|
{
|
|
t.constrained_edge[i] = ot->constrained_edge[oi];
|
|
continue;
|
|
}
|
|
|
|
bool inside = Incircle( *p, *t.PointCCW( *p ), *t.PointCW( *p ), *op );
|
|
|
|
if( inside )
|
|
{
|
|
// Lets mark this shared edge as Delaunay
|
|
t.delaunay_edge[i] = true;
|
|
ot->delaunay_edge[oi] = true;
|
|
|
|
// Lets rotate shared edge one vertex CW to legalize it
|
|
RotateTrianglePair( t, *p, *ot, *op );
|
|
|
|
// We now got one valid Delaunay Edge shared by two triangles
|
|
// This gives us 4 new edges to check for Delaunay
|
|
|
|
// 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 )
|
|
{
|
|
tcx.MapTriangleToNodes( t );
|
|
}
|
|
|
|
not_legalized = !Legalize( tcx, *ot );
|
|
|
|
if( not_legalized )
|
|
tcx.MapTriangleToNodes( *ot );
|
|
|
|
// Reset the Delaunay edges, since they only are valid Delaunay edges
|
|
// until we add a new triangle or point.
|
|
// XXX: need to think about this. Can these edges be tried after we
|
|
// return to previous recursive level?
|
|
t.delaunay_edge[i] = false;
|
|
ot->delaunay_edge[oi] = false;
|
|
|
|
// If triangle have been legalized no need to check the other edges since
|
|
// the recursive legalization will handles those so we can end here.
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Sweep::Incircle( Point& pa, Point& pb, Point& pc, Point& pd )
|
|
{
|
|
double adx = pa.x - pd.x;
|
|
double ady = pa.y - pd.y;
|
|
double bdx = pb.x - pd.x;
|
|
double bdy = pb.y - pd.y;
|
|
|
|
double adxbdy = adx * bdy;
|
|
double bdxady = bdx * ady;
|
|
double oabd = adxbdy - bdxady;
|
|
|
|
if( oabd <= 0 )
|
|
return false;
|
|
|
|
double cdx = pc.x - pd.x;
|
|
double cdy = pc.y - pd.y;
|
|
|
|
double cdxady = cdx * ady;
|
|
double adxcdy = adx * cdy;
|
|
double ocad = cdxady - adxcdy;
|
|
|
|
if( ocad <= 0 )
|
|
return false;
|
|
|
|
double bdxcdy = bdx * cdy;
|
|
double cdxbdy = cdx * bdy;
|
|
|
|
double alift = adx * adx + ady * ady;
|
|
double blift = bdx * bdx + bdy * bdy;
|
|
double clift = cdx * cdx + cdy * cdy;
|
|
|
|
double det = alift * (bdxcdy - cdxbdy) + blift * ocad + clift * oabd;
|
|
|
|
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 );
|
|
n4 = ot.NeighborCW( op );
|
|
|
|
bool ce1, ce2, ce3, ce4;
|
|
ce1 = t.GetConstrainedEdgeCCW( p );
|
|
ce2 = t.GetConstrainedEdgeCW( p );
|
|
ce3 = ot.GetConstrainedEdgeCCW( op );
|
|
ce4 = ot.GetConstrainedEdgeCW( op );
|
|
|
|
bool de1, de2, de3, de4;
|
|
de1 = t.GetDelunayEdgeCCW( p );
|
|
de2 = t.GetDelunayEdgeCW( p );
|
|
de3 = ot.GetDelunayEdgeCCW( op );
|
|
de4 = ot.GetDelunayEdgeCW( op );
|
|
|
|
t.Legalize( p, op );
|
|
ot.Legalize( op, p );
|
|
|
|
// Remap delaunay_edge
|
|
ot.SetDelunayEdgeCCW( p, de1 );
|
|
t.SetDelunayEdgeCW( p, de2 );
|
|
t.SetDelunayEdgeCCW( op, de3 );
|
|
ot.SetDelunayEdgeCW( op, de4 );
|
|
|
|
// Remap constrained_edge
|
|
ot.SetConstrainedEdgeCCW( p, ce1 );
|
|
t.SetConstrainedEdgeCW( p, ce2 );
|
|
t.SetConstrainedEdgeCCW( op, ce3 );
|
|
ot.SetConstrainedEdgeCW( op, ce4 );
|
|
|
|
// Remap neighbors
|
|
// XXX: might optimize the markNeighbor by keeping track of
|
|
// what side should be assigned to what neighbor after the
|
|
// rotation. Now mark neighbor does lots of testing to find
|
|
// the right side.
|
|
t.ClearNeighbors();
|
|
ot.ClearNeighbors();
|
|
|
|
if( n1 )
|
|
ot.MarkNeighbor( *n1 );
|
|
|
|
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 )
|
|
{
|
|
tcx.basin.left_node = node.next->next;
|
|
}
|
|
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 = tcx.basin.bottom_node->next;
|
|
}
|
|
|
|
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 = tcx.basin.right_node->next;
|
|
}
|
|
|
|
if( tcx.basin.right_node == tcx.basin.bottom_node )
|
|
{
|
|
// No valid basins
|
|
return;
|
|
}
|
|
|
|
tcx.basin.width = tcx.basin.right_node->point->x - tcx.basin.left_node->point->x;
|
|
tcx.basin.left_highest = tcx.basin.left_node->point->y > tcx.basin.right_node->point->y;
|
|
|
|
FillBasinReq( tcx, tcx.basin.bottom_node );
|
|
}
|
|
|
|
|
|
void Sweep::FillBasinReq( SweepContext& tcx, Node* node )
|
|
{
|
|
// if shallow stop filling
|
|
if( IsShallow( tcx, *node ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
Fill( tcx, *node );
|
|
|
|
if( node->prev == tcx.basin.left_node && node->next == tcx.basin.right_node )
|
|
{
|
|
return;
|
|
}
|
|
else if( node->prev == tcx.basin.left_node )
|
|
{
|
|
Orientation o = Orient2d( *node->point, *node->next->point, *node->next->next->point );
|
|
|
|
if( o == CW )
|
|
{
|
|
return;
|
|
}
|
|
|
|
node = node->next;
|
|
}
|
|
else if( node->next == tcx.basin.right_node )
|
|
{
|
|
Orientation o = Orient2d( *node->point, *node->prev->point, *node->prev->prev->point );
|
|
|
|
if( o == CCW )
|
|
{
|
|
return;
|
|
}
|
|
|
|
node = node->prev;
|
|
}
|
|
else
|
|
{
|
|
// Continue with the neighbor node with lowest Y value
|
|
if( node->prev->point->y < node->next->point->y )
|
|
{
|
|
node = node->prev;
|
|
}
|
|
else
|
|
{
|
|
node = node->next;
|
|
}
|
|
}
|
|
|
|
FillBasinReq( tcx, node );
|
|
}
|
|
|
|
|
|
bool Sweep::IsShallow( SweepContext& tcx, Node& node )
|
|
{
|
|
double height;
|
|
|
|
if( tcx.basin.left_highest )
|
|
{
|
|
height = tcx.basin.left_node->point->y - node.point->y;
|
|
}
|
|
else
|
|
{
|
|
height = tcx.basin.right_node->point->y - node.point->y;
|
|
}
|
|
|
|
// if shallow stop filling
|
|
if( tcx.basin.width > height )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void Sweep::FillEdgeEvent( SweepContext& tcx, Edge* edge, Node* node )
|
|
{
|
|
if( tcx.edge_event.right )
|
|
{
|
|
FillRightAboveEdgeEvent( tcx, edge, node );
|
|
}
|
|
else
|
|
{
|
|
FillLeftAboveEdgeEvent( tcx, edge, node );
|
|
}
|
|
}
|
|
|
|
|
|
void Sweep::FillRightAboveEdgeEvent( SweepContext& tcx, Edge* edge, Node* node )
|
|
{
|
|
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 )
|
|
{
|
|
FillRightBelowEdgeEvent( tcx, edge, *node );
|
|
}
|
|
else
|
|
{
|
|
node = node->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Sweep::FillRightBelowEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
|
|
{
|
|
if( node.point->x < edge->p->x )
|
|
{
|
|
if( Orient2d( *node.point, *node.next->point, *node.next->next->point ) == CCW )
|
|
{
|
|
// Concave
|
|
FillRightConcaveEdgeEvent( tcx, edge, node );
|
|
}
|
|
else
|
|
{
|
|
// Convex
|
|
FillRightConvexEdgeEvent( tcx, edge, node );
|
|
// Retry this one
|
|
FillRightBelowEdgeEvent( tcx, edge, node );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Sweep::FillRightConcaveEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
|
|
{
|
|
Fill( tcx, *node.next );
|
|
|
|
if( node.next->point != edge->p )
|
|
{
|
|
// Next above or below edge?
|
|
if( Orient2d( *edge->q, *node.next->point, *edge->p ) == CCW )
|
|
{
|
|
// Below
|
|
if( Orient2d( *node.point, *node.next->point, *node.next->next->point ) == CCW )
|
|
{
|
|
// Next is concave
|
|
FillRightConcaveEdgeEvent( tcx, edge, node );
|
|
}
|
|
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 )
|
|
{
|
|
// Concave
|
|
FillRightConcaveEdgeEvent( tcx, edge, *node.next );
|
|
}
|
|
else
|
|
{
|
|
// Convex
|
|
// Next above or below edge?
|
|
if( Orient2d( *edge->q, *node.next->next->point, *edge->p ) == CCW )
|
|
{
|
|
// Below
|
|
FillRightConvexEdgeEvent( tcx, edge, *node.next );
|
|
}
|
|
else
|
|
{
|
|
// Above
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Sweep::FillLeftAboveEdgeEvent( SweepContext& tcx, Edge* edge, Node* node )
|
|
{
|
|
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 )
|
|
{
|
|
FillLeftBelowEdgeEvent( tcx, edge, *node );
|
|
}
|
|
else
|
|
{
|
|
node = node->prev;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Sweep::FillLeftBelowEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
|
|
{
|
|
if( node.point->x > edge->p->x )
|
|
{
|
|
if( Orient2d( *node.point, *node.prev->point, *node.prev->prev->point ) == CW )
|
|
{
|
|
// Concave
|
|
FillLeftConcaveEdgeEvent( tcx, edge, node );
|
|
}
|
|
else
|
|
{
|
|
// Convex
|
|
FillLeftConvexEdgeEvent( tcx, edge, node );
|
|
// Retry this one
|
|
FillLeftBelowEdgeEvent( tcx, edge, 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 )
|
|
{
|
|
// Concave
|
|
FillLeftConcaveEdgeEvent( tcx, edge, *node.prev );
|
|
}
|
|
else
|
|
{
|
|
// Convex
|
|
// Next above or below edge?
|
|
if( Orient2d( *edge->q, *node.prev->prev->point, *edge->p ) == CW )
|
|
{
|
|
// Below
|
|
FillLeftConvexEdgeEvent( tcx, edge, *node.prev );
|
|
}
|
|
else
|
|
{
|
|
// Above
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Sweep::FillLeftConcaveEdgeEvent( SweepContext& tcx, Edge* edge, Node& node )
|
|
{
|
|
Fill( tcx, *node.prev );
|
|
|
|
if( node.prev->point != edge->p )
|
|
{
|
|
// Next above or below edge?
|
|
if( Orient2d( *edge->q, *node.prev->point, *edge->p ) == CW )
|
|
{
|
|
// Below
|
|
if( Orient2d( *node.point, *node.prev->point, *node.prev->prev->point ) == CW )
|
|
{
|
|
// Next is concave
|
|
FillLeftConcaveEdgeEvent( tcx, edge, node );
|
|
}
|
|
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( 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( 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
|
|
{
|
|
// XXX: I think one of the triangles should be legalized here?
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Orientation o = Orient2d( eq, op, ep );
|
|
t = &NextFlipTriangle( tcx, (int) o, *t, ot, p, op );
|
|
FlipEdgeEvent( tcx, ep, eq, t, p );
|
|
}
|
|
}
|
|
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 )
|
|
{
|
|
if( o == CCW )
|
|
{
|
|
// ot is not crossing edge after flip
|
|
int edge_index = ot.EdgeIndex( &p, &op );
|
|
ot.delaunay_edge[edge_index] = true;
|
|
Legalize( tcx, ot );
|
|
ot.ClearDelunayEdges();
|
|
return t;
|
|
}
|
|
|
|
// t is not crossing edge after flip
|
|
int edge_index = t.EdgeIndex( &p, &op );
|
|
|
|
t.delaunay_edge[edge_index] = true;
|
|
Legalize( tcx, t );
|
|
t.ClearDelunayEdges();
|
|
return ot;
|
|
}
|
|
|
|
|
|
Point& Sweep::NextFlipPoint( Point& ep, Point& eq, Triangle& ot, Point& op )
|
|
{
|
|
Orientation o2d = Orient2d( eq, op, ep );
|
|
|
|
if( o2d == CW )
|
|
{
|
|
// Right
|
|
return *ot.PointCCW( op );
|
|
}
|
|
else if( o2d == CCW )
|
|
{
|
|
// Left
|
|
return *ot.PointCW( op );
|
|
}
|
|
|
|
// throw new RuntimeException("[Unsupported] Opposing point on constrained edge");
|
|
assert( 0 );
|
|
|
|
// Never executed, due tu assert( 0 ). Just to avoid compil warning
|
|
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( 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
|
|
// improve this by getting the next ot and op before the the above
|
|
// flip and continue the flipScanEdgeEvent here
|
|
// set new ot and op here and loop back to inScanArea test
|
|
// 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
|
|
{
|
|
Point& newP = NextFlipPoint( ep, eq, ot, op );
|
|
FlipScanEdgeEvent( tcx, ep, eq, flip_triangle, ot, newP );
|
|
}
|
|
}
|
|
|
|
|
|
Sweep::~Sweep()
|
|
{
|
|
// Clean up memory
|
|
for( unsigned i = 0; i < nodes_.size(); i++ )
|
|
{
|
|
delete nodes_[i];
|
|
}
|
|
}
|
|
}
|