/// <summary>
/// Try to map a node to all sides of this triangle that don't have
/// a neighbor.
/// </summary>
public void MapTriangleToNodes(DelaunayTriangle t)
{
AdvancingFrontNode n;
for (int i = 0; i < 3; i++)
{
if (t.Neighbors[i] == null)
{
n = aFront.LocatePoint(t.PointCW(t.Points[i]));
if (n != null)
{
n.Triangle = t;
}
}
}
}
public void MapTriangleToNodes(DelaunayTriangle t)
{
for (int i = 0; i < 3; i++)
{
bool flag = t.Neighbors[i] == null;
if (flag)
{
AdvancingFrontNode advancingFrontNode = this.aFront.LocatePoint(t.PointCW(t.Points[i]));
bool flag2 = advancingFrontNode != null;
if (flag2)
{
advancingFrontNode.Triangle = t;
}
}
}
}
/// <summary>
/// When we need to traverse from one triangle to the next we need
/// the point in current triangle that is the opposite point to the next
/// triangle.
/// </summary>
private static TriangulationPoint NextFlipPoint(TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle ot, TriangulationPoint op)
{
Orientation o2d = TriangulationUtil.Orient2d(eq, op, ep);
if (o2d == Orientation.CW)
{
// Right
return(ot.PointCCW(op));
}
else if (o2d == Orientation.CCW)
{
// Left
return(ot.PointCW(op));
}
else
{
// TODO: implement support for point on constraint edge
throw new PointOnEdgeException("Point on constrained edge not supported yet");
}
}
private static TriangulationPoint NextFlipPoint(TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle ot, TriangulationPoint op)
{
Orientation orientation = TriangulationUtil.Orient2d(eq, op, ep);
bool flag = orientation == Orientation.CW;
TriangulationPoint result;
if (flag)
{
result = ot.PointCCW(op);
}
else
{
bool flag2 = orientation == Orientation.CCW;
if (!flag2)
{
throw new PointOnEdgeException("Point on constrained edge not supported yet");
}
result = ot.PointCW(op);
}
return(result);
}
private static void FlipScanEdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle flipTriangle, DelaunayTriangle t, TriangulationPoint p)
{
DelaunayTriangle delaunayTriangle = t.NeighborAcross(p);
TriangulationPoint triangulationPoint = delaunayTriangle.OppositePoint(t, p);
bool flag = delaunayTriangle == null;
if (flag)
{
throw new Exception("[BUG:FIXME] FLIP failed due to missing triangle");
}
bool flag2 = TriangulationUtil.InScanArea(eq, flipTriangle.PointCCW(eq), flipTriangle.PointCW(eq), triangulationPoint);
bool flag3 = flag2;
if (flag3)
{
DTSweep.FlipEdgeEvent(tcx, eq, triangulationPoint, delaunayTriangle, triangulationPoint);
}
else
{
TriangulationPoint p2 = DTSweep.NextFlipPoint(ep, eq, delaunayTriangle, triangulationPoint);
DTSweep.FlipScanEdgeEvent(tcx, ep, eq, flipTriangle, delaunayTriangle, p2);
}
}
/// <summary>
/// Scan part of the FlipScan algorithm<br>
/// When a triangle pair isn't flippable we will scan for the next
/// point that is inside the flip triangle scan area. When found
/// we generate a new flipEdgeEvent
/// </summary>
/// <param name="tcx"></param>
/// <param name="ep">last point on the edge we are traversing</param>
/// <param name="eq">first point on the edge we are traversing</param>
/// <param name="flipTriangle">the current triangle sharing the point eq with edge</param>
/// <param name="t"></param>
/// <param name="p"></param>
private static void FlipScanEdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle flipTriangle, 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 Exception("[BUG:FIXME] FLIP failed due to missing triangle");
}
bool inScanArea = TriangulationUtil.InScanArea(eq, flipTriangle.PointCCW(eq), flipTriangle.PointCW(eq), op);
if (inScanArea)
{
// 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 flipTriangle first
// Turns out at first glance that this is somewhat complicated
// so it will have to wait.
}
else
{
TriangulationPoint newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, flipTriangle, ot, newP);
}
}
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);
}
}
private static void EdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle triangle, TriangulationPoint point)
{
if (IsEdgeSideOfTriangle(triangle, ep, eq))
{
return;
}
TriangulationPoint p1 = triangle.PointCCW(point);
Orientation o1 = TriangulationUtil.Orient2d(eq, p1, ep);
if (o1 == Orientation.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.EdgeEvent.ConstrainedEdge.Q = p1;
triangle = triangle.NeighborAcross(point);
EdgeEvent(tcx, ep, p1, triangle, p1);
}
else
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet");
}
if (tcx.IsDebugEnabled)
{
Debug.WriteLine("EdgeEvent - Point on constrained edge");
}
return;
}
TriangulationPoint p2 = triangle.PointCW(point);
Orientation o2 = TriangulationUtil.Orient2d(eq, p2, ep);
if (o2 == Orientation.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.EdgeEvent.ConstrainedEdge.Q = p2;
triangle = triangle.NeighborAcross(point);
EdgeEvent(tcx, ep, p2, triangle, p2);
}
else
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet");
}
if (tcx.IsDebugEnabled)
{
Debug.WriteLine("EdgeEvent - Point on constrained edge");
}
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 == Orientation.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);
}
}
/// <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);
}
public TriangulationPoint OppositePoint(DelaunayTriangle t, TriangulationPoint p)
{
Debug.Assert(t != this, "self-pointer error");
return(this.PointCW(t.PointCW(p)));
}
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 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);
}
}
private static void EdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle triangle, TriangulationPoint point)
{
bool flag = DTSweep.IsEdgeSideOfTriangle(triangle, ep, eq);
if (!flag)
{
TriangulationPoint triangulationPoint = triangle.PointCCW(point);
Orientation orientation = TriangulationUtil.Orient2d(eq, triangulationPoint, ep);
bool flag2 = orientation == Orientation.Collinear;
if (flag2)
{
bool flag3 = triangle.Contains(eq, triangulationPoint);
if (!flag3)
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet");
}
triangle.MarkConstrainedEdge(eq, triangulationPoint);
tcx.EdgeEvent.ConstrainedEdge.Q = triangulationPoint;
triangle = triangle.NeighborAcross(point);
DTSweep.EdgeEvent(tcx, ep, triangulationPoint, triangle, triangulationPoint);
bool isDebugEnabled = tcx.IsDebugEnabled;
if (isDebugEnabled)
{
Debug.WriteLine("EdgeEvent - Point on constrained edge");
}
}
else
{
TriangulationPoint triangulationPoint2 = triangle.PointCW(point);
Orientation orientation2 = TriangulationUtil.Orient2d(eq, triangulationPoint2, ep);
bool flag4 = orientation2 == Orientation.Collinear;
if (flag4)
{
bool flag5 = triangle.Contains(eq, triangulationPoint2);
if (!flag5)
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet");
}
triangle.MarkConstrainedEdge(eq, triangulationPoint2);
tcx.EdgeEvent.ConstrainedEdge.Q = triangulationPoint2;
triangle = triangle.NeighborAcross(point);
DTSweep.EdgeEvent(tcx, ep, triangulationPoint2, triangle, triangulationPoint2);
bool isDebugEnabled2 = tcx.IsDebugEnabled;
if (isDebugEnabled2)
{
Debug.WriteLine("EdgeEvent - Point on constrained edge");
}
}
else
{
bool flag6 = orientation == orientation2;
if (flag6)
{
bool flag7 = orientation == Orientation.CW;
if (flag7)
{
triangle = triangle.NeighborCCW(point);
}
else
{
triangle = triangle.NeighborCW(point);
}
DTSweep.EdgeEvent(tcx, ep, eq, triangle, point);
}
else
{
DTSweep.FlipEdgeEvent(tcx, ep, eq, triangle, point);
}
}
}
}
}
