如何加快MKMapSnapshot中绘制折线的速度？

嘿，我来给你几个实用的优化方向，都是我在iOS开发里踩过坑、试过有效的办法，能帮你提升MKMapView快照折线绘制的速度：

1. 一次性完成所有绘制，避免上下文重复创建 #

很多时候速度慢是因为多次创建绘图上下文、反复切换绘制状态。你可以把所有折线的绘制逻辑放到同一个上下文里完成，减少上下文初始化和切换的开销。

示例代码：

// 先拿到地图快照
let mapSnapshot = MKMapSnapshotter(options: snapshotOptions).takeSnapshot()

// 一次性绘制所有折线
let renderer = UIGraphicsImageRenderer(size: mapSnapshot.size)
let finalImage = renderer.image { context in
    // 先绘制快照原图
    mapSnapshot.draw(at: .zero)
    
    // 遍历所有折线，在同一个上下文里完成绘制
    for polyline in yourPolylineArray {
        let path = UIBezierPath()
        // 转换折线坐标到快照坐标系
        for (index, point) in polyline.points.enumerated() {
            let snapshotPoint = mapSnapshot.point(for: point.coordinate)
            index == 0 ? path.move(to: snapshotPoint) : path.addLine(to: snapshotPoint)
        }
        // 设置样式并绘制
        UIColor.systemBlue.setStroke()
        path.lineWidth = 2.0
        path.stroke()
    }
}

2. 对折线点做抽稀处理，减少绘制点数 #

如果你的折线包含大量冗余点（比如连续的直线段），可以用道格拉斯-普克算法对坐标点进行抽稀，只保留折线的关键拐点，大幅减少需要绘制的点数。

简单的抽稀函数示例：

func simplifyPolyline(points: [CLLocationCoordinate2D], epsilon: Double) -> [CLLocationCoordinate2D] {
    guard points.count > 2 else { return points }
    
    // 找到离当前线段最远的点
    var maxDistance = 0.0
    var maxIndex = 0
    let start = points[0]
    let end = points.last!
    
    for i in 1..<points.count-1 {
        let distance = distanceFromPointToLine(point: points[i], lineStart: start, lineEnd: end)
        if distance > maxDistance {
            maxDistance = distance
            maxIndex = i
        }
    }
    
    // 如果最远点超过阈值，递归保留该点并处理前后段
    var simplified = [CLLocationCoordinate2D]()
    if maxDistance > epsilon {
        let left = simplifyPolyline(points: Array(points[0...maxIndex]), epsilon: epsilon)
        let right = simplifyPolyline(points: Array(points[maxIndex...]), epsilon: epsilon)
        simplified.append(contentsOf: left.dropLast())
        simplified.append(contentsOf: right)
    } else {
        simplified = [start, end]
    }
    
    return simplified
}

// 辅助计算点到直线的距离
private func distanceFromPointToLine(point: CLLocationCoordinate2D, lineStart: CLLocationCoordinate2D, lineEnd: CLLocationCoordinate2D) -> Double {
    // 这里用经纬度的平面近似计算，精度足够的话可以用更准确的地理距离
    let x0 = point.longitude, y0 = point.latitude
    let x1 = lineStart.longitude, y1 = lineStart.latitude
    let x2 = lineEnd.longitude, y2 = lineEnd.latitude
    
    let numerator = abs((y2 - y1)*x0 - (x2 - x1)*y0 + x2*y1 - y2*x1)
    let denominator = sqrt(pow(y2 - y1, 2) + pow(x2 - x1, 2))
    return denominator == 0 ? 0 : numerator / denominator
}

绘制前先调用这个函数处理折线点，能显著减少绘制压力。

3. 预转换坐标到快照坐标系，避免循环内重复计算 #

每次绘制时调用mapSnapshot.point(for: coordinate)转换坐标是有开销的，你可以提前把所有折线的坐标转换成快照上的像素点，缓存起来，绘制时直接使用预计算好的点。

示例：

// 提前转换所有折线的坐标到快照像素点
let precomputedPointsArray = yourPolylineArray.map { polyline in
    polyline.points.map { point in
        mapSnapshot.point(for: point.coordinate)
    }
}

// 绘制时直接用预计算的点
let finalImage = renderer.image { context in
    mapSnapshot.draw(at: .zero)
    for points in precomputedPointsArray {
        guard !points.isEmpty else { continue }
        let path = UIBezierPath()
        path.move(to: points[0])
        for i in 1..<points.count {
            path.addLine(to: points[i])
        }
        UIColor.systemBlue.setStroke()
        path.lineWidth = 2.0
        path.stroke()
    }
}

4. 直接使用Core Graphics API，减少封装开销 #

UIBezierPath是Core Graphics的上层封装，如果你追求极致速度，可以直接操作CGContext，跳过封装层的开销。

示例：

let finalImage = renderer.image { context in
    mapSnapshot.draw(at: .zero)
    let cgContext = context.cgContext
    
    // 提前设置好样式，避免循环内重复设置
    cgContext.setStrokeColor(UIColor.systemBlue.cgColor)
    cgContext.setLineWidth(2.0)
    
    for points in precomputedPointsArray {
        guard !points.isEmpty else { continue }
        cgContext.move(to: points[0])
        for i in 1..<points.count {
            cgContext.addLine(to: points[i])
        }
        cgContext.strokePath()
    }
}

5. 异步绘制，避免阻塞主线程 #

如果处理的折线数据量实在太大，别在主线程做绘制操作，把整个绘制逻辑放到后台队列，完成后再回到主线程更新UI。这样用户不会感觉到界面卡顿，体验会好很多。

示例：

DispatchQueue.global(qos: .userInitiated).async {
    let mapSnapshot = MKMapSnapshotter(options: snapshotOptions).takeSnapshot()
    // 这里执行所有绘制逻辑...
    let finalImage = renderer.image { /* 绘制代码 */ }
    
    DispatchQueue.main.async {
        // 更新UI，比如展示到UIImageView
        self.resultImageView.image = finalImage
    }
}

6. 缓存已绘制结果 #

如果你的地图区域和折线数据不会频繁变化，可以把绘制好的图片缓存起来（用NSCache或者磁盘缓存），下次需要时直接读取缓存，不用重新绘制。

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