Swift实现Photoshop魔棒选择工具遇UIBezierPath路径错乱问题求助

你的问题核心是从FloodFill生成的黑白遮罩转换为UIBezierPath时，边缘点的提取或路径构建逻辑存在缺陷，导致路径出现锯齿和错乱。以下是针对性的修复方案：

优化边缘点提取逻辑 #

遮罩正确说明像素选中区域没问题，但直接遍历所有白色像素生成路径会引入大量冗余点，且点的顺序易混乱。改用Moore邻域轮廓跟踪算法提取遮罩外轮廓，只保留边缘关键点：

func extractContour(from mask: UIImage) -> [CGPoint] {
    guard let cgImage = mask.cgImage, let data = cgImage.dataProvider?.data else { return [] }
    let bytes = CFDataGetBytePtr(data)
    let width = cgImage.width
    let height = cgImage.height
    let bytesPerRow = cgImage.bytesPerRow
    
    var contourPoints = [CGPoint]()
    var currentPoint: CGPoint?
    
    // 定位第一个白色像素作为轮廓起点
    for y in 0..<height {
        for x in 0..<width {
            let index = y * bytesPerRow + x * 4
            if bytes?[index] == 255 { // 适配RGBA格式，R通道为255代表白色区域
                currentPoint = CGPoint(x: x, y: y)
                contourPoints.append(currentPoint!)
                break
            }
        }
        if currentPoint != nil { break }
    }
    
    guard var startPoint = currentPoint else { return [] }
    var direction = 0 // 初始搜索方向：向上
    // 8个邻域方向（顺时针）
    let directions = [(-1,0), (-1,1), (0,1), (1,1), (1,0), (1,-1), (0,-1), (-1,-1)]
    
    repeat {
        // 顺时针查找下一个边缘点
        for i in 0..<8 {
            let dirIndex = (direction + i) % 8
            let dx = directions[dirIndex].0
            let dy = directions[dirIndex].1
            let nextX = Int(currentPoint!.x) + dx
            let nextY = Int(currentPoint!.y) + dy
            
            guard nextX >= 0, nextX < width, nextY >= 0, nextY < height else { continue }
            let index = nextY * bytesPerRow + nextX * 4
            if bytes?[index] == 255 {
                currentPoint = CGPoint(x: nextX, y: nextY)
                contourPoints.append(currentPoint!)
                direction = (dirIndex + 6) % 8 // 更新下一次搜索的起始方向
                break
            }
        }
    } while currentPoint != startPoint && contourPoints.count < width * height
    
    return contourPoints
}

路径去重与平滑处理 #

提取的轮廓点可能存在连续重复或过于密集的点，导致路径锯齿。添加去重和三阶贝塞尔曲线平滑逻辑：

func createSmoothPath(from points: [CGPoint]) -> UIBezierPath? {
    guard points.count >= 2 else { return nil }
    
    // 过滤相邻距离小于1像素的重复点
    let uniquePoints = points.reduce(into: [CGPoint]()) { result, point in
        if let last = result.last, last.distance(to: point) < 1.0 { return }
        result.append(point)
    }
    
    guard uniquePoints.count >= 2 else { return nil }
    
    let path = UIBezierPath()
    path.move(to: uniquePoints[0])
    
    // 用三阶贝塞尔曲线平滑路径
    for i in 1..<uniquePoints.count - 1 {
        let p0 = uniquePoints[i-1]
        let p1 = uniquePoints[i]
        let p2 = uniquePoints[i+1]
        
        let controlPoint1 = CGPoint(x: (p0.x + p1.x)/2, y: (p0.y + p1.y)/2)
        let controlPoint2 = CGPoint(x: (p1.x + p2.x)/2, y: (p1.y + p2.y)/2)
        
        path.addCurve(to: p1, controlPoint1: controlPoint1, controlPoint2: controlPoint2)
    }
    
    // 闭合路径
    path.addLine(to: uniquePoints.last!)
    path.close()
    
    return path
}

// CGPoint扩展：计算两点距离
extension CGPoint {
    func distance(to point: CGPoint) -> CGFloat {
        return sqrt(pow(x - point.x, 2) + pow(y - point.y, 2))
    }
}

替换原路径生成逻辑 #

将你原有的createMagicWandPath方法替换为以下调用逻辑：

// 假设maskImage是FloodFill生成的黑白遮罩
let contourPoints = extractContour(from: maskImage)
if let smoothPath = createSmoothPath(from: contourPoints) {
    // 使用生成的平滑路径
}

验证步骤：

1. 确认FloodFill生成的遮罩无误（你已完成此步骤）
2. 调用extractContour提取轮廓关键点
3. 调用createSmoothPath生成最终的平滑路径

内容的提问来源于stack exchange，提问作者April G