@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.1

package/pipeline/skills/shared/external/vision-framework/SKILL.md

@@ -1,477 +1,362 @@
 ---
 name: vision-framework
-description: "Implement computer vision features including text recognition (OCR), face detection, barcode scanning, image segmentation, object tracking, and document scanning in iOS apps. Covers both the modern Swift-native Vision API (iOS 16+) and legacy VNRequest patterns, VisionKit DataScannerViewController for live camera scanning, and VNCoreMLRequest for custom model inference. Use when adding OCR, barcode scanning, face detection, or custom Core ML model inference with Vision."
+description: "On-device computer vision with Vision and VisionKit: OCR, face detection and landmarks, barcode and QR scanning, person and instance segmentation, object tracking, document reading and scanning, saliency, pose, Core ML inference, Swift-native (iOS 18+) and legacy VNRequest APIs, DataScannerViewController live scanning. Use when adding OCR, barcode scanning, face detection, segmentation, tracking or Core ML image inference through Vision. Not for Core ML model conversion."
 metadata:
-  source: "dpearson2699/swift-ios-skills (PolyForm Perimeter 1.0.0)"
+  source: multi-agent-pipeline
 ---
 
 # Vision Framework
 
-Detect text, faces, barcodes, objects, and body poses in images and video using
-on-device computer vision. Patterns target iOS 26+ with Swift 6.3,
-backward-compatible where noted.
+Vision finds text, faces, barcodes, objects, people and body poses in still
+images and video frames. Everything runs on the device; no image leaves it.
+VisionKit sits on top and supplies ready-made camera UI for live scanning and
+document capture.
 
-See [references/vision-requests.md](references/vision-requests.md) for complete code patterns and
-[references/visionkit-scanner.md](references/visionkit-scanner.md) for DataScannerViewController integration.
+Baseline for this skill: iOS 26 and Swift 6.3. Where an API has a lower floor
+it is stated next to the API, so older deployment targets can still use the
+guidance.
 
-## Contents
+Load a reference when the section below is not enough:
 
-- [Two API Generations](#two-api-generations)
-- [Request Pattern (Modern API)](#request-pattern-modern-api)
-- [Text Recognition (OCR)](#text-recognition-ocr)
-- [Face Detection](#face-detection)
-- [Barcode Detection](#barcode-detection)
-- [Document Scanning (iOS 26+)](#document-scanning-ios-26)
-- [Image Segmentation](#image-segmentation)
-- [Object Tracking](#object-tracking)
-- [Other Request Types](#other-request-types)
-- [Core ML Integration](#core-ml-integration)
-- [VisionKit: DataScannerViewController](#visionkit-datascannerviewcontroller)
-- [Common Mistakes](#common-mistakes)
-- [Review Checklist](#review-checklist)
-- [References](#references)
+- `references/vision-requests.md`: longer request recipes (OCR pipeline, faces,
+  barcodes, segmentation and blur, saliency, rectangles, horizon, batching,
+  camera frames, tracking, coordinate helpers, performance).
+- `references/visionkit-scanner.md`: camera permission, `DataScannerViewController`
+  in UIKit and SwiftUI, delegate and async item streams, overlays, and
+  `VNDocumentCameraViewController` with an OCR pass.
 
-## Two API Generations
+## Choosing an API generation
 
-Vision has two distinct API layers. Prefer the modern API for new code.
+Vision ships two parallel APIs. New code should use the Swift-native one.
 
-| Aspect | Modern (iOS 18+) | Legacy |
+| Aspect | Swift-native API | Legacy API |
 |---|---|---|
-| Pattern | `let result = try await request.perform(on: image)` | `VNImageRequestHandler` + completion handler |
-| Request types | Swift types  -  structs and classes (`RecognizeTextRequest`, `DetectFaceRectanglesRequest`) | ObjC classes (`VNRecognizeTextRequest`, `VNDetectFaceRectanglesRequest`) |
-| Concurrency | Native async/await | Completion handlers or synchronous `perform` |
-| Observations | Typed return values | Cast `results` from `[Any]` |
-| Availability | iOS 18+ / macOS 15+ | iOS 11+ |
+| Availability | iOS 18, macOS 15, tvOS 18, visionOS 2 | iOS 11 and later (individual requests vary, e.g. `VNRecognizeTextRequest` is iOS 13) |
+| Types | Swift structs such as `RecognizeTextRequest`, `DetectFaceRectanglesRequest` | Objective-C classes such as `VNRecognizeTextRequest`, `VNDetectFaceRectanglesRequest` |
+| Running | `try await request.perform(on: image)` | `VNImageRequestHandler` plus `perform([request])` and a completion closure |
+| Results | Typed return value (`[RecognizedTextObservation]`, `[FaceObservation]`) | `request.results` cast from a generic observation array |
+| Geometry | `NormalizedRect` / `NormalizedPoint` with conversion helpers | `CGRect` / `CGPoint` in normalized space |
 
-The modern API uses the `ImageProcessingRequest` protocol. Each request type
-has a `perform(on:orientation:)` method that accepts `CGImage`, `CIImage`,
-`CVPixelBuffer`, `CMSampleBuffer`, `Data`, or `URL`. Most requests are
-structs; stateful requests for video tracking (e.g., `TrackObjectRequest`,
-`TrackRectangleRequest`, `DetectTrajectoriesRequest`) are final classes.
+Every Swift-native image request conforms to `ImageProcessingRequest`, whose
+`perform(on:orientation:)` accepts a `CGImage`, `CIImage`, `CVPixelBuffer`,
+`CMSampleBuffer`, image `Data` or a file `URL`. The orientation argument is
+optional.
 
-## Request Pattern (Modern API)
+Most requests are value types. Requests that must remember earlier frames are
+`final class` types conforming to `StatefulRequest`: `TrackObjectRequest`,
+`TrackRectangleRequest`, `TrackOpticalFlowRequest`, `DetectTrajectoriesRequest`,
+`DetectHumanBodyPose3DRequest` and `GeneratePersonSegmentationRequest`. Keep one
+instance alive for the whole sequence.
 
-All modern Vision requests follow the same pattern: create a request struct,
-call `perform(on:)`, and handle the typed result.
+## The request pattern
+
+Build the request, set options, await `perform(on:)`, read typed results.
 
 ```swift
 import Vision
 
-func recognizeText(in image: CGImage) async throws -> [String] {
+func menuLines(in photo: CGImage) async throws -> [String] {
     var request = RecognizeTextRequest()
     request.recognitionLevel = .accurate
-    request.recognitionLanguages = [Locale.Language(identifier: "en-US")]
-
-    let observations = try await request.perform(on: image)
-    return observations.compactMap { observation in
-        observation.topCandidates(1).first?.string
-    }
+    request.recognitionLanguages = [Locale.Language(identifier: "it-IT")]
+    let observations = try await request.perform(on: photo)
+    return observations.compactMap { $0.topCandidates(1).first?.string }
 }
 ```
 
-### Legacy Pattern (Pre-iOS 18)
-
-Use `VNImageRequestHandler` with completion-based requests when targeting
-older deployment versions.
+The same job with the legacy API, for deployment targets below iOS 18:
 
 ```swift
 import Vision
 
-func recognizeTextLegacy(in image: CGImage) throws -> [String] {
-    var recognized: [String] = []
-    let request = VNRecognizeTextRequest { request, error in
-        guard let observations = request.results as? [VNRecognizedTextObservation] else { return }
-        recognized = observations.compactMap { $0.topCandidates(1).first?.string }
+func legacyMenuLines(in photo: CGImage) throws -> [String] {
+    var lines: [String] = []
+    let request = VNRecognizeTextRequest { finished, _ in
+        let found = finished.results as? [VNRecognizedTextObservation] ?? []
+        lines = found.compactMap { $0.topCandidates(1).first?.string }
     }
     request.recognitionLevel = .accurate
-
-    let handler = VNImageRequestHandler(cgImage: image)
-    try handler.perform([request])
-    return recognized
+    try VNImageRequestHandler(cgImage: photo).perform([request])
+    return lines
 }
 ```
 
-## Text Recognition (OCR)
-
-### Modern: RecognizeTextRequest (iOS 18+)
-
-```swift
-var request = RecognizeTextRequest()
-request.recognitionLevel = .accurate       // .fast for real-time
-request.recognitionLanguages = [
-    Locale.Language(identifier: "en-US"),
-    Locale.Language(identifier: "fr-FR"),
-]
-request.usesLanguageCorrection = true
-request.customWords = ["SwiftUI", "Xcode"] // domain-specific terms
-
-let observations = try await request.perform(on: cgImage)
-for observation in observations {
-    guard let candidate = observation.topCandidates(1).first else { continue }
-    let text = candidate.string
-    let confidence = candidate.confidence  // 0.0 ... 1.0
-    let bounds = observation.boundingBox   // normalized coordinates
-}
-```
+`VNImageRequestHandler.perform` is synchronous and calls the completion before
+it returns, so run it on a background queue.
 
-### Legacy: VNRecognizeTextRequest
+## Text recognition (OCR)
 
-```swift
-let request = VNRecognizeTextRequest()
-request.recognitionLevel = .accurate
-request.recognitionLanguages = ["en-US", "fr-FR"]
-request.usesLanguageCorrection = true
-```
+`RecognizeTextRequest` (iOS 18+) options:
 
-**Key differences:** Modern API uses `Locale.Language` for languages; legacy
-uses string identifiers. Both support `.accurate` (best quality) and `.fast`
-(real-time suitable) recognition levels.
+- `recognitionLevel`: `.accurate` for stills and offline work, `.fast` for
+  live video.
+- `recognitionLanguages`: `[Locale.Language]`, ordered by priority.
+- `usesLanguageCorrection`: applies language-model correction; turn it off for
+  codes, serial numbers and similar strings.
+- `customWords`: domain vocabulary the corrector should accept.
 
-## Face Detection
+Each `RecognizedTextObservation` offers `topCandidates(_:)`; a candidate
+(`RecognizedText`) has `string` and a `confidence` from 0.0 to 1.0. The
+observation's `boundingBox` is a `NormalizedRect`.
 
-Detect face rectangles, landmarks (eyes, nose, mouth), and capture quality.
+`VNRecognizeTextRequest` has the same `recognitionLevel` and
+`usesLanguageCorrection` switches but takes languages as identifier strings
+such as `["de-DE", "en-GB"]`. That is the practical difference: `Locale.Language`
+values in the new API, strings in the old one.
 
-```swift
-// Modern API
-let faceRequest = DetectFaceRectanglesRequest()
-let faces = try await faceRequest.perform(on: cgImage)
-
-for face in faces {
-    let boundingBox = face.boundingBox   // normalized CGRect
-    let roll = face.roll                 // Measurement<UnitAngle>
-    let yaw = face.yaw                  // Measurement<UnitAngle>
-}
+## Faces
 
-// Landmarks (eyes, nose, mouth contours)
-var landmarkRequest = DetectFaceLandmarksRequest()
-let landmarkFaces = try await landmarkRequest.perform(on: cgImage)
-for face in landmarkFaces {
-    let landmarks = face.landmarks
-    let leftEye = landmarks?.leftEye?.normalizedPoints
-    let nose = landmarks?.nose?.normalizedPoints
-}
-```
+- `DetectFaceRectanglesRequest` returns `[FaceObservation]`. Each has a
+  `boundingBox` (`NormalizedRect`) and `roll`, `yaw` and `pitch` as
+  `Measurement<UnitAngle>`.
+- `DetectFaceLandmarksRequest` fills the optional `landmarks`. Regions such as
+  `leftEye`, `rightEye`, `nose`, `outerLips` and `faceContour` expose `points`
+  (`[NormalizedPoint]`) and `pointsInImageCoordinates(_:origin:)`. The legacy
+  `VNFaceLandmarkRegion2D` calls the same data `normalizedPoints`.
+- `DetectFaceCaptureQualityRequest` fills `captureQuality?.score`.
 
-### Coordinate System
+### Coordinates
 
-Vision uses a normalized coordinate system with origin at the bottom-left.
-Convert to UIKit (top-left origin) before display:
+Vision coordinates are normalized to 0...1 with the origin at the lower left.
+UIKit and SwiftUI put the origin at the top left, so flip before drawing:
 
 ```swift
-func convertToUIKit(_ rect: CGRect, imageHeight: CGFloat) -> CGRect {
-    CGRect(
-        x: rect.origin.x,
-        y: imageHeight - rect.origin.y - rect.height,
-        width: rect.width,
-        height: rect.height
-    )
-}
-```
-
-## Barcode Detection
+import Vision
 
-Detect 1D and 2D barcodes including QR codes.
+func overlayFrame(for face: FaceObservation, imageSize: CGSize) -> CGRect {
+    face.boundingBox.toImageCoordinates(imageSize, origin: .upperLeft)
+}
 
-```swift
-var request = DetectBarcodesRequest()
-request.symbologies = [.qr, .ean13, .code128, .pdf417]
-
-let barcodes = try await request.perform(on: cgImage)
-for barcode in barcodes {
-    let payload = barcode.payloadString          // decoded content
-    let symbology = barcode.symbology            // .qr, .ean13, etc.
-    let bounds = barcode.boundingBox             // normalized rect
+func flippedRect(_ normalized: CGRect, imageSize: CGSize) -> CGRect {
+    let w = normalized.width * imageSize.width
+    let h = normalized.height * imageSize.height
+    let x = normalized.minX * imageSize.width
+    let y = imageSize.height - normalized.minY * imageSize.height - h
+    return CGRect(x: x, y: y, width: w, height: h)
 }
 ```
 
-Common symbologies: `.qr`, `.aztec`, `.pdf417`, `.dataMatrix`, `.ean8`,
-`.ean13`, `.code39`, `.code128`, `.upce`, `.itf14`.
+The manual version keeps x, width and height and computes
+`y = imageHeight - originY - height`.
 
-## Document Scanning (iOS 26+)
+## Barcodes
 
-`RecognizeDocumentsRequest` provides structured document reading with layout
-understanding beyond basic OCR. Returns `DocumentObservation` objects with a
-nested `Container` structure for paragraphs, tables, lists, and barcodes.
+`DetectBarcodesRequest` reads 1D and 2D codes, QR included. Set `symbologies`
+to only what the product accepts, for example `[.qr, .pdf417, .ean13, .code128]`.
+Each `BarcodeObservation` carries `payloadString` (decoded text, optional),
+`symbology` and a normalized `boundingBox`. Frequently used symbologies:
+`.qr`, `.aztec`, `.dataMatrix`, `.pdf417`, `.ean8`, `.ean13`, `.upce`,
+`.code39`, `.code128`, `.itf14`. The full list is in
+`references/vision-requests.md`.
 
-```swift
-var request = RecognizeDocumentsRequest()
-let documents = try await request.perform(on: cgImage)
-
-for observation in documents {
-    let container = observation.document
+## Structured documents (iOS 26+)
 
-    // Full text content
-    let fullText = container.text
-
-    // Structured access to paragraphs
-    for paragraph in container.paragraphs {
-        let paragraphText = paragraph.text
-    }
+`RecognizeDocumentsRequest` goes beyond line-by-line OCR and understands layout.
+It returns `[DocumentObservation]`; `observation.document` is a
+`DocumentObservation.Container` with:
 
-    // Tables and lists
-    for table in container.tables { /* structured table data */ }
-    for list in container.lists { /* structured list data */ }
+- `text`: the whole document as a text block (`.transcript` for the string)
+- `paragraphs`: text blocks, each with `.transcript`
+- `tables` (rows and cells), `lists` (items), `barcodes`
+- `title`: optional text block
 
-    // Embedded barcodes detected within the document
-    for barcode in container.barcodes { /* barcode data */ }
+```swift
+import Vision
 
-    // Document title if detected
-    if let title = container.title { print(title) }
+func invoiceParagraphs(from scan: CGImage) async throws -> [String] {
+    let request = RecognizeDocumentsRequest()
+    guard let document = try await request.perform(on: scan).first?.document else { return [] }
+    return document.paragraphs.map(\.transcript)
 }
 ```
 
-For simpler document camera scanning, use VisionKit's
-`VNDocumentCameraViewController` which provides a full-screen camera UI with
-auto-capture, perspective correction, and multi-page scanning.
+When the user should photograph paper with the camera, VisionKit's
+`VNDocumentCameraViewController` is simpler: a full-screen camera with
+automatic capture, perspective correction and multi-page scans. See
+`references/visionkit-scanner.md`.
 
-## Image Segmentation
+## Segmentation
 
-### Modern: GeneratePersonSegmentationRequest (iOS 18+)
-
-```swift
-var request = GeneratePersonSegmentationRequest()
-request.qualityLevel = .accurate  // .balanced, .fast
+`GeneratePersonSegmentationRequest` (iOS 18+, a stateful class) returns a
+`PixelBufferObservation` mask. Read it as a `CGImage` with `try mask.cgImage`,
+wrap it in `CIImage`, and composite with Core Image's
+`CIFilter.blendWithMask()`.
 
-let mask = try await request.perform(on: cgImage)
-// mask is a PersonSegmentationObservation with a pixelBuffer property
-let maskBuffer = mask.pixelBuffer
-// Apply mask using Core Image: CIFilter.blendWithMask()
-```
+`qualityLevel` trades speed for detail. Approximate figures, to be confirmed
+on the target device:
 
-### Legacy: VNGeneratePersonSegmentationRequest
+| Level | Detail | Rough cost | Mask size |
+|---|---|---|---|
+| `.accurate` | best edges | about 1 s | full resolution |
+| `.balanced` | good | about 100 ms | 960 x 540 |
+| `.fast` | coarse | about 10 ms | 256 x 144, suits real time |
 
-```swift
-let request = VNGeneratePersonSegmentationRequest()
-request.qualityLevel = .accurate  // .balanced, .fast
-request.outputPixelFormat = kCVPixelFormatType_OneComponent8
+Legacy equivalent: `VNGeneratePersonSegmentationRequest` (iOS 15+) with
+`qualityLevel`, `outputPixelFormat = kCVPixelFormatType_OneComponent8`, run
+through `VNImageRequestHandler`; the mask is `request.results?.first?.pixelBuffer`.
 
-let handler = VNImageRequestHandler(cgImage: cgImage)
-try handler.perform([request])
+Instance segmentation separates people from each other:
 
-guard let mask = request.results?.first?.pixelBuffer else { return }
-// Apply mask using Core Image: CIFilter.blendWithMask()
-```
+- `GeneratePersonInstanceMaskRequest` (iOS 18+) returns an optional
+  `InstanceMaskObservation`. `allInstances` is an `IndexSet`;
+  `generateMask(for: IndexSet(integer: n))` returns a `CVPixelBuffer` showing
+  only person `n`.
+- `VNGeneratePersonInstanceMaskRequest` (iOS 17+) returns
+  `VNInstanceMaskObservation` with `allInstances`, `generateMask(forInstances:)`
+  and `generateMaskedImage(ofInstances:from:croppedToInstancesExtent:)`, which
+  takes the request handler and a crop flag.
 
-Quality levels:
-- `.accurate` -- best quality, slowest (~1s), full resolution
-- `.balanced` -- good quality, moderate speed (~100ms), 960x540
-- `.fast` -- lowest quality, fastest (~10ms), 256x144, suitable for real-time
+Code for masks, background blur and instances is in `references/vision-requests.md`.
 
-### Instance Segmentation (iOS 18+)
+## Object tracking
 
-Separate masks per person for individual effects.
+`TrackObjectRequest` (iOS 18+) is a `final class` that conforms to
+`ImageProcessingRequest` and `StatefulRequest` and keeps the tracking context
+between frames itself. Seed it once, then call `perform(on:)` on each frame
+with the same instance:
 
 ```swift
-// Modern API (iOS 18+)
-let request = GeneratePersonInstanceMaskRequest()
-let observation = try await request.perform(on: cgImage)
-let indices = observation.allInstances
-
-for index in indices {
-    let mask = try observation.generateMask(forInstances: IndexSet(integer: index))
-    // mask is a CVPixelBuffer with only this person visible
-}
-```
-
-```swift
-// Legacy API (iOS 17+)
-let request = VNGeneratePersonInstanceMaskRequest()
-let handler = VNImageRequestHandler(cgImage: cgImage)
-try handler.perform([request])
-
-guard let result = request.results?.first else { return }
-let indices = result.allInstances
-for index in indices {
-    let instanceMask = try result.generateMaskedImage(
-        ofInstances: IndexSet(integer: index),
-        from: handler,
-        croppedToInstancesExtent: false
-    )
-}
-```
-
-See [references/vision-requests.md](references/vision-requests.md) for mask composition and Core Image filter
-integration patterns.
-
-## Object Tracking
+import Vision
 
-### Modern: TrackObjectRequest (iOS 18+)
+final class BallTracker {
+    private let request: TrackObjectRequest
 
-`TrackObjectRequest` is a stateful request that maintains tracking context
-across frames. Conforms to both `ImageProcessingRequest` and `StatefulRequest`.
+    init(startBox: NormalizedRect) {
+        request = TrackObjectRequest(detectedObject: DetectedObjectObservation(boundingBox: startBox))
+    }
 
-```swift
-// Initialize with a detected object's bounding box
-let initialObservation = DetectedObjectObservation(boundingBox: detectedRect)
-var request = TrackObjectRequest(observation: initialObservation)
-request.trackingLevel = .accurate
-
-// For each video frame:
-let results = try await request.perform(on: pixelBuffer)
-if let tracked = results.first {
-    let updatedBounds = tracked.boundingBox
-    let confidence = tracked.confidence
+    func follow(_ frame: CVPixelBuffer) async throws -> (NormalizedRect, Float)? {
+        guard let hit = try await request.perform(on: frame) else { return nil }
+        return (hit.boundingBox, hit.confidence)
+    }
 }
 ```
 
-### Legacy: VNTrackObjectRequest
-
-```swift
-let trackRequest = VNTrackObjectRequest(detectedObjectObservation: initialObservation)
-trackRequest.trackingLevel = .accurate
-
-let sequenceHandler = VNSequenceRequestHandler()
-// For each frame:
-try sequenceHandler.perform([trackRequest], on: pixelBuffer)
-if let result = trackRequest.results?.first {
-    let updatedBounds = result.boundingBox
-    trackRequest.inputObservation = result
-}
-```
+The Swift-native `TrackObjectRequest` has no `trackingLevel`;
+`TrackRectangleRequest` does. With the legacy API, create
+`VNTrackObjectRequest(detectedObjectObservation:)`, set
+`trackingLevel = .accurate`, reuse one `VNSequenceRequestHandler` for every
+frame via `perform([request], on: pixelBuffer)`, and feed each result back
+through `inputObservation`.
 
-## Other Request Types
+## Other requests
 
-Vision provides additional requests covered in [references/vision-requests.md](references/vision-requests.md):
+All of these are Swift-native request types available on iOS 18 and macOS 15.
 
-| Request | Purpose |
+| Request | What it gives you |
 |---|---|
-| `ClassifyImageRequest` | Classify scene content (outdoor, food, animal, etc.) |
-| `GenerateAttentionBasedSaliencyImageRequest` | Heat map of where viewers focus attention |
-| `GenerateObjectnessBasedSaliencyImageRequest` | Heat map of object-like regions |
-| `GenerateForegroundInstanceMaskRequest` | Foreground object segmentation (not person-specific) |
-| `DetectRectanglesRequest` | Detect rectangular shapes (documents, cards, screens) |
-| `DetectHorizonRequest` | Detect horizon angle for auto-leveling photos |
-| `DetectHumanBodyPoseRequest` | Detect body joints (shoulders, elbows, knees) |
-| `DetectHumanBodyPose3DRequest` | 3D human body pose estimation |
-| `DetectHumanHandPoseRequest` | Detect hand joints and finger positions |
-| `DetectAnimalBodyPoseRequest` | Detect animal body joint positions |
-| `DetectFaceCaptureQualityRequest` | Face capture quality scoring (0-1) for photo selection |
-| `TrackRectangleRequest` | Track rectangular objects across video frames |
-| `TrackOpticalFlowRequest` | Optical flow between video frames |
-| `DetectTrajectoriesRequest` | Detect object trajectories in video |
-
-All modern request types above are iOS 18+ / macOS 15+.
-
-## Core ML Integration
-
-Run custom Core ML models through Vision for automatic image preprocessing
-(resizing, normalization, color space conversion).
+| `ClassifyImageRequest` | Scene labels (beach, food, dog, and so on) |
+| `GenerateAttentionBasedSaliencyImageRequest` | Heat map of where a viewer's eye goes |
+| `GenerateObjectnessBasedSaliencyImageRequest` | Heat map of regions that look like objects |
+| `GenerateForegroundInstanceMaskRequest` | Masks for foreground subjects of any kind, not only people |
+| `DetectRectanglesRequest` | Rectangular shapes: cards, receipts, screens |
+| `DetectHorizonRequest` | Horizon angle for straightening a photo |
+| `DetectHumanBodyPoseRequest` / `DetectHumanBodyPose3DRequest` | 2D body joints / 3D body pose |
+| `DetectHumanHandPoseRequest` | Hand and finger joints |
+| `DetectAnimalBodyPoseRequest` | Animal joints |
+| `DetectFaceCaptureQualityRequest` | Face capture quality score 0...1, for choosing the best shot |
+| `TrackRectangleRequest` | Follows a rectangle across frames |
+| `TrackOpticalFlowRequest` | Motion field between consecutive frames |
+| `DetectTrajectoriesRequest` | Paths of moving objects in video |
+
+## Running Core ML models through Vision
+
+Vision prepares the image for the model (scaling, cropping, pixel format,
+color space, orientation), so hand it the original image.
 
 ```swift
-// Modern API (iOS 18+)
-let model = try MLModel(contentsOf: modelURL)
-let request = CoreMLRequest(model: .init(model))
-let results = try await request.perform(on: cgImage)
-
-// Classification model
-if let classification = results.first as? ClassificationObservation {
-    let label = classification.identifier
-    let confidence = classification.confidence
-}
-```
+import CoreML
+import Vision
 
-```swift
-// Legacy API
-let vnModel = try VNCoreMLModel(for: model)
-let request = VNCoreMLRequest(model: vnModel) { request, error in
-    guard let results = request.results as? [VNClassificationObservation] else { return }
-    let topResult = results.first
+func plantSpecies(in leaf: CGImage, modelURL: URL) async throws -> (String, Float)? {
+    let model = try await MLModel.load(contentsOf: modelURL)
+    let request = CoreMLRequest(model: try CoreMLModelContainer(model: model))
+    let results = try await request.perform(on: leaf)
+    guard let best = results.first as? ClassificationObservation else { return nil }
+    return (best.identifier, best.confidence)
 }
-let handler = VNImageRequestHandler(cgImage: cgImage)
-try handler.perform([request])
 ```
 
-For model conversion and optimization, see the `coreml` skill.
+Before iOS 18: wrap the model with `VNCoreMLModel(for:)`, create
+`VNCoreMLRequest(model:completionHandler:)`, cast `results` to
+`[VNClassificationObservation]`, and run it with `VNImageRequestHandler`.
 
-## VisionKit: DataScannerViewController
+Model loading, compute units, conversion and optimization belong to the
+`coreml` skill.
 
-`DataScannerViewController` provides a full-screen live camera scanner for text
-and barcodes. See [references/visionkit-scanner.md](references/visionkit-scanner.md) for complete patterns.
+## VisionKit live scanning: DataScannerViewController
 
-### Quick Start
+`DataScannerViewController` (iOS 16+) is a full-screen live camera that finds
+text and barcodes and highlights them.
 
 ```swift
+import UIKit
 import VisionKit
 
-// Check availability (requires A12+ chip and camera)
-guard DataScannerViewController.isSupported,
-      DataScannerViewController.isAvailable else { return }
-
-let scanner = DataScannerViewController(
-    recognizedDataTypes: [
-        .text(languages: ["en"]),
-        .barcode(symbologies: [.qr, .ean13])
-    ],
-    qualityLevel: .balanced,
-    recognizesMultipleItems: true,
-    isHighFrameRateTrackingEnabled: true,
-    isHighlightingEnabled: true
-)
-scanner.delegate = self
-present(scanner, animated: true) {
-    try? scanner.startScanning()
+@MainActor
+func presentTicketScanner(from host: UIViewController, delegate: DataScannerViewControllerDelegate) {
+    guard DataScannerViewController.isSupported, DataScannerViewController.isAvailable else { return }
+    let scanner = DataScannerViewController(
+        recognizedDataTypes: [.text(languages: ["en"]), .barcode(symbologies: [.qr, .aztec])],
+        qualityLevel: .balanced,
+        recognizesMultipleItems: false,
+        isHighFrameRateTrackingEnabled: true,
+        isHighlightingEnabled: true
+    )
+    scanner.delegate = delegate
+    host.present(scanner, animated: true) {
+        try? scanner.startScanning()
+    }
 }
 ```
 
-### SwiftUI Integration
-
-Wrap `DataScannerViewController` in `UIViewControllerRepresentable`. See
-[references/visionkit-scanner.md](references/visionkit-scanner.md) for the full implementation.
-
-## Common Mistakes
-
-**DON'T:** Use the legacy `VNImageRequestHandler` API for new iOS 18+ projects.
-**DO:** Use modern struct-based requests with `perform(on:)` and async/await.
-**Why:** Modern API provides type safety, better Swift concurrency support, and cleaner error handling.
-
-**DON'T:** Forget to convert normalized coordinates before drawing bounding boxes.
-**DO:** Use `VNImageRectForNormalizedRect(_:_:_:)` or manual conversion from bottom-left origin to UIKit top-left origin.
-**Why:** Vision uses normalized coordinates (0...1) with bottom-left origin; UIKit uses points with top-left origin.
-
-**DON'T:** Run Vision requests on the main thread.
-**DO:** Perform requests on a background thread or use async/await from a detached task.
-**Why:** Image analysis is CPU/GPU-intensive and blocks the UI if run on the main actor.
-
-**DON'T:** Use `.accurate` recognition level for real-time camera feeds.
-**DO:** Use `.fast` for live video, `.accurate` for still images or offline processing.
-**Why:** Accurate recognition is too slow for 30fps video; fast recognition trades quality for speed.
-
-**DON'T:** Ignore the `confidence` score on observations.
-**DO:** Filter results by confidence threshold (e.g., > 0.5) appropriate for your use case.
-**Why:** Low-confidence results are often incorrect and degrade user experience.
-
-**DON'T:** Create a new `VNImageRequestHandler` for each frame when tracking objects.
-**DO:** Use `VNSequenceRequestHandler` for video frame sequences.
-**Why:** Sequence handler maintains temporal context for tracking; per-frame handlers lose state.
-
-**DON'T:** Request all barcode symbologies when you only need QR codes.
-**DO:** Specify only the symbologies you need in the request.
-**Why:** Fewer symbologies means faster detection and fewer false positives.
-
-**DON'T:** Assume `DataScannerViewController` is available on all devices.
-**DO:** Check both `isSupported` (hardware) and `isAvailable` (user permissions) before presenting.
-**Why:** Requires A12+ chip; `isAvailable` also checks camera access authorization.
-
-## Review Checklist
-
-- [ ] Uses modern Vision API (iOS 18+) unless targeting older deployments
-- [ ] Vision requests run off the main thread (async/await or background queue)
-- [ ] Normalized coordinates converted before UI display
-- [ ] Confidence threshold applied to filter low-quality observations
-- [ ] Recognition level matches use case (`.fast` for video, `.accurate` for stills)
-- [ ] Language hints set for text recognition when input language is known
-- [ ] Barcode symbologies limited to only those needed
-- [ ] `DataScannerViewController` availability checked before presentation
-- [ ] Camera usage description (`NSCameraUsageDescription`) in Info.plist for VisionKit
-- [ ] Person segmentation quality level appropriate for use case
-- [ ] `VNSequenceRequestHandler` used for video frame tracking (not per-frame handler)
-- [ ] Error handling covers request failures and empty results
+`isSupported` checks the hardware (A12 Bionic or later); `isAvailable`
+additionally requires camera permission. In SwiftUI, wrap the controller in a
+`UIViewControllerRepresentable`; see `references/visionkit-scanner.md`.
+
+## Common mistakes
+
+1. **Legacy handlers in new code.** A project targeting iOS 18 or later should
+   use the struct requests and `perform(on:)`: typed results, async/await, and
+   Swift errors instead of casts and callbacks.
+2. **Drawing normalized coordinates directly.** Vision uses 0...1 with a
+   lower-left origin; UIKit uses points from the top left. Convert with
+   `toImageCoordinates(_:origin:)`, `VNImageRectForNormalizedRect(_:_:_:)` or a
+   manual flip.
+3. **Running requests on the main thread.** Recognition is heavy CPU/GPU work.
+   Await the async API from a task, or dispatch legacy handlers to a
+   background queue, never block the main actor.
+4. **`.accurate` on a live camera feed.** It cannot keep up with 30 fps. Use
+   `.fast` for video and `.accurate` for photos and offline batches.
+5. **Ignoring confidence.** Low-confidence results are often wrong; drop
+   anything under a threshold that fits the feature (0.5 is a common start).
+6. **A new image handler per video frame when tracking.** Legacy tracking
+   needs `VNSequenceRequestHandler`, which carries temporal state across frames.
+7. **Asking for every symbology.** Each extra symbology costs time and invites
+   false positives; list only the ones you accept, for example just `.qr`.
+8. **Assuming the scanner exists.** Check `DataScannerViewController.isSupported`
+   (hardware) and `isAvailable` (hardware plus camera authorization) first.
+
+## Review checklist
+
+- [ ] Swift-native API used unless the deployment target is below iOS 18
+- [ ] No Vision work blocks the main thread
+- [ ] Normalized coordinates converted before anything is drawn
+- [ ] Results filtered by a confidence threshold
+- [ ] Recognition level fits the input: `.fast` for video, `.accurate` for stills
+- [ ] Recognition languages set when the input language is known
+- [ ] Barcode symbologies restricted to the needed set
+- [ ] `DataScannerViewController` support and availability checked before presenting
+- [ ] `NSCameraUsageDescription` present in Info.plist for VisionKit cameras
+- [ ] Person segmentation quality level matches the use case
+- [ ] Legacy video tracking uses one `VNSequenceRequestHandler`, not a handler per frame
+- [ ] Request failures and empty results handled
 
 ## References
 
-- Vision request patterns: [references/vision-requests.md](references/vision-requests.md)
-- VisionKit scanner integration: [references/visionkit-scanner.md](references/visionkit-scanner.md)
-- Apple docs: [Vision](https://sosumi.ai/documentation/vision) |
-  [VisionKit](https://sosumi.ai/documentation/visionkit) |
-  [RecognizeTextRequest](https://sosumi.ai/documentation/vision/recognizetextrequest) |
-  [DataScannerViewController](https://sosumi.ai/documentation/visionkit/datascannerviewcontroller)
+- `references/vision-requests.md`
+- `references/visionkit-scanner.md`
+- https://developer.apple.com/documentation/vision
+- https://developer.apple.com/documentation/visionkit
+- https://developer.apple.com/documentation/vision/recognizetextrequest
+- https://developer.apple.com/documentation/visionkit/datascannerviewcontroller