C# 在二维坐标系中查找分隔线

我目前正在寻找一个很好的算法来寻找二维坐标中的分离线

以下是我所拥有的内容：

因此，这里的算法应该返回，我有3条不同的分离线，我希望能够在执行过程中知道一个点属于哪条线

有人有办法解决这个问题吗

---

注意：区域和线在内存中由一个二维布尔数组表示。颜色是数据的一部分。

您需要的似乎是图形的连接组件，其中每个单元格都是一个顶点，如果顶点共享一条边，则顶点是连接的。有几种算法可用于查找连接的组件，最显著的是广度优先搜索和深度优先搜索

---

这些算法中的每一个都可以返回组件的数量（“线”），还允许为每个单元分配其所属组件的数量。

您需要的似乎是图形的连接组件，其中每个单元是一个顶点，如果它们共享一条边，则顶点是连接的。有几种算法可用于查找连接的组件，最显著的是广度优先搜索和深度优先搜索

---

这些算法中的每一个都可以返回组件的数量（“线”），还允许为每个单元分配其所属组件的数量。

您需要的似乎是图形的连接组件，其中每个单元是一个顶点，如果它们共享一条边，则顶点是连接的。有几种算法可用于查找连接的组件，最显著的是广度优先搜索和深度优先搜索

---

这些算法中的每一个都可以返回组件的数量（“线”），还允许为每个单元分配其所属组件的数量。

您需要的似乎是图形的连接组件，其中每个单元是一个顶点，如果它们共享一条边，则顶点是连接的。有几种算法可用于查找连接的组件，最显著的是广度优先搜索和深度优先搜索

---

这些算法中的每一个都可以返回组件的数量（“行”），还允许为每个单元分配它所属的组件的数量。

下面是我举的一个例子：（在操场上使用Swift 2 Xcode 7 beta 2进行测试）

结构点{
变量x，y:Int
init（x:Int，y:Int）{
self.x=x
self.y=y
}
/**
获取围绕它的点（X围绕P）
如果有的话{
XXX
XPX
XXX
}否则{
氧代
XPX
氧代
}
**/
func pointsAround（全部：Bool=true）->[点]{
如果有的话{
返回数组（-1…1）.flatMap{x in
（-1…1）.flatMap{y in
如果x==0&&y==0{
归零
}
返回点（self.x+x，self.y+y）
}
}
}
返回数组（-1…1）.flatMap{x in
（-1…1）.flatMap{y in
如果abs（x）==abs（y）{
归零
}
返回点（self.x+x，self.y+y）
}
}
}
}
函数区域（变量数组：[[Bool]]）->[[Point]]{
//结果
变量点=[[Point]]（）
让宽度=array.count
让高度=数组[0]。计数
//返回数组[x][y]，但带有savety检查（否则为false）
func getBool（x:Int，y:Int）->Bool{
guard 0.我举了一个例子：（在操场上用Swift 2 Xcode 7 beta 2测试）

结构点{
变量x，y:Int
init（x:Int，y:Int）{
self.x=x
self.y=y
}
/**
获取围绕它的点（X围绕P）
如果有的话{
XXX
XPX
XXX
}否则{
氧代
XPX
氧代
}
**/
func pointsAround（全部：Bool=true）->[点]{
如果有的话{
返回数组（-1…1）.flatMap{x in
（-1…1）.flatMap{y in
如果x==0&&y==0{
归零
}
返回点（self.x+x，self.y+y）
}
}
}
返回数组（-1…1）.flatMap{x in
（-1…1）.flatMap{y in
如果abs（x）==abs（y）{
归零
}
返回点（self.x+x，self.y+y）
}
}
}
}
函数区域（变量数组：[[Bool]]）->[[Point]]{
//结果
变量点=[[Point]]（）
让宽度=array.count
让高度=数组[0]。计数
//返回数组[x][y]，但带有savety检查（否则为false）
func getBool（x:Int，y:Int）->Bool{
guard 0.我举了一个例子：（在操场上用Swift 2 Xcode 7 beta 2测试）

结构点{
变量x，y:Int
init（x:Int，y:Int）{
self.x=x
self.y=y
}
/**
获取围绕它的点（X围绕P）
如果有的话{
XXX
XPX
XXX
}否则{
氧代
XPX
氧代
}
**/
func pointsAround（全部：Bool=true）->[点]{
如果有的话{
返回数组（-1…1）.flatMap{x in
（-1…1）.flatMap{y in
如果x==0&&y==0{
归零
}
返回点（self.x+x，self.y+y）
}
}
}
返回数组（-1…1）.flatMap{x in
（-1…1）.flatMap{y in
如果abs（x）==abs（y）{
归零
}
返回点（self.x+x，self.y+y）
}
}
}
}
函数区域（变量数组：[[Bool]]）->[[Point]]{
//结果
变量点=[[Point]]（）
让宽度=array.count
让高度=数组[0]。计数
//返回数组[x][y]，但带有savety检查（否则为fal
struct Point{
    var x, y: Int

    init(_ x: Int, _ y: Int) {
        self.x = x
        self.y = y
    }

    /**
    get points around it (Xs around P)
    if all {
        XXX
        XPX
        XXX
    } else {
        OXO
        XPX
        OXO
    }
    **/
    func pointsAround(all all: Bool = true) -> [Point] {
        if all {
            return Array(-1...1).flatMap{ x in
                (-1...1).flatMap{ y in
                    if x == 0 && y == 0 {
                        return nil
                    }
                    return Point(self.x + x, self.y + y)
                }
            }
        }
        return Array(-1...1).flatMap{ x in
            (-1...1).flatMap{ y in
                if abs(x) == abs(y) {
                    return nil
                }
                return Point(self.x + x, self.y + y)
            }
        }
    }
}

func distinguishAreas(var array: [[Bool]]) -> [[Point]] {
    // result
    var points = [[Point]]()

    let width = array.count
    let height = array[0].count
    // returns array[x][y] but with savety check (otherwise false)
    func getBool(x: Int, _ y: Int) -> Bool {
        guard 0..<width ~= x && 0..<height ~= y else { return false }
        return array[x][y]
    }

    // points where to check array
    var crawlers = [Point]()

    // loop through whole array
    for x in 0..<array.count {
        for y in 0..<array[0].count where array[x][y] {
            // if point (array[x][x]) is true

            // new point where to check
            crawlers = [Point(x, y)]

            // points to append (one area)
            var newPoints = [Point]()
            // loop as long as area is not "eaten" by crawlers
            while crawlers.count != 0 {

                // crawlers "eat" area and remove some of themselves
                crawlers = crawlers.filter{
                    let temp = array[$0.x][$0.y]
                    array[$0.x][$0.y] = false
                    return temp
                }

                newPoints += crawlers

                // make new crawlers around old crawlers and only where area is
                // passing false to p.pointsAround is mouch faster than true
                crawlers = crawlers.flatMap{ p in
                    p.pointsAround(all: false).filter{ getBool($0.x, $0.y) }
                }
            }
            points.append(newPoints)
        }
    }
    return points
}