react-native-rectangle-doc-scanner 0.55.0 → 0.57.0

package/dist/index.d.ts

@@ -5,3 +5,4 @@ export type { FullDocScannerResult, FullDocScannerProps, FullDocScannerStrings,
 export type { Point, Quad, Rectangle, CapturedDocument } from './types';
 export type { DetectionConfig } from './DocScanner';
 export { quadToRectangle, rectangleToQuad, scaleCoordinates, scaleRectangle, } from './utils/coordinate';
+export { DocumentDetector } from './utils/documentDetection';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scaleRectangle = exports.scaleCoordinates = exports.rectangleToQuad = exports.quadToRectangle = exports.FullDocScanner = exports.CropEditor = exports.DocScanner = void 0;
+exports.DocumentDetector = exports.scaleRectangle = exports.scaleCoordinates = exports.rectangleToQuad = exports.quadToRectangle = exports.FullDocScanner = exports.CropEditor = exports.DocScanner = void 0;
 // Main components
 var DocScanner_1 = require("./DocScanner");
 Object.defineProperty(exports, "DocScanner", { enumerable: true, get: function () { return DocScanner_1.DocScanner; } });
@@ -14,3 +14,5 @@ Object.defineProperty(exports, "quadToRectangle", { enumerable: true, get: funct
 Object.defineProperty(exports, "rectangleToQuad", { enumerable: true, get: function () { return coordinate_1.rectangleToQuad; } });
 Object.defineProperty(exports, "scaleCoordinates", { enumerable: true, get: function () { return coordinate_1.scaleCoordinates; } });
 Object.defineProperty(exports, "scaleRectangle", { enumerable: true, get: function () { return coordinate_1.scaleRectangle; } });
+var documentDetection_1 = require("./utils/documentDetection");
+Object.defineProperty(exports, "DocumentDetector", { enumerable: true, get: function () { return documentDetection_1.DocumentDetector; } });

package/dist/utils/documentDetection.d.ts

@@ -0,0 +1,23 @@
+import type { Point } from '../types';
+type Size = {
+    width: number;
+    height: number;
+};
+type Quad = [Point, Point, Point, Point];
+/**
+ * Provides document detection utilities using react-native-fast-opencv.
+ */
+export declare class DocumentDetector {
+    private static initialized;
+    /** Initialize OpenCV runtime once */
+    static initialize(): Promise<void>;
+    /** Find document contours and return the largest quadrilateral */
+    static findDocumentContours(imagePath: string): Promise<Quad | null>;
+    /** Apply a perspective transform using detected corners */
+    static perspectiveTransform(imagePath: string, corners: Quad, outputSize?: Size): Promise<string | null>;
+    /** Detect document and apply normalization */
+    static detectAndNormalize(imagePath: string, outputSize?: Size): Promise<string | null>;
+    /** Only detect document corners without transforming */
+    static getDocumentBounds(imagePath: string): Promise<Quad | null>;
+}
+export {};

package/dist/utils/documentDetection.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentDetector = void 0;
+const react_native_fast_opencv_1 = require("react-native-fast-opencv");
+const OUTPUT_SIZE = { width: 800, height: 600 };
+const MIN_AREA = 1000;
+const GAUSSIAN_KERNEL = { width: 5, height: 5 };
+const MORPH_KERNEL = { width: 3, height: 3 };
+const ADAPTIVE_THRESH_GAUSSIAN_C = 1;
+const THRESH_BINARY = 0;
+const safeRelease = (mat) => {
+    if (mat && typeof mat.release === 'function') {
+        mat.release();
+    }
+};
+const normalizePoint = (value) => {
+    if (!value) {
+        return null;
+    }
+    if (Array.isArray(value) && value.length >= 2) {
+        const [x, y] = value;
+        const px = Number(x);
+        const py = Number(y);
+        return Number.isFinite(px) && Number.isFinite(py) ? { x: px, y: py } : null;
+    }
+    if (typeof value === 'object') {
+        const maybePoint = value;
+        const px = Number(maybePoint.x);
+        const py = Number(maybePoint.y);
+        return Number.isFinite(px) && Number.isFinite(py) ? { x: px, y: py } : null;
+    }
+    return null;
+};
+const toPointArray = (value) => {
+    if (!value) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        const points = value.map(normalizePoint).filter((point) => point !== null);
+        return points.length === value.length ? points : null;
+    }
+    if (typeof value === 'object') {
+        const mat = value;
+        const data = mat.data32F ?? mat.data64F ?? mat.data32S;
+        if (!data || data.length < 8) {
+            return null;
+        }
+        const points = [];
+        for (let i = 0; i + 1 < data.length; i += 2) {
+            const x = data[i];
+            const y = data[i + 1];
+            if (Number.isFinite(x) && Number.isFinite(y)) {
+                points.push({ x, y });
+            }
+        }
+        return points.length >= 4 ? points.slice(0, 4) : null;
+    }
+    return null;
+};
+const ensureQuad = (points) => {
+    if (!points || points.length < 4) {
+        return null;
+    }
+    const quad = [points[0], points[1], points[2], points[3]];
+    for (const point of quad) {
+        if (typeof point.x !== 'number' || typeof point.y !== 'number') {
+            return null;
+        }
+    }
+    return quad;
+};
+/**
+ * Provides document detection utilities using react-native-fast-opencv.
+ */
+class DocumentDetector {
+    static initialized = false;
+    /** Initialize OpenCV runtime once */
+    static async initialize() {
+        if (!DocumentDetector.initialized) {
+            await react_native_fast_opencv_1.OpenCV.initialize();
+            DocumentDetector.initialized = true;
+        }
+    }
+    /** Find document contours and return the largest quadrilateral */
+    static async findDocumentContours(imagePath) {
+        await DocumentDetector.initialize();
+        let image;
+        let gray;
+        let blurred;
+        let thresh;
+        let morphed;
+        let kernel;
+        try {
+            image = react_native_fast_opencv_1.OpenCV.imread(imagePath);
+            gray = react_native_fast_opencv_1.OpenCV.cvtColor(image, react_native_fast_opencv_1.ColorConversionCodes.COLOR_BGR2GRAY);
+            blurred = react_native_fast_opencv_1.OpenCV.GaussianBlur(gray, GAUSSIAN_KERNEL, 0);
+            thresh = react_native_fast_opencv_1.OpenCV.adaptiveThreshold(blurred, 255, ADAPTIVE_THRESH_GAUSSIAN_C, THRESH_BINARY, 11, 2);
+            kernel = react_native_fast_opencv_1.OpenCV.getStructuringElement(react_native_fast_opencv_1.MorphShapes.MORPH_RECT, MORPH_KERNEL);
+            morphed = react_native_fast_opencv_1.OpenCV.morphologyEx(thresh, react_native_fast_opencv_1.MorphTypes.MORPH_CLOSE, kernel);
+            const contours = react_native_fast_opencv_1.OpenCV.findContours(morphed, react_native_fast_opencv_1.RetrievalModes.RETR_EXTERNAL, react_native_fast_opencv_1.ContourApproximationModes.CHAIN_APPROX_SIMPLE);
+            let largestQuad = null;
+            let maxArea = 0;
+            for (const contour of contours) {
+                const area = react_native_fast_opencv_1.OpenCV.contourArea(contour);
+                if (area <= maxArea || area <= MIN_AREA) {
+                    continue;
+                }
+                const perimeter = react_native_fast_opencv_1.OpenCV.arcLength(contour, true);
+                const approx = react_native_fast_opencv_1.OpenCV.approxPolyDP(contour, 0.02 * perimeter, true);
+                const points = ensureQuad(toPointArray(approx));
+                safeRelease(approx);
+                if (!points) {
+                    continue;
+                }
+                maxArea = area;
+                largestQuad = points;
+            }
+            return largestQuad;
+        }
+        catch (error) {
+            if (__DEV__) {
+                console.error('[DocumentDetector] findDocumentContours error', error);
+            }
+            return null;
+        }
+        finally {
+            safeRelease(kernel);
+            safeRelease(morphed);
+            safeRelease(thresh);
+            safeRelease(blurred);
+            safeRelease(gray);
+            safeRelease(image);
+        }
+    }
+    /** Apply a perspective transform using detected corners */
+    static async perspectiveTransform(imagePath, corners, outputSize = OUTPUT_SIZE) {
+        await DocumentDetector.initialize();
+        let image;
+        let srcPoints;
+        let dstPoints;
+        let transformMatrix;
+        let warped;
+        try {
+            image = react_native_fast_opencv_1.OpenCV.imread(imagePath);
+            srcPoints = react_native_fast_opencv_1.OpenCV.matFromArray(4, 1, react_native_fast_opencv_1.OpenCV.CV_32FC2, [
+                corners[0].x,
+                corners[0].y,
+                corners[1].x,
+                corners[1].y,
+                corners[2].x,
+                corners[2].y,
+                corners[3].x,
+                corners[3].y,
+            ]);
+            dstPoints = react_native_fast_opencv_1.OpenCV.matFromArray(4, 1, react_native_fast_opencv_1.OpenCV.CV_32FC2, [
+                0,
+                0,
+                outputSize.width,
+                0,
+                outputSize.width,
+                outputSize.height,
+                0,
+                outputSize.height,
+            ]);
+            transformMatrix = react_native_fast_opencv_1.OpenCV.getPerspectiveTransform(srcPoints, dstPoints);
+            warped = react_native_fast_opencv_1.OpenCV.warpPerspective(image, transformMatrix, outputSize);
+            const outputPath = imagePath.replace(/\.jpg$/i, '_normalized.jpg');
+            react_native_fast_opencv_1.OpenCV.imwrite(outputPath, warped);
+            return outputPath;
+        }
+        catch (error) {
+            if (__DEV__) {
+                console.error('[DocumentDetector] perspectiveTransform error', error);
+            }
+            return null;
+        }
+        finally {
+            safeRelease(warped);
+            safeRelease(transformMatrix);
+            safeRelease(dstPoints);
+            safeRelease(srcPoints);
+            safeRelease(image);
+        }
+    }
+    /** Detect document and apply normalization */
+    static async detectAndNormalize(imagePath, outputSize) {
+        try {
+            const corners = await DocumentDetector.findDocumentContours(imagePath);
+            if (!corners) {
+                if (__DEV__) {
+                    console.log('[DocumentDetector] No document detected');
+                }
+                return null;
+            }
+            return DocumentDetector.perspectiveTransform(imagePath, corners, outputSize ?? OUTPUT_SIZE);
+        }
+        catch (error) {
+            if (__DEV__) {
+                console.error('[DocumentDetector] detectAndNormalize error', error);
+            }
+            return null;
+        }
+    }
+    /** Only detect document corners without transforming */
+    static async getDocumentBounds(imagePath) {
+        try {
+            return DocumentDetector.findDocumentContours(imagePath);
+        }
+        catch (error) {
+            if (__DEV__) {
+                console.error('[DocumentDetector] getDocumentBounds error', error);
+            }
+            return null;
+        }
+    }
+}
+exports.DocumentDetector = DocumentDetector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-rectangle-doc-scanner",
-  "version": "0.55.0",
+  "version": "0.57.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {
@@ -19,6 +19,8 @@
     "@shopify/react-native-skia": "*",
     "react": "*",
     "react-native": "*",
+    "react-native-fast-opencv": "*",
+    "react-native-perspective-image-cropper": "*",
     "react-native-reanimated": "*",
     "react-native-vision-camera": "*",
     "react-native-worklets-core": "*",
@@ -30,8 +32,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "react-native-fast-opencv": "0.4.6",
-    "react-native-perspective-image-cropper": "^0.4.4",
+    "react-native-rectangle-doc-scanner": "^0.55.0",
     "react-native-worklets-core": "^1.6.2"
   }
 }

package/src/index.ts

@@ -20,3 +20,4 @@ export {
   scaleCoordinates,
   scaleRectangle,
 } from './utils/coordinate';
+export { DocumentDetector } from './utils/documentDetection';

package/src/utils/documentDetection.ts

@@ -0,0 +1,278 @@
+import {
+  OpenCV,
+  ColorConversionCodes,
+  MorphShapes,
+  MorphTypes,
+  RetrievalModes,
+  ContourApproximationModes,
+} from 'react-native-fast-opencv';
+import type { Point } from '../types';
+
+type MatLike = { release?: () => void } | null | undefined;
+
+type Size = { width: number; height: number };
+
+type Quad = [Point, Point, Point, Point];
+
+const OUTPUT_SIZE: Size = { width: 800, height: 600 };
+const MIN_AREA = 1000;
+const GAUSSIAN_KERNEL: Size = { width: 5, height: 5 };
+const MORPH_KERNEL: Size = { width: 3, height: 3 };
+const ADAPTIVE_THRESH_GAUSSIAN_C = 1;
+const THRESH_BINARY = 0;
+
+const safeRelease = (mat: MatLike) => {
+  if (mat && typeof mat.release === 'function') {
+    mat.release();
+  }
+};
+
+const normalizePoint = (value: unknown): Point | null => {
+  if (!value) {
+    return null;
+  }
+
+  if (Array.isArray(value) && value.length >= 2) {
+    const [x, y] = value;
+    const px = Number(x);
+    const py = Number(y);
+    return Number.isFinite(px) && Number.isFinite(py) ? { x: px, y: py } : null;
+  }
+
+  if (typeof value === 'object') {
+    const maybePoint = value as { x?: unknown; y?: unknown };
+    const px = Number(maybePoint.x);
+    const py = Number(maybePoint.y);
+    return Number.isFinite(px) && Number.isFinite(py) ? { x: px, y: py } : null;
+  }
+
+  return null;
+};
+
+const toPointArray = (value: unknown): Point[] | null => {
+  if (!value) {
+    return null;
+  }
+
+  if (Array.isArray(value)) {
+    const points = value.map(normalizePoint).filter((point): point is Point => point !== null);
+    return points.length === value.length ? points : null;
+  }
+
+  if (typeof value === 'object') {
+    const mat = value as { data32F?: number[]; data64F?: number[]; data32S?: number[] };
+    const data = mat.data32F ?? mat.data64F ?? mat.data32S;
+    if (!data || data.length < 8) {
+      return null;
+    }
+
+    const points: Point[] = [];
+    for (let i = 0; i + 1 < data.length; i += 2) {
+      const x = data[i];
+      const y = data[i + 1];
+      if (Number.isFinite(x) && Number.isFinite(y)) {
+        points.push({ x, y });
+      }
+    }
+
+    return points.length >= 4 ? points.slice(0, 4) : null;
+  }
+
+  return null;
+};
+
+const ensureQuad = (points: Point[] | null): Quad | null => {
+  if (!points || points.length < 4) {
+    return null;
+  }
+
+  const quad: Quad = [points[0], points[1], points[2], points[3]];
+  for (const point of quad) {
+    if (typeof point.x !== 'number' || typeof point.y !== 'number') {
+      return null;
+    }
+  }
+
+  return quad;
+};
+
+/**
+ * Provides document detection utilities using react-native-fast-opencv.
+ */
+export class DocumentDetector {
+  private static initialized = false;
+
+  /** Initialize OpenCV runtime once */
+  static async initialize(): Promise<void> {
+    if (!DocumentDetector.initialized) {
+      await OpenCV.initialize();
+      DocumentDetector.initialized = true;
+    }
+  }
+
+  /** Find document contours and return the largest quadrilateral */
+  static async findDocumentContours(imagePath: string): Promise<Quad | null> {
+    await DocumentDetector.initialize();
+
+    let image: MatLike;
+    let gray: MatLike;
+    let blurred: MatLike;
+    let thresh: MatLike;
+    let morphed: MatLike;
+    let kernel: MatLike;
+
+    try {
+      image = OpenCV.imread(imagePath);
+      gray = OpenCV.cvtColor(image, ColorConversionCodes.COLOR_BGR2GRAY);
+      blurred = OpenCV.GaussianBlur(gray, GAUSSIAN_KERNEL, 0);
+
+      thresh = OpenCV.adaptiveThreshold(
+        blurred,
+        255,
+        ADAPTIVE_THRESH_GAUSSIAN_C,
+        THRESH_BINARY,
+        11,
+        2,
+      );
+
+      kernel = OpenCV.getStructuringElement(MorphShapes.MORPH_RECT, MORPH_KERNEL);
+      morphed = OpenCV.morphologyEx(thresh, MorphTypes.MORPH_CLOSE, kernel);
+
+      const contours = OpenCV.findContours(
+        morphed,
+        RetrievalModes.RETR_EXTERNAL,
+        ContourApproximationModes.CHAIN_APPROX_SIMPLE,
+      );
+
+      let largestQuad: Quad | null = null;
+      let maxArea = 0;
+
+      for (const contour of contours) {
+        const area = OpenCV.contourArea(contour);
+        if (area <= maxArea || area <= MIN_AREA) {
+          continue;
+        }
+
+        const perimeter = OpenCV.arcLength(contour, true);
+        const approx = OpenCV.approxPolyDP(contour, 0.02 * perimeter, true);
+        const points = ensureQuad(toPointArray(approx));
+
+        safeRelease(approx as MatLike);
+
+        if (!points) {
+          continue;
+        }
+
+        maxArea = area;
+        largestQuad = points;
+      }
+
+      return largestQuad;
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[DocumentDetector] findDocumentContours error', error);
+      }
+      return null;
+    } finally {
+      safeRelease(kernel);
+      safeRelease(morphed);
+      safeRelease(thresh);
+      safeRelease(blurred);
+      safeRelease(gray);
+      safeRelease(image);
+    }
+  }
+
+  /** Apply a perspective transform using detected corners */
+  static async perspectiveTransform(
+    imagePath: string,
+    corners: Quad,
+    outputSize: Size = OUTPUT_SIZE,
+  ): Promise<string | null> {
+    await DocumentDetector.initialize();
+
+    let image: MatLike;
+    let srcPoints: MatLike;
+    let dstPoints: MatLike;
+    let transformMatrix: MatLike;
+    let warped: MatLike;
+
+    try {
+      image = OpenCV.imread(imagePath);
+
+      srcPoints = OpenCV.matFromArray(4, 1, OpenCV.CV_32FC2, [
+        corners[0].x,
+        corners[0].y,
+        corners[1].x,
+        corners[1].y,
+        corners[2].x,
+        corners[2].y,
+        corners[3].x,
+        corners[3].y,
+      ]);
+
+      dstPoints = OpenCV.matFromArray(4, 1, OpenCV.CV_32FC2, [
+        0,
+        0,
+        outputSize.width,
+        0,
+        outputSize.width,
+        outputSize.height,
+        0,
+        outputSize.height,
+      ]);
+
+      transformMatrix = OpenCV.getPerspectiveTransform(srcPoints, dstPoints);
+
+      warped = OpenCV.warpPerspective(image, transformMatrix, outputSize);
+
+      const outputPath = imagePath.replace(/\.jpg$/i, '_normalized.jpg');
+      OpenCV.imwrite(outputPath, warped);
+
+      return outputPath;
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[DocumentDetector] perspectiveTransform error', error);
+      }
+      return null;
+    } finally {
+      safeRelease(warped);
+      safeRelease(transformMatrix);
+      safeRelease(dstPoints);
+      safeRelease(srcPoints);
+      safeRelease(image);
+    }
+  }
+
+  /** Detect document and apply normalization */
+  static async detectAndNormalize(imagePath: string, outputSize?: Size): Promise<string | null> {
+    try {
+      const corners = await DocumentDetector.findDocumentContours(imagePath);
+      if (!corners) {
+        if (__DEV__) {
+          console.log('[DocumentDetector] No document detected');
+        }
+        return null;
+      }
+
+      return DocumentDetector.perspectiveTransform(imagePath, corners, outputSize ?? OUTPUT_SIZE);
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[DocumentDetector] detectAndNormalize error', error);
+      }
+      return null;
+    }
+  }
+
+  /** Only detect document corners without transforming */
+  static async getDocumentBounds(imagePath: string): Promise<Quad | null> {
+    try {
+      return DocumentDetector.findDocumentContours(imagePath);
+    } catch (error) {
+      if (__DEV__) {
+        console.error('[DocumentDetector] getDocumentBounds error', error);
+      }
+      return null;
+    }
+  }
+}