SPB Git

Repository Public License

VectorStudioModel.swift 15.0 KB 353 lines swift

1// ORIX Convert — App/Sources/Features/VectorStudio/VectorStudioModel.swift2// Description: Vector Studio state: the raster source, the tracing options (the engine's own descriptors), live3//              tracing with the engine's Vectorizer (a fast preview pass while a control moves, the full pass when4//              it rests; stale work is cancelled), and export through the real engine paths.5// Author: Simon-Pierre Boucher — contact@spboucher.ai6import AppKit7import ConvertCore8import EngineVector9import Observation10import UniformTypeIdentifiers1112enum VectorViewMode: String, CaseIterable, Identifiable {13    case original, vector, split, outline14    var id: String { rawValue }15    var title: String {16        switch self {17        case .original: L("Original")18        case .vector: L("Vector")19        case .split: L("Split")20        case .outline: L("Outline")21        }22    }23}2425/// A flag the tracer polls from its own thread.26nonisolated final class CancelFlag: @unchecked Sendable {27    private let lock = NSLock()28    private var cancelled = false29    func cancel() { lock.lock(); cancelled = true; lock.unlock() }30    var isCancelled: Bool { lock.lock(); defer { lock.unlock() }; return cancelled }31}3233struct PaletteEntry: Identifiable, Hashable {34    let color: VectorColor35    let shapes: Int36    var id: String { color.hex }37}3839@Observable final class VectorStudioModel {40    enum Pass: Equatable { case none, preview, full }4142    @ObservationIgnored unowned let app: AppModel43    let viewport = Viewport()4445    private(set) var source: URL?46    private(set) var sourceFormat: FormatID?47    private(set) var sourceBytes: Int64?48    private(set) var raster: DecodedRaster?49    private(set) var loadError: String?50    private(set) var isLoading = false51    /// More files dropped with the first one: candidates for "Apply to N files".52    private(set) var batch: [URL] = []5354    private(set) var descriptors: [OptionDescriptor] = []55    private(set) var optionValues: [String: OptionValue] = [:]5657    var viewMode: VectorViewMode = .split58    var showNodes = false5960    private(set) var result: VectorResult?61    private(set) var pass: Pass = .none62    private(set) var isTracing = false63    /// Stages finished ÷ stages, reported by the tracer during the full pass.64    private(set) var traceFraction: Double?65    private(set) var traceError: String?66    private(set) var layers: [(path: CGPath, color: CGColor)] = []67    private(set) var nodes: [CGPoint] = []68    private(set) var palette: [PaletteEntry] = []69    private(set) var notice: String?70    private(set) var noticeURL: URL?71    private(set) var isExporting = false7273    @ObservationIgnored private var traceTask: Task<Void, Never>?74    @ObservationIgnored private var flag = CancelFlag()75    @ObservationIgnored private var loadTask: Task<Void, Never>?7677    init(app: AppModel) { self.app = app }7879    nonisolated static let previewDimension = 5128081    var mode: VectorMode {82        if case .string(let raw)? = optionValues[VectorOptionKey.mode], let mode = VectorMode(rawValue: raw) { return mode }83        return .logo84    }85    var options: ConversionOptions { ConversionOptions(optionValues) }86    var imageSize: CGSize { raster.map { CGSize(width: $0.sourceWidth, height: $0.sourceHeight) } ?? .zero }87    /// The descriptors shown in the form: everything the engine declares except the mode (drawn as chips).88    var formDescriptors: [OptionDescriptor] { descriptors.filter { $0.id != VectorOptionKey.mode } }89    var hasFullResult: Bool { pass == .full && result != nil }90    var photographicWarning: VectorWarning? { result?.warnings.first { $0.code == "photographic-content" } }9192    // MARK: Source9394    func choose() {95        let panel = NSOpenPanel()96        panel.canChooseFiles = true97        panel.canChooseDirectories = false98        panel.allowsMultipleSelection = true99        panel.allowedContentTypes = [.image]100        panel.prompt = L("Trace")101        panel.message = L("Choose an image to trace into vector shapes")102        if panel.runModal() == .OK, !panel.urls.isEmpty { load(panel.urls) }103    }104105    func load(_ urls: [URL]) {106        loadTask?.cancel()107        loadTask = Task { await open(urls) }108    }109110    func open(_ urls: [URL], mode wanted: VectorMode? = nil) async {111        guard let url = urls.first else { return }112        cancelTrace()113        source = url114        batch = Array(urls.dropFirst())115        raster = nil; result = nil; pass = .none; layers = []; nodes = []; palette = []116        loadError = nil; traceError = nil; notice = nil; noticeURL = nil117        isLoading = true118        viewport.fit()119        let detection = FileTypeDetector.detect(url)120        sourceFormat = detection.format121        sourceBytes = FileInspector.facts(of: url).size122        guard let format = detection.format, let path = app.registry.paths(from: format, to: .svg, operation: .some(VectorEngine.vectorizeOperation)).first,123              let engine = app.registry.engine(id: path.engine) else {124            isLoading = false125            loadError = L("“%@” is not an image the tracer can read (%@).", url.lastPathComponent, detection.format?.displayName ?? L("Unknown format"))126            return127        }128        descriptors = engine.options(for: path)129        let decoded = await Task.detached(priority: .userInitiated) { () -> Result<DecodedRaster, Error> in130            Result { try RasterDecoder.decode(url) }131        }.value132        guard !Task.isCancelled, source == url else { return }133        isLoading = false134        switch decoded {135        case .failure(let error): loadError = LE((error as? LocalizedError)?.errorDescription ?? error.localizedDescription)136        case .success(let image):137            raster = image138            let launchMode = app.launch.vectorMode.flatMap { VectorMode(rawValue: $0) }139            apply(mode: wanted ?? launchMode ?? self.mode)140        }141    }142143    func clear() {144        loadTask?.cancel()145        cancelTrace()146        source = nil; raster = nil; result = nil; pass = .none; layers = []; nodes = []; palette = []; batch = []147        loadError = nil; traceError = nil; notice = nil; noticeURL = nil148    }149150    // MARK: Options151152    /// Fills every control from the engine's preset for the mode.153    func apply(mode: VectorMode) {154        optionValues = VectorEngine.presetOptions(for: mode).values155        scheduleTrace(debounce: false)156    }157158    func setOption(_ key: String, _ value: OptionValue?) {159        if let value { optionValues[key] = value } else { optionValues[key] = nil }160        scheduleTrace(debounce: true)161    }162163    // MARK: Tracing164165    func cancelTrace() {166        traceTask?.cancel()167        flag.cancel()168        isTracing = false169        traceFraction = nil170    }171172    private func scheduleTrace(debounce: Bool) {173        traceTask?.cancel()174        flag.cancel()175        guard raster != nil else { return }176        isTracing = true177        traceFraction = nil178        traceTask = Task { [weak self] in179            if debounce { try? await Task.sleep(for: .milliseconds(45)) }180            if Task.isCancelled { return }181            await self?.trace(previewFirst: true)182        }183    }184185    /// Runs the full pass now and waits for it (self-test, export).186    func traceNow() async {187        traceTask?.cancel()188        flag.cancel()189        let task = Task { await trace(previewFirst: false) }190        traceTask = task191        await task.value192    }193194    private func trace(previewFirst: Bool) async {195        guard let raster else { return }196        let settings: VectorSettings197        do { settings = try VectorSettings(options: options) } catch {198            traceError = LE((error as? LocalizedError)?.errorDescription ?? error.localizedDescription)199            isTracing = false200            return201        }202        let flag = CancelFlag()203        self.flag = flag204        isTracing = true205        traceError = nil206        let image = SendableImage(raster.image)207        let size = (width: raster.sourceWidth, height: raster.sourceHeight)208        let measure = options.bool(VectorOptionKey.measureSimilarity, default: true)209        if previewFirst, max(raster.image.width, raster.image.height) > Self.previewDimension {210            let quick = await Task.detached(priority: .userInitiated) {211                try? Vectorizer().trace(image.image, settings: settings, quality: .preview(maxDimension: Self.previewDimension), documentSize: size,212                                        measureSimilarity: false, isCancelled: { flag.isCancelled })213            }.value214            if Task.isCancelled || flag.isCancelled { return }215            if let quick { show(quick, pass: .preview) }216            // The full pass starts once the controls have rested.217            try? await Task.sleep(for: .milliseconds(380))218            if Task.isCancelled || flag.isCancelled { return }219        }220        let full = await Task.detached(priority: .userInitiated) { [weak self] () -> Result<VectorResult, Error> in221            Result {222                try Vectorizer().trace(image.image, settings: settings, quality: .full, documentSize: size, measureSimilarity: measure,223                                       progress: { _, fraction in Task { @MainActor in if !flag.isCancelled { self?.traceFraction = fraction } } },224                                       isCancelled: { flag.isCancelled })225            }226        }.value227        if Task.isCancelled || flag.isCancelled { return }228        isTracing = false229        traceFraction = nil230        switch full {231        case .success(let value): show(value, pass: .full)232        case .failure(let error):233            if error is CancellationError { return }234            traceError = LE((error as? LocalizedError)?.errorDescription ?? error.localizedDescription)235        }236    }237238    private func show(_ value: VectorResult, pass: Pass) {239        result = value240        self.pass = pass241        layers = value.document.cgLayers242        var points: [CGPoint] = []243        points.reserveCapacity(value.document.nodeCount + value.document.subpathCount)244        var counts: [VectorColor: Int] = [:]245        var order: [VectorColor] = []246        for layer in value.document.layers {247            if counts[layer.color] == nil { order.append(layer.color) }248            counts[layer.color, default: 0] += layer.subpaths.count249            for subpath in layer.subpaths {250                points.append(subpath.start.cgPoint)251                for segment in subpath.segments { points.append(segment.end.cgPoint) }252            }253        }254        nodes = points255        palette = order.map { PaletteEntry(color: $0, shapes: counts[$0] ?? 0) }256    }257258    // MARK: Export259260    private func request(for destinationFormat: FormatID, to url: URL) -> ConversionJobRequest? {261        guard let source else { return nil }262        let name = url.deletingPathExtension().lastPathComponent.replacingOccurrences(of: "{", with: "(").replacingOccurrences(of: "}", with: ")")263        return ConversionJobRequest(sources: [source], sourceFormat: sourceFormat, destinationFormat: destinationFormat, operation: VectorEngine.vectorizeOperation, options: options,264                                    destination: OutputDestination(directory: url.deletingLastPathComponent(), nameTemplate: name, conflictPolicy: .replace))265    }266267    /// Converts through the vector engine (trace, validation, safe writer) and writes `url`. Returns the written file.268    @discardableResult269    func export(_ destinationFormat: FormatID, to url: URL) async -> URL? {270        guard let request = request(for: destinationFormat, to: url) else { return nil }271        isExporting = true272        defer { isExporting = false }273        let job = await app.studio.run(request)274        guard let job, job.state == .finished, let written = job.outputs.first?.url else {275            notice = job?.error.map { LE($0) } ?? L("The export did not finish.")276            noticeURL = nil277            return nil278        }279        notice = L("“%@” was exported and verified.", written.lastPathComponent)280        noticeURL = written281        return written282    }283284    func exportWithPanel(_ destinationFormat: FormatID) {285        guard let source else { return }286        let panel = NSSavePanel()287        let ext = destinationFormat.catalogEntry?.preferredExtension ?? destinationFormat.rawValue288        panel.nameFieldStringValue = source.deletingPathExtension().lastPathComponent + "." + ext289        if let type = UTType(filenameExtension: ext) { panel.allowedContentTypes = [type] }290        panel.directoryURL = source.deletingLastPathComponent()291        panel.prompt = L("Export")292        guard panel.runModal() == .OK, let url = panel.url else { return }293        Task { await export(destinationFormat, to: url) }294    }295296    func copySVG() {297        guard hasFullResult, let svg = result?.svg else { return }298        let pasteboard = NSPasteboard.general299        pasteboard.clearContents()300        pasteboard.setString(svg, forType: .string)301        pasteboard.setString(svg, forType: NSPasteboard.PasteboardType(UTType.svg.identifier))302        notice = L("The SVG was copied (%@).", Fmt.bytes(Int64(svg.utf8.count)))303        noticeURL = nil304    }305306    /// An item that delivers the traced drawing as an `.svg` file when it is dropped (Finder or another app).307    func dragProvider() -> NSItemProvider {308        let provider = NSItemProvider()309        guard hasFullResult, let svg = result?.svg, let source else { return provider }310        let name = source.deletingPathExtension().lastPathComponent311        provider.suggestedName = name312        let folder = app.studio.scratchDirectory("drag")313        provider.registerFileRepresentation(forTypeIdentifier: UTType.svg.identifier, fileOptions: [], visibility: .all) { completion in314            let url = folder.appendingPathComponent(name + ".svg")315            do {316                try Data(svg.utf8).write(to: url, options: .atomic)317                completion(url, false, nil)318            } catch { completion(nil, false, error) }319            return nil320        }321        return provider322    }323324    /// Sends files to the Convert queue with the current tracing settings.325    func applyToFiles(_ urls: [URL]) {326        let files = urls.filter(\.isFileURL)327        guard !files.isEmpty else { return }328        let record = app.settings.stored.historyEnabled329        let options = options330        let requests = files.map { url in331            var request = ConversionJobRequest(sources: [url], destinationFormat: .svg, operation: VectorEngine.vectorizeOperation, options: options, destination: app.defaultDestination)332            request.recordInHistory = record333            return request334        }335        app.section = .convert336        app.convertPane = .queue337        Task { _ = await app.queue.enqueue(requests) }338    }339340    func chooseBatch() {341        let panel = NSOpenPanel()342        panel.canChooseFiles = true343        panel.canChooseDirectories = false344        panel.allowsMultipleSelection = true345        panel.allowedContentTypes = [.image]346        panel.prompt = L("Trace")347        panel.message = L("Choose the images to trace with these settings")348        if panel.runModal() == .OK { applyToFiles(panel.urls) }349    }350351    func dismissNotice() { notice = nil; noticeURL = nil }352}353
Files main
Menu

Theme