Using the iOS SDK

final class ImageEngineWrapper {
    private let engine: PCSEngine
    private let lock = NSLock()

    init(engine: PCSEngine) {
        self.engine = engine
    }

    func detectScene(for image: PCSImage) -> PCSSceneDetectionResult? {
        lock.lock()
        defer { lock.unlock() }
        return engine.detectSceneForImage(image)
    }

    func apply(_ param: PCSParam, to image: PCSImage, profile: PCSProfile?) -> Int32 {
        lock.lock()
        defer { lock.unlock() }
        var errorCode: Int32 = 0
        engine.applyParam(param, toImage: image, profile: profile, errorCode: &errorCode)
        return errorCode
    }
}

func makeSRGBImage(_ source: UIImage, maxDimension: CGFloat) -> UIImage {
    let size = source.size
    let scale = min(1.0, maxDimension / max(size.width, size.height))
    let targetSize = CGSize(width: (size.width * scale).rounded(),
                            height: (size.height * scale).rounded())

    let format = UIGraphicsImageRendererFormat()
    format.scale = 1
    format.preferredRange = .standard   // forces 8-bit sRGB

    return UIGraphicsImageRenderer(size: targetSize, format: format).image { ctx in
        source.draw(in: CGRect(origin: .zero, size: targetSize))
    }
}

// Must run on a background thread — blocks for the full classification pass
DispatchQueue.global(qos: .userInitiated).async {
    // 1. Prepare image (see format requirements above)
    let workImage = makeSRGBImage(uiImage, maxDimension: 2048)

    // 2. Wrap in PCSImage — on this same thread
    guard let pcsImage = PCSImage(image: workImage) else { return }

    // 3. Detect — serialized inside your engine wrapper
    guard let result = engineWrapper.detectScene(for: pcsImage) else { return }

    // result.sceneLabel — integer scene ID (see scene catalogue below)
    // result.profile    — opaque color profile, pair with this image only

    // 4. Build param from detected scene
    let param = PCSParam(sceneLabel: result.sceneLabel, usingEngine: engineWrapper.engine)

    // 5. Apply (see next section)
}

// Always copy param before passing to the SDK — the engine can mutate it
let paramCopy = param.copy() as! PCSParam

var errorCode: Int32 = 0
engine.applyParam(paramCopy, toImage: pcsImage, profile: result.profile, errorCode: &errorCode)

if errorCode == 0 {
    // Extract the corrected image on the same thread as pcsImage was created
    let corrected = pcsImage.generateImage(withColorSpace: CGColorSpaceCreateDeviceRGB())
    // corrected is a new UIImage with corrections applied
}

// Detection is expensive — do it once
let detectionResult = engine.detectSceneForImage(pcsImage)

// Slider changes strength — reuse the profile
func applyWithStrength(_ strength: Int) {
    let param = PCSParam(sceneLabel: detectionResult.sceneLabel, usingEngine: engine)
    let adjusted = param.withStrength(strength)
    let copy = adjusted.copy() as! PCSParam
    engine.applyParam(copy, toImage: pcsImage, profile: detectionResult.profile, errorCode: &errorCode)
}

// No correction (identity)
let identity = PCSParam()

// Scene-optimized param
let sceneParam = PCSParam(sceneLabel: result.sceneLabel, usingEngine: engine)

// Adjust strength
let adjusted = sceneParam.withStrength(80)

// Check if no correction has been selected
if param == PCSParam() {
    print("No correction applied")
}

let maxPreviewDimension: CGFloat = 2048
let workImage = makeSRGBImage(uiImage, maxDimension: maxPreviewDimension)

let maxExportDimension: CGFloat = 4096
let maxExportMegapixels: CGFloat = 12_000_000

let w = uiImage.size.width, h = uiImage.size.height
let scaleDim = min(1.0, maxExportDimension / max(w, h))
let scaleMP  = min(1.0, sqrt(maxExportMegapixels / (w * h)))
let scale    = min(scaleDim, scaleMP)

let exportImage = makeSRGBImage(uiImage, maxDimension: max(w, h) * scale)

let corrected: UIImage? = autoreleasepool {
    guard let pcsImage = PCSImage(image: workImage) else { return nil }
    var errorCode: Int32 = 0
    engine.applyParam(paramCopy, toImage: pcsImage, profile: profile, errorCode: &errorCode)
    return errorCode == 0 ? pcsImage.generateImage(withColorSpace: CGColorSpaceCreateDeviceRGB()) : nil
}

// Create the engine once
let engine = PCSEngine(apiKey: apiKey, certificate: cert, /* ... */)
let wrapper = ImageEngineWrapper(engine: engine)

// Process multiple images serially (or in parallel with multiple engines)
for imageUrl in imageUrls {
    let source = UIImage(contentsOfFile: imageUrl.path)!
    correctImage(source, using: wrapper) { result in
        // save result
    }
}

var param = PCSParam(sceneLabel: result.sceneLabel, usingEngine: engine)
param.lutOutputGuid = "LOOK_GUID_FROM_SDK"   // GUID from PCSEngine.getSceneDescriptions()
param.lutOutputStrength = 80                 // 0–100
param.iOutLUTcontrast = 0
param.iOutLUTsaturation = 0

let copy = param.copy() as! PCSParam
engine.applyParam(copy, toImage: pcsImage, profile: result.profile, errorCode: &errorCode)