//Method 2. Triangulation walk
//This assumes there are no holes in the mesh
//And that we have a super-triangle around the triangulation
private static void FindIntersectingEdges_TriangleWalk(HalfEdgeData2 triangleData, MyVector2 c_p1, MyVector2 c_p2, List <HalfEdge2> intersectingEdges)
{
//Step 1. Begin at a triangle connected to the constraint edges's vertex c_p1
HalfEdgeFace2 f = null;
foreach (HalfEdgeFace2 testFace in triangleData.faces)
{
//The edges the triangle consists of
HalfEdge2 e1 = testFace.edge;
HalfEdge2 e2 = e1.nextEdge;
HalfEdge2 e3 = e2.nextEdge;
//Does one of these edges include the first vertex in the constraint edge
if (e1.v.position.Equals(c_p1) || e2.v.position.Equals(c_p1) || e3.v.position.Equals(c_p1))
{
f = testFace;
break;
}
}
//Step2. Walk around p1 until we find a triangle with an edge that intersects with the edge p1-p2
//Step3. March from one triangle to the next in the general direction of p2
}
//Find all triangles opposite of vertex p
//But we will find all edges opposite to p, and from these edges we can find the triangles
private static void AddTrianglesOppositePToStack(MyVector2 p, Stack <HalfEdge2> trianglesOppositeP, HalfEdgeData2 triangulationData)
{
//Find a vertex at position p and then rotate around it, triangle-by-triangle, to find all opposite edges
HalfEdgeVertex2 rotateAroundThis = null;
foreach (HalfEdgeVertex2 v in triangulationData.vertices)
{
if (v.position.Equals(p))
{
rotateAroundThis = v;
}
}
//Which triangle is this vertex a part of, so we know when we have rotated all the way around
HalfEdgeFace2 tStart = rotateAroundThis.edge.face;
HalfEdgeFace2 tCurrent = null;
int safety = 0;
while (tCurrent != tStart)
{
safety += 1;
if (safety > 10000)
{
Debug.Log("Stuck in endless loop when finding opposite edges in Delaunay Sloan");
break;
}
//The edge opposite to p
HalfEdge2 edgeOppositeRotateVertex = rotateAroundThis.edge.nextEdge.oppositeEdge;
//Try to add the edge to the list iof triangles we are interested in
//Null might happen if we are at the border
//A stack might include duplicates so we have to check for that as well
if (edgeOppositeRotateVertex != null && !trianglesOppositeP.Contains(edgeOppositeRotateVertex))
{
trianglesOppositeP.Push(edgeOppositeRotateVertex);
}
//Rotate left - this assumes we can always rotate left so no holes are allowed
//and neither can we investigate one of the vertices thats a part of the supertriangle
//which we dont need to worry about because p is never a part of the supertriangle
rotateAroundThis = rotateAroundThis.edge.oppositeEdge.v;
//In which triangle are we now?
tCurrent = rotateAroundThis.edge.face;
}
}
//
// Try to restore the delaunay triangulation by flipping newly created edges
//
//This process is similar to when we created the original delaunay triangulation
//This step can maybe be skipped if you just want a triangulation and Ive noticed its often not flipping any triangles
private IEnumerator RestoreDelaunayTriangulation(MyVector2 c_p1, MyVector2 c_p2, List <HalfEdge2> newEdges, HalfEdgeData2 triangleData, Normalizer2 normalizer)
{
int safety = 0;
int flippedEdges = 0;
//Repeat 4.1 - 4.3 until no further swaps take place
while (true)
{
safety += 1;
if (safety > 100000)
{
Debug.Log("Stuck in endless loop when delaunay after fixing constrained edges");
break;
}
bool hasFlippedEdge = false;
//Step 4.1. Loop over each edge in the list of newly created edges
for (int j = 0; j < newEdges.Count; j++)
{
HalfEdge2 e = newEdges[j];
//Step 4.2. Let the newly created edge be defined by the vertices
MyVector2 v_k = e.v.position;
MyVector2 v_l = e.prevEdge.v.position;
//If this edge is equal to the constrained edge, then skip to step 4.1
//because we are not allowed to flip the constrained edge
if ((v_k.Equals(c_p1) && v_l.Equals(c_p2)) || (v_l.Equals(c_p1) && v_k.Equals(c_p2)))
{
continue;
}
//Step 4.3. If the two triangles that share edge v_k and v_l don't satisfy the delaunay criterion,
//so that a vertex of one of the triangles is inside the circumcircle of the other triangle, flip the edge
//The third vertex of the triangle belonging to this edge
MyVector2 v_third_pos = e.nextEdge.v.position;
//The vertice belonging to the triangle on the opposite side of the edge and this vertex is not a part of the edge
MyVector2 v_opposite_pos = e.oppositeEdge.nextEdge.v.position;
//Test if we should flip this edge
if (DelaunayMethods.ShouldFlipEdge(v_l, v_k, v_third_pos, v_opposite_pos))
{
//Flip the edge
hasFlippedEdge = true;
HalfEdgeHelpMethods.FlipTriangleEdge(e);
flippedEdges += 1;
//
// PAUSE AND VISUALIZE
//
visualizeController.DisplayMeshMain(triangleData, normalizer);
yield return(new WaitForSeconds(0.5f));
}
}
//We have searched through all edges and havent found an edge to flip, so we cant improve anymore
if (!hasFlippedEdge)
{
//Debug.Log("Found a constrained delaunay triangulation in " + flippedEdges + " flips");
break;
}
}
}
//
// Remove the edges that intersects with a constraint by flipping triangles
//
//The idea here is that all possible triangulations for a set of points can be found
//by systematically swapping the diagonal in each convex quadrilateral formed by a pair of triangles
//So we will test all possible arrangements and will always find a triangulation which includes the constrained edge
private IEnumerator RemoveIntersectingEdges(MyVector2 v_i, MyVector2 v_j, Queue <HalfEdge2> intersectingEdges, List <HalfEdge2> newEdges, HalfEdgeData2 triangleData, Normalizer2 normalizer)
{
int safety = 0;
//While some edges still cross the constrained edge, do steps 3.1 and 3.2
while (intersectingEdges.Count > 0)
{
safety += 1;
if (safety > 100000)
{
Debug.Log("Stuck in infinite loop when fixing constrained edges");
break;
}
//Step 3.1. Remove an edge from the list of edges that intersects the constrained edge
HalfEdge2 e = intersectingEdges.Dequeue();
//The vertices belonging to the two triangles
MyVector2 v_k = e.v.position;
MyVector2 v_l = e.prevEdge.v.position;
MyVector2 v_3rd = e.nextEdge.v.position;
//The vertex belonging to the opposite triangle and isn't shared by the current edge
MyVector2 v_opposite_pos = e.oppositeEdge.nextEdge.v.position;
//Step 3.2. If the two triangles don't form a convex quadtrilateral
//place the edge back on the list of intersecting edges (because this edge cant be flipped)
//and go to step 3.1
if (!_Geometry.IsQuadrilateralConvex(v_k, v_l, v_3rd, v_opposite_pos))
{
intersectingEdges.Enqueue(e);
continue;
}
else
{
//Flip the edge like we did when we created the delaunay triangulation
HalfEdgeHelpMethods.FlipTriangleEdge(e);
//
// PAUSE AND VISUALIZE
//
visualizeController.DisplayMeshMain(triangleData, normalizer);
yield return(new WaitForSeconds(0.5f));
//The new diagonal is defined by the vertices
MyVector2 v_m = e.v.position;
MyVector2 v_n = e.prevEdge.v.position;
//If this new diagonal intersects with the constrained edge, add it to the list of intersecting edges
if (IsEdgeCrossingEdge(v_i, v_j, v_m, v_n))
{
intersectingEdges.Enqueue(e);
}
//Place it in the list of newly created edges
else
{
newEdges.Add(e);
}
}
}
}
IEnumerator InsertPoints(HashSet <MyVector2> points, HalfEdgeData2 triangulationData, Triangle2 superTriangle)
{
//VISUALZ
ShowTriangles(triangulationData);
//VISUALZ - dont show the colored mesh until its finished because its flickering
controller.shouldDisplayColoredMesh = false;
yield return(new WaitForSeconds(controller.pauseTime));
//Step 4. Loop over each point we want to insert and do Steps 5-7
//These are for display purposes only
int missedPoints = 0;
int flippedEdges = 0;
foreach (MyVector2 p in points)
{
//Step 5. Insert the new point in the triangulation
//Find the existing triangle the point is in
HalfEdgeFace2 f = PointTriangulationIntersection.TriangulationWalk(p, null, triangulationData);
//We couldnt find a triangle maybe because the point is not in the triangulation?
if (f == null)
{
missedPoints += 1;
}
//Delete this triangle and form 3 new triangles by connecting p to each of the vertices in the old triangle
HalfEdgeHelpMethods.SplitTriangleFaceAtPoint(f, p, triangulationData);
//VISUALZ
//Display the point as a black circle
ShowCircle(p);
yield return(new WaitForSeconds(controller.pauseTime));
ShowTriangles(triangulationData);
yield return(new WaitForSeconds(controller.pauseTime));
//Step 6. Initialize stack. Place all triangles which are adjacent to the edges opposite p on a LIFO stack
//The report says we should place triangles, but it's easier to place edges with our data structure
Stack <HalfEdge2> trianglesToInvestigate = new Stack <HalfEdge2>();
AddTrianglesOppositePToStack(p, trianglesToInvestigate, triangulationData);
//Step 7. Restore delaunay triangulation
//While the stack is not empty
int safety = 0;
while (trianglesToInvestigate.Count > 0)
{
safety += 1;
if (safety > 1000000)
{
Debug.Log("Stuck in infinite loop when restoring delaunay in incremental sloan algorithm");
break;
}
//Step 7.1. Remove a triangle from the stack
HalfEdge2 edgeToTest = trianglesToInvestigate.Pop();
//Step 7.2. Do we need to flip this edge?
//If p is outside or on the circumcircle for this triangle, we have a delaunay triangle and can return to next loop
MyVector2 a = edgeToTest.v.position;
MyVector2 b = edgeToTest.prevEdge.v.position;
MyVector2 c = edgeToTest.nextEdge.v.position;
//abc are here counter-clockwise
if (DelaunayMethods.ShouldFlipEdgeStable(a, b, c, p))
{
HalfEdgeHelpMethods.FlipTriangleEdge(edgeToTest);
//Step 7.3. Place any triangles which are now opposite p on the stack
AddTrianglesOppositePToStack(p, trianglesToInvestigate, triangulationData);
flippedEdges += 1;
//VISUALZ
controller.flipText.text = "Flipped edges: " + flippedEdges;
ShowTriangles(triangulationData);
yield return(new WaitForSeconds(controller.pauseTime));
}
}
}
//Dont show the last point we added
controller.ResetBlackMeshes();
//Step 8. Delete the vertices belonging to the supertriangle
StartCoroutine(RemoveSuperTriangle(superTriangle, triangulationData));
yield return(null);
}