Swift中如何将UIImage转换为UIBezierPath？

Hey there! Let's tackle this problem head-on. First, a crucial reality check: you can't directly convert a UIImage back to a UIBezierPath once you've rendered the path into a bitmap image. Here's why and what you can do instead:

The Core Issue #

When you convert a UIBezierPath to a UIImage, you're turning vector-based shape data into a pixel-based bitmap. All the mathematical information about the path's curves, lines, and control points gets lost in this process—your UIImage is just a grid of colored pixels, not a editable shape.

So the best solution depends on whether you can adjust how you store the data, or if you're stuck working with the existing UIImage.

Option 1: Store the UIBezierPath Directly (Recommended) #

This is the cleanest, most reliable approach. Instead of converting the path to an image first, archive the UIBezierPath itself into Data, then convert that data to base64 for storage. When you need it back, reverse the process.

Code Example: Archiving & Unarchiving UIBezierPath

// Archive a UIBezierPath to Data
func archiveBezierPath(_ path: UIBezierPath) -> Data? {
    do {
        return try NSKeyedArchiver.archivedData(
            withRootObject: path,
            requiringSecureCoding: false
        )
    } catch {
        print("Failed to archive path: \(error.localizedDescription)")
        return nil
    }
}

// Unarchive Data back to UIBezierPath
func unarchiveBezierPath(from data: Data) -> UIBezierPath? {
    do {
        guard let path = try NSKeyedUnarchiver.unarchivedObject(
            ofClass: UIBezierPath.self,
            from: data
        ) else {
            return nil
        }
        return path
    } catch {
        print("Failed to unarchive path: \(error.localizedDescription)")
        return nil
    }
}

How to Use This:

1. When saving:

   let path = UIBezierPath(ovalIn: CGRect(x: 0, y: 0, width: 100, height: 100))
   if let pathData = archiveBezierPath(path) {
       let base64String = pathData.base64EncodedString()
       // Store base64String in your database
   }
   

2. When retrieving:

   if let stringData = Data(base64Encoded: storedBase64String) {
       if let restoredPath = unarchiveBezierPath(from: stringData) {
           // Use your original UIBezierPath!
       }
   }
   

Option 2: Reconstruct Path from UIImage (If You Have No Other Choice) #

If you're stuck with the UIImage and can't go back to storing the path directly, you can attempt to reconstruct the path using edge detection and pixel analysis. This is far from perfect—it works best with simple, high-contrast shapes and will never give you the exact original path.

Example with Core Image Edge Detection

func attemptPathReconstruction(from image: UIImage) -> UIBezierPath? {
    guard let ciImage = CIImage(image: image) else { return nil }
    
    // Use Core Image's edge detection filter to highlight shape outlines
    let edgeFilter = CIFilter(name: "CIColorEdges")!
    edgeFilter.setValue(ciImage, forKey: kCIInputImageKey)
    edgeFilter.setValue(0.3, forKey: kCIInputIntensityKey) // Adjust based on your image
    
    guard let edgeImage = edgeFilter.outputImage else { return nil }
    
    // Convert CIImage to pixel data for analysis
    let context = CIContext(options: [.useSoftwareRenderer: false])
    let width = Int(edgeImage.extent.width)
    let height = Int(edgeImage.extent.height)
    var pixelData = [UInt8](repeating: 0, count: width * height * 4)
    
    context.render(
        edgeImage,
        toBitmap: &pixelData,
        rowBytes: width * 4,
        bounds: edgeImage.extent,
        format: CIFormat.RGBA8,
        colorSpace: CGColorSpaceCreateDeviceRGB()
    )
    
    // Build path from edge pixels (simplified example)
    let path = UIBezierPath()
    var firstPointFound = false
    
    for y in 0..<height {
        for x in 0..<width {
            let pixelIndex = (y * width + x) * 4
            let alpha = pixelData[pixelIndex + 3]
            if alpha > 127 { // Opaque edge pixel
                let point = CGPoint(x: x, y: height - y) // Flip coordinate system
                if !firstPointFound {
                    path.move(to: point)
                    firstPointFound = true
                } else {
                    path.addLine(to: point)
                }
            }
        }
    }
    
    // Optional: Simplify the path to remove redundant points
    let simplifiedPath = path.flattened()
    return simplifiedPath
}

Notes on This Method:

• The resulting path will have lots of extra points—you'll need to add logic to smooth or simplify it.
• It won't work well with complex shapes, low-contrast images, or images with multiple overlapping paths.
• This is a last-resort solution, not a replacement for storing the original path.

Final Takeaway #

Always prioritize storing the UIBezierPath itself (via archiving) instead of converting it to an image first. This preserves all the vector data and lets you restore the exact path later. If you have no other option, edge detection can give you a rough approximation, but it's never as reliable.

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