/// <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); }
/// <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); } List <Vertices> polys = new List <Vertices>(); bool[] covered = new bool[triangles.Count]; for (int i = 0; i < triangles.Count; ++i) { covered[i] = false; //Check here for degenerate triangles Vertices triangle = triangles[i]; Vector2 a = triangle[0]; Vector2 b = triangle[1]; Vector2 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; } } int polyIndex = 0; bool notDone = true; while (notDone) { int currTri = -1; for (int i = 0; i < triangles.Count; ++i) { if (covered[i]) { continue; } currTri = i; break; } if (currTri == -1) { notDone = false; } else { Vertices poly = new Vertices(3); for (int i = 0; i < 3; i++) { poly.Add(triangles[currTri][i]); } covered[currTri] = true; int index = 0; for (int i = 0; i < 2 * triangles.Count; ++i, ++index) { while (index >= triangles.Count) { index -= triangles.Count; } if (covered[index]) { continue; } Vertices 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.WriteLine("Skipping corrupt poly."); } } if (poly.Count >= 3) { polyIndex++; //Must be outside (polyIndex < polysLength) test } } } //TODO: Add sanity check //Remove empty vertice collections for (int i = polys.Count - 1; i >= 0; i--) { if (polys[i].Count == 0) { polys.RemoveAt(i); } } return(polys); }