react-native-image-stitcher 0.1.0

package/dist/camera/PanoramaGuidance.js

@@ -0,0 +1,246 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * PanoramaGuidance — gyroscope-driven pan-speed indicator for the
+ * tap-and-hold panorama flow.
+ *
+ *   ┌──────────────────────────────────────────────────────────┐
+ *   │            (camera preview)                              │
+ *   │                                                          │
+ *   │            ↓                                             │ ← portrait + landscape pan
+ *   │           green / yellow / red                           │
+ *   │                                                          │
+ *   │           "Pan slowly" / "Slow down" / "Too fast"        │
+ *   └──────────────────────────────────────────────────────────┘
+ *
+ * Why this exists
+ *   The SCANS-mode stitcher needs ~30–50 % overlap between
+ *   consecutive frames.  At 30 fps, frames are ~33 ms apart, so
+ *   pan rates above roughly 30°/s (≈ 0.5 rad/s) produce frames
+ *   the stitcher can't align — and the user finds out only after
+ *   the post-release "Stitching failed" alert.  Real-time feedback
+ *   prevents that failure mode.
+ *
+ * What it does
+ *   - Subscribes to the device gyroscope (react-native-sensors)
+ *     ONLY while `active` is true; tears down on inactive so the
+ *     sensor isn't running the rest of the time the screen is up.
+ *   - Detects portrait vs landscape from window dimensions; the
+ *     dominant pan axis changes accordingly:
+ *       portrait  → user pans horizontally → we track gyro Y.
+ *       landscape → user pans vertically → we track gyro X.
+ *   - Maps the dominant axis's |rad/s| onto a colour scale and a
+ *     human-readable hint.  Defaults are tuned for SCANS but
+ *     overrideable.
+ *
+ * Performance
+ *   The gyroscope fires ~30 Hz.  We update an Animated.Value (which
+ *   updates the colour interpolation on the native driver) and only
+ *   call setState when the qualitative bucket (good/warn/bad)
+ *   changes — keeps re-render volume low.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PanoramaGuidance = PanoramaGuidance;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+const react_native_sensors_1 = require("react-native-sensors");
+const useDeviceOrientation_1 = require("./useDeviceOrientation");
+const DEFAULT_GOOD = 0.5;
+const DEFAULT_WARN = 1.0;
+const COLOR_GOOD = '#34C759';
+const COLOR_WARN = '#FFCC00';
+const COLOR_BAD = '#FF3B30';
+const DEFAULT_MESSAGES = {
+    good: 'Good pace — keep going',
+    warn: 'Slow down a bit',
+    bad: 'Too fast — slow down',
+};
+function bucketFor(rate, good, warn) {
+    const abs = Math.abs(rate);
+    if (abs <= good)
+        return 'good';
+    if (abs <= warn)
+        return 'warn';
+    return 'bad';
+}
+function colorFor(bucket) {
+    switch (bucket) {
+        case 'good':
+            return COLOR_GOOD;
+        case 'warn':
+            return COLOR_WARN;
+        case 'bad':
+            return COLOR_BAD;
+    }
+}
+function PanoramaGuidance({ active, axis, goodMaxRadPerSec = DEFAULT_GOOD, warnMaxRadPerSec = DEFAULT_WARN, messages, style, }) {
+    // Use the accelerometer-based hook (NOT useWindowDimensions) so
+    // we detect physical orientation even though the app is
+    // portrait-locked at the OS level.
+    const deviceOrientation = (0, useDeviceOrientation_1.useDeviceOrientation)();
+    const isPortrait = deviceOrientation === 'portrait'
+        || deviceOrientation === 'portrait-upside-down';
+    // Auto-detect: in portrait the user pans horizontally
+    // (left↔right across the rack) → gyro Y axis dominates.
+    // In landscape the user pans vertically (up↕down a tall fixture)
+    // → gyro X axis dominates.
+    const resolvedAxis = axis ?? (isPortrait ? 'horizontal' : 'vertical');
+    // Qualitative bucket — drives both the message and (via colour)
+    // the arrow tint.  Stored in state so a *change* in bucket
+    // re-renders, but per-sample updates do NOT.
+    const [bucket, setBucket] = (0, react_1.useState)('good');
+    // Last known rotation rate for the dominant axis, kept in a ref
+    // to avoid re-rendering every sample.  Read by the bucket logic
+    // and (indirectly, via colour interpolation) the animated tint.
+    const lastBucketRef = (0, react_1.useRef)('good');
+    (0, react_1.useEffect)(() => {
+        if (!active) {
+            lastBucketRef.current = 'good';
+            setBucket('good');
+            return;
+        }
+        // Sample at 33 ms (~30 Hz) — matches the typical recording
+        // frame rate so each gyro sample maps to one frame's pan.
+        (0, react_native_sensors_1.setUpdateIntervalForType)(react_native_sensors_1.SensorTypes.gyroscope, 33);
+        let subscription = react_native_sensors_1.gyroscope.subscribe({
+            next: ({ x, y }) => {
+                const rate = resolvedAxis === 'horizontal' ? y : x;
+                const next = bucketFor(rate, goodMaxRadPerSec, warnMaxRadPerSec);
+                if (next !== lastBucketRef.current) {
+                    lastBucketRef.current = next;
+                    setBucket(next);
+                }
+            },
+            error: (err) => {
+                // eslint-disable-next-line no-console
+                console.warn('[PanoramaGuidance] gyroscope error', err);
+            },
+        });
+        return () => {
+            subscription?.unsubscribe();
+            subscription = null;
+        };
+    }, [active, resolvedAxis, goodMaxRadPerSec, warnMaxRadPerSec]);
+    const resolvedMessages = (0, react_1.useMemo)(() => ({
+        good: messages?.good ?? DEFAULT_MESSAGES.good,
+        warn: messages?.warn ?? DEFAULT_MESSAGES.warn,
+        bad: messages?.bad ?? DEFAULT_MESSAGES.bad,
+    }), [messages]);
+    if (!active)
+        return null;
+    const tint = colorFor(bucket);
+    const message = resolvedMessages[bucket];
+    // Arrow glyph for the dominant axis.  The arrow renders a
+    // pannable direction hint — landscape gets a vertical arrow
+    // (the user's panning that way), portrait gets a horizontal
+    // arrow.
+    const arrow = resolvedAxis === 'horizontal' ? '↔' : '↕';
+    // Place the pill at user-perceived bottom across all four
+    // orientations.  Same pattern as <CaptureStatusOverlay> — the
+    // app layout is portrait-locked so we re-position via absolute
+    // coords + apply a rotation transform.
+    const pillOrientationStyle = pillStyleForOrientation(deviceOrientation);
+    return (react_1.default.createElement(react_native_1.View, { pointerEvents: "none", style: [styles.root, pillOrientationStyle, style], accessibilityRole: "alert", accessibilityLiveRegion: "polite" },
+        react_1.default.createElement(react_native_1.View, { style: [styles.pill, { borderColor: tint }] },
+            react_1.default.createElement(react_native_1.Text, { style: [styles.arrow, { color: tint }] }, arrow),
+            react_1.default.createElement(react_native_1.Text, { style: [styles.message, { color: tint }], numberOfLines: 1 }, message))));
+}
+/**
+ * Mirror of bannerStyleForOrientation in CaptureStatusOverlay,
+ * but anchored at user-perceived BOTTOM instead of TOP.
+ */
+function pillStyleForOrientation(orientation) {
+    switch (orientation) {
+        case 'landscape-left':
+            return {
+                top: 0,
+                bottom: 0,
+                left: 8,
+                alignItems: 'flex-start',
+                justifyContent: 'center',
+                transform: [{ rotate: '90deg' }],
+            };
+        case 'landscape-right':
+            return {
+                top: 0,
+                bottom: 0,
+                right: 8,
+                alignItems: 'flex-end',
+                justifyContent: 'center',
+                transform: [{ rotate: '-90deg' }],
+            };
+        case 'portrait-upside-down':
+            return {
+                top: 24,
+                left: 0,
+                right: 0,
+                alignItems: 'center',
+                transform: [{ rotate: '180deg' }],
+            };
+        case 'portrait':
+        default:
+            return {
+                bottom: 24,
+                left: 0,
+                right: 0,
+                alignItems: 'center',
+            };
+    }
+}
+const styles = react_native_1.StyleSheet.create({
+    root: {
+        position: 'absolute',
+    },
+    pill: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        paddingHorizontal: 14,
+        paddingVertical: 8,
+        borderRadius: 24,
+        borderWidth: 2,
+        backgroundColor: 'rgba(0,0,0,0.55)',
+    },
+    arrow: {
+        fontSize: 22,
+        fontWeight: '700',
+        marginRight: 8,
+    },
+    message: {
+        fontSize: 14,
+        fontWeight: '600',
+    },
+});
+//# sourceMappingURL=PanoramaGuidance.js.map

package/dist/camera/PanoramaSettingsModal.d.ts

@@ -0,0 +1,311 @@
+/**
+ * PanoramaSettingsModal — runtime A/B testing surface for the
+ * stitcher pipeline.  Operators in the field can toggle warper,
+ * blender, and tuning constants between captures to see what
+ * looks best on real shelf scenes.
+ *
+ * The modal is presentational: the host owns the settings state
+ * (typically `useState<PanoramaSettings>`) and renders the modal
+ * with `visible` toggled by a gear-icon press in the capture
+ * header.  Settings flow OUT via `onChange` for each tweak.
+ *
+ * Why expose this as an SDK component instead of leaving it to
+ * each host?  The set of tunable knobs IS the SDK's contract —
+ * if a new setting is added (e.g. registration MP) the SDK ships
+ * the UI for it in lockstep with the param itself, instead of
+ * forcing every host app to update its settings screen.
+ */
+import React from 'react';
+export interface PanoramaSettings {
+    warperType: 'plane' | 'cylindrical' | 'spherical';
+    blenderType: 'multiband' | 'feather';
+    /**
+     * Seam finder strategy.  "graphcut" finds optimal seams before
+     * blending (cleaner output, pairs with multiband, more memory).
+     * "skip" streams warp+feed (lower peak memory, fine with feather).
+     */
+    seamFinderType: 'graphcut' | 'skip';
+    /**
+     * V16 Phase 1b.fix5c (Ram's call 2026-05-10) — toggle the
+     * max-inscribed-rectangle crop on the batch-keyframe output
+     * panorama.  When false (default), the output is cropped to the
+     * bounding rectangle of non-black pixels only (cv::boundingRect)
+     * — preserves all stitched content at the cost of some black
+     * corners where cv::Stitcher's projection didn't fill.  When
+     * true, the post-stitch pipeline additionally runs
+     * `MaxInscribedRectFromMask` to find the largest axis-aligned
+     * rectangle entirely inside content, followed by the
+     * column-projection second-pass.  Inscribed-rect can be
+     * over-aggressive on lopsided masks (field log showed a
+     * 1146×1102 bbox shrinking to a 602×1102 strip), so default OFF
+     * lets the operator see the full stitched scene; flip ON to
+     * A/B against the cleaner-but-smaller output.
+     */
+    enableMaxInscribedRectCrop: boolean;
+    /**
+     * Phase 4.4 EXPERIMENTAL: when true, the host swaps the
+     * vision-camera-backed CameraView for an ARKit-backed ARCameraView
+     * during panorama capture.  Default false (keeps the existing
+     * stitcher flow untouched).  Phase 5 will add AR-backed photo /
+     * video capture and pose-driven stitching; until then this is
+     * preview-only — useful for verifying the AR session renders
+     * cleanly on the operator's device before we cut over.
+     */
+    useARPreview: boolean;
+    /**
+     * V15 — Incremental engine choice for live realtime stitching.
+     *   'hybrid'           — Whole-frame projection + feature matching;
+     *                        planar by default (was cylindrical).
+     *   'slitscan-rotate'  — V13.0a baseline + 1D NCC for rotation
+     *                        wobble correction.
+     *   'slitscan-both'    — DEFAULT.  V13.0a + no accept gate +
+     *                        feather blend.  Iterate via per-stage
+     *                        toggles below.
+     *
+     * All three are A/B-comparable on the same scene by toggling here
+     * without restarting the app.
+     */
+    incrementalEngine: 'batch-keyframe' | 'hybrid' | 'slitscan-rotate' | 'slitscan-both';
+    /**
+     * V15 — Slit-scan slit width (fraction of pan-axis retained per
+     * frame).  Range 0.10 – 0.70.  Smaller = less within-slit multi-
+     * depth disagreement but tighter overlap budget at fast pans.
+     * Default 0.30.  Only applied to slitscan-* engines.
+     */
+    slitWidthFraction: number;
+    /**
+     * V15 — Per-stage correction toggles for slitscan-both.  Settings
+     * UI exposes these so iteration happens via toggles, not rebuilds.
+     */
+    acceptGate: 0 | 50;
+    enableTriangulation: boolean;
+    enableTriAccumulator: boolean;
+    enable2dNcc: boolean;
+    enableRansacHomography: boolean;
+    paintMode: 'FirstPaintedWins' | 'FeatherBlend';
+    hybridProjection: 'Cylindrical' | 'Planar';
+    /** 1D NCC search radius (slitscan-rotate only). */
+    nccSearchRadius1d: number;
+    /** **DEPRECATED in V15.0d** — see `planeSource`.  Kept on the type
+     *  for backward compat with stored settings.  When `planeSource`
+     *  is 'Disabled' (default) and this is true, the engine treats it
+     *  as 'ARKitDetected'. */
+    useDetectedPlane: boolean;
+    /** V15.0d — source of the plane used by the V15.0b plane-projected
+     *  stitch path.  Slit-scan modes only.
+     *
+     *  - 'Disabled': no plane projection (plain slit-scan).
+     *  - 'ARKitDetected': use ARKit's first vertical plane that aligns
+     *    with the camera's view direction.  Falls back to slit-scan
+     *    silently when no aligned plane is found.
+     *  - 'Virtual': synthesize a plane perpendicular to the camera at
+     *    `virtualPlaneDepthMeters` distance.  Always works; loses
+     *    "real depth" advantage but immune to ARKit picking the wrong
+     *    surface (which is the common failure mode for ARKitDetected). */
+    planeSource: 'Disabled' | 'ARKitDetected' | 'Virtual';
+    /** V15.0d — depth (m) of the synthetic plane in front of the camera
+     *  when `planeSource = 'Virtual'`.  0.3 – 5.0 m.  Default 1.5 m. */
+    virtualPlaneDepthMeters: number;
+    /** V15.0d — alignment threshold (cosine) for ARKit-detected planes.
+     *  Higher = stricter (fewer planes accepted).  0.0 – 1.0.
+     *  Default 0.6 (≈53° max angle off-camera). */
+    arkitPlaneAlignmentThreshold: number;
+    /** V15.0g — plane-projection rendering style.  Trapezoidal is the
+     *  V15.0b legacy 3D-correct mapping; Rectified is V15.0g's clean-
+     *  rectangle paste that eliminates tilt-induced trapezoidal
+     *  distortion.  Default Rectified.  Ignored when planeSource =
+     *  Disabled. */
+    planeProjectionStyle: 'Trapezoidal' | 'Rectified';
+    /** V15.0d — 2D NCC search half-window in pixels.  4 – 30.
+     *  Default 12. */
+    nccSearchMargin2d: number;
+    /** V15.0d — 2D NCC confidence threshold below which corrections
+     *  are rejected.  0.30 – 0.99.  Default 0.75. */
+    nccConfidenceThreshold2d: number;
+    /** V15.0d (1B) — EMA smoothing on 2D NCC corrections to damp
+     *  single-frame snaps.  Default false. */
+    enableNcc2dEmaSmoothing: boolean;
+    /** V15.0d — EMA weight on the CURRENT-frame correction.  0.05 – 0.95.
+     *  Default 0.4 (60% prev / 40% current). */
+    ncc2dEmaAlpha: number;
+    /** V15.0d (1C) — pan-axis-aware 2D NCC: clamp the cross-axis
+     *  correction tighter than the pan-axis.  Default false. */
+    enableNcc2dPanAxisLock: boolean;
+    /** V15.0d — cross-axis clamp (px) when pan-axis lock is on.
+     *  0 – 30.  Default 5. */
+    ncc2dCrossAxisLockPx: number;
+    /** V16 — frame-selection mode for the live engine.
+     *
+     *  - 'time-based' (default): every ARFrame is forwarded to the
+     *    engine; the engine's own gate (kMinAcceptDeltaPx etc.) decides.
+     *    Backward-compatible with all prior versions.
+     *  - 'pose-based': frames are pre-filtered by a KeyframeGate that
+     *    projects each onto the latched ARKit plane and accepts only
+     *    when overlap with the previous keyframe is < 1 −
+     *    overlapThreshold.  Bounded to keyframeMaxCount frames per
+     *    capture (matches iOS Camera / Samsung Pano architecture).
+     *    Requires planeSource != 'Disabled' to engage.
+     *  - 'flow-based' (V16 A2, DEFAULT): same KeyframeGate cap +
+     *    threshold but the novelty metric is sparse-Lucas-Kanade
+     *    optical flow on full-frame content instead of plane-projected
+     *    polygon overlap.  Plane-independent (scale-invariant — works
+     *    regardless of latched plane size); the metric is "median
+     *    pan-axis feature displacement / pan-axis frame dim", which is
+     *    a direct measure of % new content on the leading edge.  Falls
+     *    back to angular delta when feature tracking fails (texture-
+     *    poor scene / motion exceeds KLT pyramid window). */
+    frameSelectionMode: 'time-based' | 'pose-based' | 'flow-based';
+    /** V16 — required NEW-content fraction for a keyframe to be
+     *  accepted (pose-based AND flow-based modes share this knob;
+     *  both interpret 0.40 as "40 % new content").  Tuneable from
+     *  0.20 to 0.60 in the modal. */
+    keyframeOverlapThreshold: number;
+    /** V16 — hard cap on keyframes per capture (pose-based + flow-
+     *  based modes).  Default 6.  Once reached, all further frames are
+     *  rejected and the host should auto-finalize. */
+    keyframeMaxCount: number;
+    /** V16 A2 — flow-based mode: max Shi-Tomasi corners to detect per
+     *  accepted keyframe.  More = more robust median pan-axis
+     *  displacement but slower detect (~15-25 ms at 150 on iPhone 13
+     *  Pro).  Range 50 – 300, default 150. */
+    flowMaxCorners: number;
+    /** V16 A2 — flow-based mode: Shi-Tomasi quality level (0, 1].
+     *  Lower = more (weaker) corners detected; higher = fewer
+     *  (stronger) corners.  Default 0.01.  Range 0.005 – 0.05 in the
+     *  modal. */
+    flowQualityLevel: number;
+    /** V16 A2 — flow-based mode: minimum pixel distance between
+     *  detected corners at WORKING resolution (the gate internally
+     *  downscales the frame to 720 px longest side for KLT).  Higher
+     *  = more spatially-spread features.  Default 10. */
+    flowMinDistance: number;
+    /** V16 — flow-based mode: translation budget in CENTIMETRES.
+     *  When > 0, the gate force-accepts a frame if the camera has
+     *  translated more than this distance (3D Euclidean) since the
+     *  last accepted keyframe — even when novelty < threshold.
+     *  Bounds the parallax between adjacent keyframes so the
+     *  downstream affine stitcher matcher can fit a homography.
+     *  Range 0 – 100 cm in the modal, default 0 = disabled.
+     *  Recommended starting value once enabled: 8 cm. */
+    flowMaxTranslationCm: number;
+    /** V16 — flow-based mode: percentile used to aggregate tracked-
+     *  feature absolute displacements into the novelty estimate.
+     *  Pre-V16 used median (0.50); 0.85 picks up leading-edge
+     *  motion sooner — matches user perception of "new content
+     *  visible" better.  Range 0.50 – 0.99, default 0.85. */
+    flowNoveltyPercentile: number;
+    /** V16 — flow-based mode: eval-throttle.  Gate evaluation runs
+     *  every Nth consumeFrame from the AR delegate instead of every
+     *  frame.  Pure CPU/battery savings — doesn't change WHICH
+     *  frames are accepted, just samples less frequently.  Range
+     *  1 – 10, default 1 (every frame). */
+    flowEvalEveryNFrames: number;
+    /** V15.0c — sliver position within the camera frame.  'Center' is
+     *  V13.x default.  'Bottom' takes leading-edge content for top-to-
+     *  bottom pan; 'Top' for bottom-to-top pan. */
+    sliverPosition: 'Center' | 'Bottom' | 'Top';
+    /** V15.0c — paint full first frame, then add slivers as user pans.
+     *  Useful with 'Bottom' or 'Top' sliverPosition. */
+    firstFrameFullFrame: boolean;
+    /** Hard cap on hold duration (ms).  0 disables auto-stop. */
+    maxRecordingMs: number;
+    /** Frames per second of recording to sample for stitching. */
+    framesPerSecond: number;
+    /** Floor / ceiling on extracted frame count. */
+    minFrames: number;
+    maxFrames: number;
+    /** JPEG quality (0-100) for output panorama. */
+    quality: number;
+    /**
+     * 2026-05-14 (revised) — capture-source picker for the panorama
+     * camera screen.  Two options after the 2026-05-14 user-reported
+     * Galaxy A35 crash + simplification request:
+     *
+     *   'ar' (DEFAULT) — Use the AR stack (ARKit on iOS, ARCore on
+     *                    Android).  Plane detection, pose-aware
+     *                    capture, pose-driven gate.  Falls back to
+     *                    non-AR silently if the device doesn't
+     *                    support AR.
+     *   'non-ar'      — Use vision-camera.  Disables all AR-based
+     *                    services (planeSource=Disabled, no plane
+     *                    polling, no AR session, frameSelectionMode
+     *                    flipped to flow-based).  Lens-switcher chip
+     *                    on the capture screen lets the operator
+     *                    toggle 0.5× / 1× without re-opening Settings.
+     *                    The chip is hidden if the device has only
+     *                    one physical back lens.
+     *
+     * Cascade: switching from 'ar' → 'non-ar' triggers a useEffect
+     * in `AuditCaptureScreen` that patches dependent settings
+     * (planeSource, frameSelectionMode, useARPreview) to a coherent
+     * non-AR state.  Operators don't have to know which other
+     * settings to flip.
+     *
+     * Earlier draft (replaced 2026-05-14) had 4 values:
+     * 'auto' | 'ar' | 'wide' | 'ultrawide'.  The pre-mount
+     * physical-lens selection ('wide' / 'ultrawide') crashed the
+     * Galaxy A35 vision-camera CameraCaptureSession with a Parcel
+     * exception (physical_camera_id=null in AidlCamera3-Device
+     * configureStreams) — Camera2 can't be reliably steered to a
+     * specific physical lens via vision-camera's `physicalDevices`
+     * filter on this hardware.  The post-mount on-screen chip path
+     * works because vision-camera selects the safe multi-lens
+     * virtual device first, and the lens swap happens against an
+     * already-open camera.
+     */
+    captureSource: 'ar' | 'non-ar';
+    /**
+     * 2026-05-16 (Issue 5) — diagnostic toast on every successful
+     * finalize.  When `true`, the host renders a transient toast
+     * summarising the C+D progressive-confidence retry telemetry:
+     *
+     *   "Stitch: 6/6 frames retained at thresh 1.00 (1 attempt)"
+     *
+     * Defaults to `false` so end-users don't see it.  Toggle from the
+     * Settings modal under "Debug".  Independent from any log-level
+     * controls — purely a UI affordance for field testing.
+     */
+    debug: boolean;
+    /**
+     * 2026-05-14 — `cv::Stitcher` pipeline mode for the batch stitch.
+     *
+     *   'auto' (DEFAULT)
+     *     The capture engine looks at the accumulated translation vs
+     *     rotation magnitudes between first and last accepted keyframe
+     *     poses (AR-mode) or the windowed IMU integration (non-AR
+     *     mode) and picks PANORAMA or SCANS at finalize time.
+     *
+     *   'panorama'
+     *     `cv::Stitcher::PANORAMA` — rotation-only pipeline.  Best for
+     *     "rotate phone in place to capture a wide field of view"
+     *     captures.  ORB feature matching + global BundleAdjusterRay +
+     *     SphericalWarper.  Sharp seams, expensive memory.  WARNING:
+     *     on translation-heavy input the rotation-only homography fit
+     *     diverges and the canvas can blow up to multi-GB on Android
+     *     (2026-05-14 lmkd kill observed).  Pick this only for genuine
+     *     rotation panoramas.
+     *
+     *   'scans'
+     *     `cv::Stitcher::SCANS` — translational pipeline.  Best for
+     *     "walk past a shelf and pan sideways" captures.  Affine
+     *     matcher + AffineBasedEstimator + BundleAdjusterAffine +
+     *     PlaneWarper.  Canvas size bounded by sum of frame areas.
+     *     Slight quality drop on pure rotations but works for them too.
+     *
+     * iOS NOTE: as of 2026-05-14 the iOS stitcher uses a hand-rolled
+     * PANORAMA-style pipeline (OpenCVStitcher.mm:600+) regardless of
+     * this setting.  Setting is passed through to iOS but ignored.
+     * Android honours it via image_stitcher_jni.cpp.  Bridging iOS is
+     * a follow-up.
+     */
+    stitchMode: 'auto' | 'panorama' | 'scans';
+}
+export declare const DEFAULT_PANORAMA_SETTINGS: PanoramaSettings;
+export interface PanoramaSettingsModalProps {
+    visible: boolean;
+    settings: PanoramaSettings;
+    onChange: (next: PanoramaSettings) => void;
+    onClose: () => void;
+}
+export declare function PanoramaSettingsModal({ visible, settings, onChange, onClose, }: PanoramaSettingsModalProps): React.JSX.Element;
+//# sourceMappingURL=PanoramaSettingsModal.d.ts.map