/// <summary> /// Triangulate simple polygon with holes /// </summary> public static void Triangulate(DTSweepContext tcx) { tcx.CreateAdvancingFront(); Sweep(tcx); // TODO: remove temporary // Check if the sweep algorithm is legalize robust // By doing a legalize on all triangles and see if anything happens // we know if the sweep algorithm missed some legalizations // Console.WriteLine("============================"); // foreach ( DelaunayTriangle t in tcx.Triangles ) // { // if( Legalize( tcx, t ) ) // { // tcx.getDebugContext().setPrimaryTriangle( t ); // Console.WriteLine("[FIX] Triangle needed legalization after sweep"); // } // } // Finalize triangulation if (tcx.TriangulationMode == TriangulationMode.Polygon) { FinalizationPolygon(tcx); } else { FinalizationConvexHull(tcx); } tcx.Done(); }
private static void FlipEdgeEvent( DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle t, TriangulationPoint p) { DelaunayTriangle ot = t.NeighborAcrossFrom(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 (tcx.IsDebugEnabled) { tcx.DTDebugContext.PrimaryTriangle = t; tcx.DTDebugContext.SecondaryTriangle = ot; } // TODO: remove bool inScanArea = TriangulationUtil.InScanArea(p, t.PointCCWFrom(p), t.PointCWFrom(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 FinalizationPolygon(DTSweepContext tcx) { // Get an Internal triangle to start with DelaunayTriangle t = tcx.Front.Head.Next.Triangle; TriangulationPoint p = tcx.Front.Head.Next.Point; while (!t.GetConstrainedEdgeCW(p)) { t = t.NeighborCCWFrom(p); } // Collect interior triangles constrained by edges tcx.MeshClean(t); }
/// <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) { AdvancingFrontNode n1, n2, n3; DelaunayTriangle t1; TriangulationPoint first, p1; n1 = tcx.Front.Head.Next; n2 = n1.Next; n3 = n2.Next; first = n1.Point; TurnAdvancingFrontConvex(tcx, n1, n2); n1 = tcx.Front.Tail.Prev; if (n1.Triangle.Contains(n1.Next.Point) && n1.Triangle.Contains(n1.Prev.Point)) { t1 = n1.Triangle.NeighborAcrossFrom(n1.Point); RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point)); tcx.MapTriangleToNodes(n1.Triangle); tcx.MapTriangleToNodes(t1); } n1 = tcx.Front.Head.Next; if (n1.Triangle.Contains(n1.Prev.Point) && n1.Triangle.Contains(n1.Next.Point)) { t1 = n1.Triangle.NeighborAcrossFrom(n1.Point); RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point)); tcx.MapTriangleToNodes(n1.Triangle); tcx.MapTriangleToNodes(t1); } // TODO: implement ConvexHull for lower right and left boundary // Lower right boundary first = tcx.Front.Head.Point; n2 = tcx.Front.Tail.Prev; t1 = n2.Triangle; p1 = n2.Point; do { tcx.RemoveFromList(t1); p1 = t1.PointCCWFrom(p1); if (p1 == first) { break; } t1 = t1.NeighborCCWFrom(p1); } while (true); // Lower left boundary first = tcx.Front.Head.Next.Point; p1 = t1.PointCWFrom(tcx.Front.Head.Point); t1 = t1.NeighborCWFrom(tcx.Front.Head.Point); do { tcx.RemoveFromList(t1); p1 = t1.PointCCWFrom(p1); t1 = t1.NeighborCCWFrom(p1); } while (p1 != first); tcx.FinalizeTriangulation(); }
/// <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.Front.Tail) { if (tcx.IsDebugEnabled) { tcx.DTDebugContext.ActiveNode = c; } 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> /// 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, newNode; node = tcx.LocateNode(point); if (tcx.IsDebugEnabled) { tcx.DTDebugContext.ActiveNode = node; } 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> /// 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> /// 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) { continue; } 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; } if (!TriangulationUtil.SmartIncircle(p, t.PointCCWFrom(p), t.PointCWFrom(p), op)) { continue; } // 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 if (!Legalize(tcx, t)) { tcx.MapTriangleToNodes(t); } if (!Legalize(tcx, ot)) { 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 FillLeftConcaveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node) { Fill(tcx, node.Prev); if (node.Prev.Point != edge.P) { // Next 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) { // Next is concave FillLeftConcaveEdgeEvent(tcx, edge, node); } else { // Next is convex } } } }
private static void FillEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node) { if (tcx.EdgeEvent.Right) { FillRightAboveEdgeEvent(tcx, edge, node); } else { FillLeftAboveEdgeEvent(tcx, edge, node); } }
/// <summary> /// Recursive algorithm to fill a Basin with triangles /// </summary> private static void FillBasinReq(DTSweepContext tcx, AdvancingFrontNode node) { if (IsShallow(tcx, node)) { return; // if shallow stop filling } Fill(tcx, node); if (node.Prev == tcx.Basin.leftNode && node.Next == tcx.Basin.rightNode) { return; } else 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 a basin that has formed on the Advancing Front to the right /// of given node.<br> /// 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) { return; // No valid basin } 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) { return; // No valid basins } 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> /// Fills holes in the Advancing Front /// </summary> private static void FillAdvancingFront(DTSweepContext tcx, AdvancingFrontNode n) { AdvancingFrontNode node; double angle; // Fill right holes node = n.Next; while (node.HasNext) { angle = HoleAngle(node); if (angle > PI_div2 || angle < -PI_div2) { break; } Fill(tcx, node); node = node.Next; } // Fill left holes node = n.Prev; while (node.HasPrev) { angle = HoleAngle(node); if (angle > PI_div2 || angle < -PI_div2) { break; } Fill(tcx, node); node = node.Prev; } // Fill right basins if (n.HasNext && n.Next.HasNext) { angle = BasinAngle(n); if (angle < PI_3div4) { FillBasin(tcx, n); } } }
/// <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 void EdgeEvent( DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle triangle, TriangulationPoint point) { TriangulationPoint p1, p2; if (tcx.IsDebugEnabled) { tcx.DTDebugContext.PrimaryTriangle = triangle; } if (IsEdgeSideOfTriangle(triangle, ep, eq)) { return; } p1 = triangle.PointCCWFrom(point); Orientation o1 = TriangulationUtil.Orient2d(eq, p1, ep); if (o1 == Orientation.Collinear) { // TODO: Split edge in two //// splitEdge( ep, eq, p1 ); // edgeEvent( tcx, p1, eq, triangle, point ); // edgeEvent( tcx, ep, p1, triangle, p1 ); // return; throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet", eq, p1, ep); } p2 = triangle.PointCWFrom(point); Orientation o2 = TriangulationUtil.Orient2d(eq, p2, ep); if (o2 == Orientation.Collinear) { // TODO: Split edge in two // edgeEvent( tcx, p2, eq, triangle, point ); // edgeEvent( tcx, ep, p2, triangle, p2 ); // return; throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet", eq, p2, ep); } 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.NeighborCCWFrom(point); } else { triangle = triangle.NeighborCWFrom(point); } EdgeEvent(tcx, ep, eq, triangle, point); } else { // This triangle crosses constraint so lets flippin start! FlipEdgeEvent(tcx, ep, eq, triangle, point); } }
/// <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; TriangulationPoint op, newP; bool inScanArea; ot = t.NeighborAcrossFrom(p); 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"); } if (tcx.IsDebugEnabled) { Console.WriteLine("[FLIP:SCAN] - scan next point"); // TODO: remove tcx.DTDebugContext.PrimaryTriangle = t; tcx.DTDebugContext.SecondaryTriangle = ot; } inScanArea = TriangulationUtil.InScanArea(eq, flipTriangle.PointCCWFrom(eq), flipTriangle.PointCWFrom(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 { newP = NextFlipPoint(ep, eq, ot, op); FlipScanEdgeEvent(tcx, ep, eq, flipTriangle, ot, newP); } }
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; }
private static void FillRightAboveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node) { while (node.Next.Point.X < edge.P.X) { if (tcx.IsDebugEnabled) { tcx.DTDebugContext.ActiveNode = node; } // Check if next node is below the edge Orientation o1 = TriangulationUtil.Orient2d(edge.Q, node.Next.Point, edge.P); if (o1 == Orientation.CCW) { FillRightBelowEdgeEvent(tcx, edge, node); } else { node = node.Next; } } }
/// <summary> /// Creates a new front triangle and legalize it /// </summary> private static AdvancingFrontNode NewFrontTriangle( DTSweepContext tcx, TriangulationPoint point, AdvancingFrontNode node) { AdvancingFrontNode newNode; DelaunayTriangle triangle; triangle = new DelaunayTriangle(point, node.Point, node.Next.Point); triangle.MarkNeighbor(node.Triangle); tcx.Triangles.Add(triangle); newNode = new AdvancingFrontNode(point); newNode.Next = node.Next; newNode.Prev = node; node.Next.Prev = newNode; node.Next = newNode; tcx.AddNode(newNode); // XXX: BST if (tcx.IsDebugEnabled) { tcx.DTDebugContext.ActiveNode = newNode; } if (!Legalize(tcx, triangle)) { tcx.MapTriangleToNodes(triangle); } return newNode; }
private static void FillRightBelowEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node) { if (tcx.IsDebugEnabled) { tcx.DTDebugContext.ActiveNode = node; } if (node.Point.X < edge.P.X) { // needed? if (TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point) == Orientation.CCW) { // Concave FillRightConcaveEdgeEvent(tcx, edge, node); } else { // Convex FillRightConvexEdgeEvent(tcx, edge, node); // Retry this one FillRightBelowEdgeEvent(tcx, edge, node); } } }
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 (tcx.IsDebugEnabled) { tcx.DTDebugContext.PrimaryTriangle = node.Triangle; } 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( String.Format( "Warning: Skipping Edge: {0}", e.Message ) ); throw; } }
private static void FillRightConvexEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node) { // Next 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 // Next above or below edge? if (TriangulationUtil.Orient2d(edge.Q, node.Next.Next.Point, edge.P) == Orientation.CCW) { // Below FillRightConvexEdgeEvent(tcx, edge, node.Next); } else { // Above } } }
public DTSweepDebugContext(DTSweepContext tcx) : base(tcx) { }
/// <summary> /// Start sweeping the Y-sorted point set from bottom to top /// </summary> private static void Sweep(DTSweepContext tcx) { var points = tcx.Points; TriangulationPoint point; AdvancingFrontNode node; for (int i = 1; i < points.Count; i++) { point = points[i]; node = PointEvent(tcx, point); if (point.HasEdges) { foreach (DTSweepConstraint e in point.Edges) { if (tcx.IsDebugEnabled) { tcx.DTDebugContext.ActiveConstraint = e; } EdgeEvent(tcx, e, node); } } tcx.Update(null); } }