@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/CoreImage/CIFilter.swift

@@ -0,0 +1,243 @@
+import class Foundation.NSNumber
+import struct Foundation.Data
+import SwiftUI
+
+// `CIFilter`: a named filter with key-value inputs, as on Apple platforms
+// (`setValue(_:forKey:)` with the `kCI…Key` names, `inputKeys`,
+// `outputImage`). Each built-in appends one step to its input's recipe and
+// works out the output's extent; the page runs the step
+// (Web/src/imageOps.ts; the formulas are in docs/ops-protocol.md, "Bitmaps
+// and Core Image").
+
+public let kCIInputImageKey = "inputImage"
+public let kCIOutputImageKey = "outputImage"
+public let kCIInputIntensityKey = "inputIntensity"
+public let kCIInputRadiusKey = "inputRadius"
+public let kCIInputScaleKey = "inputScale"
+public let kCIInputCenterKey = "inputCenter"
+public let kCIInputAngleKey = "inputAngle"
+public let kCIInputWidthKey = "inputWidth"
+public let kCIInputSharpnessKey = "inputSharpness"
+public let kCIInputAmountKey = "inputAmount"
+public let kCIInputBrightnessKey = "inputBrightness"
+public let kCIInputContrastKey = "inputContrast"
+public let kCIInputSaturationKey = "inputSaturation"
+public let kCIInputColorKey = "inputColor"
+public let kCIInputExtentKey = "inputExtent"
+
+/// The filters the shim implements, by Core Image name.
+enum _CIFilterKind: String, CaseIterable {
+    case sepiaTone = "CISepiaTone"
+    case crystallize = "CICrystallize"
+    case edges = "CIEdges"
+    case gaussianBlur = "CIGaussianBlur"
+    case pixellate = "CIPixellate"
+    case unsharpMask = "CIUnsharpMask"
+    case vignette = "CIVignette"
+    case qrCodeGenerator = "CIQRCodeGenerator"
+
+    /// In Core Image's order.
+    var inputKeys: [String] {
+        switch self {
+        case .sepiaTone, .edges: [kCIInputImageKey, kCIInputIntensityKey]
+        case .crystallize: [kCIInputImageKey, kCIInputRadiusKey, kCIInputCenterKey]
+        case .gaussianBlur: [kCIInputImageKey, kCIInputRadiusKey]
+        case .pixellate: [kCIInputImageKey, kCIInputCenterKey, kCIInputScaleKey]
+        case .unsharpMask: [kCIInputImageKey, kCIInputRadiusKey, kCIInputIntensityKey]
+        case .vignette: [kCIInputImageKey, kCIInputIntensityKey, kCIInputRadiusKey]
+        case .qrCodeGenerator: ["inputMessage", "inputCorrectionLevel"]
+        }
+    }
+
+    /// Core Image's defaults.
+    var defaults: [String: Any] {
+        switch self {
+        case .sepiaTone, .edges: [kCIInputIntensityKey: 1.0]
+        case .crystallize: [kCIInputRadiusKey: 20.0, kCIInputCenterKey: CIVector(x: 150, y: 150)]
+        case .gaussianBlur: [kCIInputRadiusKey: 10.0]
+        case .pixellate: [kCIInputCenterKey: CIVector(x: 150, y: 150), kCIInputScaleKey: 8.0]
+        case .unsharpMask: [kCIInputRadiusKey: 2.5, kCIInputIntensityKey: 0.5]
+        case .vignette: [kCIInputIntensityKey: 0.0, kCIInputRadiusKey: 1.0]
+        case .qrCodeGenerator: ["inputMessage": Data(), "inputCorrectionLevel": "M"]
+        }
+    }
+}
+
+/// A Core Image filter. Made by name (`CIFilter(name: "CISepiaTone")`) or,
+/// typed, through `CoreImage.CIFilterBuiltins` (`CIFilter.sepiaTone()`).
+open class CIFilter: @unchecked Sendable {
+    let kind: _CIFilterKind?
+    private var values: [String: Any]
+
+    /// A filter of your own: override `outputImage`.
+    public init() {
+        kind = nil
+        values = [:]
+    }
+
+    init(kind: _CIFilterKind) {
+        self.kind = kind
+        values = kind.defaults
+    }
+
+    /// One of the built-ins the shim implements, with its default inputs; nil
+    /// for any other name.
+    public convenience init?(name: String) {
+        guard let kind = _CIFilterKind(rawValue: name) else { return nil }
+        self.init(kind: kind)
+    }
+
+    public convenience init?(name: String, parameters params: [String: Any]?) {
+        self.init(name: name)
+        for (key, value) in params ?? [:] { setValue(value, forKey: key) }
+    }
+
+    /// The Core Image names of the filters the shim implements.
+    public class func filterNames(inCategory category: String?) -> [String] {
+        _CIFilterKind.allCases.map(\.rawValue)
+    }
+
+    open var name: String { kind?.rawValue ?? String(describing: type(of: self)) }
+
+    /// A filter with the same inputs (`NSCopying`). A filter of your own class
+    /// is returned as is: there is no way to make another of it here.
+    open func copy() -> Any {
+        guard let kind else { return self }
+        let filter = CIFilter(kind: kind)
+        filter.values = values
+        return filter
+    }
+
+    open var inputKeys: [String] { kind?.inputKeys ?? [] }
+    open var outputKeys: [String] { [kCIOutputImageKey] }
+
+    /// Sets an input. Numbers may be any numeric type; a center may be a
+    /// `CIVector` or a `CGPoint`.
+    open func setValue(_ value: Any?, forKey key: String) {
+        values[key] = value
+    }
+
+    open func value(forKey key: String) -> Any? {
+        if key == kCIOutputImageKey { return outputImage }
+        return values[key]
+    }
+
+    /// Restores every input but the image to Core Image's default.
+    open func setDefaults() {
+        for (key, value) in kind?.defaults ?? [:] { values[key] = value }
+    }
+
+    /// The filtered image: a new recipe; nil without an input image (or, for
+    /// the QR code generator, for a message too long for any version).
+    open var outputImage: CIImage? {
+        guard let kind else { return nil }
+        if kind == .qrCodeGenerator { return qrCode() }
+        guard let input = values[kCIInputImageKey] as? CIImage else { return nil }
+        guard input._recipe.source != nil else { return input }
+        return output(kind, from: input)
+    }
+
+    // MARK: Typed access for the builtins
+
+    func number(_ key: String) -> Double { Self.double(values[key]) ?? Self.double(kind?.defaults[key]) ?? 0 }
+    func setNumber(_ key: String, _ value: Double) { values[key] = value }
+    func point(_ key: String) -> CGPoint { Self.point(values[key]) ?? Self.point(kind?.defaults[key]) ?? .zero }
+    func image(_ key: String) -> CIImage? { values[key] as? CIImage }
+    func setImage(_ key: String, _ image: CIImage?) { values[key] = image }
+    var message: Data {
+        get {
+            switch values["inputMessage"] {
+            case let data as Data: data
+            case let string as String: Data(string.utf8)
+            default: Data()
+            }
+        }
+        set { values["inputMessage"] = newValue }
+    }
+    var correctionLevel: String {
+        get { values["inputCorrectionLevel"] as? String ?? "M" }
+        set { values["inputCorrectionLevel"] = newValue }
+    }
+
+    static func double(_ value: Any?) -> Double? {
+        switch value {
+        case let v as Double: v
+        case let v as Float: Double(v)
+        case let v as Int: Double(v)
+        case let v as NSNumber: v.doubleValue
+        default: nil
+        }
+    }
+
+    static func point(_ value: Any?) -> CGPoint? {
+        switch value {
+        case let v as CIVector: v.cgPointValue
+        case let v as CGPoint: v
+        default: nil
+        }
+    }
+
+    // MARK: Outputs
+
+    private func output(_ kind: _CIFilterKind, from input: CIImage) -> CIImage {
+        let extent = input.extent
+        func step(_ op: String, _ fields: [String: _JSON], extent newExtent: CGRect? = nil) -> CIImage {
+            var object = fields
+            object["op"] = .string(op)
+            return CIImage(_recipe: input._recipe.adding(.object(object), extent: newExtent ?? extent))
+        }
+        func center(_ point: CGPoint) -> _JSON { .array([.number(point.x), .number(point.y)]) }
+        switch kind {
+        case .sepiaTone:
+            return step("sepiaTone", ["intensity": .number(number(kCIInputIntensityKey))])
+        case .edges:
+            return step("edges", ["intensity": .number(number(kCIInputIntensityKey))])
+        case .crystallize:
+            // Core Image's smallest crystal is a pixel.
+            let radius = max(1, number(kCIInputRadiusKey))
+            return step("crystallize", ["radius": .number(radius), "center": center(point(kCIInputCenterKey))])
+        case .pixellate:
+            let scale = number(kCIInputScaleKey)
+            guard scale > 1 else { return input }
+            return step("pixellate", ["scale": .number(scale), "center": center(point(kCIInputCenterKey))])
+        case .gaussianBlur:
+            let radius = number(kCIInputRadiusKey)
+            guard radius > 0 else { return input }
+            // The blur reaches three standard deviations (sigma = radius) past
+            // every edge, fading to clear; a clamped image stays infinite.
+            let reach = (3 * radius).rounded(.up)
+            let grown = extent.isInfinite ? extent : extent.insetBy(dx: -reach, dy: -reach)
+            return step("gaussianBlur", ["radius": .number(radius)], extent: grown)
+        case .unsharpMask:
+            let radius = number(kCIInputRadiusKey)
+            guard radius > 0 else { return input }
+            return step("unsharpMask", ["radius": .number(radius), "intensity": .number(number(kCIInputIntensityKey))])
+        case .vignette:
+            // Measured from the middle of the input, in units of half its
+            // diagonal; an infinite image has no middle, so nothing changes.
+            guard !extent.isInfinite else { return input }
+            let halfDiagonal = (extent.width * extent.width + extent.height * extent.height).squareRoot() / 2
+            return step("vignette", [
+                "intensity": .number(number(kCIInputIntensityKey)), "radius": .number(number(kCIInputRadiusKey)),
+                "center": center(CGPoint(x: extent.midX, y: extent.midY)), "size": .number(halfDiagonal),
+            ])
+        case .qrCodeGenerator:
+            return input
+        }
+    }
+
+    private func qrCode() -> CIImage? {
+        let level = _QRCode.ErrorCorrection(letter: correctionLevel) ?? .medium
+        guard let code = _QRCode.encode([UInt8](message), correction: level) else { return nil }
+        // One pixel per module and a one-module light margin, black on white.
+        let side = code.size + 2
+        var pixels = [UInt8](repeating: 255, count: side * side)
+        for y in 0..<code.size {
+            for x in 0..<code.size where code.module(x: x, y: y) {
+                pixels[(y + 1) * side + x + 1] = 0
+            }
+        }
+        let source = _ImageSource(pixels: pixels, width: side, height: side, format: .gray)
+        return CIImage(_recipe: _ImageRecipe(source: source))
+    }
+}

package/Sources/CoreImage/CIFilterBuiltins.swift

@@ -0,0 +1,136 @@
+import struct Foundation.Data
+import SwiftUI
+
+// `CoreImage.CIFilterBuiltins`: typed filters. `CIFilter.sepiaTone()` returns
+// `CIFilter & CISepiaTone`, whose properties read and write the same inputs
+// as `setValue(_:forKey:)`. The protocols are class-bound, as on Apple
+// platforms, so `let filter = CIFilter.qrCodeGenerator()` can be configured
+// from a non-mutating method.
+
+public protocol CIFilterProtocol: AnyObject {
+    var outputImage: CIImage? { get }
+}
+
+public protocol CISepiaTone: CIFilterProtocol {
+    var inputImage: CIImage? { get set }
+    var intensity: Float { get set }
+}
+
+public protocol CICrystallize: CIFilterProtocol {
+    var inputImage: CIImage? { get set }
+    var radius: Float { get set }
+    var center: CGPoint { get set }
+}
+
+public protocol CIEdges: CIFilterProtocol {
+    var inputImage: CIImage? { get set }
+    var intensity: Float { get set }
+}
+
+public protocol CIGaussianBlur: CIFilterProtocol {
+    var inputImage: CIImage? { get set }
+    var radius: Float { get set }
+}
+
+public protocol CIPixellate: CIFilterProtocol {
+    var inputImage: CIImage? { get set }
+    var center: CGPoint { get set }
+    var scale: Float { get set }
+}
+
+public protocol CIUnsharpMask: CIFilterProtocol {
+    var inputImage: CIImage? { get set }
+    var radius: Float { get set }
+    var intensity: Float { get set }
+}
+
+public protocol CIVignette: CIFilterProtocol {
+    var inputImage: CIImage? { get set }
+    var intensity: Float { get set }
+    var radius: Float { get set }
+}
+
+public protocol CIQRCodeGenerator: CIFilterProtocol {
+    /// The bytes to encode (byte mode).
+    var message: Data { get set }
+    /// `"L"`, `"M"` (the default), `"Q"` or `"H"`.
+    var correctionLevel: String { get set }
+}
+
+extension CIFilter {
+    public static func sepiaTone() -> CIFilter & CISepiaTone { _SepiaToneFilter(kind: .sepiaTone) }
+    public static func crystallize() -> CIFilter & CICrystallize { _CrystallizeFilter(kind: .crystallize) }
+    public static func edges() -> CIFilter & CIEdges { _EdgesFilter(kind: .edges) }
+    public static func gaussianBlur() -> CIFilter & CIGaussianBlur { _GaussianBlurFilter(kind: .gaussianBlur) }
+    public static func pixellate() -> CIFilter & CIPixellate { _PixellateFilter(kind: .pixellate) }
+    public static func unsharpMask() -> CIFilter & CIUnsharpMask { _UnsharpMaskFilter(kind: .unsharpMask) }
+    public static func vignette() -> CIFilter & CIVignette { _VignetteFilter(kind: .vignette) }
+    public static func qrCodeGenerator() -> CIFilter & CIQRCodeGenerator { _QRCodeGeneratorFilter(kind: .qrCodeGenerator) }
+}
+
+// The typed properties, shared by the filter classes below.
+extension CIFilter {
+    var _inputImage: CIImage? {
+        get { image(kCIInputImageKey) }
+        set { setImage(kCIInputImageKey, newValue) }
+    }
+    var _intensity: Float {
+        get { Float(number(kCIInputIntensityKey)) }
+        set { setNumber(kCIInputIntensityKey, Double(newValue)) }
+    }
+    var _radius: Float {
+        get { Float(number(kCIInputRadiusKey)) }
+        set { setNumber(kCIInputRadiusKey, Double(newValue)) }
+    }
+    var _scale: Float {
+        get { Float(number(kCIInputScaleKey)) }
+        set { setNumber(kCIInputScaleKey, Double(newValue)) }
+    }
+    var _center: CGPoint {
+        get { point(kCIInputCenterKey) }
+        set { setValue(CIVector(cgPoint: newValue), forKey: kCIInputCenterKey) }
+    }
+}
+
+final class _SepiaToneFilter: CIFilter, CISepiaTone {
+    var inputImage: CIImage? { get { _inputImage } set { _inputImage = newValue } }
+    var intensity: Float { get { _intensity } set { _intensity = newValue } }
+}
+
+final class _CrystallizeFilter: CIFilter, CICrystallize {
+    var inputImage: CIImage? { get { _inputImage } set { _inputImage = newValue } }
+    var radius: Float { get { _radius } set { _radius = newValue } }
+    var center: CGPoint { get { _center } set { _center = newValue } }
+}
+
+final class _EdgesFilter: CIFilter, CIEdges {
+    var inputImage: CIImage? { get { _inputImage } set { _inputImage = newValue } }
+    var intensity: Float { get { _intensity } set { _intensity = newValue } }
+}
+
+final class _GaussianBlurFilter: CIFilter, CIGaussianBlur {
+    var inputImage: CIImage? { get { _inputImage } set { _inputImage = newValue } }
+    var radius: Float { get { _radius } set { _radius = newValue } }
+}
+
+final class _PixellateFilter: CIFilter, CIPixellate {
+    var inputImage: CIImage? { get { _inputImage } set { _inputImage = newValue } }
+    var center: CGPoint { get { _center } set { _center = newValue } }
+    var scale: Float { get { _scale } set { _scale = newValue } }
+}
+
+final class _UnsharpMaskFilter: CIFilter, CIUnsharpMask {
+    var inputImage: CIImage? { get { _inputImage } set { _inputImage = newValue } }
+    var radius: Float { get { _radius } set { _radius = newValue } }
+    var intensity: Float { get { _intensity } set { _intensity = newValue } }
+}
+
+final class _VignetteFilter: CIFilter, CIVignette {
+    var inputImage: CIImage? { get { _inputImage } set { _inputImage = newValue } }
+    var intensity: Float { get { _intensity } set { _intensity = newValue } }
+    var radius: Float { get { _radius } set { _radius = newValue } }
+}
+
+final class _QRCodeGeneratorFilter: CIFilter, CIQRCodeGenerator {
+    // `message` and `correctionLevel` are CIFilter's own (CIFilter.swift).
+}

package/Sources/CoreImage/CIImage.swift

@@ -0,0 +1,162 @@
+// Core Image, as far as SwiftUI apps use it: an image from a UIImage or a
+// file, the built-in filters of `CoreImage.CIFilterBuiltins` that Hacking
+// with SwiftUI's Instafilter and Hot Prospects apply (sepia tone, crystallize,
+// edges, Gaussian blur, pixellate, unsharp mask, vignette, the QR code
+// generator), and a context that turns the result into a `CGImage`.
+//
+// Nothing is computed here but sizes. A `CIImage` is a recipe (the shim's
+// `_ImageRecipe`: a source plus filter steps); the page runs the steps on
+// the decoded pixels when it draws the image (Web/src/imageOps.ts,
+// docs/ops-protocol.md, "Bitmaps and Core Image"). The QR code generator is
+// the exception: it makes its modules here, as a pixel buffer.
+//
+// `import CoreImage.CIFilterBuiltins` names a Clang submodule on Apple
+// platforms; a Swift module has none, so the CLI stages that line as
+// `import CoreImage` (packages/cli/src/stage.ts).
+
+// Only the Foundation types Core Image takes are imported: Foundation's own
+// CGRect and CGPoint would clash with the shim's, which the apps use (the
+// CLI's generated file settles them the same way).
+import struct Foundation.Data
+import SwiftUI
+
+/// An image in Core Image's coordinate space: units of source pixels, origin
+/// at the bottom left. Immutable; filters make new ones.
+public final class CIImage: @unchecked Sendable {
+    public let _recipe: _ImageRecipe
+
+    public init(_recipe recipe: _ImageRecipe) {
+        _recipe = recipe
+    }
+
+    /// The rectangle the image covers; `.infinite` after `clampedToExtent()`,
+    /// `.null` for an empty image.
+    public var extent: CGRect { _recipe.extent }
+
+    /// An image with nothing in it.
+    public static func empty() -> CIImage { CIImage(_recipe: .empty) }
+
+    /// The bitmap's pixels, `(0, 0, width, height)`.
+    public convenience init(cgImage: CGImage) {
+        self.init(_recipe: cgImage._recipe)
+    }
+
+    public convenience init(cgImage: CGImage, options: [CIImageOption: Any]?) {
+        self.init(cgImage: cgImage)
+    }
+
+    /// A UIImage's bitmap; nil for an empty image, an SF Symbol or a catalog
+    /// image (the page holds those). Its extent is the bitmap in pixels.
+    public convenience init?(image: UIImage) {
+        if let backing = image._ciImage as? CIImage {
+            self.init(_recipe: backing._recipe)
+            return
+        }
+        guard let recipe = image._recipe, recipe.source != nil else { return nil }
+        self.init(_recipe: recipe)
+    }
+
+    public convenience init?(image: UIImage, options: [CIImageOption: Any]?) {
+        self.init(image: image)
+    }
+
+    /// The image in a PNG, JPEG, GIF, WebP, BMP, HEIC or AVIF file.
+    public convenience init?(data: Data) {
+        guard let source = _ImageSource(encoded: [UInt8](data)) else { return nil }
+        self.init(_recipe: _ImageRecipe(source: source))
+    }
+
+    public convenience init?(data: Data, options: [CIImageOption: Any]?) {
+        self.init(data: data)
+    }
+
+    /// The image cut to `rect` (its extent becomes the overlap).
+    public func cropped(to rect: CGRect) -> CIImage {
+        let extent = self.extent.intersection(rect)
+        guard !extent.isNull, extent.width > 0, extent.height > 0 else { return .empty() }
+        if extent == self.extent { return self }
+        return CIImage(_recipe: _recipe.adding(.object([
+            "op": .string("crop"), "x": .number(extent.minX), "y": .number(extent.minY),
+            "width": .number(extent.width), "height": .number(extent.height),
+        ]), extent: extent))
+    }
+
+    /// The image repeated outward from its edge pixels without end, so a blur
+    /// does not fade at the borders; crop it afterwards.
+    public func clampedToExtent() -> CIImage {
+        guard _recipe.source != nil, !extent.isInfinite else { return self }
+        return CIImage(_recipe: _recipe.adding(.object(["op": .string("clamp")]), extent: .infinite))
+    }
+
+    /// The output of the filter `name` with this image as its input and
+    /// `parameters` set; the empty image for a filter the shim does not have.
+    public func applyingFilter(_ name: String, parameters params: [String: Any]) -> CIImage {
+        guard let filter = CIFilter(name: name) else { return .empty() }
+        filter.setValue(self, forKey: kCIInputImageKey)
+        for (key, value) in params { filter.setValue(value, forKey: key) }
+        return filter.outputImage ?? .empty()
+    }
+
+    public func applyingFilter(_ name: String) -> CIImage {
+        applyingFilter(name, parameters: [:])
+    }
+
+    /// `CIGaussianBlur` with `inputRadius` = `sigma`.
+    public func applyingGaussianBlur(sigma: Double) -> CIImage {
+        applyingFilter("CIGaussianBlur", parameters: [kCIInputRadiusKey: sigma])
+    }
+
+    /// The bitmap this image was made from, if it was made from one unchanged.
+    public var cgImage: CGImage? {
+        let extent = self.extent
+        guard _recipe.source != nil, !extent.isInfinite, !extent.isNull, extent.origin == .zero else { return nil }
+        return CGImage(_recipe: _recipe)
+    }
+}
+
+/// Options for creating an image; accepted and ignored.
+public struct CIImageOption: Hashable, RawRepresentable, Sendable {
+    public let rawValue: String
+    public init(rawValue: String) { self.rawValue = rawValue }
+
+    public static let applyOrientationProperty = CIImageOption(rawValue: "kCIImageApplyOrientationProperty")
+    public static let colorSpace = CIImageOption(rawValue: "kCIImageColorSpace")
+}
+
+/// A vector of up to four numbers; filters take points (`inputCenter`) as one.
+public final class CIVector: @unchecked Sendable {
+    private let values: [Double]
+
+    public init(values: [CGFloat], count: Int) { self.values = Array(values.prefix(count)) }
+    public convenience init(x: CGFloat) { self.init(values: [x], count: 1) }
+    public convenience init(x: CGFloat, y: CGFloat) { self.init(values: [x, y], count: 2) }
+    public convenience init(x: CGFloat, y: CGFloat, z: CGFloat) { self.init(values: [x, y, z], count: 3) }
+    public convenience init(x: CGFloat, y: CGFloat, z: CGFloat, w: CGFloat) { self.init(values: [x, y, z, w], count: 4) }
+    public convenience init(cgPoint point: CGPoint) { self.init(x: point.x, y: point.y) }
+    public convenience init(cgRect rect: CGRect) { self.init(x: rect.minX, y: rect.minY, z: rect.width, w: rect.height) }
+
+    public var count: Int { values.count }
+    public func value(at index: Int) -> CGFloat { index < values.count ? values[index] : 0 }
+    public var x: CGFloat { value(at: 0) }
+    public var y: CGFloat { value(at: 1) }
+    public var z: CGFloat { value(at: 2) }
+    public var w: CGFloat { value(at: 3) }
+    public var cgPointValue: CGPoint { CGPoint(x: x, y: y) }
+    public var cgRectValue: CGRect { CGRect(x: x, y: y, width: z, height: w) }
+}
+
+// UIKit's Core Image additions.
+extension UIImage {
+    /// An image drawn from `ciImage`'s extent, which must be finite.
+    public convenience init(ciImage: CIImage) {
+        self.init(ciImage: ciImage, scale: 1, orientation: .up)
+    }
+
+    public convenience init(ciImage: CIImage, scale: CGFloat, orientation: UIImage.Orientation) {
+        let recipe = ciImage._recipe.rendered(in: ciImage.extent) ?? .empty
+        self.init(_recipe: recipe, scale: scale, ciImage: ciImage)
+    }
+
+    /// The `CIImage` the image was made from with `UIImage(ciImage:)`, else nil.
+    public var ciImage: CIImage? { _ciImage as? CIImage }
+}