/// <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); } }
/// <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); } }
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); }
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); } } } } }