从注解中，您找到了算法（摩尔Neighborhood Tracing）。下面是一个很好地解决您的问题的实现。我会评论一些你可能会考虑的改进。
首先，您需要将数据放入缓冲区，每个像素一个字节。你似乎知道如何做到这一点，所以我就不赘述了。0应该是“透明的”，非0应该是“填充的”。在文献中，这些通常是白色（0）背景上的黑色（1）行，因此我将使用这种命名。
我发现的最好的介绍（经常被引用）是乔治Ghuneim的Contour Tracing网站。非常有用的网站。我看到过一些MNT的实现会过度检查一些像素。我尝试遵循Abeer仔细描述的算法来避免这种情况。
我想对这段代码做更多的测试，但它可以处理您的情况。
首先，该算法在单元格网格上操作：

public struct Cell: Equatable {
    public var x: Int
    public var y: Int
}

public struct Grid: Equatable {
    public var width: Int
    public var height: Int
    public var values: [UInt8]

    public var columns: Range<Int> { 0..<width }
    public var rows: Range<Int> { 0..<height }

    // The pixels immediately outside the grid are white. 
    // Accessing beyond that is a runtime error.
    public subscript (p: Cell) -> Bool {
        if p.x == -1 || p.y == -1 || p.x == width || p.y == height { return false }
        else { return values[p.y * width + p.x] != 0 }
    }

    public init?(width: Int, height: Int, values: [UInt8]) {
        guard values.count == height * width else { return nil }
        self.height = height
        self.width = width
        self.values = values
    }
}

还有“方向”的概念。这有两种形式：从中心到8个相邻单元中的一个的方向，以及“回溯”方向，这是在搜索期间“进入”单元的方向

enum Direction: Equatable {
    case north, northEast, east, southEast, south, southWest, west, northWest
    
    mutating func rotateClockwise() {
        self = switch self {
        case .north: .northEast
        case .northEast: .east
        case .east: .southEast
        case .southEast: .south
        case .south: .southWest
        case .southWest: .west
        case .west: .northWest
        case .northWest: .north
        }
    }

    //
    // Given a direction from the center, this is the direction that box was entered from when
    // rotating clockwise.
    //
    // +---+---+---+
    // + ↓ + ← + ← +
    // +---+---+---+
    // + ↓ +   + ↑ +
    // +---+---+---+
    // + → + → + ↑ +
    // +---+---+---+
    func backtrackDirection() -> Direction {
        switch self {
        case .north: .west
        case .northEast: .west
        case .east: .north
        case .southEast: .north
        case .south: .east
        case .southWest: .east
        case .west: .south
        case .northWest: .south
        }
    }
}

细胞可以在给定的方向上前进：

extension Cell {
    func inDirection(_ direction: Direction) -> Cell {
        switch direction {
        case .north:     Cell(x: x,     y: y - 1)
        case .northEast: Cell(x: x + 1, y: y - 1)
        case .east:      Cell(x: x + 1, y: y    )
        case .southEast: Cell(x: x + 1, y: y + 1)
        case .south:     Cell(x: x    , y: y + 1)
        case .southWest: Cell(x: x - 1, y: y + 1)
        case .west:      Cell(x: x - 1, y: y    )
        case .northWest: Cell(x: x - 1, y: y - 1)
        }
    }
}

最后是摩尔Neighbor算法：

public struct BorderFinder {
    public init() {}

    // Returns the point and the direction of the previous point
    // Since this scans left-to-right, the previous point is always to the west
    // The grid includes x=-1, so it's ok if this is an edge.
    func startingPoint(for grid: Grid) -> (point: Cell, direction: Direction)? {
        for y in grid.rows {
            for x in grid.columns {
                let point = Cell(x: x, y: y)
                if grid[point] {
                    return (point, .west)
                }
            }
        }
        return nil
    }

    /// Finds the boundary of a blob within `grid`
    ///
    /// - Parameter grid: an Array of bytes representing a 2D grid of UInt8. Each cell is either zero (white) or non-zero (black).
    /// - Returns: An array of points defining the boundary. The boundary includes only black points.
    ///            If multiple "blobs" exist, it is not defined which will be returned.
    ///            If no blob is found, an empty array is returned
    public func findBorder(in grid: Grid) -> [Cell] {
        guard let start = startingPoint(for: grid) else { return [] }
        var (point, direction) = start
        var boundary: [Cell] = [point]

        var rotations = 0
        repeat {
            direction.rotateClockwise()
            let nextPoint = point.inDirection(direction)
            if grid[nextPoint] {
                boundary.append(nextPoint)
                point = nextPoint
                direction = direction.backtrackDirection()
                rotations = 0
            } else {
                rotations += 1
            }
        } while (point, direction) != start && rotations <= 7

        return boundary
    }
}

这将返回单元格列表。它可以转换为CGPath，如下所示：

let data = ... Bitmap data with background as 0, and foreground as non-0 ...
let grid = Grid(width: image.width, height: image.height, values: Array(data))!

let points = BorderFinder().findBorder(in: grid)

let path = CGMutablePath()
let start = points.first!

path.move(to: CGPoint(x: start.x, y: start.y))
for point in points.dropFirst() {
    let cgPoint = CGPoint(x: point.x, y: point.y)
    path.addLine(to: cgPoint)
}
path.closeSubpath()

生成以下路径：

这里有我使用的完整示例代码a gist。（此示例代码并不意味着是如何准备图像以进行处理的良好示例。我只是把它放在一起来研究算法。）
对未来工作的一些思考：

• 您可以通过先将图像缩放到更小的尺寸来获得更好更快的结果。半比例当然效果很好，但考虑甚至1/10的比例。
• 首先对图像应用一个小的高斯模糊，可能会获得更好的效果。这将消除边缘中的小间隙（这可能给算法带来麻烦），并降低轮廓的复杂性。
• 管理5000个路径元素，每个路径元素都是2像素的线，这可能不是很好。预缩放图像可以帮助很多。另一种方法是应用Ramer–Douglas–Peucker来进一步简化轮廓。