Question

我目前正在寻找一种好的算法来找到2D坐标中的分隔线。

以下是我所拥有的内容：

lines

所以这里的算法应该返回我有3个不同的分隔线，我希望以后能够在执行期间知道一个点属于哪一行。

有没有人有想法解决这个问题？

注意：区域和线条在内存中由布尔值的2D数组表示。颜色是数据的一部分。

Answer 1

你需要的东西似乎是图形的连通分量，其中每个单元格是一个顶点，如果它们共享一个边，则连接顶点。有几种算法可用于查找连接的组件，最值得注意的是广度优先搜索和深度优先搜索。

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

Answer 2

以下是我提出的一个示例:(使用Swift 2 Xcode 7 beta 2在Playground中测试）

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
}

编辑：在评论// crawlers "eat" area and remove some of themselves下进行了更改，这使得算法在大区域内更有效

在2D坐标系中查找分隔的线

2 个答案: