Vision Only Locates

/// Vision on the device: it only LOCATES text (docs/SPARK-ARCHITECTURE.md,
/// Practical photo translation). Pippa reads the photo herself and corrects
/// what Vision misread; the numbered lines tell her where things are and let
/// the phone draw her translation back over each one.
enum VisionReader {
    /// The lines in reading order (top to bottom, then left to right), boxes
    /// normalized with the origin at the top left.
    static func lines(in image: CGImage) async throws -> [VisionLine] {
        var request = RecognizeTextRequest()
        request.recognitionLevel = .accurate
        request.usesLanguageCorrection = true
        request.automaticallyDetectsLanguage = true
        let observations = try await request.perform(on: image, orientation: .up)
        let found: [(text: String, box: VisionLine.Box, confidence: Double)] = observations.compactMap { observation in
            guard let best = observation.topCandidates(1).first, let text = best.string.nonEmpty else { return nil }
            let rect = observation.boundingBox
            // Vision's origin is the lower left; the photo's is the upper left.
            let box = VisionLine.Box(x: rect.origin.x, y: 1 - rect.origin.y - rect.height,
                                     w: rect.width, h: rect.height)
            return (text, box, Double(best.confidence))
        }
        return ordered(found.map { VisionLine(n: 0, text: $0.text, box: $0.box, confidence: $0.confidence) })
    }

    /// Reading order: rows by their vertical centre (a row is anything whose
    /// centres sit within half a line of each other), each row left to
    /// right; then numbered from 1.
    static func ordered(_ lines: [VisionLine]) -> [VisionLine] {
        let sorted = lines.sorted { ($0.box.y + $0.box.h / 2) < ($1.box.y + $1.box.h / 2) }
        var rows: [[VisionLine]] = []
        for line in sorted {
            let centre = line.box.y + line.box.h / 2
            if let last = rows.last?.last,
               abs((last.box.y + last.box.h / 2) - centre) < min(last.box.h, line.box.h) / 2 {
                rows[rows.count - 1].append(line)
            } else {
                rows.append([line])
            }
        }
        var numbered: [VisionLine] = []
        for row in rows {
            for line in row.sorted(by: { $0.box.x < $1.box.x }) {
                var copy = line
                copy.n = numbered.count + 1
                numbered.append(copy)
            }
        }
        return numbered
    }

/// The photo with each Vision line outlined, and Pippa's translation drawn
/// over its line on a softened patch as soon as it arrives.
struct TranslatedPhoto: View {
    let image: UIImage
    let lines: [VisionLine]
    let translations: [Int: String]
    @State private var showTranslations = true

    var body: some View {
        Image(uiImage: image)
            .resizable()
            .scaledToFit()
            .overlay {
                GeometryReader { geometry in
                    ForEach(lines) { line in
                        let rect = OverlayGeometry.rect(line.box, in: geometry.size)
                        if showTranslations, let text = translations[line.n] {
                            Text(text)
                                .font(.system(size: OverlayGeometry.fontSize(for: rect)))
                                .minimumScaleFactor(0.35)
                                .lineLimit(2)
                                .foregroundStyle(.white)
                                .padding(.horizontal, 2)
                                .frame(width: rect.width, height: rect.height)
                                .background(.ultraThinMaterial.opacity(0.95), in: RoundedRectangle(cornerRadius: 3))
                                .position(x: rect.midX, y: rect.midY)
                        } else {
                            RoundedRectangle(cornerRadius: 2)
                                .stroke(Palette.ember.opacity(0.85), lineWidth: 1.5)
                                .frame(width: rect.width, height: rect.height)
                                .position(x: rect.midX, y: rect.midY)
                        }
                    }
                }
            }
            .clipShape(RoundedRectangle(cornerRadius: 12))
            .onTapGesture { showTranslations.toggle() }
            .accessibilityLabel(showTranslations ? "Photo with translations; tap to see the original" : "The original photo; tap for translations")
    }
}

/// Where a normalized Vision box lands on the drawn photo, and how big its
/// type can be.
enum OverlayGeometry {
    static func rect(_ box: VisionLine.Box, in size: CGSize) -> CGRect {
        CGRect(x: box.x * size.width, y: box.y * size.height,
               width: max(box.w * size.width, 8), height: max(box.h * size.height, 8))
    }

    static func fontSize(for rect: CGRect) -> CGFloat {
        min(max(rect.height * 0.72, 8), 34)
    }
}