private void FlipEdgeEvent(SweepContext tcx, TriPoint ep, TriPoint eq, Triangle t, TriPoint p)
{
Triangle ot = t.NeighborAcross(p);
TriPoint op = ot.OppositePoint(t, p);
if (TriUtil.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.EdgeEvent.ConstrainedEdge.Q && ep == tcx.EdgeEvent.ConstrainedEdge.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
{
Winding o = TriUtil.Orient2d(eq, op, ep);
t = NextFlipTriangle(tcx, o, t, ot, p, op);
FlipEdgeEvent(tcx, ep, eq, t, p);
}
}
else
{
TriPoint newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP);
EdgeEvent(tcx, ep, eq, t, p);
}
}
private void Fill(SweepContext tcx, Node node)
{
Triangle triangle = new Triangle(node.Prev.Point, node.Point, node.Next.Point);
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);
}
}
private Node NewFrontTriangle(SweepContext tcx, TriPoint 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.Add(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);
}
private bool 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.DelaunayEdge[i])
{
continue;
}
Triangle ot = t.GetNeighbor(i);
if (ot != null)
{
TriPoint p = t.Points[i];
TriPoint 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.ConstrainedEdge[oi] || ot.DelaunayEdge[oi])
{
t.ConstrainedEdge[i] = ot.ConstrainedEdge[oi];
continue;
}
bool inside = Incircle(p, t.PointCCW(p), t.PointCW(p), op);
if (inside)
{
// Lets mark this shared edge as Delaunay
t.DelaunayEdge[i] = true;
ot.DelaunayEdge[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.DelaunayEdge[i] = false;
ot.DelaunayEdge[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);
}
