private void FlipEdgeEvent(SweepContext tcx, TriPoint ep, TriPoint eq, Triangle t, TriPoint p) { Triangle ot = t.NeighborAcross(p); TriPoint op = ot.OppositePoint(t, p); if (TriUtil.InScanArea(p, t.PointCCW(p), t.PointCW(p), op)) { // 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) { t.MarkConstrainedEdge(ep, eq); ot.MarkConstrainedEdge(ep, eq); Legalize(tcx, t); Legalize(tcx, ot); } else { // XXX: I think one of the triangles should be legalized here? } } else { Winding o = TriUtil.Orient2d(eq, op, ep); t = NextFlipTriangle(tcx, o, t, ot, p, op); FlipEdgeEvent(tcx, ep, eq, t, p); } } else { TriPoint newP = NextFlipPoint(ep, eq, ot, op); FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP); EdgeEvent(tcx, ep, eq, t, p); } }
private void Fill(SweepContext tcx, Node node) { Triangle triangle = new Triangle(node.Prev.Point, node.Point, node.Next.Point); triangle.MarkNeighbor(node.Prev.Triangle); triangle.MarkNeighbor(node.Triangle); tcx.AddToMap(triangle); // Update the advancing front node.Prev.Next = node.Next; node.Next.Prev = node.Prev; // If it was legalized the triangle has already been mapped if (!Legalize(tcx, triangle)) { tcx.MapTriangleToNodes(triangle); } }
private Node NewFrontTriangle(SweepContext tcx, TriPoint point, Node node) { Triangle triangle = new Triangle(point, node.Point, node.Next.Point); triangle.MarkNeighbor(node.Triangle); tcx.AddToMap(triangle); Node new_node = new Node(point); _nodes.Add(new_node); new_node.Next = node.Next; new_node.Prev = node; node.Next.Prev = new_node; node.Next = new_node; if (!Legalize(tcx, triangle)) { tcx.MapTriangleToNodes(triangle); } return(new_node); }
private bool Legalize(SweepContext tcx, Triangle 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++) { if (t.DelaunayEdge[i]) { continue; } Triangle ot = t.GetNeighbor(i); if (ot != null) { TriPoint p = t.Points[i]; TriPoint op = ot.OppositePoint(t, p); int oi = ot.Index(op); // If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization) // then we should not try to legalize if (ot.ConstrainedEdge[oi] || ot.DelaunayEdge[oi]) { t.ConstrainedEdge[i] = ot.ConstrainedEdge[oi]; continue; } bool inside = Incircle(p, t.PointCCW(p), t.PointCW(p), op); if (inside) { // Lets mark this shared edge as Delaunay t.DelaunayEdge[i] = true; ot.DelaunayEdge[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 not_legalized = !Legalize(tcx, t); if (not_legalized) { tcx.MapTriangleToNodes(t); } not_legalized = !Legalize(tcx, ot); if (not_legalized) { 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.DelaunayEdge[i] = false; ot.DelaunayEdge[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); }