/// <param name="t">Opposite triangle</param>
/// <param name="p">The point in t that isn't shared between the triangles</param>
public TriangulationPoint OppositePoint(DelaunayTriangle t, TriangulationPoint p)
{
Debug.Assert(t != this, "self-pointer error");
return(PointCW(t.PointCW(p)));
}
private static void RotateTrianglePair(DelaunayTriangle t, TriangulationPoint p, DelaunayTriangle ot, TriangulationPoint op)
{
DelaunayTriangle delaunayTriangle = t.NeighborCCW(p);
DelaunayTriangle delaunayTriangle2 = t.NeighborCW(p);
DelaunayTriangle delaunayTriangle3 = ot.NeighborCCW(op);
DelaunayTriangle delaunayTriangle4 = ot.NeighborCW(op);
bool constrainedEdgeCCW = t.GetConstrainedEdgeCCW(p);
bool constrainedEdgeCW = t.GetConstrainedEdgeCW(p);
bool constrainedEdgeCCW2 = ot.GetConstrainedEdgeCCW(op);
bool constrainedEdgeCW2 = ot.GetConstrainedEdgeCW(op);
bool delaunayEdgeCCW = t.GetDelaunayEdgeCCW(p);
bool delaunayEdgeCW = t.GetDelaunayEdgeCW(p);
bool delaunayEdgeCCW2 = ot.GetDelaunayEdgeCCW(op);
bool delaunayEdgeCW2 = ot.GetDelaunayEdgeCW(op);
t.Legalize(p, op);
ot.Legalize(op, p);
ot.SetDelaunayEdgeCCW(p, delaunayEdgeCCW);
t.SetDelaunayEdgeCW(p, delaunayEdgeCW);
t.SetDelaunayEdgeCCW(op, delaunayEdgeCCW2);
ot.SetDelaunayEdgeCW(op, delaunayEdgeCW2);
ot.SetConstrainedEdgeCCW(p, constrainedEdgeCCW);
t.SetConstrainedEdgeCW(p, constrainedEdgeCW);
t.SetConstrainedEdgeCCW(op, constrainedEdgeCCW2);
ot.SetConstrainedEdgeCW(op, constrainedEdgeCW2);
t.Neighbors.Clear();
ot.Neighbors.Clear();
bool flag = delaunayTriangle != null;
if (flag)
{
ot.MarkNeighbor(delaunayTriangle);
}
bool flag2 = delaunayTriangle2 != null;
if (flag2)
{
t.MarkNeighbor(delaunayTriangle2);
}
bool flag3 = delaunayTriangle3 != null;
if (flag3)
{
t.MarkNeighbor(delaunayTriangle3);
}
bool flag4 = delaunayTriangle4 != null;
if (flag4)
{
ot.MarkNeighbor(delaunayTriangle4);
}
t.MarkNeighbor(ot);
}
public void AddTriangle(DelaunayTriangle t)
{
_triangles.Add(t);
}
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 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 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);
}
}
}
}
}
public void MeshClean(DelaunayTriangle triangle)
{
this.MeshCleanReq(triangle);
}
public void RemoveFromList(DelaunayTriangle triangle)
{
this.Triangles.Remove(triangle);
}
