/// <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) { Next = node.Next, Prev = node }; node.Next.Prev = newNode; node.Next = newNode; tcx.AddNode(newNode); // XXX: BST if (!Legalize(tcx, triangle)) { tcx.MapTriangleToNodes(triangle); } return(newNode); }
/// <summary>We will traverse the entire advancing front and fill it to form a convex hull.</summary> private static void TurnAdvancingFrontConvex(DtSweepContext tcx, AdvancingFrontNode b, AdvancingFrontNode c) { AdvancingFrontNode first = b; while (c != tcx.AFront.Tail) { if (TriangulationUtil.Orient2d(b.Point, c.Point, c.Next.Point) == Orientation.Ccw) { // [b,c,d] Concave - fill around c Fill(tcx, c); c = c.Next; } else { // [b,c,d] Convex if (b != first && TriangulationUtil.Orient2d(b.Prev.Point, b.Point, c.Point) == Orientation.Ccw) { // [a,b,c] Concave - fill around b Fill(tcx, b); b = b.Prev; } else { // [a,b,c] Convex - nothing to fill b = c; c = c.Next; } } } }
/// <summary> /// Fills the edge event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="edge">The edge</param> /// <param name="node">The node</param> private static void FillEdgeEvent(DtSweepContext tcx, DtSweepConstraint edge, AdvancingFrontNode node) { if (tcx.EdgeEvent.Right) { FillRightAboveEdgeEvent(tcx, edge, node); } else { FillLeftAboveEdgeEvent(tcx, edge, node); } }
/// <summary> /// Finalizations the polygon using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> private static void FinalizationPolygon(DtSweepContext tcx) { // Get an Internal triangle to start with DelaunayTriangle t = tcx.AFront.Head.Next.Triangle; TriangulationPoint p = tcx.AFront.Head.Next.Point; while (!t.GetConstrainedEdgeCw(p)) { t = t.NeighborCcw(p); } // Collect interior triangles constrained by edges tcx.MeshClean(t); }
/// <summary>Fills holes in the Advancing Front</summary> private static void FillAdvancingFront(DtSweepContext tcx, AdvancingFrontNode n) { double angle; // Fill right holes AdvancingFrontNode node = n.Next; while (node.HasNext) { // 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.HasPrev) { // if HoleAngle exceeds 90 degrees then break. if (LargeHole_DontFill(node)) { break; } angle = HoleAngle(node); if (angle > PiDiv2 || angle < -PiDiv2) { break; } Fill(tcx, node); node = node.Prev; } // Fill right basins if (n.HasNext && n.Next.HasNext) { angle = BasinAngle(n); if (angle < Pi3Div4) { FillBasin(tcx, n); } } }
/// <summary>Recursive algorithm to fill a Basin with triangles</summary> private static void FillBasinReq(DtSweepContext tcx, AdvancingFrontNode node) { // if shallow stop filling if (IsShallow(tcx, node)) { return; } Fill(tcx, node); if (node.Prev == tcx.Basin.LeftNode && node.Next == tcx.Basin.RightNode) { return; } if (node.Prev == tcx.Basin.LeftNode) { Orientation o = TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point); if (o == Orientation.Cw) { return; } node = node.Next; } else if (node.Next == tcx.Basin.RightNode) { Orientation o = TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point); if (o == Orientation.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); }
/// <summary> /// Fills the left above edge event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="edge">The edge</param> /// <param name="node">The node</param> private static void FillLeftAboveEdgeEvent(DtSweepContext tcx, DtSweepConstraint edge, AdvancingFrontNode node) { while (node.Prev.Point.X > edge.P.X) { // Check if next node is below the edge Orientation o1 = TriangulationUtil.Orient2d(edge.Q, node.Prev.Point, edge.P); if (o1 == Orientation.Cw) { FillLeftBelowEdgeEvent(tcx, edge, node); } else { node = node.Prev; } } }
/// <summary> /// Find closes node to the left of the new point and create a new triangle. If needed new holes and basins will /// be filled to. /// </summary> private static AdvancingFrontNode PointEvent(DtSweepContext tcx, TriangulationPoint point) { AdvancingFrontNode node = tcx.LocateNode(point); AdvancingFrontNode newNode = 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 + TriangulationUtil.Epsilon) { Fill(tcx, node); } tcx.AddNode(newNode); FillAdvancingFront(tcx, newNode); return(newNode); }
/// <summary> /// Fills the left concave edge event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="edge">The edge</param> /// <param name="node">The node</param> private static void FillLeftConcaveEdgeEvent(DtSweepContext tcx, DtSweepConstraint edge, AdvancingFrontNode node) { Fill(tcx, node.Prev); if (node.Prev.Point != edge.P) { // GetNext above or below edge? if (TriangulationUtil.Orient2d(edge.Q, node.Prev.Point, edge.P) == Orientation.Cw) { // Below if (TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point) == Orientation.Cw) { // GetNext is concave FillLeftConcaveEdgeEvent(tcx, edge, node); } } } }
/// <summary>Triangulate simple polygon with holes</summary> public static void Triangulate(DtSweepContext tcx) { tcx.CreateAdvancingFront(); Sweep(tcx); // Finalize triangulation if (tcx.TriangulationMode == TriangulationMode.Polygon) { FinalizationPolygon(tcx); } else { FinalizationConvexHull(tcx); } tcx.Done(); }
/// <summary> /// Fills the left below edge event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="edge">The edge</param> /// <param name="node">The node</param> private static void FillLeftBelowEdgeEvent(DtSweepContext tcx, DtSweepConstraint edge, AdvancingFrontNode node) { if (node.Point.X > edge.P.X) { if (TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point) == Orientation.Cw) { // Concave FillLeftConcaveEdgeEvent(tcx, edge, node); } else { // Convex FillLeftConvexEdgeEvent(tcx, edge, node); // Retry this one FillLeftBelowEdgeEvent(tcx, edge, node); } } }
/// <summary> /// Fills a basin that has formed on the Advancing Front to the right of given node. First we decide a left,bottom /// and right node that forms the boundaries of the basin. Then we do a reqursive fill. /// </summary> /// <param name="tcx"></param> /// <param name="node">starting node, this or next node will be left node</param> private static void FillBasin(DtSweepContext tcx, AdvancingFrontNode node) { if (TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point) == Orientation.Ccw) { // tcx.basin.leftNode = node.next.next; tcx.Basin.LeftNode = node; } else { tcx.Basin.LeftNode = node.Next; } // Find the bottom and right node tcx.Basin.BottomNode = tcx.Basin.LeftNode; while (tcx.Basin.BottomNode.HasNext && tcx.Basin.BottomNode.Point.Y >= tcx.Basin.BottomNode.Next.Point.Y) { tcx.Basin.BottomNode = tcx.Basin.BottomNode.Next; } if (tcx.Basin.BottomNode == tcx.Basin.LeftNode) { // No valid basins return; } tcx.Basin.RightNode = tcx.Basin.BottomNode; while (tcx.Basin.RightNode.HasNext && tcx.Basin.RightNode.Point.Y < tcx.Basin.RightNode.Next.Point.Y) { tcx.Basin.RightNode = tcx.Basin.RightNode.Next; } if (tcx.Basin.RightNode == tcx.Basin.BottomNode) { // No valid basins return; } tcx.Basin.Width = tcx.Basin.RightNode.Point.X - tcx.Basin.LeftNode.Point.X; tcx.Basin.LeftHighest = tcx.Basin.LeftNode.Point.Y > tcx.Basin.RightNode.Point.Y; FillBasinReq(tcx, tcx.Basin.BottomNode); }
/// <summary> /// Describes whether is shallow /// </summary> /// <param name="tcx">The tcx</param> /// <param name="node">The node</param> /// <returns>The bool</returns> private static bool IsShallow(DtSweepContext tcx, AdvancingFrontNode node) { double height; if (tcx.Basin.LeftHighest) { height = tcx.Basin.LeftNode.Point.Y - node.Point.Y; } else { height = tcx.Basin.RightNode.Point.Y - node.Point.Y; } if (tcx.Basin.Width > height) { return(true); } return(false); }
/// <summary>Start sweeping the Y-sorted point set from bottom to top</summary> private static void Sweep(DtSweepContext tcx) { List <TriangulationPoint> points = tcx.Points; for (int i = 1; i < points.Count; i++) { TriangulationPoint point = points[i]; AdvancingFrontNode node = PointEvent(tcx, point); if (point.HasEdges) { foreach (DtSweepConstraint e in point.Edges) { EdgeEvent(tcx, e, node); } } tcx.Update(null); } }
/// <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); } }
/// <summary> /// Fills the right convex edge event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="edge">The edge</param> /// <param name="node">The node</param> private static void FillRightConvexEdgeEvent(DtSweepContext tcx, DtSweepConstraint edge, AdvancingFrontNode node) { // GetNext concave or convex? if (TriangulationUtil.Orient2d(node.Next.Point, node.Next.Next.Point, node.Next.Next.Next.Point) == Orientation.Ccw) { // Concave FillRightConcaveEdgeEvent(tcx, edge, node.Next); } else { // Convex // GetNext above or below edge? if (TriangulationUtil.Orient2d(edge.Q, node.Next.Next.Point, edge.P) == Orientation.Ccw) { // Below FillRightConvexEdgeEvent(tcx, edge, node.Next); } } }
/// <summary> /// After a flip we have two triangles and know that only one will still be intersecting the edge. So decide which /// to contiune with and legalize the other /// </summary> /// <param name="tcx"></param> /// <param name="o">should be the result of an TriangulationUtil.orient2d( eq, op, ep )</param> /// <param name="t">triangle 1</param> /// <param name="ot">triangle 2</param> /// <param name="p">a point shared by both triangles</param> /// <param name="op">another point shared by both triangles</param> /// <returns>returns the triangle still intersecting the edge</returns> private static DelaunayTriangle NextFlipTriangle(DtSweepContext tcx, Orientation o, DelaunayTriangle t, DelaunayTriangle ot, TriangulationPoint p, TriangulationPoint op) { int edgeIndex; if (o == Orientation.Ccw) { // ot is not crossing edge after flip edgeIndex = ot.EdgeIndex(p, op); ot.EdgeIsDelaunay[edgeIndex] = true; Legalize(tcx, ot); ot.EdgeIsDelaunay.Clear(); return(t); } // t is not crossing edge after flip edgeIndex = t.EdgeIndex(p, op); t.EdgeIsDelaunay[edgeIndex] = true; Legalize(tcx, t); t.EdgeIsDelaunay.Clear(); return(ot); }
/// <summary> /// Scan part of the FlipScan algorithm 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); // see https://github.com/greenm01/poly2tri/issues/102 //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"); //} TriangulationPoint op = ot.OppositePoint(t, p); 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> /// Edges the event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="edge">The edge</param> /// <param name="node">The node</param> private static void EdgeEvent(DtSweepContext tcx, DtSweepConstraint edge, AdvancingFrontNode node) { try { tcx.EdgeEvent.ConstrainedEdge = edge; tcx.EdgeEvent.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); } catch (PointOnEdgeException e) { Debug.WriteLine("Skipping Edge: {0}", e.Message); } }
/// <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> /// Flips the edge event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="ep">The ep</param> /// <param name="eq">The eq</param> /// <param name="t">The </param> /// <param name="p">The </param> /// <exception cref="Exception">Intersecting Constraints</exception> private static void FlipEdgeEvent(DtSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle t, TriangulationPoint p) { DelaunayTriangle ot = t.NeighborAcross(p); // see https://github.com/greenm01/poly2tri/issues/102 //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"); } TriangulationPoint op = ot.OppositePoint(t, p); 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> /// Edges the event using the specified tcx /// </summary> /// <param name="tcx">The tcx</param> /// <param name="ep">The ep</param> /// <param name="eq">The eq</param> /// <param name="triangle">The triangle</param> /// <param name="point">The point</param> /// <exception cref="PointOnEdgeException">EdgeEvent - Point on constrained edge not supported yet</exception> /// <exception cref="PointOnEdgeException">EdgeEvent - Point on constrained edge not supported yet</exception> 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); }