private static bool Legalize(DTSweepContext tcx, DelaunayTriangle t)
{
bool result;
for (int i = 0; i < 3; i++)
{
bool flag = t.EdgeIsDelaunay[i];
if (!flag)
{
DelaunayTriangle delaunayTriangle = t.Neighbors[i];
bool flag2 = delaunayTriangle != null;
if (flag2)
{
TriangulationPoint triangulationPoint = t.Points[i];
TriangulationPoint triangulationPoint2 = delaunayTriangle.OppositePoint(t, triangulationPoint);
int index = delaunayTriangle.IndexOf(triangulationPoint2);
bool flag3 = delaunayTriangle.EdgeIsConstrained[index] || delaunayTriangle.EdgeIsDelaunay[index];
if (flag3)
{
t.EdgeIsConstrained[i] = delaunayTriangle.EdgeIsConstrained[index];
}
else
{
bool flag4 = TriangulationUtil.SmartIncircle(triangulationPoint, t.PointCCW(triangulationPoint), t.PointCW(triangulationPoint), triangulationPoint2);
bool flag5 = flag4;
if (flag5)
{
t.EdgeIsDelaunay[i] = true;
delaunayTriangle.EdgeIsDelaunay[index] = true;
DTSweep.RotateTrianglePair(t, triangulationPoint, delaunayTriangle, triangulationPoint2);
bool flag6 = !DTSweep.Legalize(tcx, t);
bool flag7 = flag6;
if (flag7)
{
tcx.MapTriangleToNodes(t);
}
flag6 = !DTSweep.Legalize(tcx, delaunayTriangle);
bool flag8 = flag6;
if (flag8)
{
tcx.MapTriangleToNodes(delaunayTriangle);
}
t.EdgeIsDelaunay[i] = false;
delaunayTriangle.EdgeIsDelaunay[index] = false;
result = true;
return(result);
}
}
}
}
}
result = false;
return(result);
}
private static void Fill(DTSweepContext tcx, AdvancingFrontNode node)
{
DelaunayTriangle delaunayTriangle = new DelaunayTriangle(node.Prev.Point, node.Point, node.Next.Point);
delaunayTriangle.MarkNeighbor(node.Prev.Triangle);
delaunayTriangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(delaunayTriangle);
node.Prev.Next = node.Next;
node.Next.Prev = node.Prev;
tcx.RemoveNode(node);
bool flag = !DTSweep.Legalize(tcx, delaunayTriangle);
if (flag)
{
tcx.MapTriangleToNodes(delaunayTriangle);
}
}
/// <summary>
/// Adds a triangle to the advancing front to fill a hole.
/// </summary>
/// <param name="tcx"></param>
/// <param name="node">middle node, that is the bottom of the hole</param>
private static void Fill(DTSweepContext tcx, AdvancingFrontNode node)
{
DelaunayTriangle triangle = new DelaunayTriangle(node.Prev.Point, node.Point, node.Next.Point);
// TODO: should copy the cEdge value from neighbor triangles
// for now cEdge values are copied during the legalize
triangle.MarkNeighbor(node.Prev.Triangle);
triangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(triangle);
// Update the advancing front
node.Prev.Next = node.Next;
node.Next.Prev = node.Prev;
tcx.RemoveNode(node);
// If it was legalized the triangle has already been mapped
if (!Legalize(tcx, triangle))
{
tcx.MapTriangleToNodes(triangle);
}
}
private static AdvancingFrontNode NewFrontTriangle(DTSweepContext tcx, TriangulationPoint point, AdvancingFrontNode node)
{
DelaunayTriangle delaunayTriangle = new DelaunayTriangle(point, node.Point, node.Next.Point);
delaunayTriangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(delaunayTriangle);
AdvancingFrontNode advancingFrontNode = new AdvancingFrontNode(point);
advancingFrontNode.Next = node.Next;
advancingFrontNode.Prev = node;
node.Next.Prev = advancingFrontNode;
node.Next = advancingFrontNode;
tcx.AddNode(advancingFrontNode);
bool flag = !DTSweep.Legalize(tcx, delaunayTriangle);
if (flag)
{
tcx.MapTriangleToNodes(delaunayTriangle);
}
return(advancingFrontNode);
}
/// <summary>
/// Creates a new front triangle and legalize it
/// </summary>
private static AdvancingFrontNode NewFrontTriangle(DTSweepContext tcx, TriangulationPoint point, AdvancingFrontNode node)
{
DelaunayTriangle triangle = new DelaunayTriangle(point, node.Point, node.Next.Point);
triangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(triangle);
AdvancingFrontNode newNode = new AdvancingFrontNode(point);
newNode.Next = node.Next;
newNode.Prev = node;
node.Next.Prev = newNode;
node.Next = newNode;
tcx.AddNode(newNode); // XXX: BST
if (!Legalize(tcx, triangle))
{
tcx.MapTriangleToNodes(triangle);
}
return(newNode);
}
private static void FlipEdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle t, TriangulationPoint p)
{
DelaunayTriangle ot = t.NeighborAcross(p);
TriangulationPoint op = ot.OppositePoint(t, p);
if (ot == null)
{
// If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here
throw new InvalidOperationException("[BUG:FIXME] FLIP failed due to missing triangle");
}
if (t.GetConstrainedEdgeAcross(p))
{
throw new Exception("Intersecting Constraints");
}
bool inScanArea = TriangulationUtil.InScanArea(p, t.PointCCW(p), t.PointCW(p), op);
if (inScanArea)
{
// 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)
{
if (tcx.IsDebugEnabled)
{
Console.WriteLine("[FLIP] - constrained edge done"); // TODO: remove
}
t.MarkConstrainedEdge(ep, eq);
ot.MarkConstrainedEdge(ep, eq);
Legalize(tcx, t);
Legalize(tcx, ot);
}
else
{
if (tcx.IsDebugEnabled)
{
Console.WriteLine("[FLIP] - subedge done"); // TODO: remove
}
// XXX: I think one of the triangles should be legalized here?
}
}
else
{
if (tcx.IsDebugEnabled)
{
Console.WriteLine("[FLIP] - flipping and continuing with triangle still crossing edge");
}
// TODO: remove
Orientation o = TriangulationUtil.Orient2d(eq, op, ep);
t = NextFlipTriangle(tcx, o, t, ot, p, op);
FlipEdgeEvent(tcx, ep, eq, t, p);
}
}
else
{
TriangulationPoint newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP);
EdgeEvent(tcx, ep, eq, t, p);
}
}
/// <summary>
/// If this is a Delaunay Triangulation of a pointset we need to fill so the triangle mesh gets a ConvexHull
/// </summary>
private static void FinalizationConvexHull(DTSweepContext tcx)
{
DelaunayTriangle t1, t2;
AdvancingFrontNode n1 = tcx.aFront.Head.Next;
AdvancingFrontNode n2 = n1.Next;
TurnAdvancingFrontConvex(tcx, n1, n2);
// TODO: implement ConvexHull for lower right and left boundary
// Lets remove triangles connected to the two "algorithm" points
// XXX: When the first the nodes are points in a triangle we need to do a flip before
// removing triangles or we will lose a valid triangle.
// Same for last three nodes!
// !!! If I implement ConvexHull for lower right and left boundary this fix should not be
// needed and the removed triangles will be added again by default
n1 = tcx.aFront.Tail.Prev;
if (n1.Triangle.Contains(n1.Next.Point) && n1.Triangle.Contains(n1.Prev.Point))
{
t1 = n1.Triangle.NeighborAcross(n1.Point);
RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point));
tcx.MapTriangleToNodes(n1.Triangle);
tcx.MapTriangleToNodes(t1);
}
n1 = tcx.aFront.Head.Next;
if (n1.Triangle.Contains(n1.Prev.Point) && n1.Triangle.Contains(n1.Next.Point))
{
t1 = n1.Triangle.NeighborAcross(n1.Point);
RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point));
tcx.MapTriangleToNodes(n1.Triangle);
tcx.MapTriangleToNodes(t1);
}
// Lower right boundary
TriangulationPoint first = tcx.aFront.Head.Point;
n2 = tcx.aFront.Tail.Prev;
t1 = n2.Triangle;
TriangulationPoint p1 = n2.Point;
n2.Triangle = null;
do
{
tcx.RemoveFromList(t1);
p1 = t1.PointCCW(p1);
if (p1 == first)
{
break;
}
t2 = t1.NeighborCCW(p1);
t1.Clear();
t1 = t2;
} while (true);
// Lower left boundary
first = tcx.aFront.Head.Next.Point;
p1 = t1.PointCW(tcx.aFront.Head.Point);
t2 = t1.NeighborCW(tcx.aFront.Head.Point);
t1.Clear();
t1 = t2;
while (p1 != first) //TODO: Port note. This was do while before.
{
tcx.RemoveFromList(t1);
p1 = t1.PointCCW(p1);
t2 = t1.NeighborCCW(p1);
t1.Clear();
t1 = t2;
}
// Remove current head and tail node now that we have removed all triangles attached
// to them. Then set new head and tail node points
tcx.aFront.Head = tcx.aFront.Head.Next;
tcx.aFront.Head.Prev = null;
tcx.aFront.Tail = tcx.aFront.Tail.Prev;
tcx.aFront.Tail.Next = null;
tcx.FinalizeTriangulation();
}
/// <summary>
/// Returns true if triangle was legalized
/// </summary>
private static bool Legalize(DTSweepContext tcx, DelaunayTriangle 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++)
{
// TODO: fix so that cEdge is always valid when creating new triangles then we can check it here
// instead of below with ot
if (t.EdgeIsDelaunay[i])
{
continue;
}
DelaunayTriangle ot = t.Neighbors[i];
if (ot != null)
{
TriangulationPoint p = t.Points[i];
TriangulationPoint op = ot.OppositePoint(t, p);
int oi = ot.IndexOf(op);
// If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
// then we should not try to legalize
if (ot.EdgeIsConstrained[oi] || ot.EdgeIsDelaunay[oi])
{
t.EdgeIsConstrained[i] = ot.EdgeIsConstrained[oi];
// XXX: have no good way of setting this property when creating new triangles so lets set it here
continue;
}
bool inside = TriangulationUtil.SmartIncircle(p, t.PointCCW(p), t.PointCW(p), op);
if (inside)
{
// Lets mark this shared edge as Delaunay
t.EdgeIsDelaunay[i] = true;
ot.EdgeIsDelaunay[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 notLegalized = !Legalize(tcx, t);
if (notLegalized)
{
tcx.MapTriangleToNodes(t);
}
notLegalized = !Legalize(tcx, ot);
if (notLegalized)
{
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.EdgeIsDelaunay[i] = false;
ot.EdgeIsDelaunay[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);
}
private static void FinalizationConvexHull(DTSweepContext tcx)
{
AdvancingFrontNode advancingFrontNode = tcx.aFront.Head.Next;
AdvancingFrontNode advancingFrontNode2 = advancingFrontNode.Next;
DTSweep.TurnAdvancingFrontConvex(tcx, advancingFrontNode, advancingFrontNode2);
advancingFrontNode = tcx.aFront.Tail.Prev;
bool flag = advancingFrontNode.Triangle.Contains(advancingFrontNode.Next.Point) && advancingFrontNode.Triangle.Contains(advancingFrontNode.Prev.Point);
DelaunayTriangle delaunayTriangle;
if (flag)
{
delaunayTriangle = advancingFrontNode.Triangle.NeighborAcross(advancingFrontNode.Point);
DTSweep.RotateTrianglePair(advancingFrontNode.Triangle, advancingFrontNode.Point, delaunayTriangle, delaunayTriangle.OppositePoint(advancingFrontNode.Triangle, advancingFrontNode.Point));
tcx.MapTriangleToNodes(advancingFrontNode.Triangle);
tcx.MapTriangleToNodes(delaunayTriangle);
}
advancingFrontNode = tcx.aFront.Head.Next;
bool flag2 = advancingFrontNode.Triangle.Contains(advancingFrontNode.Prev.Point) && advancingFrontNode.Triangle.Contains(advancingFrontNode.Next.Point);
if (flag2)
{
delaunayTriangle = advancingFrontNode.Triangle.NeighborAcross(advancingFrontNode.Point);
DTSweep.RotateTrianglePair(advancingFrontNode.Triangle, advancingFrontNode.Point, delaunayTriangle, delaunayTriangle.OppositePoint(advancingFrontNode.Triangle, advancingFrontNode.Point));
tcx.MapTriangleToNodes(advancingFrontNode.Triangle);
tcx.MapTriangleToNodes(delaunayTriangle);
}
TriangulationPoint point = tcx.aFront.Head.Point;
advancingFrontNode2 = tcx.aFront.Tail.Prev;
delaunayTriangle = advancingFrontNode2.Triangle;
TriangulationPoint triangulationPoint = advancingFrontNode2.Point;
advancingFrontNode2.Triangle = null;
DelaunayTriangle delaunayTriangle2;
while (true)
{
tcx.RemoveFromList(delaunayTriangle);
triangulationPoint = delaunayTriangle.PointCCW(triangulationPoint);
bool flag3 = triangulationPoint == point;
if (flag3)
{
break;
}
delaunayTriangle2 = delaunayTriangle.NeighborCCW(triangulationPoint);
delaunayTriangle.Clear();
delaunayTriangle = delaunayTriangle2;
}
point = tcx.aFront.Head.Next.Point;
triangulationPoint = delaunayTriangle.PointCW(tcx.aFront.Head.Point);
delaunayTriangle2 = delaunayTriangle.NeighborCW(tcx.aFront.Head.Point);
delaunayTriangle.Clear();
delaunayTriangle = delaunayTriangle2;
while (triangulationPoint != point)
{
tcx.RemoveFromList(delaunayTriangle);
triangulationPoint = delaunayTriangle.PointCCW(triangulationPoint);
delaunayTriangle2 = delaunayTriangle.NeighborCCW(triangulationPoint);
delaunayTriangle.Clear();
delaunayTriangle = delaunayTriangle2;
}
tcx.aFront.Head = tcx.aFront.Head.Next;
tcx.aFront.Head.Prev = null;
tcx.aFront.Tail = tcx.aFront.Tail.Prev;
tcx.aFront.Tail.Next = null;
tcx.FinalizeTriangulation();
}
private static void FlipEdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle t, TriangulationPoint p)
{
DelaunayTriangle delaunayTriangle = t.NeighborAcross(p);
TriangulationPoint triangulationPoint = delaunayTriangle.OppositePoint(t, p);
bool flag = delaunayTriangle == null;
if (flag)
{
throw new InvalidOperationException("[BUG:FIXME] FLIP failed due to missing triangle");
}
bool constrainedEdgeAcross = t.GetConstrainedEdgeAcross(p);
if (constrainedEdgeAcross)
{
throw new Exception("Intersecting Constraints");
}
bool flag2 = TriangulationUtil.InScanArea(p, t.PointCCW(p), t.PointCW(p), triangulationPoint);
bool flag3 = flag2;
if (flag3)
{
DTSweep.RotateTrianglePair(t, p, delaunayTriangle, triangulationPoint);
tcx.MapTriangleToNodes(t);
tcx.MapTriangleToNodes(delaunayTriangle);
bool flag4 = p == eq && triangulationPoint == ep;
if (flag4)
{
bool flag5 = eq == tcx.EdgeEvent.ConstrainedEdge.Q && ep == tcx.EdgeEvent.ConstrainedEdge.P;
if (flag5)
{
bool isDebugEnabled = tcx.IsDebugEnabled;
if (isDebugEnabled)
{
Console.WriteLine("[FLIP] - constrained edge done");
}
t.MarkConstrainedEdge(ep, eq);
delaunayTriangle.MarkConstrainedEdge(ep, eq);
DTSweep.Legalize(tcx, t);
DTSweep.Legalize(tcx, delaunayTriangle);
}
else
{
bool isDebugEnabled2 = tcx.IsDebugEnabled;
if (isDebugEnabled2)
{
Console.WriteLine("[FLIP] - subedge done");
}
}
}
else
{
bool isDebugEnabled3 = tcx.IsDebugEnabled;
if (isDebugEnabled3)
{
Console.WriteLine("[FLIP] - flipping and continuing with triangle still crossing edge");
}
Orientation o = TriangulationUtil.Orient2d(eq, triangulationPoint, ep);
t = DTSweep.NextFlipTriangle(tcx, o, t, delaunayTriangle, p, triangulationPoint);
DTSweep.FlipEdgeEvent(tcx, ep, eq, t, p);
}
}
else
{
TriangulationPoint p2 = DTSweep.NextFlipPoint(ep, eq, delaunayTriangle, triangulationPoint);
DTSweep.FlipScanEdgeEvent(tcx, ep, eq, t, delaunayTriangle, p2);
DTSweep.EdgeEvent(tcx, ep, eq, t, p);
}
}
