/// <summary>
/// Triangulate simple polygon with holes
/// </summary>
public static void Triangulate(DTSweepContext tcx)
{
tcx.CreateAdvancingFront();
Sweep(tcx);
// Finalize triangulation
if (tcx.TriangulationMode == TriangulationMode.Polygon)
{
FinalizationPolygon(tcx);
}
else
{
FinalizationConvexHull(tcx);
}
tcx.Done();
}
public int[] Triangulate(UnityEngine.Vector2[] verts)
{
PolygonPoint[] points = new PolygonPoint[verts.Length];
for (int i = 0; i < verts.Length; i++)
points[i] = new PolygonPoint(verts[i].x, verts[i].y);
Polygon polygon = new Polygon(points);
DTSweepContext tcx = new DTSweepContext();
tcx.PrepareTriangulation(polygon);
DTSweep.Triangulate(tcx);
int[] resultPoints = new int[polygon.Triangles.Count * 3];
int idx = 0;
foreach (DelaunayTriangle triangle in polygon.Triangles) {
resultPoints[idx++] = FindIndex(points, triangle.Points._0);
resultPoints[idx++] = FindIndex(points, triangle.Points._1);
resultPoints[idx++] = FindIndex(points, triangle.Points._2);
}
return resultPoints;
}
/// <summary>
/// Start sweeping the Y-sorted point set from bottom to top
/// </summary>
private static void Sweep(DTSweepContext tcx)
{
List<TriangulationPoint> points = tcx.Points;
TriangulationPoint point;
AdvancingFrontNode node;
for (int i = 1; i < points.Count; i++)
{
point = points[i];
node = PointEvent(tcx, point);
if (point.HasEdges)
{
foreach (DTSweepConstraint e in point.Edges)
{
EdgeEvent(tcx, e, node);
}
}
tcx.Update(null);
}
}
/// <summary>
/// Returns true if triangle was legalized
/// </summary>
private static bool Legalize(DTSweepContext tcx, DelaunayTriangle t)
{
int oi;
bool inside;
TriangulationPoint p, op;
DelaunayTriangle ot;
// 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++)
{
// TODO: fix so that cEdge is always valid when creating new triangles then we can check it here
// instead of below with ot
if (t.EdgeIsDelaunay[i])
{
continue;
}
ot = t.Neighbors[i];
if (ot != null)
{
p = t.Points[i];
op = ot.OppositePoint(t, p);
oi = ot.IndexOf(op);
// If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
// then we should not try to legalize
if (ot.EdgeIsConstrained[oi] || ot.EdgeIsDelaunay[oi])
{
t.EdgeIsConstrained[i] = ot.EdgeIsConstrained[oi];
// XXX: have no good way of setting this property when creating new triangles so lets set it here
continue;
}
inside = TriangulationUtil.SmartIncircle(p,
t.PointCCW(p),
t.PointCW(p),
op);
if (inside)
{
bool notLegalized;
// Lets mark this shared edge as Delaunay
t.EdgeIsDelaunay[i] = true;
ot.EdgeIsDelaunay[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
notLegalized = !Legalize(tcx, t);
if (notLegalized)
{
tcx.MapTriangleToNodes(t);
}
notLegalized = !Legalize(tcx, ot);
if (notLegalized)
{
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.EdgeIsDelaunay[i] = false;
ot.EdgeIsDelaunay[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;
}
private static bool IsShallow(DTSweepContext tcx, AdvancingFrontNode node)
{
double height;
if (tcx.Basin.leftHighest)
{
height = tcx.Basin.leftNode.Point.Y - node.Point.Y;
}
else
{
height = tcx.Basin.rightNode.Point.Y - node.Point.Y;
}
if (tcx.Basin.width > height)
{
return true;
}
return false;
}
/// <summary>
/// Fills holes in the Advancing Front
/// </summary>
private static void FillAdvancingFront(DTSweepContext tcx, AdvancingFrontNode n)
{
AdvancingFrontNode node;
double angle;
// Fill right holes
node = n.Next;
while (node.HasNext)
{
angle = HoleAngle(node);
if (angle > PI_div2 || angle < -PI_div2)
{
break;
}
Fill(tcx, node);
node = node.Next;
}
// Fill left holes
node = n.Prev;
while (node.HasPrev)
{
angle = HoleAngle(node);
if (angle > PI_div2 || angle < -PI_div2)
{
break;
}
Fill(tcx, node);
node = node.Prev;
}
// Fill right basins
if (n.HasNext && n.Next.HasNext)
{
angle = BasinAngle(n);
if (angle < PI_3div4)
{
FillBasin(tcx, n);
}
}
}
/// <summary>
/// After a flip we have two triangles and know that only one will still be
/// intersecting the edge. So decide which to contiune with and legalize the other
/// </summary>
/// <param name="tcx"></param>
/// <param name="o">should be the result of an TriangulationUtil.orient2d( eq, op, ep )</param>
/// <param name="t">triangle 1</param>
/// <param name="ot">triangle 2</param>
/// <param name="p">a point shared by both triangles</param>
/// <param name="op">another point shared by both triangles</param>
/// <returns>returns the triangle still intersecting the edge</returns>
private static DelaunayTriangle NextFlipTriangle(DTSweepContext tcx, Orientation o, DelaunayTriangle t,
DelaunayTriangle ot, TriangulationPoint p,
TriangulationPoint op)
{
int edgeIndex;
if (o == Orientation.CCW)
{
// ot is not crossing edge after flip
edgeIndex = ot.EdgeIndex(p, op);
ot.EdgeIsDelaunay[edgeIndex] = true;
Legalize(tcx, ot);
ot.EdgeIsDelaunay.Clear();
return t;
}
// t is not crossing edge after flip
edgeIndex = t.EdgeIndex(p, op);
t.EdgeIsDelaunay[edgeIndex] = true;
Legalize(tcx, t);
t.EdgeIsDelaunay.Clear();
return ot;
}
private static void FlipEdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq,
DelaunayTriangle t, TriangulationPoint p)
{
TriangulationPoint op, newP;
DelaunayTriangle ot;
bool inScanArea;
ot = t.NeighborAcross(p);
op = ot.OppositePoint(t, p);
if (ot == null)
{
// If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here
throw new InvalidOperationException("[BUG:FIXME] FLIP failed due to missing triangle");
}
inScanArea = TriangulationUtil.InScanArea(p, t.PointCCW(p), t.PointCW(p), op);
if (inScanArea)
{
// 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)
{
if (tcx.IsDebugEnabled) Console.WriteLine("[FLIP] - constrained edge done"); // TODO: remove
t.MarkConstrainedEdge(ep, eq);
ot.MarkConstrainedEdge(ep, eq);
Legalize(tcx, t);
Legalize(tcx, ot);
}
else
{
if (tcx.IsDebugEnabled) Console.WriteLine("[FLIP] - subedge done"); // TODO: remove
// XXX: I think one of the triangles should be legalized here?
}
}
else
{
if (tcx.IsDebugEnabled)
Console.WriteLine("[FLIP] - flipping and continuing with triangle still crossing edge");
// TODO: remove
Orientation o = TriangulationUtil.Orient2d(eq, op, ep);
t = NextFlipTriangle(tcx, o, t, ot, p, op);
FlipEdgeEvent(tcx, ep, eq, t, p);
}
}
else
{
newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP);
EdgeEvent(tcx, ep, eq, t, p);
}
}
private static void FillLeftAboveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
while (node.Prev.Point.X > edge.P.X)
{
// Check if next node is below the edge
Orientation o1 = TriangulationUtil.Orient2d(edge.Q, node.Prev.Point, edge.P);
if (o1 == Orientation.CW)
{
FillLeftBelowEdgeEvent(tcx, edge, node);
}
else
{
node = node.Prev;
}
}
}
/// <summary>
/// If this is a Delaunay Triangulation of a pointset we need to fill so the triangle mesh gets a ConvexHull
/// </summary>
private static void FinalizationConvexHull(DTSweepContext tcx)
{
AdvancingFrontNode n1, n2;
DelaunayTriangle t1, t2;
TriangulationPoint first, p1;
n1 = tcx.aFront.Head.Next;
n2 = n1.Next;
first = n1.Point;
TurnAdvancingFrontConvex(tcx, n1, n2);
// TODO: implement ConvexHull for lower right and left boundary
// Lets remove triangles connected to the two "algorithm" points
// XXX: When the first the nodes are points in a triangle we need to do a flip before
// removing triangles or we will lose a valid triangle.
// Same for last three nodes!
// !!! If I implement ConvexHull for lower right and left boundary this fix should not be
// needed and the removed triangles will be added again by default
n1 = tcx.aFront.Tail.Prev;
if (n1.Triangle.Contains(n1.Next.Point) && n1.Triangle.Contains(n1.Prev.Point))
{
t1 = n1.Triangle.NeighborAcross(n1.Point);
RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point));
tcx.MapTriangleToNodes(n1.Triangle);
tcx.MapTriangleToNodes(t1);
}
n1 = tcx.aFront.Head.Next;
if (n1.Triangle.Contains(n1.Prev.Point) && n1.Triangle.Contains(n1.Next.Point))
{
t1 = n1.Triangle.NeighborAcross(n1.Point);
RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point));
tcx.MapTriangleToNodes(n1.Triangle);
tcx.MapTriangleToNodes(t1);
}
// Lower right boundary
first = tcx.aFront.Head.Point;
n2 = tcx.aFront.Tail.Prev;
t1 = n2.Triangle;
p1 = n2.Point;
n2.Triangle = null;
do
{
tcx.RemoveFromList(t1);
p1 = t1.PointCCW(p1);
if (p1 == first) break;
t2 = t1.NeighborCCW(p1);
t1.Clear();
t1 = t2;
} while (true);
// Lower left boundary
first = tcx.aFront.Head.Next.Point;
p1 = t1.PointCW(tcx.aFront.Head.Point);
t2 = t1.NeighborCW(tcx.aFront.Head.Point);
t1.Clear();
t1 = t2;
while (p1 != first) //TODO: Port note. This was do while before.
{
tcx.RemoveFromList(t1);
p1 = t1.PointCCW(p1);
t2 = t1.NeighborCCW(p1);
t1.Clear();
t1 = t2;
}
// Remove current head and tail node now that we have removed all triangles attached
// to them. Then set new head and tail node points
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 FillRightBelowEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
if (node.Point.x < edge.P.x) // needed?
{
if (TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point) == Orientation.CCW)
{
// Concave
FillRightConcaveEdgeEvent(tcx, edge, node);
}
else
{
// Convex
FillRightConvexEdgeEvent(tcx, edge, node);
// Retry this one
FillRightBelowEdgeEvent(tcx, edge, node);
}
}
}
public void CreateMesh(Vector2[] vertsToCopy, Transform transform)
{
List<Vector3> resultsLocal = new List<Vector3>();
List<int> resultsTriIndexesLocal = new List<int>();
List<int> resultsTriIndexesReversedLocal = new List<int>();
List<Vector2> uvsLocal = new List<Vector2>();
List<Vector3> normalsLocal = new List<Vector3>();
Sprite spr = transform.GetComponent<SpriteRenderer>().sprite;
Rect rec = spr.rect;
Vector3 bound = transform.GetComponent<Renderer>().bounds.max- transform.GetComponent<Renderer>().bounds.min ;
TextureImporter textureImporter = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(spr)) as TextureImporter;
int i = 0;
Polygon poly = new Polygon();
for (i=0; i <vertsToCopy.Length;i++)
{
poly.Points.Add(new TriangulationPoint(vertsToCopy[i].x, vertsToCopy[i].y));
}
DTSweepContext tcx = new DTSweepContext();
tcx.PrepareTriangulation(poly);
DTSweep.Triangulate(tcx);
int indexNumber = 0;
bool multiSprites = false;
foreach (DelaunayTriangle triangle in poly.Triangles)
{
Vector3 v = new Vector3();
foreach (TriangulationPoint p in triangle.Points)
{
v = new Vector3((float)p.X, (float)p.Y,0);
if(!resultsLocal.Contains(v))
{
resultsLocal.Add(v);
resultsTriIndexesLocal.Add(indexNumber);
Vector2 newUv = new Vector2((v.x /bound.x) + 0.5f, (v.y /bound.y) + 0.5f);
newUv.x *= rec.width/ spr.texture.width;
newUv.y *= rec.height/ spr.texture.height;
//Debug.Log(spr.textureRectOffset);
newUv.x += (rec.x)/ spr.texture.width;
newUv.y += (rec.y) / spr.texture.height;
//Debug.Log(Application.unityVersion);
SpriteMetaData[] smdArray = textureImporter.spritesheet;
Vector2 pivot = new Vector2(.0f,.0f);;
for (int j = 0; j < smdArray.Length; j++)
{
if (smdArray[j].name == spr.name)
{
switch(smdArray[j].alignment)
{
case(0):
smdArray[j].pivot = Vector2.zero;
break;
case(1):
smdArray[j].pivot = new Vector2(0f,1f) -new Vector2(.5f,.5f);
break;
case(2):
smdArray[j].pivot = new Vector2(0.5f,1f) -new Vector2(.5f,.5f);
break;
case(3):
smdArray[j].pivot = new Vector2(1f,1f) -new Vector2(.5f,.5f);
break;
case(4):
smdArray[j].pivot = new Vector2(0f,.5f) -new Vector2(.5f,.5f);
break;
case(5):
smdArray[j].pivot = new Vector2(1f,.5f) -new Vector2(.5f,.5f);
break;
case(6):
smdArray[j].pivot = new Vector2(0f,0f) -new Vector2(.5f,.5f);
break;
case(7):
smdArray[j].pivot = new Vector2(0.5f,0f) -new Vector2(.5f,.5f);
break;
case(8):
smdArray[j].pivot = new Vector2(1f,0f) -new Vector2(.5f,.5f);
break;
case(9):
smdArray[j].pivot -= new Vector2(.5f,.5f);
break;
}
pivot = smdArray[j].pivot ;
}
}
if(textureImporter.spriteImportMode == SpriteImportMode.Single)
pivot = textureImporter.spritePivot-new Vector2(.5f,.5f);
newUv.x += ((pivot.x)*rec.width)/ spr.texture.width;
newUv.y += ((pivot.y)*rec.height)/ spr.texture.height;
/*
if(Application.unityVersion != "4.3.0f4")
{
Debug.Log(spr.textureRectOffset.x);
newUv.x += (spr.textureRectOffset.x)/ spr.texture.width;
newUv.y += (spr.textureRectOffset.y)/ spr.texture.height;
}
*/
uvsLocal.Add(newUv);
normalsLocal.Add(new Vector3(0,0,-1));
indexNumber++;
}
else
{
resultsTriIndexesLocal.Add(resultsLocal.LastIndexOf(v));
}
}
}
if(!multiSprites)
Debug.Log("Tip: Sprite Pivot should be set to Center, with no custom pivot before conversion");
for (int j = resultsTriIndexesLocal.Count-1; j >=0; j--)
{
resultsTriIndexesReversedLocal.Add(resultsTriIndexesLocal[j]);
}
results.AddRange(resultsLocal);
resultsTriIndexes.AddRange(resultsTriIndexesLocal);
resultsTriIndexesReversed.AddRange(resultsTriIndexesReversedLocal);
uvs.AddRange(uvsLocal);
normals.AddRange(normalsLocal);
resultsLocal.Clear();
resultsTriIndexesLocal.Clear();
resultsTriIndexesReversedLocal.Clear();
uvsLocal.Clear();
normalsLocal.Clear();
finalVertices = results.ToArray();
finalNormals = normals.ToArray();
finalUvs= uvs.ToArray();
finalTriangles = resultsTriIndexesReversed.ToArray();
//results.Clear();
//resultsTriIndexesReversed.Clear();
}
//public bool ReverseNormals;
public GameObject Run(Transform transform,bool ReverseNormals )
{
PolygonCollider2D polygonCollider = transform.GetComponent<PolygonCollider2D>();
Sprite spr = transform.GetComponent<SpriteRenderer>().sprite;
Rect rec = spr.rect;
//for(int path =0;path<polygonCollider.pathCount;path++)
//{
int path =0;
bool overwrite = false;
MeshedSprite = new GameObject();
Undo.RegisterCreatedObjectUndo (MeshedSprite, "Created Mesh");
mf = MeshedSprite.AddComponent<MeshFilter>();
mr = MeshedSprite.AddComponent<MeshRenderer>();
mesh = new Mesh();
if(AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Models/"+transform.name+"_MESH.asset",typeof(Mesh)))
{
if(EditorUtility.DisplayDialog("Overwrite Asset?","Do you want to overwrite the current Mesh & Material?","Yes, Overwrite","No, Create New Mesh & Material"))
{
mesh = AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Models/"+transform.name+"_MESH.asset",typeof(Mesh))as Mesh;
overwrite = true;
}
else
{
string meshPath = AssetDatabase.GenerateUniqueAssetPath("Assets/Puppet2D/Models/"+transform.name+"_MESH.asset");
AssetDatabase.CreateAsset(mesh,meshPath);
}
}
else
{
string meshPath = AssetDatabase.GenerateUniqueAssetPath("Assets/Puppet2D/Models/"+transform.name+"_MESH.asset");
AssetDatabase.CreateAsset(mesh,meshPath);
}
Vector3 bound = transform.renderer.bounds.max- transform.renderer.bounds.min ;
List<Vector3> results = new List<Vector3>();
List<int> resultsTriIndexes = new List<int>();
List<int> resultsTriIndexesReversed = new List<int>();
List<Vector2> uvs = new List<Vector2>();
List<Vector3> normals = new List<Vector3>();
Vector2[] vertsToCopy = polygonCollider.GetPath(path);
int i = 0;
Polygon poly = new Polygon();
for (i=0; i <vertsToCopy.Length;i++)
{
poly.Points.Add(new TriangulationPoint(vertsToCopy[i].x, vertsToCopy[i].y));
}
DTSweepContext tcx = new DTSweepContext();
tcx.PrepareTriangulation(poly);
DTSweep.Triangulate(tcx);
int indexNumber = 0;
foreach (DelaunayTriangle triangle in poly.Triangles)
{
Vector3 v = new Vector3();
foreach (TriangulationPoint p in triangle.Points)
{
v = new Vector3((float)p.X, (float)p.Y,0);
if(!results.Contains(v))
{
results.Add(v);
resultsTriIndexes.Add(indexNumber);
Vector2 newUv = new Vector2((v.x /bound.x) + 0.5f, (v.y /bound.y) + 0.5f);
newUv.x *= rec.width/ spr.texture.width;
newUv.y *= rec.height/ spr.texture.height;
//Debug.Log(spr.textureRectOffset);
newUv.x += (rec.x)/ spr.texture.width;
newUv.y += (rec.y) / spr.texture.height;
uvs.Add(newUv);
normals.Add(new Vector3(0,0,-1));
indexNumber++;
}
else
{
resultsTriIndexes.Add(results.LastIndexOf(v));
}
}
}
for (int j = resultsTriIndexes.Count-1; j >=0; j--)
{
resultsTriIndexesReversed.Add(resultsTriIndexes[j]);
}
mf.mesh = mesh;
mesh.vertices = results.ToArray();
mesh.uv = uvs.ToArray();
mesh.normals = normals.ToArray();
mesh.triangles = resultsTriIndexesReversed.ToArray();
mesh.RecalculateBounds();
results.Clear();
resultsTriIndexesReversed.Clear();
//}
if(overwrite)
{
mr.material = AssetDatabase.LoadAssetAtPath("Assets/Puppet2D/Models/Materials/"+transform.name+"_MAT.mat",typeof(Material)) as Material;
}
else
{
Material newMat = new Material(Shader.Find("Unlit/Transparent"));
string materialPath = AssetDatabase.GenerateUniqueAssetPath("Assets/Puppet2D/Models/Materials/"+transform.name+"_MAT.mat");
AssetDatabase.CreateAsset(newMat, materialPath);
mr.material = newMat;
}
return MeshedSprite;
}
private static void FlipEdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle t, TriangulationPoint p)
{
DelaunayTriangle ot = t.NeighborAcrossFrom(p);
TriangulationPoint op = ot.OppositePoint(t, p);
if (ot == null)
{
// If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here
throw new InvalidOperationException("[BUG:FIXME] FLIP failed due to missing triangle");
}
if (tcx.IsDebugEnabled)
{
tcx.DebugContext.PrimaryTriangle = t;
tcx.DebugContext.SecondaryTriangle = ot;
} // TODO: remove
bool inScanArea = TriangulationUtil.InScanArea(p, t.PointCCWFrom(p), t.PointCWFrom(p), op);
if (inScanArea)
{
// Lets rotate shared edge one vertex CW
RotateTrianglePair(t, p, ot, op);
tcx.MapTriangleToNodes(t);
tcx.MapTriangleToNodes(ot);
if (p.Equals(eq) && op.Equals(ep))
{
if (eq.Equals(tcx.EdgeEvent.ConstrainedEdge.Q) && ep.Equals(tcx.EdgeEvent.ConstrainedEdge.P))
{
if (tcx.IsDebugEnabled)
{
Console.WriteLine("[FLIP] - constrained edge done"); // TODO: remove
}
t.MarkConstrainedEdge(ep, eq);
ot.MarkConstrainedEdge(ep, eq);
Legalize(tcx, t);
Legalize(tcx, ot);
}
else
{
if (tcx.IsDebugEnabled)
{
Console.WriteLine("[FLIP] - subedge done"); // TODO: remove
}
// XXX: I think one of the triangles should be legalized here?
}
}
else
{
if (tcx.IsDebugEnabled)
{
Console.WriteLine("[FLIP] - flipping and continuing with triangle still crossing edge"); // TODO: remove
}
Orientation o = TriangulationUtil.Orient2d(eq, op, ep);
t = NextFlipTriangle(tcx, o, t, ot, p, op);
FlipEdgeEvent(tcx, ep, eq, t, p);
}
}
else
{
TriangulationPoint newP;
if (NextFlipPoint(ep, eq, ot, op, out newP))
{
FlipScanEdgeEvent(tcx, ep, eq, t, ot, newP);
EdgeEvent(tcx, ep, eq, t, p);
}
}
}
private static void EdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq, DelaunayTriangle triangle, TriangulationPoint point)
{
if (tcx.IsDebugEnabled)
{
tcx.DebugContext.PrimaryTriangle = triangle;
}
if (IsEdgeSideOfTriangle(triangle, ep, eq))
{
return;
}
TriangulationPoint p1 = triangle.PointCCWFrom(point);
Orientation o1 = TriangulationUtil.Orient2d(eq, p1, ep);
if (o1 == Orientation.Collinear)
{
if (triangle.Contains(eq) && triangle.Contains(p1))
{
triangle.MarkConstrainedEdge(eq, p1);
// We are modifying the constraint maybe it would be better to
// not change the given constraint and just keep a variable for the new constraint
tcx.EdgeEvent.ConstrainedEdge.Q = p1;
triangle = triangle.NeighborAcrossFrom(point);
EdgeEvent(tcx, ep, p1, triangle, p1);
}
else
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet", ep, eq, p1);
}
if (tcx.IsDebugEnabled)
{
Console.WriteLine("EdgeEvent - Point on constrained edge");
}
return;
}
TriangulationPoint p2 = triangle.PointCWFrom(point);
Orientation o2 = TriangulationUtil.Orient2d(eq, p2, ep);
if (o2 == Orientation.Collinear)
{
if (triangle.Contains(eq) && triangle.Contains(p2))
{
triangle.MarkConstrainedEdge(eq, p2);
// We are modifying the constraint maybe it would be better to
// not change the given constraint and just keep a variable for the new constraint
tcx.EdgeEvent.ConstrainedEdge.Q = p2;
triangle = triangle.NeighborAcrossFrom(point);
EdgeEvent(tcx, ep, p2, triangle, p2);
}
else
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet", ep, eq, p2);
}
if (tcx.IsDebugEnabled)
{
Console.WriteLine("EdgeEvent - Point on constrained edge");
}
return;
}
if (o1 == o2)
{
// Need to decide if we are rotating CW or CCW to get to a triangle
// that will cross edge
triangle = o1 == Orientation.Clockwise ? triangle.NeighborCCWFrom(point) : triangle.NeighborCWFrom(point);
EdgeEvent(tcx, ep, eq, triangle, point);
}
else
{
// This triangle crosses constraint so lets flippin start!
FlipEdgeEvent(tcx, ep, eq, triangle, point);
}
}
/// <summary>
/// If this is a Delaunay Triangulation of a pointset we need to fill so the triangle mesh gets a ConvexHull
/// </summary>
private static void FinalizationConvexHull(DTSweepContext tcx)
{
DelaunayTriangle t1, t2;
AdvancingFrontNode n1 = tcx.Front.Head.Next;
AdvancingFrontNode n2 = n1.Next;
TurnAdvancingFrontConvex(tcx, n1, n2);
// Lets remove triangles connected to the two "algorithm" points
// XXX: When the first three nodes are points in a triangle we need to do a flip before
// removing triangles or we will lose a valid triangle.
// Same for last three nodes!
// !!! If I implement ConvexHull for lower right and left boundary this fix should not be
// needed and the removed triangles will be added again by default
n1 = tcx.Front.Tail.Prev;
if (n1.Triangle.Contains(n1.Next.Point) && n1.Triangle.Contains(n1.Prev.Point))
{
t1 = n1.Triangle.NeighborAcrossFrom(n1.Point);
RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point));
tcx.MapTriangleToNodes(n1.Triangle);
tcx.MapTriangleToNodes(t1);
}
n1 = tcx.Front.Head.Next;
if (n1.Triangle.Contains(n1.Prev.Point) && n1.Triangle.Contains(n1.Next.Point))
{
t1 = n1.Triangle.NeighborAcrossFrom(n1.Point);
RotateTrianglePair(n1.Triangle, n1.Point, t1, t1.OppositePoint(n1.Triangle, n1.Point));
tcx.MapTriangleToNodes(n1.Triangle);
tcx.MapTriangleToNodes(t1);
}
// Lower right boundary
TriangulationPoint first = tcx.Front.Head.Point;
n2 = tcx.Front.Tail.Prev;
t1 = n2.Triangle;
TriangulationPoint p1 = n2.Point;
n2.Triangle = null;
do
{
tcx.RemoveFromList(t1);
p1 = t1.PointCCWFrom(p1);
if (p1.Equals(first))
{
break;
}
t2 = t1.NeighborCCWFrom(p1);
t1.Clear();
t1 = t2;
} while (true);
// Lower left boundary
first = tcx.Front.Head.Next.Point;
p1 = t1.PointCWFrom(tcx.Front.Head.Point);
t2 = t1.NeighborCWFrom(tcx.Front.Head.Point);
t1.Clear();
t1 = t2;
while (p1.Equals(first))
{
tcx.RemoveFromList(t1);
p1 = t1.PointCCWFrom(p1);
t2 = t1.NeighborCCWFrom(p1);
t1.Clear();
t1 = t2;
}
// Remove current head and tail node now that we have removed all triangles attached
// to them. Then set new head and tail node points
tcx.Front.Head = tcx.Front.Head.Next;
tcx.Front.Head.Prev = null;
tcx.Front.Tail = tcx.Front.Tail.Prev;
tcx.Front.Tail.Next = null;
}
private static void FillLeftBelowEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
if (node.Point.X > edge.P.X)
{
if (TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point) == Orientation.CW)
{
// Concave
FillLeftConcaveEdgeEvent(tcx, edge, node);
}
else
{
// Convex
FillLeftConvexEdgeEvent(tcx, edge, node);
// Retry this one
FillLeftBelowEdgeEvent(tcx, edge, node);
}
}
}
/// <summary>
/// We will traverse the entire advancing front and fill it to form a convex hull.
/// </summary>
private static void TurnAdvancingFrontConvex(DTSweepContext tcx, AdvancingFrontNode b, AdvancingFrontNode c)
{
AdvancingFrontNode first = b;
while (c != tcx.aFront.Tail)
{
if (TriangulationUtil.Orient2d(b.Point, c.Point, c.Next.Point) == Orientation.CCW)
{
// [b,c,d] Concave - fill around c
Fill(tcx, c);
c = c.Next;
}
else
{
// [b,c,d] Convex
if (b != first && TriangulationUtil.Orient2d(b.Prev.Point, b.Point, c.Point) == Orientation.CCW)
{
// [a,b,c] Concave - fill around b
Fill(tcx, b);
b = b.Prev;
}
else
{
// [a,b,c] Convex - nothing to fill
b = c;
c = c.Next;
}
}
}
}
private static void EdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq,
DelaunayTriangle triangle, TriangulationPoint point)
{
TriangulationPoint p1, p2;
if (IsEdgeSideOfTriangle(triangle, ep, eq))
{
return;
}
p1 = triangle.PointCCW(point);
Orientation o1 = TriangulationUtil.Orient2d(eq, p1, ep);
if (o1 == Orientation.Collinear)
{
if (triangle.Contains(eq, p1))
{
triangle.MarkConstrainedEdge(eq, p1);
// We are modifying the constraint maybe it would be better to
// not change the given constraint and just keep a variable for the new constraint
tcx.EdgeEvent.ConstrainedEdge.Q = p1;
triangle = triangle.NeighborAcross(point);
EdgeEvent(tcx, ep, p1, triangle, p1);
}
else
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet");
}
if (tcx.IsDebugEnabled)
{
Debug.WriteLine("EdgeEvent - Point on constrained edge");
}
return;
}
p2 = triangle.PointCW(point);
Orientation o2 = TriangulationUtil.Orient2d(eq, p2, ep);
if (o2 == Orientation.Collinear)
{
if (triangle.Contains(eq, p2))
{
triangle.MarkConstrainedEdge(eq, p2);
// We are modifying the constraint maybe it would be better to
// not change the given constraint and just keep a variable for the new constraint
tcx.EdgeEvent.ConstrainedEdge.Q = p2;
triangle = triangle.NeighborAcross(point);
EdgeEvent(tcx, ep, p2, triangle, p2);
}
else
{
throw new PointOnEdgeException("EdgeEvent - Point on constrained edge not supported yet");
}
if (tcx.IsDebugEnabled)
{
Debug.WriteLine("EdgeEvent - Point on constrained edge");
}
return;
}
if (o1 == o2)
{
// Need to decide if we are rotating CW or CCW to get to a triangle
// that will cross edge
if (o1 == Orientation.CW)
{
triangle = triangle.NeighborCCW(point);
}
else
{
triangle = triangle.NeighborCW(point);
}
EdgeEvent(tcx, ep, eq, triangle, point);
}
else
{
// This triangle crosses constraint so lets flippin start!
FlipEdgeEvent(tcx, ep, eq, triangle, point);
}
}
private static void FinalizationPolygon(DTSweepContext tcx)
{
// Get an Internal triangle to start with
DelaunayTriangle t = tcx.aFront.Head.Next.Triangle;
TriangulationPoint p = tcx.aFront.Head.Next.Point;
while (!t.GetConstrainedEdgeCW(p))
{
t = t.NeighborCCW(p);
}
// Collect interior triangles constrained by edges
tcx.MeshClean(t);
}
/// <summary>
/// Find closes node to the left of the new point and
/// create a new triangle. If needed new holes and basins
/// will be filled to.
/// </summary>
private static AdvancingFrontNode PointEvent(DTSweepContext tcx, TriangulationPoint point)
{
AdvancingFrontNode node, newNode;
node = tcx.LocateNode(point);
newNode = NewFrontTriangle(tcx, point, node);
// Only need to check +epsilon since point never have smaller
// x value than node due to how we fetch nodes from the front
if (point.X <= node.Point.X + TriangulationUtil.EPSILON)
{
Fill(tcx, node);
}
tcx.AddNode(newNode);
FillAdvancingFront(tcx, newNode);
return newNode;
}
/// <summary>
/// Creates a new front triangle and legalize it
/// </summary>
private static AdvancingFrontNode NewFrontTriangle(DTSweepContext tcx, TriangulationPoint point,
AdvancingFrontNode node)
{
AdvancingFrontNode newNode;
DelaunayTriangle triangle;
triangle = new DelaunayTriangle(point, node.Point, node.Next.Point);
triangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(triangle);
newNode = new AdvancingFrontNode(point);
newNode.Next = node.Next;
newNode.Prev = node;
node.Next.Prev = newNode;
node.Next = newNode;
tcx.AddNode(newNode); // XXX: BST
if (!Legalize(tcx, triangle))
{
tcx.MapTriangleToNodes(triangle);
}
return newNode;
}
/// <summary>
/// Scan part of the FlipScan algorithm<br>
/// When a triangle pair isn't flippable we will scan for the next
/// point that is inside the flip triangle scan area. When found
/// we generate a new flipEdgeEvent
/// </summary>
/// <param name="tcx"></param>
/// <param name="ep">last point on the edge we are traversing</param>
/// <param name="eq">first point on the edge we are traversing</param>
/// <param name="flipTriangle">the current triangle sharing the point eq with edge</param>
/// <param name="t"></param>
/// <param name="p"></param>
private static void FlipScanEdgeEvent(DTSweepContext tcx, TriangulationPoint ep, TriangulationPoint eq,
DelaunayTriangle flipTriangle, DelaunayTriangle t, TriangulationPoint p)
{
DelaunayTriangle ot;
TriangulationPoint op, newP;
bool inScanArea;
ot = t.NeighborAcross(p);
op = ot.OppositePoint(t, p);
if (ot == null)
{
// If we want to integrate the fillEdgeEvent do it here
// With current implementation we should never get here
throw new Exception("[BUG:FIXME] FLIP failed due to missing triangle");
}
inScanArea = TriangulationUtil.InScanArea(eq, flipTriangle.PointCCW(eq), flipTriangle.PointCW(eq), op);
if (inScanArea)
{
// flip with new edge op->eq
FlipEdgeEvent(tcx, eq, op, ot, op);
// TODO: Actually I just figured out that it should be possible to
// improve this by getting the next ot and op before the the above
// flip and continue the flipScanEdgeEvent here
// set new ot and op here and loop back to inScanArea test
// also need to set a new flipTriangle first
// Turns out at first glance that this is somewhat complicated
// so it will have to wait.
}
else
{
newP = NextFlipPoint(ep, eq, ot, op);
FlipScanEdgeEvent(tcx, ep, eq, flipTriangle, ot, newP);
}
}
private static void EdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
try
{
tcx.EdgeEvent.ConstrainedEdge = edge;
tcx.EdgeEvent.Right = edge.P.X > edge.Q.X;
if (IsEdgeSideOfTriangle(node.Triangle, edge.P, edge.Q))
{
return;
}
// For now we will do all needed filling
// TODO: integrate with flip process might give some better performance
// but for now this avoid the issue with cases that needs both flips and fills
FillEdgeEvent(tcx, edge, node);
EdgeEvent(tcx, edge.P, edge.Q, node.Triangle, edge.Q);
}
catch (PointOnEdgeException e)
{
Debug.WriteLine(String.Format("Skipping Edge: {0}", e.Message));
}
}
/// <summary>
/// Fills a basin that has formed on the Advancing Front to the right
/// of given node.<br>
/// First we decide a left,bottom and right node that forms the
/// boundaries of the basin. Then we do a reqursive fill.
/// </summary>
/// <param name="tcx"></param>
/// <param name="node">starting node, this or next node will be left node</param>
private static void FillBasin(DTSweepContext tcx, AdvancingFrontNode node)
{
if (TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point) == Orientation.CCW)
{
// tcx.basin.leftNode = node.next.next;
tcx.Basin.leftNode = node;
}
else
{
tcx.Basin.leftNode = node.Next;
}
// Find the bottom and right node
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;
}
if (tcx.Basin.bottomNode == tcx.Basin.leftNode)
{
// No valid basins
return;
}
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;
}
if (tcx.Basin.rightNode == tcx.Basin.bottomNode)
{
// No valid basins
return;
}
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;
FillBasinReq(tcx, tcx.Basin.bottomNode);
}
private static void FillEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
if (tcx.EdgeEvent.Right)
{
FillRightAboveEdgeEvent(tcx, edge, node);
}
else
{
FillLeftAboveEdgeEvent(tcx, edge, node);
}
}
/// <summary>
/// Recursive algorithm to fill a Basin with triangles
/// </summary>
private static void FillBasinReq(DTSweepContext tcx, AdvancingFrontNode node)
{
// if shallow stop filling
if (IsShallow(tcx, node))
{
return;
}
Fill(tcx, node);
if (node.Prev == tcx.Basin.leftNode && node.Next == tcx.Basin.rightNode)
{
return;
}
else if (node.Prev == tcx.Basin.leftNode)
{
Orientation o = TriangulationUtil.Orient2d(node.Point, node.Next.Point, node.Next.Next.Point);
if (o == Orientation.CW)
{
return;
}
node = node.Next;
}
else if (node.Next == tcx.Basin.rightNode)
{
Orientation o = TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point);
if (o == Orientation.CCW)
{
return;
}
node = node.Prev;
}
else
{
// Continue with the neighbor node with lowest Y value
if (node.Prev.Point.Y < node.Next.Point.Y)
{
node = node.Prev;
}
else
{
node = node.Next;
}
}
FillBasinReq(tcx, node);
}
private static void FillRightConvexEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
// Next concave or convex?
if (TriangulationUtil.Orient2d(node.Next.Point, node.Next.Next.Point, node.Next.Next.Next.Point) ==
Orientation.CCW)
{
// Concave
FillRightConcaveEdgeEvent(tcx, edge, node.Next);
}
else
{
// Convex
// Next above or below edge?
if (TriangulationUtil.Orient2d(edge.Q, node.Next.Next.Point, edge.P) == Orientation.CCW)
{
// Below
FillRightConvexEdgeEvent(tcx, edge, node.Next);
}
else
{
// Above
}
}
}
/// <summary>
/// Adds a triangle to the advancing front to fill a hole.
/// </summary>
/// <param name="tcx"></param>
/// <param name="node">middle node, that is the bottom of the hole</param>
private static void Fill(DTSweepContext tcx, AdvancingFrontNode node)
{
DelaunayTriangle triangle = new DelaunayTriangle(node.Prev.Point, node.Point, node.Next.Point);
// TODO: should copy the cEdge value from neighbor triangles
// for now cEdge values are copied during the legalize
triangle.MarkNeighbor(node.Prev.Triangle);
triangle.MarkNeighbor(node.Triangle);
tcx.Triangles.Add(triangle);
// Update the advancing front
node.Prev.Next = node.Next;
node.Next.Prev = node.Prev;
tcx.RemoveNode(node);
// If it was legalized the triangle has already been mapped
if (!Legalize(tcx, triangle))
{
tcx.MapTriangleToNodes(triangle);
}
}
private static void FillLeftConcaveEdgeEvent(DTSweepContext tcx, DTSweepConstraint edge, AdvancingFrontNode node)
{
Fill(tcx, node.Prev);
if (node.Prev.Point != edge.P)
{
// Next above or below edge?
if (TriangulationUtil.Orient2d(edge.Q, node.Prev.Point, edge.P) == Orientation.CW)
{
// Below
if (TriangulationUtil.Orient2d(node.Point, node.Prev.Point, node.Prev.Prev.Point) == Orientation.CW)
{
// Next is concave
FillLeftConcaveEdgeEvent(tcx, edge, node);
}
else
{
// Next is convex
}
}
}
}
public static List<Vertices> ConvexPartition(DetectedVertices vertices)
{
Polygon poly = new Polygon();
foreach (var vertex in vertices)
poly.Points.Add(new TriangulationPoint(vertex.X, vertex.Y));
if (vertices.Holes != null)
{
foreach (var holeVertices in vertices.Holes)
{
Polygon hole = new Polygon();
foreach (var 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 FVector2((float)p.X, (float)p.Y));
}
results.Add(v);
}
return results;
}
/// <summary>
/// Returns true if triangle was legalized
/// </summary>
private static bool Legalize(DTSweepContext tcx, DelaunayTriangle 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++)
{
// TODO: fix so that cEdge is always valid when creating new triangles then we can check it here
// instead of below with ot
if (t.EdgeIsDelaunay[i])
{
continue;
}
DelaunayTriangle ot = t.Neighbors[i];
if (ot == null)
{
continue;
}
TriangulationPoint p = t.Points[i];
TriangulationPoint op = ot.OppositePoint(t, p);
int oi = ot.IndexOf(op);
// If this is a Constrained Edge or a Delaunay Edge(only during recursive legalization)
// then we should not try to legalize
if (ot.EdgeIsConstrained[oi] || ot.EdgeIsDelaunay[oi])
{
t.SetConstrainedEdgeAcross(p, ot.EdgeIsConstrained[oi]); // XXX: have no good way of setting this property when creating new triangles so lets set it here
continue;
}
if (!TriangulationUtil.SmartIncircle(p, t.PointCCWFrom(p), t.PointCWFrom(p), op))
{
continue;
}
// Lets mark this shared edge as Delaunay
t.EdgeIsDelaunay[i] = true;
ot.EdgeIsDelaunay[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
if (!Legalize(tcx, t))
{
tcx.MapTriangleToNodes(t);
}
if (!Legalize(tcx, ot))
{
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.EdgeIsDelaunay[i] = false;
ot.EdgeIsDelaunay[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);
}
public static List<Vertices> ConvexPartition(Vertices vertices)
{
Polygon poly = new Polygon();
foreach (FVector2 vertex in vertices)
{
poly.Points.Add(new TriangulationPoint(vertex.X, vertex.Y));
}
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 FVector2((float)p.X, (float)p.Y));
}
results.Add(v);
}
return results;
}