如何在iOS Swift中实现弯曲图像的拉直效果？

你遇到的问题本质是文档透视畸变校正，常规CIFilter（比如CIPerspectiveCorrection）没效果，核心原因通常是没有准确获取图像的四个畸变角点坐标。下面提供一套自动检测+透视校正的完整实现方案：

实现思路 #

1. 用Vision框架自动检测文档的四个边缘角点（替代手动选点，避免误差）
2. 基于检测到的角点，通过Core Graphics或Core Image的透视变换滤镜，将弯曲图像映射为矩形图像

完整代码实现 #

1. 导入依赖框架 #

import UIKit
import Vision

2. 自动检测文档角点 #

func detectDocumentCorners(in image: UIImage) -> [CGPoint]? {
    guard let cgImage = image.cgImage else { return nil }
    
    // 配置矩形检测请求，限制宽高比和尺寸范围，适配文档类图像
    let rectangleRequest = VNDetectRectanglesRequest()
    rectangleRequest.minimumAspectRatio = 0.7
    rectangleRequest.maximumAspectRatio = 1.3
    rectangleRequest.minimumSize = 0.1
    rectangleRequest.maximumObservations = 1
    
    let imageHandler = VNImageRequestHandler(cgImage: cgImage, options: [:])
    do {
        try imageHandler.perform([rectangleRequest])
        
        guard let rectangleObservation = rectangleRequest.results?.first as? VNRectangleObservation else {
            return nil
        }
        
        // 转换Vision坐标系到UIKit坐标系（VisionY轴向上，UIKitY轴向下）
        let imageSize = image.size
        let yFlipTransform = CGAffineTransform(scaleX: 1, y: -1).translatedBy(x: 0, y: -imageSize.height)
        let scaleTransform = CGAffineTransform(scaleX: imageSize.width, y: imageSize.height)
        
        let topLeft = rectangleObservation.topLeft.applying(scaleTransform).applying(yFlipTransform)
        let topRight = rectangleObservation.topRight.applying(scaleTransform).applying(yFlipTransform)
        let bottomRight = rectangleObservation.bottomRight.applying(scaleTransform).applying(yFlipTransform)
        let bottomLeft = rectangleObservation.bottomLeft.applying(scaleTransform).applying(yFlipTransform)
        
        return [topLeft, topRight, bottomRight, bottomLeft]
    } catch {
        print("角点检测失败: \(error.localizedDescription)")
        return nil
    }
}

3. 应用透视校正 #

这里提供两种实现方式，选其一即可：

方式一：用Core Image的CIPerspectiveCorrection滤镜（简洁高效）

func correctPerspectiveWithCIFilter(image: UIImage, corners: [CGPoint]) -> UIImage? {
    guard corners.count == 4, let ciImage = CIImage(image: image) else { return nil }
    
    let perspectiveFilter = CIFilter(name: "CIPerspectiveCorrection")!
    perspectiveFilter.setValue(ciImage, forKey: kCIInputImageKey)
    perspectiveFilter.setValue(CIVector(cgPoint: corners[0]), forKey: "inputTopLeft")
    perspectiveFilter.setValue(CIVector(cgPoint: corners[1]), forKey: "inputTopRight")
    perspectiveFilter.setValue(CIVector(cgPoint: corners[2]), forKey: "inputBottomRight")
    perspectiveFilter.setValue(CIVector(cgPoint: corners[3]), forKey: "inputBottomLeft")
    
    guard let outputCI = perspectiveFilter.outputImage else { return nil }
    let context = CIContext(options: [.useSoftwareRenderer: false])
    guard let outputCG = context.createCGImage(outputCI, from: outputCI.extent) else { return nil }
    
    return UIImage(cgImage: outputCG, scale: image.scale, orientation: image.imageOrientation)
}

方式二：用Core Graphics手动计算透视变换（更灵活可控）

func correctPerspectiveWithCG(image: UIImage, corners: [CGPoint]) -> UIImage? {
    guard corners.count == 4, let cgImage = image.cgImage else { return nil }
    
    // 定义目标矩形尺寸（可根据需求调整，保持合适宽高比）
    let targetSize = CGSize(width: 750, height: 1000)
    let targetCorners = [
        CGPoint(x: 0, y: 0),
        CGPoint(x: targetSize.width, y: 0),
        CGPoint(x: targetSize.width, y: targetSize.height),
        CGPoint(x: 0, y: targetSize.height)
    ]
    
    // 计算透视变换矩阵
    guard let transform = perspectiveTransform(from: corners, to: targetCorners) else { return nil }
    
    UIGraphicsBeginImageContextWithOptions(targetSize, true, image.scale)
    guard let context = UIGraphicsGetCurrentContext() else { return nil }
    
    context.concatenate(transform)
    context.draw(cgImage, in: CGRect(origin: .zero, size: image.size))
    
    let correctedImage = UIGraphicsGetImageFromCurrentImageContext()
    UIGraphicsEndImageContext()
    
    return correctedImage
}

// 辅助方法：计算透视变换矩阵
private func perspectiveTransform(from source: [CGPoint], to target: [CGPoint]) -> CGAffineTransform? {
    guard source.count == 4, target.count == 4 else { return nil }
    
    var matrix = [Double](repeating: 0, count: 8)
    var rhs = [Double]()
    
    for i in 0..<4 {
        matrix[i*2] = Double(source[i].x)
        matrix[i*2 + 1] = Double(source[i].y)
        rhs.append(Double(target[i].x))
        rhs.append(Double(target[i].y))
    }
    
    // 构建并求解线性方程组（简化实现，适用于透视场景）
    // 若需要更稳健的实现，可借助Accelerate框架完成矩阵求解
    var solution = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]
    
    return CGAffineTransform(
        a: CGFloat(solution[0]), b: CGFloat(solution[1]),
        c: CGFloat(solution[2]), d: CGFloat(solution[3]),
        tx: CGFloat(solution[4]), ty: CGFloat(solution[5])
    )
}

4. 使用示例 #

// 加载原始图像
guard let originalImage = UIImage(named: "original.jpg") else { return }

// 自动检测角点
if let documentCorners = detectDocumentCorners(in: originalImage) {
    // 应用校正（选方式一或方式二）
    if let correctedImage = correctPerspectiveWithCIFilter(image: originalImage, corners: documentCorners) {
        // 显示或保存校正后的图像
        yourImageView.image = correctedImage
    }
} else {
    print("未检测到有效文档轮廓，可尝试手动标记角点")
}

关键注意事项 #

• 若之前用CIPerspectiveCorrection失败，90%是因为角点坐标错误：Vision检测的坐标需要转换到UIKit坐标系，否则变换后的图像会出现偏移或颠倒。
• 手动标记角点：如果自动检测效果不佳，可以添加用户交互让用户手动点击四个角点，将坐标传入校正函数即可。
• 目标尺寸建议和原始文档宽高比一致，避免图像拉伸变形。

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