react-native-image-stitcher 0.1.0

package/ios/Sources/RNImageStitcher/Stitcher.swift

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: Apache-2.0
+// Stitcher.swift
+//
+// Pure-Swift wrapper around the Objective-C(++) `OpenCVStitcher`.
+// Mirrors the layering of `QualityChecker.swift` ↔ `QualityCheckerBridge.swift`
+// from Phase 1: this file does the type translation between Swift
+// idioms (Result, throwing functions, Error) and the ObjC interface.
+// It does NOT import OpenCV or React — keeping it framework-light is
+// what lets `swift test` build clean from the command line.
+//
+// XCTest coverage:
+//   The pure algorithmic part of stitching lives in OpenCV itself
+//   (cv::Stitcher::SCANS — well-tested upstream).  Our test surface
+//   is therefore "did we wire it correctly + handle errors right?",
+//   covered by `StitcherTests.swift` against synthetic fixture
+//   images.  Those tests need an iOS simulator (OpenCV ships only
+//   iOS XCFramework binaries from the opencv-mobile fork), so they
+//   live behind an availability check that lets `swift test` skip
+//   them gracefully on macOS-only CI.
+
+#if canImport(UIKit)
+import Foundation
+import UIKit
+
+// `OpenCVStitcher` is an ObjC class; the SwiftPM target excludes the
+// .mm files (they need OpenCV to compile) but the Pods build does
+// include them.  When the Pods build is the one running, this Swift
+// file links against the ObjC class via the umbrella header.
+//
+// In the SwiftPM macOS test build, OpenCVStitcher isn't available;
+// `canImport(UIKit)` plus the .mm file's exclusion in Package.swift
+// keeps everything compilable.
+
+public struct StitchOptions {
+  public let framePaths: [String]
+  public let outputPath: String
+  public let jpegQuality: Int
+  public init(framePaths: [String], outputPath: String, jpegQuality: Int = 85) {
+    self.framePaths = framePaths
+    self.outputPath = outputPath
+    self.jpegQuality = jpegQuality
+  }
+}
+
+public struct StitchVideoOptions {
+  /// Path to the recorded mp4 (with or without `file://` prefix).
+  public let videoPath: String
+  /// Where the resulting panoramic JPEG should be written.
+  public let outputPath: String
+  /// How many frames to sample from the video for stitching.
+  /// 10 is the empirical sweet spot — enough overlap to keep
+  /// homography solid, few enough that stitching stays under 4
+  /// seconds on iPhone 14+ for a typical ~3s pan.
+  public let maxFrames: Int
+  /// JPEG quality [0..100] applied to BOTH the intermediate
+  /// frames AND the final panorama.
+  public let jpegQuality: Int
+  /// "plane" / "cylindrical" / "spherical".  See OpenCVStitcher.h
+  /// for guidance.  Default "plane".
+  public let warperType: String
+  /// "multiband" / "feather".  Default "multiband".
+  public let blenderType: String
+  /// "graphcut" / "skip".  Default "graphcut".
+  /// "graphcut" runs cv::detail::GraphCutSeamFinder for clean
+  /// seams (more memory).  "skip" streams warp+feed for low peak
+  /// memory at the cost of less optimal seams.
+  public let seamFinderType: String
+  public init(
+    videoPath: String,
+    outputPath: String,
+    maxFrames: Int = 10,
+    jpegQuality: Int = 85,
+    warperType: String = "plane",
+    blenderType: String = "multiband",
+    seamFinderType: String = "graphcut"
+  ) {
+    self.videoPath = videoPath
+    self.outputPath = outputPath
+    self.maxFrames = maxFrames
+    self.jpegQuality = jpegQuality
+    self.warperType = warperType
+    self.blenderType = blenderType
+    self.seamFinderType = seamFinderType
+  }
+}
+
+public struct StitchResult: Equatable {
+  public let outputPath: String
+  public let width: Int
+  public let height: Int
+  public let durationMs: Double
+}
+
+public enum StitcherError: Error {
+  case insufficientFrames(count: Int)
+  case readFailed(path: String)
+  case writeFailed(path: String)
+  case opencvFailed(code: Int, message: String)
+
+  /// Build a Swift error from the NSError the ObjC layer hands back.
+  /// Codes are aligned with `OpenCVStitcher.mm`'s `cv::Stitcher::Status`
+  /// mapping so the JS layer can branch on classes of failure.
+  static func fromNSError(_ err: NSError) -> StitcherError {
+    switch err.code {
+    case 1000:
+      // Pulled from the description text — we don't have the count
+      // structurally because the ObjC error doesn't carry it.
+      return .insufficientFrames(count: -1)
+    case 1001:
+      let path = (err.userInfo[NSLocalizedDescriptionKey] as? String) ?? "<unknown>"
+      return .readFailed(path: path)
+    case 1002:
+      let path = (err.userInfo[NSLocalizedDescriptionKey] as? String) ?? "<unknown>"
+      return .writeFailed(path: path)
+    default:
+      let msg = (err.userInfo[NSLocalizedDescriptionKey] as? String) ?? "OpenCV failure"
+      return .opencvFailed(code: err.code, message: msg)
+    }
+  }
+}
+
+public enum Stitcher {
+
+  /// Stitch the configured frames into a panorama at `options.outputPath`.
+  /// Throws `StitcherError` on failure; returns the result on success.
+  ///
+  /// This is synchronous on the calling thread.  The RN bridge in
+  /// `StitcherBridge.swift` dispatches it to a background queue so
+  /// the JS thread isn't blocked during what's typically a 1–4s
+  /// operation on iPhone hardware.
+  public static func stitch(_ options: StitchOptions) throws -> StitchResult {
+    if options.framePaths.count < 2 {
+      throw StitcherError.insufficientFrames(count: options.framePaths.count)
+    }
+
+    // The ObjC method's `(NSError **)error` last parameter is
+    // imported by Swift as a throwing method — calling with `try`
+    // catches the NSError; there's no `error:` argument to pass.
+    do {
+      let result = try OpenCVStitcher.stitchFramePaths(
+        options.framePaths,
+        outputPath: options.outputPath,
+        jpegQuality: options.jpegQuality,
+        warperType: "plane",
+        blenderType: "multiband",
+        seamFinderType: "graphcut",
+        // AR-STITCHING-TWO-MODES — see memory/ar-stitching-two-modes.md
+        // Generic Stitcher API doesn't carry capture orientation;
+        // pass nil → .mm treats as "portrait" → no bake-rotation.
+        // Callers that care about output orientation (e.g.
+        // IncrementalStitcher) hit the method directly with
+        // the right value.
+        captureOrientation: nil,
+        // V16 Phase 1b.fix5c — generic Stitcher API defaults the
+        // crop strategy to bbox-only (matches the operator-default
+        // in the panorama settings modal).  Callers that want
+        // inscribed-rect can use IncrementalStitcher with
+        // the toggle on.
+        useInscribedRectCrop: false
+      )
+      return StitchResult(
+        outputPath: result.outputPath,
+        width: result.width,
+        height: result.height,
+        durationMs: result.durationMs
+      )
+    } catch let nsError as NSError {
+      throw StitcherError.fromNSError(nsError)
+    }
+  }
+
+  /// Bake EXIF rotation into pixels for the image at `imagePath`.
+  /// Returns the post-rotation dimensions so the host can keep its
+  /// width/height fields aligned with what's now on disk.
+  ///
+  /// Idempotent on already-normalised files.  Errors mirror the
+  /// existing StitcherError shape so JS can switch on `.code`.
+  public static func normaliseOrientation(
+    imagePath: String
+  ) throws -> (width: Int, height: Int) {
+    do {
+      let dict = try OpenCVStitcher.normaliseImage(atPath: imagePath)
+      let width = dict["width"]?.intValue ?? 0
+      let height = dict["height"]?.intValue ?? 0
+      return (width: width, height: height)
+    } catch let nsError as NSError {
+      throw StitcherError.fromNSError(nsError)
+    }
+  }
+
+  /// Combined pipeline: extract frames from a recorded video,
+  /// stitch them into a panorama, write the result to
+  /// `options.outputPath`.  Used by the host app's tap-and-hold
+  /// shutter — the JS side records video while the user holds the
+  /// button and calls this on release.
+  ///
+  /// All temp frame extraction lives in /tmp and is torn down by
+  /// the ObjC layer regardless of success or failure.
+  public static func stitchVideo(
+    _ options: StitchVideoOptions,
+    poses: [[String: Any]]? = nil
+  ) throws -> StitchResult {
+    do {
+      let result: RNStitchResult
+      if let poses = poses, !poses.isEmpty {
+        // Phase 5: pose-driven path.  Skips features → matching →
+        // BundleAdjuster on the native side; cv::detail::CameraParams
+        // come straight from the ARKit poses with the appropriate
+        // coordinate-system flip (Y-up → Y-down, -Z → +Z).
+        result = try OpenCVStitcher.stitchVideo(
+          atPath: options.videoPath,
+          outputPath: options.outputPath,
+          maxFrames: options.maxFrames,
+          jpegQuality: options.jpegQuality,
+          warperType: options.warperType,
+          blenderType: options.blenderType,
+          seamFinderType: options.seamFinderType,
+          poses: poses
+        )
+      } else {
+        // Existing feature-matched path.
+        result = try OpenCVStitcher.stitchVideo(
+          atPath: options.videoPath,
+          outputPath: options.outputPath,
+          maxFrames: options.maxFrames,
+          jpegQuality: options.jpegQuality,
+          warperType: options.warperType,
+          blenderType: options.blenderType,
+          seamFinderType: options.seamFinderType
+        )
+      }
+      return StitchResult(
+        outputPath: result.outputPath,
+        width: result.width,
+        height: result.height,
+        durationMs: result.durationMs
+      )
+    } catch let nsError as NSError {
+      throw StitcherError.fromNSError(nsError)
+    }
+  }
+}
+#endif

package/ios/Sources/RNImageStitcher/StitcherBridge.m

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: Apache-2.0
+//
+// StitcherBridge.m
+//
+// RN bridge declaration for the Swift `StitcherBridge`.
+// Same pattern as `QualityCheckerBridge.m`.  Without this file the
+// JS side's `NativeModules.BatchStitcher` would resolve to
+// `undefined` because RN's module map is populated by RCT_EXTERN_*
+// macros, not Swift @objc decorators alone.
+//
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(BatchStitcher, NSObject)
+
+RCT_EXTERN_METHOD(stitch:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(stitchVideo:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+RCT_EXTERN_METHOD(normaliseOrientation:(NSDictionary *)options
+                  resolver:(RCTPromiseResolveBlock)resolver
+                  rejecter:(RCTPromiseRejectBlock)rejecter)
+
+@end

package/ios/Sources/RNImageStitcher/StitcherBridge.swift

@@ -0,0 +1,246 @@
+// SPDX-License-Identifier: Apache-2.0
+// StitcherBridge.swift
+//
+// React Native bridge for the SDK's image stitcher.  Mirrors the
+// QualityCheckerBridge pattern: the algorithm lives in
+// `Stitcher.swift` (which depends only on UIKit + the ObjC
+// `OpenCVStitcher`); this file is the translation between RN's
+// promise-based bridge and the throwing-Swift API.
+//
+// Threading:
+//   `Stitcher.stitch(...)` is synchronous and CPU-heavy (1–4 seconds
+//   for typical 4-frame panoramas on an A17 phone).  Running it on
+//   the JS-thread-owned bridge queue would freeze the UI.  We
+//   dispatch onto a global utility queue so the user sees their
+//   spinner animate while the panorama assembles.
+
+#if canImport(React)
+import Foundation
+import React
+import UIKit
+
+@objc(BatchStitcher)
+public class StitcherBridge: NSObject {
+
+  // Stitching is a CPU-bound background operation; let RN drop the
+  // module setup to a background queue too so the main thread isn't
+  // blocked during initialisation.
+  @objc public static func requiresMainQueueSetup() -> Bool { return false }
+
+  /// Constants exposed to JS at module load time.  Read via
+  /// `NativeModules.BatchStitcher.physicalMemoryBytes`.
+  ///
+  /// Used by the SDK's `DEFAULT_PANORAMA_SETTINGS` to pick
+  /// memory-appropriate defaults: high-quality MultiBand+GraphCut
+  /// on devices with ≥2 GB physical RAM, low-memory Feather+skip
+  /// on devices with <2 GB.  The user can still override either
+  /// way via the panorama settings modal.
+  ///
+  /// CRITICAL: this MUST be a class method (`static`), not an
+  /// instance method.  React Native's bridge gathers constants by
+  /// trying `[ModuleClass respondsToSelector:@selector(constants
+  /// ToExport)]` first; only the class-method form satisfies that
+  /// without forcing module instantiation.  When this was an
+  /// instance method, the module was lazily created on the first
+  /// `stitchVideo` call — so by then JS had already read empty
+  /// constants and our `_isLowMem` check fell back incorrectly.
+  ///
+  /// Reading `ProcessInfo.processInfo.physicalMemory` is thread-
+  /// safe (no UIKit dependency), so the constants gathering can
+  /// happen off main thread; `requiresMainQueueSetup = false`
+  /// stays correct.
+  ///
+  /// Returning `[String: Any]` (not `[AnyHashable: Any]`) so the
+  /// Swift→ObjC bridge produces an `NSDictionary<NSString *, id> *`
+  /// which is exactly what RN's `constantsToExport` declares.
+  @objc public static func constantsToExport() -> [String: Any] {
+    let bytes = ProcessInfo.processInfo.physicalMemory
+    NSLog("[BatchStitcher] constantsToExport: physicalMemoryBytes=%llu",
+          bytes)
+    return [
+      "physicalMemoryBytes": NSNumber(value: bytes),
+    ]
+  }
+
+  /// Bridged entry: stitch the frames at `options.framePaths` into a
+  /// panorama at `options.outputPath`.  Resolves with
+  /// `{ outputPath, width, height, durationMs }` to match the JS
+  /// `StitchFramesResult` type.  Reject codes correspond to the
+  /// `StitcherError` cases so the JS host can branch on
+  /// "need more frames" vs. "decode failed" etc.
+  /// Bridged entry: end-to-end video → panorama pipeline.  Resolves
+  /// with the same `{ outputPath, width, height, durationMs }` shape
+  /// as `stitch` so the JS layer can swap between "stitch from
+  /// pre-captured photos" and "stitch from a tap-hold video" without
+  /// branching on result type.
+  ///
+  /// Expected `options` keys: `videoPath`, `outputPath`, `maxFrames`
+  /// (default 10), `quality` (default 85).
+  @objc(stitchVideo:resolver:rejecter:)
+  public func stitchVideo(
+    options: NSDictionary,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let videoPath = options["videoPath"] as? String else {
+      rejecter("invalid-options", "videoPath must be a string", nil)
+      return
+    }
+    guard let outputPath = options["outputPath"] as? String else {
+      rejecter("invalid-options", "outputPath must be a string", nil)
+      return
+    }
+    let maxFrames = (options["maxFrames"] as? Int) ?? 10
+    let jpegQuality = (options["quality"] as? Int) ?? 85
+    let warperType = (options["warperType"] as? String) ?? "plane"
+    let blenderType = (options["blenderType"] as? String) ?? "multiband"
+    let seamFinderType = (options["seamFinderType"] as? String) ?? "graphcut"
+    // Optional pose log from the host's RNSARSession snapshot.
+    // When present and non-empty, the native stitcher routes to the
+    // pose-driven path (skips features → matching → BA).
+    let poses = options["poses"] as? [[String: Any]]
+
+    let stitchOpts = StitchVideoOptions(
+      videoPath: videoPath,
+      outputPath: outputPath,
+      maxFrames: maxFrames,
+      jpegQuality: jpegQuality,
+      warperType: warperType,
+      blenderType: blenderType,
+      seamFinderType: seamFinderType
+    )
+
+    DispatchQueue.global(qos: .userInitiated).async {
+      do {
+        let result = try Stitcher.stitchVideo(stitchOpts, poses: poses)
+        resolver([
+          "outputPath": result.outputPath,
+          "width": result.width,
+          "height": result.height,
+          "durationMs": result.durationMs,
+        ])
+      } catch let err as StitcherError {
+        switch err {
+        case .insufficientFrames(let count):
+          rejecter(
+            "insufficient-frames",
+            "Need at least 2 frames to stitch (got \(count))",
+            err
+          )
+        case .readFailed(let path):
+          rejecter("read-failed", "Could not read input: \(path)", err)
+        case .writeFailed(let path):
+          rejecter("write-failed", "Could not write panorama: \(path)", err)
+        case .opencvFailed(let code, let message):
+          rejecter("opencv-failed-\(code)", message, err)
+        }
+      } catch {
+        rejecter("unknown", "Unexpected stitcher failure: \(error)", error)
+      }
+    }
+  }
+
+  /// Bake EXIF orientation into the pixels of the image at the
+  /// given path.  Resolves with the post-rotation `{ width, height }`
+  /// so the JS layer can update its own metadata.
+  ///
+  /// Expected `options` keys: `imagePath`.
+  @objc(normaliseOrientation:resolver:rejecter:)
+  public func normaliseOrientation(
+    options: NSDictionary,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let imagePath = options["imagePath"] as? String else {
+      rejecter("invalid-options", "imagePath must be a string", nil)
+      return
+    }
+    DispatchQueue.global(qos: .userInitiated).async {
+      do {
+        let dims = try Stitcher.normaliseOrientation(imagePath: imagePath)
+        resolver([
+          "width": dims.width,
+          "height": dims.height,
+        ])
+      } catch let err as StitcherError {
+        switch err {
+        case .insufficientFrames(let count):
+          rejecter("insufficient-frames", "(unexpected for normalise) frames=\(count)", err)
+        case .readFailed(let path):
+          rejecter("read-failed", "Could not read image: \(path)", err)
+        case .writeFailed(let path):
+          rejecter("write-failed", "Could not write image: \(path)", err)
+        case .opencvFailed(let code, let message):
+          rejecter("opencv-failed-\(code)", message, err)
+        }
+      } catch {
+        rejecter("unknown", "Unexpected normaliseOrientation failure: \(error)", error)
+      }
+    }
+  }
+
+  @objc(stitch:resolver:rejecter:)
+  public func stitch(
+    options: NSDictionary,
+    resolver: @escaping RCTPromiseResolveBlock,
+    rejecter: @escaping RCTPromiseRejectBlock
+  ) {
+    // Translate the dictionary the JS layer hands us into the typed
+    // StitchOptions struct.  Defensive: missing / wrong-typed fields
+    // raise a recognisable bridge-side error instead of throwing
+    // deep inside ObjC.
+    guard let framePaths = options["framePaths"] as? [String] else {
+      rejecter("invalid-options", "framePaths must be an array of strings", nil)
+      return
+    }
+    guard let outputPath = options["outputPath"] as? String else {
+      rejecter("invalid-options", "outputPath must be a string", nil)
+      return
+    }
+    let jpegQuality = (options["quality"] as? Int) ?? 85
+
+    let stitchOpts = StitchOptions(
+      framePaths: framePaths,
+      outputPath: outputPath,
+      jpegQuality: jpegQuality
+    )
+
+    DispatchQueue.global(qos: .userInitiated).async {
+      do {
+        let result = try Stitcher.stitch(stitchOpts)
+        resolver([
+          "outputPath": result.outputPath,
+          "width": result.width,
+          "height": result.height,
+          "durationMs": result.durationMs,
+        ])
+      } catch let err as StitcherError {
+        switch err {
+        case .insufficientFrames(let count):
+          rejecter(
+            "insufficient-frames",
+            "Need at least 2 frames to stitch (got \(count))",
+            err
+          )
+        case .readFailed(let path):
+          rejecter(
+            "read-failed",
+            "Could not read input image: \(path)",
+            err
+          )
+        case .writeFailed(let path):
+          rejecter(
+            "write-failed",
+            "Could not write stitched panorama: \(path)",
+            err
+          )
+        case .opencvFailed(let code, let message):
+          rejecter("opencv-failed-\(code)", message, err)
+        }
+      } catch {
+        rejecter("unknown", "Unexpected stitcher failure: \(error)", error)
+      }
+    }
+  }
+}
+#endif

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "react-native-image-stitcher",
+  "version": "0.1.0",
+  "description": "Pose-aware panorama capture + stitching for React Native. One <Camera> component, both tap-to-photo and hold-to-pan modes, both AR-backed and IMU-fallback capture paths.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "src",
+    "ios/Sources",
+    "ios/Package.swift",
+    "android/build.gradle",
+    "android/src/main/java",
+    "android/src/main/cpp",
+    "android/src/main/AndroidManifest.xml",
+    "cpp",
+    "scripts/postinstall-fetch-binaries.js",
+    "scripts/opencv-version.txt",
+    "RNImageStitcher.podspec",
+    "react-native.config.js",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "postinstall": "node scripts/postinstall-fetch-binaries.js"
+  },
+  "keywords": [
+    "react-native",
+    "panorama",
+    "stitching",
+    "image-stitcher",
+    "camera",
+    "opencv",
+    "arkit",
+    "arcore",
+    "vision-camera",
+    "shelf-scan"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bhargavkanda/react-native-image-stitcher.git"
+  },
+  "bugs": {
+    "url": "https://github.com/bhargavkanda/react-native-image-stitcher/issues"
+  },
+  "homepage": "https://github.com/bhargavkanda/react-native-image-stitcher#readme",
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "expo-sensors": "^14.0.0",
+    "react": "^19.0.0",
+    "react-native": "^0.84.0",
+    "react-native-safe-area-context": "^4.0.0",
+    "react-native-sensors": "^7.0.0",
+    "react-native-vision-camera": "^4.0.0",
+    "rxjs": "^7.0.0",
+    "typescript": "^5.5.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.72.0",
+    "react-native-vision-camera": ">=4.7.0",
+    "react-native-sensors": ">=7.0.0",
+    "expo-sensors": ">=14.0.0",
+    "react-native-safe-area-context": ">=4.0.0"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,34 @@
+/**
+ * react-native.config.js — describe this SDK's native surface to RN
+ * autolinking.  Without this file autolinking would look for a
+ * podspec named `CaptureSdk.podspec` (the slug of the package name
+ * `react-native-image-stitcher`) and miss our actual file
+ * `RNImageStitcher.podspec` at the package root.
+ *
+ * Declaring the explicit paths here also lets autolinking find the
+ * Android source directory once Phase 3 lands (currently absent —
+ * the `android` block is included now so the iOS-Android shape is
+ * symmetric and operators don't have to re-edit this file mid-work).
+ */
+const path = require('path');
+
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {
+        podspecPath: path.join(__dirname, 'RNImageStitcher.podspec'),
+      },
+      android: {
+        // RELATIVE path on purpose.  RN's autolinking computes
+        // `path.join(root, sourceDir)` where `root` is the package
+        // root in node_modules (a symlink in our case).  An ABSOLUTE
+        // sourceDir gets concatenated by path.join rather than
+        // treated as already-resolved, producing a broken double
+        // path and silently failing detection.  Relative `'android'`
+        // joins cleanly and resolves through the symlink to the
+        // real Android module folder.
+        sourceDir: 'android',
+      },
+    },
+  },
+};

package/scripts/opencv-version.txt

@@ -0,0 +1 @@
+4.10.0