按交叉点将任意多边形数量分组-C＃

Question

I have multiple lists of polygons that each represent an physical object. For example:

List<CurveLoop> A could represent a rectangle with a hole in it. One curve within this list would be the outline of the rectangle, and another curve would be the hole.

I want a method that will return a list of lists, where each list contains all the objects that intersect.

I already have a method that will return whether two of the objects intersect:

bool _CurveLoopsIntersect(List<CurveLoop> curveLoopsA, List<CurveLoop> curveLoopsB) {...}

will return true if any any two curves within the two lists touch.

Below is the code I have so far, but it just gives me a single pass. I think I need multiple passes, so that if object A and B intersect, and B and C intersect, then they would form set { A, B, C }. I need an arbitrary number of passes though, and sometimes the objects won't intersect at all, or be part of different sets, such as {A, B, C} and {D, E} and {F}.

public List<CurveLoop> _MergeCurveLoops(List<List<CurveLoop>> elementCurveLoops, View view)
{
    // ...
    // Preprocessing

    var listOfLists = new List<List<CurveLoop>>();
    foreach (var elementCurveLoop in elementCurveLoops)
    {
        var newList = elementCurveLoops.FindAll(x => _CurveLoopsIntersect(x, elementCurveLoop));
        listOfLists.Add(newList);
    }
}


private bool _CurveLoopsIntersect(List<CurveLoop> curveLoopsA, List<CurveLoop> curveLoopsB)
{
    foreach (var curveLoopA in curveLoopsA)
    {
        foreach (var curveA in curveLoopA)
        {
             foreach (var curveLoopB in curveLoopsB)
             {
                 foreach (var curveB in curveLoopB)
                     {
                     var result = curveA.Intersect(curveB);

                     if (result == SetComparisonResult.Overlap ||
                         result == SetComparisonResult.Subset ||
                         result == SetComparisonResult.Superset ||
                         result == SetComparisonResult.Equal)
                     {
                         return true;
                     }
                 }
             }
         }
     }
     return false;
}

Answer 1

This can be implemented using some code like this psuedu

set = a,b,c, ...

While(set not empty) {
Create newSet 
Add set.first to new list
Remove set.first from set // this line isnt necessary if a curve doesnt intersect with self


For (i = 0 , i < newset.length , i++) 
 {        
      newSet.add(set.FindAll(x => _CurveLoopsIntersect(x, newSet[i]));
      set.removeRange(newSet);  // this line may have error that the first element doesnt exist in set
 }
 Add newSet to set of sets

}

Answer 2

Thanks, you put me in the right direction. You were right, using a Set was the right approach. I used a set in combination with a recursive function (similar to your while loop).

The code I wrote is below:

    static List<Polygon> _RecursiveMergePolygons(List<Polygon> polygons, View view)
    {
        HashSet<Polygon> initialSet = new HashSet<Polygon>(polygons);

        HashSet<Polygon> finalSet = new HashSet<Polygon>(polygons);

        foreach (var polygon in initialSet)
        {
            // Should always return at least 1 instance
            var polys = polygons.FindAll(x => _PolygonsIntersect(x, polygon));

            // if it's greater than 1, then merge them and restart the recursion, otherwise continue
            if (polys.Count > 1)
            {
                foreach (var poly in polys)
                {
                    finalSet.Remove(poly);
                }
                var mergedPolygon = new Polygon(polys, view);
                finalSet.Add(mergedPolygon);
                break;
            }
        }
        if (finalSet.Count == initialSet.Count)
        {
            return finalSet.ToList();
        }
        return _RecursiveMergePolygons(finalSet.ToList(), view);
    }