private static bool LargeHole_DontFill(AdvancingFrontNode node)
{
AdvancingFrontNode next = node.Next;
AdvancingFrontNode prev = node.Prev;
bool flag = !DTSweep.AngleExceeds90Degrees(node.Point, next.Point, prev.Point);
bool result;
if (flag)
{
result = false;
}
else
{
AdvancingFrontNode next2 = next.Next;
bool flag2 = next2 != null && !DTSweep.AngleExceedsPlus90DegreesOrIsNegative(node.Point, next2.Point, prev.Point);
if (flag2)
{
result = false;
}
else
{
AdvancingFrontNode prev2 = prev.Prev;
bool flag3 = prev2 != null && !DTSweep.AngleExceedsPlus90DegreesOrIsNegative(node.Point, next.Point, prev2.Point);
result = !flag3;
}
}
return(result);
}
private static void TurnAdvancingFrontConvex(DTSweepContext tcx, AdvancingFrontNode b, AdvancingFrontNode c)
{
AdvancingFrontNode advancingFrontNode = b;
while (c != tcx.aFront.Tail)
{
bool flag = TriangulationUtil.Orient2d(b.Point, c.Point, c.Next.Point) == Orientation.CCW;
if (flag)
{
DTSweep.Fill(tcx, c);
c = c.Next;
}
else
{
bool flag2 = b != advancingFrontNode && TriangulationUtil.Orient2d(b.Prev.Point, b.Point, c.Point) == Orientation.CCW;
if (flag2)
{
DTSweep.Fill(tcx, b);
b = b.Prev;
}
else
{
b = c;
c = c.Next;
}
}
}
}
private static void FillBasin(DTSweepContext tcx, AdvancingFrontNode node)
{
bool flag = TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point) == Orientation.CCW;
if (flag)
{
tcx.Basin.leftNode = node;
}
else
{
tcx.Basin.leftNode = node.Next;
}
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;
}
bool flag2 = tcx.Basin.bottomNode == tcx.Basin.leftNode;
if (!flag2)
{
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;
}
bool flag3 = tcx.Basin.rightNode == tcx.Basin.bottomNode;
if (!flag3)
{
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);
DTSweep.FillBasinReq(tcx, tcx.Basin.bottomNode);
}
}
}
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 FillEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
bool right = tcx.EdgeEvent.Right;
if (right)
{
DTSweep.FillRightAboveEdgeEvent(tcx, edge, node);
}
else
{
DTSweep.FillLeftAboveEdgeEvent(tcx, edge, node);
}
}
private static void FillBasinReq(DTSweepContext tcx, AdvancingFrontNode node)
{
bool flag = DTSweep.IsShallow(tcx, node);
if (!flag)
{
DTSweep.Fill(tcx, node);
bool flag2 = node.Prev == tcx.Basin.leftNode && node.Next == tcx.Basin.rightNode;
if (!flag2)
{
bool flag3 = node.Prev == tcx.Basin.leftNode;
if (flag3)
{
Orientation orientation = TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point);
bool flag4 = orientation == Orientation.CW;
if (flag4)
{
return;
}
node = node.Next;
}
else
{
bool flag5 = node.Next == tcx.Basin.rightNode;
if (flag5)
{
Orientation orientation2 = TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point);
bool flag6 = orientation2 == Orientation.CCW;
if (flag6)
{
return;
}
node = node.Prev;
}
else
{
bool flag7 = node.Prev.Point.Y < node.Next.Point.Y;
if (flag7)
{
node = node.Prev;
}
else
{
node = node.Next;
}
}
}
DTSweep.FillBasinReq(tcx, node);
}
}
}
private static AdvancingFrontNode PointEvent(DTSweepContext tcx, TriangulationPoint point)
{
AdvancingFrontNode advancingFrontNode = tcx.LocateNode(point);
AdvancingFrontNode advancingFrontNode2 = DTSweep.NewFrontTriangle(tcx, point, advancingFrontNode);
bool flag = point.X <= advancingFrontNode.Point.X + TriangulationUtil.EPSILON;
if (flag)
{
DTSweep.Fill(tcx, advancingFrontNode);
}
tcx.AddNode(advancingFrontNode2);
DTSweep.FillAdvancingFront(tcx, advancingFrontNode2);
return(advancingFrontNode2);
}
public static void Triangulate(DTSweepContext tcx)
{
tcx.CreateAdvancingFront();
DTSweep.Sweep(tcx);
bool flag = tcx.TriangulationMode == TriangulationMode.Polygon;
if (flag)
{
DTSweep.FinalizationPolygon(tcx);
}
else
{
DTSweep.FinalizationConvexHull(tcx);
}
tcx.Done();
}
private static void FillLeftAboveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
while (node.Prev.Point.X > edge.P.X)
{
Orientation orientation = TriangulationUtil.Orient2d(edge.Q, node.Prev.Point, edge.P);
bool flag = orientation == Orientation.CW;
if (flag)
{
DTSweep.FillLeftBelowEdgeEvent(tcx, edge, node);
}
else
{
node = node.Prev;
}
}
}
private static void FillLeftConvexEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
bool flag = TriangulationUtil.Orient2d(node.Prev.Point, node.Prev.Prev.Point, node.Prev.Prev.Prev.Point) == Orientation.CW;
if (flag)
{
DTSweep.FillLeftConcaveEdgeEvent(tcx, edge, node.Prev);
}
else
{
bool flag2 = TriangulationUtil.Orient2d(edge.Q, node.Prev.Prev.Point, edge.P) == Orientation.CW;
if (flag2)
{
DTSweep.FillLeftConvexEdgeEvent(tcx, edge, node.Prev);
}
}
}
private static void Fill(DTSweepContext tcx, AdvancingFrontNode node)
{
DelaunayTriangle delaunayTriangle = new DelaunayTriangle(node.Prev.Point, node.Point, node.Next.Point);
delaunayTriangle.MarkNeighbor(node.Prev.Triangle);
delaunayTriangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(delaunayTriangle);
node.Prev.Next = node.Next;
node.Next.Prev = node.Prev;
tcx.RemoveNode(node);
bool flag = !DTSweep.Legalize(tcx, delaunayTriangle);
if (flag)
{
tcx.MapTriangleToNodes(delaunayTriangle);
}
}
/// <summary>
/// Decompose the polygon into several smaller non-concave polygon.
/// </summary>
public static List <Vertices> ConvexPartition(Vertices vertices)
{
Debug.Assert(vertices.Count > 3);
Polygon poly = new Polygon();
foreach (TSVector2 vertex in vertices)
{
poly.Points.Add(new TriangulationPoint(vertex.x, vertex.y));
}
if (vertices.Holes != null)
{
foreach (Vertices holeVertices in vertices.Holes)
{
Polygon hole = new Polygon();
foreach (TSVector2 vertex in holeVertices)
{
hole.Points.Add(new TriangulationPoint(vertex.x, vertex.y));
}
poly.AddHole(hole);
}
}
DTSweepContext tcx = new DTSweepContext();
tcx.PrepareTriangulation(poly);
DTSweep.Triangulate(tcx);
List <Vertices> results = new List <Vertices>();
foreach (DelaunayTriangle triangle in poly.Triangles)
{
Vertices v = new Vertices();
foreach (TriangulationPoint p in triangle.Points)
{
v.Add(new TSVector2((FP)p.X, (FP)p.Y));
}
results.Add(v);
}
return(results);
}
private static void FillRightBelowEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
bool flag = node.Point.X < edge.P.X;
if (flag)
{
bool flag2 = TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point) == Orientation.CCW;
if (flag2)
{
DTSweep.FillRightConcaveEdgeEvent(tcx, edge, node);
}
else
{
DTSweep.FillRightConvexEdgeEvent(tcx, edge, node);
DTSweep.FillRightBelowEdgeEvent(tcx, edge, node);
}
}
}
private static void FillRightConcaveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
DTSweep.Fill(tcx, node.Next);
bool flag = node.Next.Point != edge.P;
if (flag)
{
bool flag2 = TriangulationUtil.Orient2d(edge.Q, node.Next.Point, edge.P) == Orientation.CCW;
if (flag2)
{
bool flag3 = TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point) == Orientation.CCW;
if (flag3)
{
DTSweep.FillRightConcaveEdgeEvent(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);
bool flag = DTSweep.IsEdgeSideOfTriangle(node.Triangle, edge.P, edge.Q);
if (!flag)
{
DTSweep.FillEdgeEvent(tcx, edge, node);
DTSweep.EdgeEvent(tcx, edge.P, edge.Q, node.Triangle, edge.Q);
}
}
catch (PointOnEdgeException ex)
{
Debug.WriteLine("Skipping Edge: " + ex.Message);
}
}
private static void FillAdvancingFront(DTSweepContext tcx, AdvancingFrontNode n)
{
AdvancingFrontNode advancingFrontNode = n.Next;
while (advancingFrontNode.HasNext)
{
bool flag = DTSweep.LargeHole_DontFill(advancingFrontNode);
if (flag)
{
break;
}
DTSweep.Fill(tcx, advancingFrontNode);
advancingFrontNode = advancingFrontNode.Next;
}
advancingFrontNode = n.Prev;
while (advancingFrontNode.HasPrev)
{
bool flag2 = DTSweep.LargeHole_DontFill(advancingFrontNode);
if (flag2)
{
break;
}
FP x = DTSweep.HoleAngle(advancingFrontNode);
bool flag3 = x > DTSweep.PI_div2 || x < -DTSweep.PI_div2;
if (flag3)
{
break;
}
DTSweep.Fill(tcx, advancingFrontNode);
advancingFrontNode = advancingFrontNode.Prev;
}
bool flag4 = n.HasNext && n.Next.HasNext;
if (flag4)
{
FP x = DTSweep.BasinAngle(n);
bool flag5 = x < DTSweep.PI_3div4;
if (flag5)
{
DTSweep.FillBasin(tcx, n);
}
}
}
private static void Sweep(DTSweepContext tcx)
{
List <TriangulationPoint> points = tcx.Points;
for (int i = 1; i < points.Count; i++)
{
TriangulationPoint triangulationPoint = points[i];
AdvancingFrontNode node = DTSweep.PointEvent(tcx, triangulationPoint);
bool hasEdges = triangulationPoint.HasEdges;
if (hasEdges)
{
foreach (DTSweepConstraint current in triangulationPoint.Edges)
{
DTSweep.EdgeEvent(tcx, current, node);
}
}
tcx.Update(null);
}
}
private static AdvancingFrontNode NewFrontTriangle(DTSweepContext tcx, TriangulationPoint point, AdvancingFrontNode node)
{
DelaunayTriangle delaunayTriangle = new DelaunayTriangle(point, node.Point, node.Next.Point);
delaunayTriangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(delaunayTriangle);
AdvancingFrontNode advancingFrontNode = new AdvancingFrontNode(point);
advancingFrontNode.Next = node.Next;
advancingFrontNode.Prev = node;
node.Next.Prev = advancingFrontNode;
node.Next = advancingFrontNode;
tcx.AddNode(advancingFrontNode);
bool flag = !DTSweep.Legalize(tcx, delaunayTriangle);
if (flag)
{
tcx.MapTriangleToNodes(delaunayTriangle);
}
return(advancingFrontNode);
}
public static List <Vertices> ConvexPartition(Vertices vertices)
{
Debug.Assert(vertices.Count > 3);
Polygon polygon = new Polygon();
foreach (TSVector2 current in vertices)
{
polygon.Points.Add(new TriangulationPoint(current.x, current.y));
}
bool flag = vertices.Holes != null;
if (flag)
{
foreach (Vertices current2 in vertices.Holes)
{
Polygon polygon2 = new Polygon();
foreach (TSVector2 current3 in current2)
{
polygon2.Points.Add(new TriangulationPoint(current3.x, current3.y));
}
polygon.AddHole(polygon2);
}
}
DTSweepContext dTSweepContext = new DTSweepContext();
dTSweepContext.PrepareTriangulation(polygon);
DTSweep.Triangulate(dTSweepContext);
List <Vertices> list = new List <Vertices>();
foreach (DelaunayTriangle current4 in polygon.Triangles)
{
Vertices vertices2 = new Vertices();
foreach (TriangulationPoint current5 in current4.Points)
{
vertices2.Add(new TSVector2(current5.X, current5.Y));
}
list.Add(vertices2);
}
return(list);
}
private static DelaunayTriangle NextFlipTriangle(DTSweepContext tcx, Orientation o, DelaunayTriangle t, DelaunayTriangle ot, TriangulationPoint p, TriangulationPoint op)
{
bool flag = o == Orientation.CCW;
DelaunayTriangle result;
if (flag)
{
int index = ot.EdgeIndex(p, op);
ot.EdgeIsDelaunay[index] = true;
DTSweep.Legalize(tcx, ot);
ot.EdgeIsDelaunay.Clear();
result = t;
}
else
{
int index = t.EdgeIndex(p, op);
t.EdgeIsDelaunay[index] = true;
DTSweep.Legalize(tcx, t);
t.EdgeIsDelaunay.Clear();
result = ot;
}
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 FinalizationConvexHull(DTSweepContext tcx)
{
AdvancingFrontNode advancingFrontNode = tcx.aFront.Head.Next;
AdvancingFrontNode advancingFrontNode2 = advancingFrontNode.Next;
DTSweep.TurnAdvancingFrontConvex(tcx, advancingFrontNode, advancingFrontNode2);
advancingFrontNode = tcx.aFront.Tail.Prev;
bool flag = advancingFrontNode.Triangle.Contains(advancingFrontNode.Next.Point) && advancingFrontNode.Triangle.Contains(advancingFrontNode.Prev.Point);
DelaunayTriangle delaunayTriangle;
if (flag)
{
delaunayTriangle = advancingFrontNode.Triangle.NeighborAcross(advancingFrontNode.Point);
DTSweep.RotateTrianglePair(advancingFrontNode.Triangle, advancingFrontNode.Point, delaunayTriangle, delaunayTriangle.OppositePoint(advancingFrontNode.Triangle, advancingFrontNode.Point));
tcx.MapTriangleToNodes(advancingFrontNode.Triangle);
tcx.MapTriangleToNodes(delaunayTriangle);
}
advancingFrontNode = tcx.aFront.Head.Next;
bool flag2 = advancingFrontNode.Triangle.Contains(advancingFrontNode.Prev.Point) && advancingFrontNode.Triangle.Contains(advancingFrontNode.Next.Point);
if (flag2)
{
delaunayTriangle = advancingFrontNode.Triangle.NeighborAcross(advancingFrontNode.Point);
DTSweep.RotateTrianglePair(advancingFrontNode.Triangle, advancingFrontNode.Point, delaunayTriangle, delaunayTriangle.OppositePoint(advancingFrontNode.Triangle, advancingFrontNode.Point));
tcx.MapTriangleToNodes(advancingFrontNode.Triangle);
tcx.MapTriangleToNodes(delaunayTriangle);
}
TriangulationPoint point = tcx.aFront.Head.Point;
advancingFrontNode2 = tcx.aFront.Tail.Prev;
delaunayTriangle = advancingFrontNode2.Triangle;
TriangulationPoint triangulationPoint = advancingFrontNode2.Point;
advancingFrontNode2.Triangle = null;
DelaunayTriangle delaunayTriangle2;
while (true)
{
tcx.RemoveFromList(delaunayTriangle);
triangulationPoint = delaunayTriangle.PointCCW(triangulationPoint);
bool flag3 = triangulationPoint == point;
if (flag3)
{
break;
}
delaunayTriangle2 = delaunayTriangle.NeighborCCW(triangulationPoint);
delaunayTriangle.Clear();
delaunayTriangle = delaunayTriangle2;
}
point = tcx.aFront.Head.Next.Point;
triangulationPoint = delaunayTriangle.PointCW(tcx.aFront.Head.Point);
delaunayTriangle2 = delaunayTriangle.NeighborCW(tcx.aFront.Head.Point);
delaunayTriangle.Clear();
delaunayTriangle = delaunayTriangle2;
while (triangulationPoint != point)
{
tcx.RemoveFromList(delaunayTriangle);
triangulationPoint = delaunayTriangle.PointCCW(triangulationPoint);
delaunayTriangle2 = delaunayTriangle.NeighborCCW(triangulationPoint);
delaunayTriangle.Clear();
delaunayTriangle = delaunayTriangle2;
}
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();
}
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);
}
}
}
}
}
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 bool AngleExceeds90Degrees(TriangulationPoint origin, TriangulationPoint pa, TriangulationPoint pb)
{
FP x = DTSweep.Angle(origin, pa, pb);
return(x > DTSweep.PI_div2 || x < -DTSweep.PI_div2);
}
private static bool AngleExceedsPlus90DegreesOrIsNegative(TriangulationPoint origin, TriangulationPoint pa, TriangulationPoint pb)
{
FP x = DTSweep.Angle(origin, pa, pb);
return(x > DTSweep.PI_div2 || x < 0);
}
