/// <summary>
/// Combine a list of triangles into a list of convex polygons.
/// Note: This only works on triangles.
/// </summary>
/// <param name="triangles">The triangles.</param>
/// <param name="maxPolys">The maximun number of polygons to return.</param>
/// <param name="tolerance">The tolerance</param>
public static List <Vertices> PolygonizeTriangles(List <Vertices> triangles, int maxPolys = int.MaxValue,
float tolerance = 0.001f)
{
if (triangles.Count <= 0)
{
return(triangles);
}
var polys = new List <Vertices>();
var covered = new bool[triangles.Count];
for (var i = 0; i < triangles.Count; ++i)
{
covered[i] = false;
//Check here for degenerate triangles
var triangle = triangles[i];
var a = triangle[0];
var b = triangle[1];
var c = triangle[2];
if (a.x == b.x && a.y == b.y || b.x == c.x && b.y == c.y || a.x == c.x && a.y == c.y)
{
covered[i] = true;
}
}
var polyIndex = 0;
var notDone = true;
while (notDone)
{
var currTri = -1;
for (var i = 0; i < triangles.Count; ++i)
{
if (covered[i])
{
continue;
}
currTri = i;
break;
}
if (currTri == -1)
{
notDone = false;
}
else
{
var poly = new Vertices(3);
for (var i = 0; i < 3; i++)
{
poly.Add(triangles[currTri][i]);
}
covered[currTri] = true;
var index = 0;
for (var i = 0; i < 2 * triangles.Count; ++i, ++index)
{
while (index >= triangles.Count)
{
index -= triangles.Count;
}
if (covered[index])
{
continue;
}
var newP = AddTriangle(triangles[index], poly);
if (newP == null)
{
continue; // is this right
}
if (newP.Count > Settings.MaxPolygonVertices)
{
continue;
}
if (newP.IsConvex())
{
//Or should it be IsUsable? Maybe re-write IsConvex to apply the angle threshold from Box2d
poly = new Vertices(newP);
covered[index] = true;
}
}
//We have a maximum of polygons that we need to keep under.
if (polyIndex < maxPolys)
{
SimplifyTools.MergeParallelEdges(poly, tolerance);
//If identical points are present, a triangle gets
//borked by the MergeParallelEdges function, hence
//the vertex number check
if (poly.Count >= 3)
{
polys.Add(new Vertices(poly));
}
else
{
Debug.Log("Skipping corrupt poly.");
}
}
if (poly.Count >= 3)
{
polyIndex++; //Must be outside (polyIndex < polysLength) test
}
}
}
//TODO: Add sanity check
//Remove empty vertice collections
for (var i = polys.Count - 1; i >= 0; i--)
{
if (polys[i].Count == 0)
{
polys.RemoveAt(i);
}
}
return(polys);
}
/// <summary>
/// Implements "A new algorithm for Boolean operations on general polygons"
/// available here: http://liama.ia.ac.cn/wiki/_media/user:dong:dong_cg_05.pdf
/// Merges two polygons, a subject and a clip with the specified operation. Polygons may not be
/// self-intersecting.
/// Warning: May yield incorrect results or even crash if polygons contain collinear points.
/// </summary>
/// <param name="subject">The subject polygon.</param>
/// <param name="clip">
/// The clip polygon, which is added,
/// substracted or intersected with the subject
/// </param>
/// <param name="clipType">
/// The operation to be performed. Either
/// Union, Difference or Intersection.
/// </param>
/// <param name="error">The error generated (if any)</param>
/// <returns>
/// A list of closed polygons, which make up the result of the clipping operation.
/// Outer contours are ordered counter clockwise, holes are ordered clockwise.
/// </returns>
private static List <Vertices> Execute(Vertices subject, Vertices clip, PolyClipType clipType, out PolyClipError error)
{
Debug.Assert(subject.IsSimple() && clip.IsSimple(), "Non simple input!", "Input polygons must be simple (cannot intersect themselves).");
// Copy polygons
Vertices slicedSubject;
Vertices slicedClip;
// Calculate the intersection and touch points between
// subject and clip and add them to both
CalculateIntersections(subject, clip, out slicedSubject, out slicedClip);
// Translate polygons into upper right quadrant
// as the algorithm depends on it
Vector2 lbSubject = subject.GetAABB().LowerBound;
Vector2 lbClip = clip.GetAABB().LowerBound;
Vector2 translate;
Vector2.Min(ref lbSubject, ref lbClip, out translate);
translate = Vector2.One - translate;
if (translate != Vector2.Zero)
{
slicedSubject.Translate(ref translate);
slicedClip.Translate(ref translate);
}
// Enforce counterclockwise contours
slicedSubject.ForceCounterClockWise();
slicedClip.ForceCounterClockWise();
List <Edge> subjectSimplices;
List <float> subjectCoeff;
List <Edge> clipSimplices;
List <float> clipCoeff;
// Build simplical chains from the polygons and calculate the
// the corresponding coefficients
CalculateSimplicalChain(slicedSubject, out subjectCoeff, out subjectSimplices);
CalculateSimplicalChain(slicedClip, out clipCoeff, out clipSimplices);
List <Edge> resultSimplices;
// Determine the characteristics function for all non-original edges
// in subject and clip simplical chain and combine the edges contributing
// to the result, depending on the clipType
CalculateResultChain(subjectCoeff, subjectSimplices, clipCoeff, clipSimplices, clipType,
out resultSimplices);
List <Vertices> result;
// Convert result chain back to polygon(s)
error = BuildPolygonsFromChain(resultSimplices, out result);
// Reverse the polygon translation from the beginning
// and remove collinear points from output
translate *= -1f;
for (int i = 0; i < result.Count; ++i)
{
result[i].Translate(ref translate);
SimplifyTools.CollinearSimplify(result[i]);
}
return(result);
}