react-native-image-stitcher 0.1.0

package/dist/camera/PanoramaSettingsModal.js

@@ -0,0 +1,611 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * 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.
+ */
+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.DEFAULT_PANORAMA_SETTINGS = void 0;
+exports.PanoramaSettingsModal = PanoramaSettingsModal;
+const react_1 = __importStar(require("react"));
+const react_native_1 = require("react-native");
+// Per-device default selection.  We read the iPhone's physical
+// RAM at SDK module load (exposed by `BatchStitcher`'s
+// `constantsToExport`) and pick the heaviest blender + seam
+// finder combo that fits.  Threshold (2 GB) is conservative —
+// iPhone 6s through iPhone X have 2 GB exactly; below that
+// (iPhone 6 / 5s) is unsupported by RN 0.84 anyway.  The user
+// can still flip ANY of these in the settings modal at runtime;
+// this only chooses the INITIAL default.
+const _physicalMemoryBytes = (() => {
+    const m = react_native_1.NativeModules.BatchStitcher;
+    const bytes = m && typeof m === 'object'
+        ? m.physicalMemoryBytes
+        : undefined;
+    return typeof bytes === 'number' ? bytes : 0;
+})();
+const _isLowMem = _physicalMemoryBytes > 0
+    && _physicalMemoryBytes < 2 * 1024 * 1024 * 1024;
+// One-line diagnostic so the host's Metro console shows what the
+// SDK saw at module load.  If `physicalMemoryBytes=0` here, the
+// native bridge's `constantsToExport` isn't being picked up by
+// React Native and we should investigate the @objc registration.
+// The defaults always pick the SAFE fallback (multiband+graphcut)
+// when the value is 0 — this log is the only signal we have.
+// eslint-disable-next-line no-console
+console.log('[capture-sdk] PanoramaSettings defaults: '
+    + `physicalMemoryBytes=${_physicalMemoryBytes} `
+    + `isLowMem=${_isLowMem} `
+    + `→ blender=${_isLowMem ? 'feather' : 'multiband'} `
+    + `seam=${_isLowMem ? 'skip' : 'graphcut'}`);
+exports.DEFAULT_PANORAMA_SETTINGS = {
+    warperType: 'plane',
+    // High-quality defaults on devices with ≥2 GB RAM (iPhone X+):
+    // MultiBandBlender + GraphCutSeamFinder, the same combo
+    // cv::Stitcher::PANORAMA uses internally and what produced the
+    // sharpest output during iteration.
+    // Low-memory devices (<2 GB) fall back to FeatherBlender + skip
+    // seam (streams warp+feed) so peak memory stays under the
+    // tighter jetsam threshold.  Either way, the user can switch
+    // both in the settings modal.
+    blenderType: _isLowMem ? 'feather' : 'multiband',
+    seamFinderType: _isLowMem ? 'skip' : 'graphcut',
+    // V16 Phase 1b.fix5c — default OFF.  See PanoramaSettings.enableMaxInscribedRectCrop.
+    enableMaxInscribedRectCrop: false,
+    // AR-backed capture is the default — vision-camera path is kept as
+    // a fallback while we shake out edge cases.
+    useARPreview: true,
+    // V16 Phase 1 — batch-keyframe is the new default-recommended
+    // engine: KeyframeGate caps input at ≤ keyframeMaxCount frames,
+    // OpenCVStitcher's BA + GraphCut + ExposureCompensator +
+    // MultiBandBlender runs once on shutter release.  Existing
+    // slitscan-* engines remain available for wide-pan fallback.
+    incrementalEngine: 'batch-keyframe',
+    slitWidthFraction: 0.30,
+    acceptGate: 0,
+    enableTriangulation: false,
+    enableTriAccumulator: false,
+    enable2dNcc: false,
+    enableRansacHomography: false,
+    // V15.0c — Ram observation: FirstPaintedWins is consistently the best
+    // output across all combinations.  Default switched from FeatherBlend.
+    paintMode: 'FirstPaintedWins',
+    hybridProjection: 'Planar',
+    nccSearchRadius1d: 15,
+    useDetectedPlane: false,
+    // V16 Phase 1 — Virtual plane is the default since batch-keyframe
+    // is the recommended engine and the gate needs a plane to compute
+    // polygon overlap.  Virtual works without ARKit-detected planes (a
+    // synthesized plane perpendicular to the first-frame camera at
+    // virtualPlaneDepthMeters); operators can flip to ARKitDetected
+    // when in a controlled scene with a clearly-visible wall.  Disabled
+    // is still selectable for the older slit-scan paths that don't
+    // need a plane.
+    // V16 Phase 1b.fix5c (Ram's call 2026-05-10): switched default
+    // from 'Virtual' to 'ARKitDetected'.  ARKit's real plane gives
+    // better intrinsics-to-pixel alignment than a synthesised plane
+    // at a fixed depth, when ARKit can find a vertical plane.  Falls
+    // back to slit-scan when no plane latches.
+    planeSource: 'ARKitDetected',
+    virtualPlaneDepthMeters: 1.5,
+    arkitPlaneAlignmentThreshold: 0.6,
+    // V15.0g — Rectified is the default (Trapezoidal had the tilt-
+    // induced bottom-wider-than-top distortion that was the field
+    // blocker on V15.0e/f).  Trapezoidal stays available for
+    // operator A/B comparison.
+    planeProjectionStyle: 'Rectified',
+    // V15.0d — NCC 2D defaults match V15.0c.4's hardcoded values, now
+    // tunable via the settings UI.  EMA smoothing and pan-axis lock are
+    // off by default so the V15.0c.4 baseline behaviour is preserved
+    // until the operator explicitly opts in.
+    nccSearchMargin2d: 12,
+    // V15.0i.1 — default raised to 0.99 per Ram (only apply on near-
+    // perfect overlap matches; reject ambiguous matches that snap to
+    // wrong patterns on repetitive textures like shelf rails).
+    nccConfidenceThreshold2d: 0.99,
+    enableNcc2dEmaSmoothing: false,
+    ncc2dEmaAlpha: 0.4,
+    enableNcc2dPanAxisLock: false,
+    ncc2dCrossAxisLockPx: 5,
+    // V16 A2 (2026-05-13) — flow-based is now the default.  Ram report
+    // 2026-05-13 13:05 showed that pose-based on a small latched plane
+    // produces "bursts" of accepts on small physical motion: a 0.64 m²
+    // plane at 2.7 m perpDist gave 6 accepts in 1 s over 12 cm of
+    // translation because the plane-projected polygon covers only a
+    // sliver of the frame, hyperinflating newContent.  Flow-based
+    // measures novelty from real image content (sparse KLT), is
+    // plane-independent, and is invariant to plane size.  Operators
+    // can still flip back to 'pose-based' or 'time-based' in the modal
+    // for A/B testing or low-texture scenes.  Same defaults shared
+    // between pose-based and flow-based (40 % new content per
+    // keyframe, ≤ 6 keyframes per capture).
+    frameSelectionMode: 'flow-based',
+    // 2026-05-15 (U4) — flow-based default novelty 0.40 → 0.20.
+    // Accept frames with 20 % new content (was 40 %).  More inclusive
+    // selection for shelf-pan captures where panning slowly produces
+    // gradual content reveal.  Operator can still bump via Settings.
+    keyframeOverlapThreshold: 0.20,
+    keyframeMaxCount: 6,
+    // V16 A2 — flow-based mode tuning.  Defaults are the values that
+    // tested cleanly on iPhone 13 Pro / 14 Pro: 150 corners give a
+    // stable median across the frame; quality=0.01 + minDistance=10
+    // give spatially-spread, repeatable detection.  All three are
+    // tunable in the modal under "Flow tuning".
+    flowMaxCorners: 150,
+    flowQualityLevel: 0.01,
+    flowMinDistance: 10,
+    // V16 — translation-budget force-accept (Flow strategy only).
+    // 2026-05-16 (Issue 4a fix) — default flipped from 0 (disabled) to
+    // 25 cm so the "Rotate the camera instead of moving it sideways"
+    // warning fires out-of-the-box.  Set to 0 in Settings to disable
+    // both the warning AND the gate's force-accept on budget crossing.
+    // 2026-05-17 (Issue 4-A v2) — raised 25 → 50 cm.  The 25-cm budget
+    // was too tight given IMU double-integration drift (the
+    // accelerometer's noise floor accumulates several cm of bogus
+    // "translation" per second even when the phone is held still).
+    // Combined with the new `resetAnchor` at handleHoldStart (so drift
+    // doesn't compound across captures), 50 cm gives the warning real
+    // headroom for genuine sideways motion without false positives.
+    flowMaxTranslationCm: 50,
+    // V16 — novelty aggregation percentile.  0.85 picks up leading-
+    // edge motion sooner than the pre-V16 median (0.50).  Operator
+    // can dial down toward 0.5 for more-conservative captures or up
+    // toward 0.99 for more-aggressive.
+    flowNoveltyPercentile: 0.85,
+    // V16 — every-Nth-frame eval throttle.  2026-05-15 (U4): default
+    // 1 → 5 to reduce per-frame KeyframeGate CPU cost (Shi-Tomasi +
+    // calcOpticalFlowPyrLK is ~3-5 ms per ARFrame on Galaxy A35; at
+    // 30 fps that's ~15 % CPU on flow alone).  Evaluating every 5th
+    // frame yields novelty samples at ~6 Hz which is still well above
+    // the 1-2 Hz keyframe-accept cadence.
+    // matches pre-V16 behaviour).  Set higher to cut CPU on long
+    // captures at the cost of acceptance latency.
+    flowEvalEveryNFrames: 5,
+    // V15.0c — sliver tweaks: leading-edge sliver from BOTTOM for typical
+    // top-to-bottom pan + full first-frame anchor produced the best
+    // outputs in early iteration.
+    sliverPosition: 'Bottom',
+    firstFrameFullFrame: true,
+    maxRecordingMs: 8000,
+    framesPerSecond: 3,
+    minFrames: 6,
+    maxFrames: 16,
+    quality: 85,
+    // 2026-05-14 (revised) — capture source defaults to 'ar' (AR-backed
+    // is the recommended path; non-AR is the explicit opt-out).  Stitch
+    // mode stays 'auto' — the auto-resolution heuristic between PANORAMA
+    // and SCANS is per-capture, not per-mode, so it's safe to leave on.
+    captureSource: 'ar',
+    stitchMode: 'auto',
+    debug: false,
+};
+function PanoramaSettingsModal({ visible, settings, onChange, onClose, }) {
+    const update = (patch) => onChange({ ...settings, ...patch });
+    // V16 Phase 1b — derive the 2-axis (timing × algorithm) UI state
+    // from the underlying single `incrementalEngine` field.  Storage
+    // shape is unchanged; the modal just presents it in two segmented
+    // controls so the user's mental model matches the system's actual
+    // primary axis (batch vs realtime).
+    //
+    // Mapping:
+    //   incrementalEngine === 'batch-keyframe'  → timing='batch'
+    //   incrementalEngine === 'hybrid'          → timing='realtime', algo='hybrid'
+    //   incrementalEngine === 'slitscan-rotate' → timing='realtime', algo='slitscan-rotate'
+    //   incrementalEngine === 'slitscan-both'   → timing='realtime', algo='slitscan-both'
+    const timing = settings.incrementalEngine === 'batch-keyframe' ? 'batch' : 'realtime';
+    // When in batch mode, remember 'hybrid' as the realtime algorithm
+    // the user would land on if they flipped timing back.  When already
+    // in realtime, the engine field IS the algorithm.
+    const realtimeAlgorithm = settings.incrementalEngine === 'batch-keyframe'
+        ? 'hybrid'
+        : settings.incrementalEngine;
+    const setTiming = (t) => {
+        if (t === 'batch') {
+            update({ incrementalEngine: 'batch-keyframe' });
+        }
+        else {
+            update({ incrementalEngine: realtimeAlgorithm });
+        }
+    };
+    // Frame Selection only makes sense for batch and hybrid engines —
+    // slit-scan needs dense input and the gate would starve it.
+    const showFrameSelection = timing === 'batch' || realtimeAlgorithm === 'hybrid';
+    return (react_1.default.createElement(react_native_1.Modal, { visible: visible, animationType: "slide", transparent: true, statusBarTranslucent: true, onRequestClose: onClose },
+        react_1.default.createElement(react_native_1.View, { style: styles.backdrop },
+            react_1.default.createElement(react_native_1.View, { style: styles.sheet },
+                react_1.default.createElement(react_native_1.View, { style: styles.header },
+                    react_1.default.createElement(react_native_1.Text, { style: styles.title }, "Panorama settings"),
+                    react_1.default.createElement(react_native_1.Pressable, { onPress: onClose, hitSlop: 12, accessibilityRole: "button", accessibilityLabel: "Close settings", style: styles.closeBtn },
+                        react_1.default.createElement(react_native_1.Text, { style: styles.closeText }, "\u00D7"))),
+                react_1.default.createElement(react_native_1.ScrollView, { contentContainerStyle: styles.body },
+                    react_1.default.createElement(react_native_1.Text, { style: styles.debugLine }, `device: physicalMemoryBytes=${_physicalMemoryBytes} `
+                        + `(${(_physicalMemoryBytes / (1024 ** 3)).toFixed(2)} GB) · `
+                        + `isLowMem=${_isLowMem ? 'yes' : 'no'} · `
+                        + `default blender=${_isLowMem ? 'feather' : 'multiband'}`),
+                    react_1.default.createElement(SectionHeader, { title: "Capture source" }),
+                    react_1.default.createElement(SegmentedControl, { options: ['ar', 'non-ar'], value: settings.captureSource, onChange: (v) => update({ captureSource: v }), caption: "ar (default): ARKit / ARCore \u2014 plane detection, pose-aware capture, full AR stack.  non-ar: vision-camera only \u2014 disables AR plane detection, flips frame-selection to flow-based, runs IMU translation gate.  In non-ar mode, the on-screen lens-switcher chip lets you toggle 0.5\u00D7 / 1\u00D7 lens during capture (only shown when the device has both lenses)." }),
+                    react_1.default.createElement(SectionHeader, { title: "Stitch mode" }),
+                    react_1.default.createElement(SegmentedControl, { options: ['auto', 'panorama', 'scans'], value: settings.stitchMode, onChange: (v) => update({ stitchMode: v }), caption: "auto (default): pick PANORAMA or SCANS based on translation/rotation totals at finalize. panorama: cv::Stitcher::PANORAMA \u2014 rotation-only (spherical warper, BA-ray); best for rotate-in-place captures, BAD on translation. scans: cv::Stitcher::SCANS \u2014 affine pipeline (plane warper, BA-affine); best for shelf-pan captures." }),
+                    react_1.default.createElement(SectionHeader, { title: "Stitch timing" }),
+                    react_1.default.createElement(SegmentedControl, { options: ['batch', 'realtime'], value: timing, onChange: (v) => setTiming(v), caption: "batch (recommended): full cv::Stitcher pipeline at shutter release. Highest quality. ~1\u20132 s post-release. realtime: incremental during pan; lower latency, fewer quality stages." }),
+                    showFrameSelection && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement(SectionHeader, { title: "Frame selection (V16)" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['time-based', 'pose-based', 'flow-based'], value: settings.frameSelectionMode, onChange: (v) => update({ frameSelectionMode: v }), caption: "flow-based (V16 A2, default): KeyframeGate uses sparse-Lucas-Kanade optical flow on full frame \u2014 plane-independent, invariant to plane size. pose-based: plane-polygon overlap (oversensitive on small latched planes). time-based: every ARFrame goes to the engine." }),
+                        (settings.frameSelectionMode === 'pose-based' ||
+                            settings.frameSelectionMode === 'flow-based') && (react_1.default.createElement(react_1.default.Fragment, null,
+                            react_1.default.createElement(SectionHeader, { title: "Overlap threshold (new content per keyframe)" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['20%', '30%', '40%', '50%', '60%'], value: `${Math.round(settings.keyframeOverlapThreshold * 100)}%`, onChange: (v) => update({ keyframeOverlapThreshold: parseInt(v, 10) / 100 }), caption: "Required NEW content per keyframe. 40% (default) \u2248 4\u20135 keyframes for a 90\u00B0 pan. Same threshold semantics for both pose-based and flow-based." }),
+                            react_1.default.createElement(SectionHeader, { title: "Max keyframes per capture" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['3', '4', '5', '6', '8', '10'], value: String(settings.keyframeMaxCount), onChange: (v) => update({ keyframeMaxCount: parseInt(v, 10) }), caption: "Hard cap. 6 (default) matches Samsung's behaviour. Once reached, host auto-finalizes." }))),
+                        settings.frameSelectionMode === 'flow-based' && (react_1.default.createElement(react_1.default.Fragment, null,
+                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 max corners" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['50', '100', '150', '200', '300'], value: String(settings.flowMaxCorners), onChange: (v) => update({ flowMaxCorners: parseInt(v, 10) }), caption: "Max Shi-Tomasi corners detected per accepted keyframe. More = more robust median, slower detect. 150 = default." }),
+                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 quality level" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['0.005', '0.01', '0.02', '0.03', '0.05'], value: String(settings.flowQualityLevel), onChange: (v) => update({ flowQualityLevel: parseFloat(v) }), caption: "Shi-Tomasi corner quality threshold. Lower = more (weaker) corners; higher = fewer (stronger) corners. 0.01 = default." }),
+                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 min distance" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['5', '8', '10', '15', '20'], value: String(settings.flowMinDistance), onChange: (v) => update({ flowMinDistance: parseInt(v, 10) }), caption: "Min pixel distance between detected corners (working resolution = 720 px longest side). Higher = more spatially-spread features. 10 = default." }),
+                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 translation budget (cm)" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['0', '5', '8', '12', '20', '50'], value: String(settings.flowMaxTranslationCm), onChange: (v) => update({ flowMaxTranslationCm: parseInt(v, 10) }), caption: "Force-accept when camera has moved this many cm since last keyframe, even if novelty < overlap threshold. Bounds parallax so the stitcher can match. 0 = disabled (default). 8 = recommended starting value." }),
+                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 novelty percentile" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['0.50', '0.70', '0.85', '0.95', '0.99'], value: settings.flowNoveltyPercentile.toFixed(2), onChange: (v) => update({ flowNoveltyPercentile: parseFloat(v) }), caption: "How tracked-feature displacements are aggregated into novelty. 0.50 = pre-V16 median behaviour (conservative). 0.85 = picks up leading-edge motion sooner (default, matches user perception). 0.99 = near-max, very aggressive." }),
+                            react_1.default.createElement(SectionHeader, { title: "Flow tuning \u2014 eval every N frames" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['1', '2', '3', '5', '10'], value: String(settings.flowEvalEveryNFrames), onChange: (v) => update({ flowEvalEveryNFrames: parseInt(v, 10) }), caption: "Throttle gate evaluation to every Nth AR frame. 1 = every frame (default, no throttle). 3-5 = noticeable CPU/battery savings on long captures, up to N-1 frames of acceptance latency." }))))),
+                    react_1.default.createElement(SectionHeader, { title: "AR plane projection" }),
+                    react_1.default.createElement(SegmentedControl, { options: ['Disabled', 'ARKitDetected', 'Virtual'], value: settings.planeSource, onChange: (v) => update({ planeSource: v }), caption: "Disabled: no plane (gate falls back to angular delta). ARKitDetected: latch ARKit's vertical plane (best fidelity, picky). Virtual: synthesise plane perpendicular to camera at a fixed depth (always works)." }),
+                    settings.planeSource === 'ARKitDetected' && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement(SectionHeader, { title: "ARKit alignment threshold" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['0.3', '0.5', '0.6', '0.7', '0.85'], value: settings.arkitPlaneAlignmentThreshold.toFixed(2), onChange: (v) => update({ arkitPlaneAlignmentThreshold: parseFloat(v) }), caption: "Min dot product between candidate plane normal and camera facing. 0.6 (default) = ~53\u00B0 max angle off-camera. Higher = stricter." }))),
+                    settings.planeSource === 'Virtual' && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement(SectionHeader, { title: "Virtual plane depth" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['0.5m', '1.0m', '1.5m', '2.0m', '3.0m'], value: `${settings.virtualPlaneDepthMeters.toFixed(1)}m`, onChange: (v) => update({ virtualPlaneDepthMeters: parseFloat(v) }), caption: "Synthetic plane depth at first frame. Set to your typical scan distance." }))),
+                    settings.planeSource !== 'Disabled' && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement(SectionHeader, { title: "Plane projection style" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['Rectified', 'Trapezoidal'], value: settings.planeProjectionStyle, onChange: (v) => update({ planeProjectionStyle: v }), caption: "Rectified (default): clean rectangle paste, no tilt distortion. Trapezoidal: V15.0b legacy 3D-correct raycast \u2014 geometric purity at the cost of tilt artifacts." }))),
+                    react_1.default.createElement(SectionHeader, { title: "Algorithm" }),
+                    timing === 'batch' ? (react_1.default.createElement(react_native_1.View, { style: styles.infoBox },
+                        react_1.default.createElement(react_native_1.Text, { style: styles.infoText }, "Full feature-matched pipeline: ORB \u2192 BFMatcher \u2192 RANSAC \u2192 BundleAdjusterRay \u2192 waveCorrect \u2192 Warper \u2192 GraphCutSeamFinder \u2192 ExposureCompensator \u2192 MultiBandBlender. No engine choice in batch mode."))) : (react_1.default.createElement(SegmentedControl, { options: ['hybrid', 'slitscan-rotate', 'slitscan-both'], value: realtimeAlgorithm, onChange: (v) => update({ incrementalEngine: v }), caption: "hybrid: streaming planar projection + feature matching. slitscan-rotate: V13.0a + 1D NCC. slitscan-both: V13.0a + no accept gate + feather blend (iteration playground)." })),
+                    timing === 'batch' && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Warper" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['plane', 'cylindrical', 'spherical'], value: settings.warperType, onChange: (v) => update({ warperType: v }), caption: "plane (default, recommended for retail shelves): flat rectangular output. cylindrical: rotational mid-arc, gentle curvature. spherical: wide pans (180\u00B0+) but always-curved." }),
+                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Blender" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['multiband', 'feather'], value: settings.blenderType, onChange: (v) => update({ blenderType: v }), caption: "multiband (default): Laplacian-pyramid blending; cleanest seams. feather: faster, no halo when exposure varies." }),
+                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Seam finder" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['graphcut', 'skip'], value: settings.seamFinderType, onChange: (v) => update({ seamFinderType: v }), caption: "graphcut (default): cv::detail::GraphCutSeamFinder; optimal seams, pairs with multiband, holds all warps in memory. skip: stream warp+feed (lower peak memory)." }),
+                        react_1.default.createElement(SectionHeader, { title: "Batch tuning \u2014 Inscribed-rect crop" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableMaxInscribedRectCrop ? 'on' : 'off', onChange: (v) => update({ enableMaxInscribedRectCrop: v === 'on' }), caption: "off (default): final crop is just cv::boundingRect of non-black pixels \u2014 preserves all stitched content; may have black corners. on: additionally run MaxInscribedRectFromMask + column-projection second-pass for a clean-cornered rectangle \u2014 can shrink the output if the panorama mask is lopsided. A/B against the bbox crop on real scenes." }))),
+                    timing === 'realtime' && realtimeAlgorithm === 'hybrid' && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement(SectionHeader, { title: "Hybrid tuning \u2014 Projection" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['Planar', 'Cylindrical'], value: settings.hybridProjection, onChange: (v) => update({ hybridProjection: v }), caption: "Planar (default): cv::detail::PlaneWarper. Cylindrical: V12.x \u2013 V14.0a behaviour (legacy)." }))),
+                    timing === 'realtime' && realtimeAlgorithm.startsWith('slitscan') && (react_1.default.createElement(react_1.default.Fragment, null,
+                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Slit width" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['0.01', '0.05', '0.10', '0.20', '0.30', '0.50'], value: settings.slitWidthFraction.toFixed(2), onChange: (v) => update({ slitWidthFraction: parseFloat(v) }), caption: "Fraction of pan-axis retained per sliver. 0.30 (V15 default) \u2248 324 px. Smaller = less within-slit depth disagreement." }),
+                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Sliver position" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['Center', 'Bottom', 'Top'], value: settings.sliverPosition, onChange: (v) => update({ sliverPosition: v }), caption: "Where on the camera sensor frame the sliver is taken." }),
+                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Full first-frame" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.firstFrameFullFrame ? 'on' : 'off', onChange: (v) => update({ firstFrameFullFrame: v === 'on' }), caption: "ON: first accepted frame paints the full camera frame at the canvas anchor; subsequent frames use sliver clip." }),
+                        react_1.default.createElement(SectionHeader, { title: "Slit-scan tuning \u2014 Paint mode" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['FirstPaintedWins', 'FeatherBlend'], value: settings.paintMode, onChange: (v) => update({ paintMode: v }), caption: "FirstPaintedWins (default): protect already-painted pixels. FeatherBlend: alpha-blend new content into overlap." }))),
+                    react_1.default.createElement(Accordion, { title: "Advanced \u2014 2D NCC fine-alignment", badge: "advanced" },
+                        react_1.default.createElement(SectionHeader, { title: "Enable 2D NCC" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enable2dNcc ? 'on' : 'off', onChange: (v) => update({ enable2dNcc: v === 'on' }), caption: "V13.0g 2D NCC fine-alignment after pose-driven projection. Refines (\u0394x, \u0394y) translation via cv::matchTemplate." }),
+                        settings.enable2dNcc && (react_1.default.createElement(react_1.default.Fragment, null,
+                            react_1.default.createElement(SectionHeader, { title: "Confidence threshold" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['0.50', '0.65', '0.75', '0.85', '0.95', '0.99'], value: settings.nccConfidenceThreshold2d.toFixed(2), onChange: (v) => update({ nccConfidenceThreshold2d: parseFloat(v) }), caption: "Reject NCC corrections below this confidence. 0.99 = only apply on near-perfect overlap." }),
+                            react_1.default.createElement(SectionHeader, { title: "Search half-window (px)" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['6', '10', '12', '20', '30'], value: String(settings.nccSearchMargin2d), onChange: (v) => update({ nccSearchMargin2d: parseInt(v, 10) }), caption: "Pixels: 2D NCC searches \u00B1this around the pose-predicted match." }),
+                            react_1.default.createElement(SectionHeader, { title: "EMA smoothing" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableNcc2dEmaSmoothing ? 'on' : 'off', onChange: (v) => update({ enableNcc2dEmaSmoothing: v === 'on' }), caption: "Damp single-frame snaps to spurious peaks via EMA." }),
+                            settings.enableNcc2dEmaSmoothing && (react_1.default.createElement(react_1.default.Fragment, null,
+                                react_1.default.createElement(SectionHeader, { title: "EMA alpha (current-frame weight)" }),
+                                react_1.default.createElement(SegmentedControl, { options: ['0.20', '0.30', '0.40', '0.60', '0.80'], value: settings.ncc2dEmaAlpha.toFixed(2), onChange: (v) => update({ ncc2dEmaAlpha: parseFloat(v) }) }))),
+                            react_1.default.createElement(SectionHeader, { title: "Pan-axis lock" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableNcc2dPanAxisLock ? 'on' : 'off', onChange: (v) => update({ enableNcc2dPanAxisLock: v === 'on' }), caption: "Clamp cross-axis correction tighter than pan-axis (pose + 1D NCC handle cross-axis already)." }),
+                            settings.enableNcc2dPanAxisLock && (react_1.default.createElement(react_1.default.Fragment, null,
+                                react_1.default.createElement(SectionHeader, { title: "Cross-axis clamp (px)" }),
+                                react_1.default.createElement(SegmentedControl, { options: ['2', '5', '10', '15'], value: String(settings.ncc2dCrossAxisLockPx), onChange: (v) => update({ ncc2dCrossAxisLockPx: parseInt(v, 10) }) })))))),
+                    timing === 'realtime' && realtimeAlgorithm === 'slitscan-both' && (react_1.default.createElement(Accordion, { title: "Advanced \u2014 Slit-scan experimental", badge: "experimental" },
+                        react_1.default.createElement(SectionHeader, { title: "Triangulation parallax" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableTriangulation ? 'on' : 'off', onChange: (v) => update({ enableTriangulation: v === 'on' }), caption: "V13.0e ORB triangulation + median-Z parallax correction. Adds ~10ms/accept." }),
+                        react_1.default.createElement(SectionHeader, { title: "RANSAC homography" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.enableRansacHomography ? 'on' : 'off', onChange: (v) => update({ enableRansacHomography: v === 'on' }), caption: "V14.0a RANSAC homography per slit + cv::warpPerspective. Known limitation: can absorb pan as scale, leaving gaps." }),
+                        react_1.default.createElement(SectionHeader, { title: "Accept gate (px)" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['0', '50'], value: String(settings.acceptGate), onChange: (v) => update({ acceptGate: parseInt(v, 10) }), caption: "0 = accept on every frame (Apple-dense). 50 = V13.0g throttle." }))),
+                    react_1.default.createElement(SectionHeader, { title: "Recording cap" }),
+                    react_1.default.createElement(SegmentedControl, { options: ['4 s', '6 s', '8 s', '10 s'], value: `${Math.round(settings.maxRecordingMs / 1000)} s`, onChange: (v) => update({ maxRecordingMs: parseInt(v, 10) * 1000 }), caption: "Auto-stops the hold-recording at this duration." }),
+                    react_1.default.createElement(SectionHeader, { title: "JPEG quality" }),
+                    react_1.default.createElement(SegmentedControl, { options: ['70', '85', '92'], value: String(settings.quality), onChange: (v) => update({ quality: parseInt(v, 10) }), caption: "Higher = bigger files, sharper detail. 85 is the recommended default." }),
+                    react_1.default.createElement(SectionHeader, { title: "Debug" }),
+                    react_1.default.createElement(SegmentedControl, { options: ['off', 'on'], value: settings.debug ? 'on' : 'off', onChange: (v) => update({ debug: v === 'on' }), caption: "When ON, every successful stitch shows a popup with the C+D progressive-confidence retry telemetry (frames included, final threshold, retry attempts). Off by default." }),
+                    react_1.default.createElement(Accordion, { title: "Diagnostics / fallbacks", badge: "rarely needed" },
+                        react_1.default.createElement(react_native_1.View, { style: styles.infoBox },
+                            react_1.default.createElement(react_native_1.Text, { style: styles.infoText }, "AR-backed capture is the recommended path. Toggle off ONLY if ARKit fails on a specific device (very rare on modern iPhones). Doing so falls back to vision-camera video recording + post-stitch via cv::Stitcher.")),
+                        react_1.default.createElement(SectionHeader, { title: "AR-backed capture" }),
+                        react_1.default.createElement(SegmentedControl, { options: ['on', 'off'], value: settings.useARPreview ? 'on' : 'off', onChange: (v) => update({ useARPreview: v === 'on' }), caption: "Default ON. OFF only when ARKit is unavailable or for A/B testing." }),
+                        !settings.useARPreview && (react_1.default.createElement(react_1.default.Fragment, null,
+                            react_1.default.createElement(SectionHeader, { title: "Frame extraction \u2014 Frames per second" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['2', '3', '4'], value: String(settings.framesPerSecond), onChange: (v) => update({ framesPerSecond: parseInt(v, 10) }), caption: "Frames/sec extracted from the recorded video. Lower = faster but riskier overlap." }),
+                            react_1.default.createElement(SectionHeader, { title: "Frame extraction \u2014 Frame count clamp" }),
+                            react_1.default.createElement(SegmentedControl, { options: ['4-12', '6-16', '8-20'], value: `${settings.minFrames}-${settings.maxFrames}`, onChange: (v) => {
+                                    const [min, max] = v.split('-').map((n) => parseInt(n, 10));
+                                    update({ minFrames: min, maxFrames: max });
+                                }, caption: "Floor/ceiling for extracted frames." })))),
+                    react_1.default.createElement(react_native_1.Pressable, { onPress: () => onChange(exports.DEFAULT_PANORAMA_SETTINGS), style: styles.resetBtn, accessibilityRole: "button", accessibilityLabel: "Reset to defaults" },
+                        react_1.default.createElement(react_native_1.Text, { style: styles.resetText }, "Reset to defaults")))))));
+}
+function SectionHeader({ title }) {
+    return react_1.default.createElement(react_native_1.Text, { style: styles.sectionHeader }, title);
+}
+/**
+ * Collapsible section.  Used for closed-by-default groupings
+ * ("Advanced", "Diagnostics / fallbacks") so the modal's primary
+ * surface stays focused on the controls operators actually touch
+ * day-to-day.
+ *
+ * State is local — each Accordion instance manages its own open
+ * flag.  The modal opens fresh-collapsed every mount which is what
+ * we want for now; persisting open state across mounts (e.g. via
+ * AsyncStorage) is a future enhancement.
+ */
+function Accordion({ title, initiallyOpen = false, badge, children, }) {
+    const [open, setOpen] = (0, react_1.useState)(initiallyOpen);
+    return (react_1.default.createElement(react_native_1.View, { style: styles.accordion },
+        react_1.default.createElement(react_native_1.Pressable, { onPress: () => setOpen((v) => !v), style: styles.accordionHeader, accessibilityRole: "button", accessibilityState: { expanded: open }, accessibilityLabel: `${title}, ${open ? 'expanded' : 'collapsed'}` },
+            react_1.default.createElement(react_native_1.Text, { style: styles.accordionChevron }, open ? '▼' : '▶'),
+            react_1.default.createElement(react_native_1.Text, { style: styles.accordionTitle }, title),
+            badge ? react_1.default.createElement(Tag, { label: badge }) : null),
+        open ? react_1.default.createElement(react_native_1.View, { style: styles.accordionBody }, children) : null));
+}
+/**
+ * Small grey-text badge.  Marks sections / fields as "advanced",
+ * "experimental", "legacy", or similar — quick visual signal that
+ * the operator can usually ignore them.
+ */
+function Tag({ label }) {
+    return (react_1.default.createElement(react_native_1.View, { style: styles.tag },
+        react_1.default.createElement(react_native_1.Text, { style: styles.tagText }, label)));
+}
+function SegmentedControl({ options, value, onChange, caption, }) {
+    return (react_1.default.createElement(react_native_1.View, null,
+        react_1.default.createElement(react_native_1.View, { style: styles.segmentedRow }, options.map((opt) => {
+            const selected = opt === value;
+            return (react_1.default.createElement(react_native_1.Pressable, { key: opt, onPress: () => onChange(opt), style: [
+                    styles.segment,
+                    selected && styles.segmentSelected,
+                ], accessibilityRole: "button", accessibilityState: { selected }, accessibilityLabel: `${opt}${selected ? ' (selected)' : ''}` },
+                react_1.default.createElement(react_native_1.Text, { style: [
+                        styles.segmentText,
+                        selected && styles.segmentTextSelected,
+                    ] }, opt)));
+        })),
+        caption ? react_1.default.createElement(react_native_1.Text, { style: styles.caption }, caption) : null));
+}
+const styles = react_native_1.StyleSheet.create({
+    backdrop: {
+        flex: 1,
+        backgroundColor: 'rgba(0,0,0,0.55)',
+        justifyContent: 'flex-end',
+    },
+    sheet: {
+        backgroundColor: '#1c1c1e',
+        borderTopLeftRadius: 16,
+        borderTopRightRadius: 16,
+        paddingBottom: 32,
+        maxHeight: '88%',
+    },
+    header: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'space-between',
+        paddingHorizontal: 20,
+        paddingVertical: 16,
+        borderBottomWidth: react_native_1.StyleSheet.hairlineWidth,
+        borderBottomColor: 'rgba(255,255,255,0.15)',
+    },
+    title: {
+        color: '#ffffff',
+        fontSize: 18,
+        fontWeight: '600',
+    },
+    closeBtn: {
+        width: 36,
+        height: 36,
+        borderRadius: 18,
+        backgroundColor: 'rgba(255,255,255,0.12)',
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    closeText: {
+        color: '#ffffff',
+        fontSize: 22,
+        fontWeight: '300',
+        lineHeight: 24,
+    },
+    body: {
+        paddingHorizontal: 20,
+        paddingTop: 12,
+    },
+    sectionHeader: {
+        color: '#ffffff',
+        opacity: 0.85,
+        fontSize: 13,
+        fontWeight: '600',
+        textTransform: 'uppercase',
+        letterSpacing: 0.5,
+        marginTop: 18,
+        marginBottom: 8,
+    },
+    row: {
+        marginTop: 4,
+    },
+    label: {
+        color: '#ffffff',
+        opacity: 0.85,
+        fontSize: 13,
+        fontWeight: '600',
+        textTransform: 'uppercase',
+        letterSpacing: 0.5,
+        marginTop: 18,
+        marginBottom: 8,
+    },
+    segmentedRow: {
+        flexDirection: 'row',
+        backgroundColor: 'rgba(255,255,255,0.08)',
+        borderRadius: 10,
+        padding: 4,
+        gap: 4,
+    },
+    segment: {
+        flex: 1,
+        paddingVertical: 10,
+        paddingHorizontal: 8,
+        borderRadius: 7,
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    segmentSelected: {
+        backgroundColor: '#ffffff',
+    },
+    segmentText: {
+        color: '#ffffff',
+        fontSize: 13,
+        fontWeight: '500',
+        opacity: 0.85,
+    },
+    segmentTextSelected: {
+        color: '#000000',
+        fontWeight: '700',
+        opacity: 1,
+    },
+    caption: {
+        color: 'rgba(255,255,255,0.55)',
+        fontSize: 11,
+        marginTop: 6,
+        lineHeight: 16,
+    },
+    debugLine: {
+        color: 'rgba(255,200,0,0.85)',
+        fontFamily: 'Menlo',
+        fontSize: 10,
+        paddingVertical: 8,
+        paddingHorizontal: 6,
+        backgroundColor: 'rgba(255,200,0,0.08)',
+        borderRadius: 6,
+        marginBottom: 4,
+    },
+    resetBtn: {
+        marginTop: 28,
+        paddingVertical: 12,
+        borderRadius: 8,
+        borderWidth: 1,
+        borderColor: 'rgba(255,255,255,0.25)',
+        alignItems: 'center',
+    },
+    resetText: {
+        color: '#ffffff',
+        fontSize: 14,
+        fontWeight: '500',
+    },
+    // V16 Phase 1b — Accordion + Tag + InfoBox
+    accordion: {
+        marginTop: 18,
+        backgroundColor: 'rgba(255,255,255,0.04)',
+        borderRadius: 8,
+        overflow: 'hidden',
+    },
+    accordionHeader: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        paddingVertical: 12,
+        paddingHorizontal: 12,
+        gap: 8,
+    },
+    accordionChevron: {
+        color: 'rgba(255,255,255,0.5)',
+        fontSize: 11,
+        width: 14,
+    },
+    accordionTitle: {
+        color: '#ffffff',
+        opacity: 0.85,
+        fontSize: 13,
+        fontWeight: '600',
+        textTransform: 'uppercase',
+        letterSpacing: 0.5,
+        flex: 1,
+    },
+    accordionBody: {
+        paddingHorizontal: 12,
+        paddingBottom: 14,
+    },
+    tag: {
+        backgroundColor: 'rgba(255,255,255,0.12)',
+        paddingHorizontal: 6,
+        paddingVertical: 2,
+        borderRadius: 4,
+    },
+    tagText: {
+        color: 'rgba(255,255,255,0.7)',
+        fontSize: 9,
+        fontWeight: '600',
+        textTransform: 'uppercase',
+        letterSpacing: 0.5,
+    },
+    infoBox: {
+        backgroundColor: 'rgba(255,255,255,0.06)',
+        borderRadius: 8,
+        padding: 12,
+        marginTop: 4,
+    },
+    infoText: {
+        color: 'rgba(255,255,255,0.75)',
+        fontSize: 12,
+        lineHeight: 17,
+    },
+});
+//# sourceMappingURL=PanoramaSettingsModal.js.map