feat: new functions

Author: lukaszkurantdev

cpp/FOCV_Function.cpp

@@ -86,6 +86,15 @@ jsi::Object FOCV_Object::create(jsi::Runtime& runtime, const jsi::Value* argumen
                 object = cv::Scalar(a);
             }
         } break;
+        case hashString("rotated_rect", 11): {
+            int x = arguments[1].asNumber();
+            int y = arguments[2].asNumber();
+            int width  = arguments[3].asNumber();
+            int height = arguments[4].asNumber();
+            int angle = arguments[5].asNumber();
+            
+            object = cv::RotatedRect(cv::Point(x,y), cv::Size(width, height), angle);
+        } break;
     }
 
     std::string id = FOCV_Storage::save(object);
@@ -189,6 +198,15 @@ jsi::Object FOCV_Object::convertToJSI(jsi::Runtime& runtime, const jsi::Value* a
             value.setProperty(runtime, "c", jsi::Value(scalar.val[2]));
             value.setProperty(runtime, "d", jsi::Value(scalar.val[3]));
         } break;
+        case hashString("rotated_rect", 11): {
+            cv::RotatedRect rect = FOCV_Storage::get<cv::RotatedRect>(id);
+            
+            value.setProperty(runtime, "centerX", jsi::Value(rect.center.x));
+            value.setProperty(runtime, "centerY", jsi::Value(rect.center.y));
+            value.setProperty(runtime, "width", jsi::Value(rect.size.width));
+            value.setProperty(runtime, "height", jsi::Value(rect.size.height));
+            value.setProperty(runtime, "angle", jsi::Value(rect.angle));
+        } break;
     }
 
     return value;

cpp/FOCV_Object.cpp

@@ -31,7 +31,7 @@ export function ImageExample() {
       const lowerBound = OpenCV.createObject(ObjectType.Vec3b, 0, 120, 120);
       const upperBound = OpenCV.createObject(ObjectType.Vec3b, 255, 255, 255);
 
-      OpenCV.invoke('inRange', dst, lowerBound, upperBound, dst);
+      // OpenCV.invoke('inRange', dst, lowerBound, upperBound, dst);
 
       const result = OpenCV.toJSValue(dst);
       setB64(result.base64);

example/src/ImageExample.tsx

@@ -53,8 +53,16 @@ export function VisionCameraExample() {
     OpenCV.invoke('cvtColor', src, dst, ColorConversionCodes.COLOR_BGR2RGB);
     OpenCV.invoke('cvtColor', dst, dst, ColorConversionCodes.COLOR_BGR2HSV);
 
-    const lowerBound = OpenCV.createObject(ObjectType.Vec3b, 37, 120, 120);
-    const upperBound = OpenCV.createObject(ObjectType.Vec3b, 60, 255, 255);
+    const lowerBound = OpenCV.frameBufferToMat(
+      1,
+      3,
+      new Uint8Array([37, 120, 120])
+    );
+    const upperBound = OpenCV.frameBufferToMat(
+      1,
+      3,
+      new Uint8Array([60, 255, 255])
+    );
 
     OpenCV.invoke('inRange', dst, lowerBound, upperBound, dst);
 
@@ -64,21 +72,25 @@ export function VisionCameraExample() {
     const grayChannel = OpenCV.copyObjectFromVector(channels, 0);
     const rectangles: Rect[] = [];
 
-    const contours = OpenCV.invoke(
+    const contours = OpenCV.createObject(ObjectType.MatVector);
+
+    OpenCV.invoke(
       'findContours',
       grayChannel,
+      contours,
       RetrievalModes.RETR_TREE,
       ContourApproximationModes.CHAIN_APPROX_SIMPLE
     );
 
-    for (const contour of contours) {
-      const { value: area } = OpenCV.invoke('contourArea', contour, false);
+    // TO CHECK!
+    // for (const contour of contours) {
+    //   const { value: area } = OpenCV.invoke('contourArea', contour, false);
 
-      if (area > 3000) {
-        const rect = OpenCV.invoke('boundingRect', contour);
-        rectangles.push(rect);
-      }
-    }
+    //   if (area > 3000) {
+    //     const rect = OpenCV.invoke('boundingRect', contour);
+    //     rectangles.push(rect);
+    //   }
+    // }
 
     frame.render();
 

example/src/VisionCameraExample.tsx

@@ -1,9 +1,6 @@
 import type { TurboModule } from 'react-native';
 import { TurboModuleRegistry } from 'react-native';
 
-
-
-
 export interface Spec extends TurboModule {
   multiply(a: number, b: number): Promise<number>;
 }

src/NativeFastOpencv.ts

@@ -73,14 +73,14 @@ export enum MorphShapes {
 }
 
 export enum MorphTypes {
-  MORPH_ERODE = 'MORPH_ERODE',
-  MORPH_DILATE = 'MORPH_DILATE',
-  MORPH_OPEN = 'MORPH_OPEN',
-  MORPH_CLOSE = 'MORPH_CLOSE',
-  MORPH_GRADIENT = 'MORPH_GRADIENT',
-  MORPH_TOPHAT = 'MORPH_TOPHAT',
-  MORPH_BLACKHAT = 'MORPH_BLACKHAT',
-  MORPH_HITMISS = 'MORPH_HITMISS',
+  MORPH_ERODE = 0,
+  MORPH_DILATE = 1,
+  MORPH_OPEN = 2,
+  MORPH_CLOSE = 3,
+  MORPH_GRADIENT = 4,
+  MORPH_TOPHAT = 5,
+  MORPH_BLACKHAT = 6,
+  MORPH_HITMISS = 7,
 }
 
 export enum SpecialFilter {

src/constants/ImageProcessing.ts

@@ -4,25 +4,30 @@ import type { Mat } from '../objects/Objects';
 export type ColorConversion = {
   /**
    * Converts an image from one color space to another.
+   * @param name Function name.
    * @param src input image: 8-bit unsigned, 16-bit unsigned ( CV_16UC... ), or single-precision floating-point.
    * @param dst output image of the same size and depth as src.
    * @param code color space conversion code.
    * @param dstCn number of channels in the destination image; if the parameter is 0, the number of the channels is derived automatically from src and code.
    */
-  cvtColor(
+  invoke(
+    name: 'cvtColor',
     src: Mat,
     dst: Mat,
     code: ColorConversionCodes,
     dstCn?: number
   ): void;
+
   /**
    * Converts an image from one color space to another where the source image is stored in two planes. This function only supports YUV420 to RGB conversion as of now.
+   * @param name Function name.
    * @param src1 8-bit image (CV_8U) of the Y plane.
    * @param src2 image containing interleaved U/V plane.
    * @param dst output image.
    * @param code Specifies the type of conversion
    */
-  cvtColorTwoPlane(
+  invoke(
+    name: 'cvtColorTwoPlane',
     src1: Mat,
     src2: Mat,
     dst: Mat,
@@ -36,36 +41,36 @@ export type ColorConversion = {
       | ColorConversionCodes.COLOR_YUV2BGRA_NV21
       | ColorConversionCodes.COLOR_YUV2RGBA_NV21
   ): void;
+
   /**
    * main function for all demosaicing processes
+   * @param name Function name.
    * @param src input image: 8-bit unsigned or 16-bit unsigned.
    * @param dst output image of the same size and depth as src.
    * @param code Color space conversion code (see the description below).
    * @param dstCn number of channels in the destination image
    */
-  demosaicing(
+  invoke(
+    name: 'demosaicing',
     src: Mat,
     dst: Mat,
-    code: //Demosaicing using bilinear interpolation
-    | ColorConversionCodes.COLOR_BayerBG2BGR
+    code:
+      | ColorConversionCodes.COLOR_BayerBG2BGR
       | ColorConversionCodes.COLOR_BayerGB2BGR
       | ColorConversionCodes.COLOR_BayerRG2BGR
       | ColorConversionCodes.COLOR_BayerGR2BGR
       | ColorConversionCodes.COLOR_BayerBG2GRAY
       | ColorConversionCodes.COLOR_BayerGB2GRAY
       | ColorConversionCodes.COLOR_BayerRG2GRAY
       | ColorConversionCodes.COLOR_BayerGR2GRAY
-      // Demosaicing using Variable Number of Gradients.
       | ColorConversionCodes.COLOR_BayerBG2BGR_VNG
       | ColorConversionCodes.COLOR_BayerGB2BGR_VNG
       | ColorConversionCodes.COLOR_BayerRG2BGR_VNG
       | ColorConversionCodes.COLOR_BayerGR2BGR_VNG
-      // Edge-Aware Demosaicing.
       | ColorConversionCodes.COLOR_BayerBG2BGR_EA
       | ColorConversionCodes.COLOR_BayerGB2BGR_EA
       | ColorConversionCodes.COLOR_BayerRG2BGR_EA
       | ColorConversionCodes.COLOR_BayerGR2BGR_EA
-      // Demosaicing with alpha channel
       | ColorConversionCodes.COLOR_BayerBG2BGRA
       | ColorConversionCodes.COLOR_BayerGB2BGRA
       | ColorConversionCodes.COLOR_BayerRG2BGRA