public Triangle(HalfEdge halfEdge)
{
this.halfEdge = halfEdge;
}
public static List <VoronoiCell> GenerateVoronoiDiagram(List <Vector3> sites)
{
//First generate the delaunay triangulation
List <Triangle> triangles = TriangulateByFlippingEdges(sites);
//Generate the voronoi diagram
//Step 1. For every delaunay edge, compute a voronoi edge
//The voronoi edge is the edge connecting the circumcenters of two neighboring delaunay triangles
List <VoronoiEdge> voronoiEdges = new List <VoronoiEdge>();
for (int i = 0; i < triangles.Count; i++)
{
Triangle t = triangles[i];
//Each triangle consists of these edges
HalfEdge e1 = t.halfEdge;
HalfEdge e2 = e1.nextEdge;
HalfEdge e3 = e2.nextEdge;
//Calculate the circumcenter for this triangle
Vector3 v1 = e1.v.position;
Vector3 v2 = e2.v.position;
Vector3 v3 = e3.v.position;
//The circumcenter is the center of a circle where the triangles corners is on the circumference of that circle
//The .XZ() is an extension method that removes the y value of a vector3 so it becomes a vector2
Vector2 center2D = CalculateCircleCenter(new Vector2(v1.x, v1.z), new Vector2(v2.x, v2.z), new Vector2(v3.x, v3.z));
//The circumcenter is also known as a voronoi vertex, which is a position in the diagram where we are equally
//close to the surrounding sites
Vector3 voronoiVertex = new Vector3(center2D.x, 0f, center2D.y);
TryAddVoronoiEdgeFromTriangleEdge(e1, voronoiVertex, voronoiEdges);
TryAddVoronoiEdgeFromTriangleEdge(e2, voronoiVertex, voronoiEdges);
TryAddVoronoiEdgeFromTriangleEdge(e3, voronoiVertex, voronoiEdges);
}
//Step 2. Find the voronoi cells where each cell is a list of all edges belonging to a site
List <VoronoiCell> voronoiCells = new List <VoronoiCell>();
for (int i = 0; i < voronoiEdges.Count; i++)
{
VoronoiEdge e = voronoiEdges[i];
//Find the position in the list of all cells that includes this site
int cellPos = TryFindCellPos(e, voronoiCells);
//No cell was found so we need to create a new cell
if (cellPos == -1)
{
VoronoiCell newCell = new VoronoiCell(e.sitePos);
voronoiCells.Add(newCell);
newCell.edges.Add(e);
}
else
{
voronoiCells[cellPos].edges.Add(e);
}
}
return(voronoiCells);
}
public static List <Triangle> TriangulateByFlippingEdges(List <Vector3> sites)
{
//Step 1. Triangulate the points with some algorithm
//Vector3 to vertex
List <Vertex> vertices = new List <Vertex>();
for (int i = 0; i < sites.Count; i++)
{
vertices.Add(new Vertex(sites[i]));
}
//Triangulate the convex hull of the sites
List <Triangle> triangles = TriangulatePoints(vertices);
//List triangles = TriangulatePoints.TriangleSplitting(vertices);
//Step 2. Change the structure from triangle to half-edge to make it faster to flip edges
List <HalfEdge> halfEdges = TransformFromTriangleToHalfEdge(triangles);
//Step 3. Flip edges until we have a delaunay triangulation
int safety = 0;
int flippedEdges = 0;
while (true)
{
safety += 1;
if (safety > 100000)
{
Debug.Log("Stuck in endless loop");
break;
}
bool hasFlippedEdge = false;
//Search through all edges to see if we can flip an edge
for (int i = 0; i < halfEdges.Count; i++)
{
HalfEdge thisEdge = halfEdges[i];
//Is this edge sharing an edge, otherwise its a border, and then we cant flip the edge
if (thisEdge.oppositeEdge == null)
{
continue;
}
//The vertices belonging to the two triangles, c-a are the edge vertices, b belongs to this triangle
Vertex a = thisEdge.v;
Vertex b = thisEdge.nextEdge.v;
Vertex c = thisEdge.prevEdge.v;
Vertex d = thisEdge.oppositeEdge.nextEdge.v;
Vector2 aPos = a.GetPos2D_XZ();
Vector2 bPos = b.GetPos2D_XZ();
Vector2 cPos = c.GetPos2D_XZ();
Vector2 dPos = d.GetPos2D_XZ();
//Use the circle test to test if we need to flip this edge
if (IsPointInsideOutsideOrOnCircle(aPos, bPos, cPos, dPos) < 0f)
{
//Are these the two triangles that share this edge forming a convex quadrilateral?
//Otherwise the edge cant be flipped
if (IsQuadrilateralConvex(aPos, bPos, cPos, dPos))
{
//If the new triangle after a flip is not better, then dont flip
//This will also stop the algoritm from ending up in an endless loop
if (IsPointInsideOutsideOrOnCircle(bPos, cPos, dPos, aPos) < 0f)
{
continue;
}
//Flip the edge
flippedEdges += 1;
hasFlippedEdge = true;
FlipEdge(thisEdge);
}
}
}
//We have searched through all edges and havent found an edge to flip, so we have a Delaunay triangulation!
if (!hasFlippedEdge)
{
//Debug.Log("Found a delaunay triangulation");
break;
}
}
//Debug.Log("Flipped edges: " + flippedEdges);
//Dont have to convert from half edge to triangle because the algorithm will modify the objects, which belongs to the
//original triangles, so the triangles have the data we need
return(triangles);
}
private static void FlipEdge(HalfEdge one)
{
//The data we need
//This edge's triangle
HalfEdge two = one.nextEdge;
HalfEdge three = one.prevEdge;
//The opposite edge's triangle
HalfEdge four = one.oppositeEdge;
HalfEdge five = one.oppositeEdge.nextEdge;
HalfEdge six = one.oppositeEdge.prevEdge;
//The vertices
Vertex a = one.v;
Vertex b = one.nextEdge.v;
Vertex c = one.prevEdge.v;
Vertex d = one.oppositeEdge.nextEdge.v;
//Flip
//Change vertex
a.halfEdge = one.nextEdge;
c.halfEdge = one.oppositeEdge.nextEdge;
//Change half-edge
//Half-edge - half-edge connections
one.nextEdge = three;
one.prevEdge = five;
two.nextEdge = four;
two.prevEdge = six;
three.nextEdge = five;
three.prevEdge = one;
four.nextEdge = six;
four.prevEdge = two;
five.nextEdge = one;
five.prevEdge = three;
six.nextEdge = two;
six.prevEdge = four;
//Half-edge - vertex connection
one.v = b;
two.v = b;
three.v = c;
four.v = d;
five.v = d;
six.v = a;
//Half-edge - triangle connection
Triangle t1 = one.t;
Triangle t2 = four.t;
one.t = t1;
three.t = t1;
five.t = t1;
two.t = t2;
four.t = t2;
six.t = t2;
//Opposite-edges are not changing!
//Triangle connection
t1.v1 = b;
t1.v2 = c;
t1.v3 = d;
t2.v1 = b;
t2.v2 = d;
t2.v3 = a;
t1.halfEdge = three;
t2.halfEdge = four;
}
public static List <HalfEdge> TransformFromTriangleToHalfEdge(List <Triangle> triangles)
{
//Make sure the triangles have the same orientation
OrientTrianglesClockwise(triangles);
//First create a list with all possible half-edges
List <HalfEdge> halfEdges = new List <HalfEdge>(triangles.Count * 3);
for (int i = 0; i < triangles.Count; i++)
{
Triangle t = triangles[i];
HalfEdge he1 = new HalfEdge(t.v1);
HalfEdge he2 = new HalfEdge(t.v2);
HalfEdge he3 = new HalfEdge(t.v3);
he1.nextEdge = he2;
he2.nextEdge = he3;
he3.nextEdge = he1;
he1.prevEdge = he3;
he2.prevEdge = he1;
he3.prevEdge = he2;
//The vertex needs to know of an edge going from it
he1.v.halfEdge = he2;
he2.v.halfEdge = he3;
he3.v.halfEdge = he1;
//The face the half-edge is connected to
t.halfEdge = he1;
he1.t = t;
he2.t = t;
he3.t = t;
//Add the half-edges to the list
halfEdges.Add(he1);
halfEdges.Add(he2);
halfEdges.Add(he3);
}
//Find the half-edges going in the opposite direction
for (int i = 0; i < halfEdges.Count; i++)
{
HalfEdge he = halfEdges[i];
Vertex goingToVertex = he.v;
Vertex goingFromVertex = he.prevEdge.v;
for (int j = 0; j < halfEdges.Count; j++)
{
//Dont compare with itself
if (i == j)
{
continue;
}
HalfEdge heOpposite = halfEdges[j];
//Is this edge going between the vertices in the opposite direction
if (goingFromVertex.position == heOpposite.v.position && goingToVertex.position == heOpposite.prevEdge.v.position)
{
he.oppositeEdge = heOpposite;
break;
}
}
}
return(halfEdges);
}
