pcolton / potrace Goto Github PK

 init(data: UnsafeMutableRawPointer, width: Int, height: Int) {

        let pixelData = data.assumingMemoryBound(to: UInt8.self)

        bm = Bitmap(width: width, height: height)

        var j = 0, i = 0
        
        for _ in 0..<bm.data.count {
            let val = 0.2126 * Double(pixelData[i]) + 0.7153 * Double(pixelData[i + 1]) +
                0.0721 * Double(pixelData[i + 2])
            bm.data[j] = val < 128 ? 1 : 0
            i += 4
            j += 1
        }
    }

import SwiftUI

struct ContentView: View {
    @State private var turdSize: Int = 2
    @State private var curveTolerance: Float = 1.0
    @State private var optCurve: Bool = true
    @State private var originalImage: UIImage? = UIImage(named: "elephant")
    @State private var curvesImage: UIImage?
    // ... other state properties ...

    // MARK: - Body
    var body: some View {
        VStack {
            if let originalImage = originalImage {
                Image(uiImage: originalImage)
                    .resizable()
                    .aspectRatio(contentMode: .fit)
            }

            if let curvesImage = curvesImage {
                Image(uiImage: curvesImage)
                    .resizable()
                    .aspectRatio(contentMode: .fit)
            }

            Text("Curve Tolerance (\(curveTolerance))")
            Slider(value: $curveTolerance, in: 0...10, step: 0.1)
                .disabled(!optCurve)
                .onChange(of: curveTolerance) { newValue in
                    updateImage()
                }

            Text("Turd Size (\(turdSize))")
            Slider(value: Binding(
                get: { Float(turdSize) },
                set: { turdSize = Int($0) }
            ), in: 0...100)
                .onChange(of: turdSize) { newValue in
                    updateImage()
                }

            Toggle("Optimize Curve", isOn: $optCurve)
                .onChange(of: optCurve) { newValue in
                    updateImage()
                }
        }
        .onAppear {
            updateImage()
        }
    }
    
    // MARK: - Methods
    func updateImage() {
        guard let originalImage = originalImage,
              var pixelData = originalImage.pixelData() else {
            print("Could not get pixel data from the image.")
            return
        }

        // Assuming `Potrace` is your image processing object and `Settings` is the configuration
        var settings = Potrace.Settings()
        settings.turdsize = turdSize
        settings.optcurve = optCurve
        settings.opttolerance = Double(curveTolerance)

        // Process the image pixels with Potrace
        let width = Int(originalImage.size.width)
        let height = Int(originalImage.size.height)

        // Pass the array of UInt8 to the Potrace initializer
        pixelData.withUnsafeMutableBytes { rawBufferPointer in
            guard let rawPointer = rawBufferPointer.baseAddress else {
                print("Unable to get raw pointer to pixel data.")
                return
            }
            DispatchQueue.global(qos: .userInitiated).async {
                let potrace = Potrace(data: rawPointer, width: width, height: height)
                potrace.process(settings: settings)
                // Assuming we get a bezier path back to convert to UIImage
                let bezierPath = potrace.getBezierPath(scale: 2.0)
                let newImage = self.imageFromBezierPath(path: bezierPath, size: CGSize(width: width, height: height))

                DispatchQueue.main.async {
                    // Update the curvesImage on the main thread since it's a UI update
                    self.curvesImage = newImage
                }
            }
        }

    }
    
    private func imageFromBezierPath(path: UIBezierPath, size: CGSize) -> UIImage {
        UIGraphicsBeginImageContextWithOptions(size, false, 0)
        if let context = UIGraphicsGetCurrentContext() {
            UIColor.black.set()
            context.addPath(path.cgPath)
            context.fillPath()
            let image = UIGraphicsGetImageFromCurrentImageContext() ?? UIImage()
            UIGraphicsEndImageContext()
            return image
        }
        return UIImage()
    }
}

extension UIImage {
    func pixelData() -> [UInt8]? {
        let size = self.size
        let dataSize = size.width * size.height * 4
        var pixelData = [UInt8](repeating: 0, count: Int(dataSize))
        let colorSpace = CGColorSpaceCreateDeviceRGB()
        let context = CGContext(data: &pixelData,
                                width: Int(size.width),
                                height: Int(size.height),
                                bitsPerComponent: 8,
                                bytesPerRow: 4 * Int(size.width),
                                space: colorSpace,
                                bitmapInfo: CGImageAlphaInfo.noneSkipLast.rawValue)
        guard let cgImage = self.cgImage else { return nil }
        context?.draw(cgImage, in: CGRect(x: 0, y: 0, width: size.width, height: size.height))
        
        return pixelData
    }
}

// Preview provider
struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}