Merge pull request #4 from lukaszkurantdev/feat/mat-to-buffer

feat: mat to buffer (#3)

Author: lukaszkurantdev

cpp/FOCV_Function.cpp

@@ -1266,6 +1266,13 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum
             auto id = FOCV_Storage::save(rect);
             return FOCV_JsiObject::wrap(runtime, "rotated_rect", id);
         } break;
+        case hashString("convertTo", 9): {
+            auto src = args.asMatPtr(1);
+            auto dst = args.asMatPtr(2);
+            auto rtype = args.asNumber(3);
+            
+            (*src).convertTo(*dst, rtype);
+        } break;
     }
 
     return value;

cpp/react-native-fast-opencv.cpp

@@ -55,7 +55,7 @@ jsi::Value OpenCVPlugin::get(jsi::Runtime& runtime, const jsi::PropNameID& propN
         return FOCV_JsiObject::wrap(runtime, "mat", id);
     });
   }
-    if (propName == "base64ToMat") {
+  else if (propName == "base64ToMat") {
       return jsi::Function::createFromHostFunction(
           runtime, jsi::PropNameID::forAscii(runtime, "frameBufferToMat"), 1,
           [=](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
@@ -69,7 +69,37 @@ jsi::Value OpenCVPlugin::get(jsi::Runtime& runtime, const jsi::PropNameID& propN
           return FOCV_JsiObject::wrap(runtime, "mat", id);
       });
     }
-  else if (propName == "createObject") {
+  else if (propName == "matToBuffer") {
+      return jsi::Function::createFromHostFunction(
+          runtime, jsi::PropNameID::forAscii(runtime, "matToBuffer"), 1,
+          [=](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
+              size_t count) -> jsi::Object {
+                  
+                  std::string id = FOCV_JsiObject::id_from_wrap(runtime, arguments[0]);
+                  auto mat = *FOCV_Storage::get<cv::Mat>(id);
+                        
+                  jsi::Object value(runtime);
+                        
+                  value.setProperty(runtime, "cols", jsi::Value(mat.cols));
+                  value.setProperty(runtime, "rows", jsi::Value(mat.rows));
+                  value.setProperty(runtime, "channels", jsi::Value(mat.channels()));
+                  
+                  auto type = arguments[1].asString(runtime).utf8(runtime);
+                  int size = mat.cols * mat.rows * mat.channels();
+                  
+                  if(type == "uint8") {
+                      auto arr = TypedArray<TypedArrayKind::Uint8Array>(runtime, size);
+                      arr.updateUnsafe(runtime, (uint8_t*)mat.data, size * sizeof(uint8_t));
+                      value.setProperty(runtime, "buffer", arr);
+                  } else if(type == "float32") {
+                      auto arr = TypedArray<TypedArrayKind::Float32Array>(runtime, size);
+                      arr.updateUnsafe(runtime, (float32_t*)mat.data, size * sizeof(float32_t));
+                      value.setProperty(runtime, "buffer", arr);
+                  }
+                  
+                  return value;
+      });
+    } else if (propName == "createObject") {
       return jsi::Function::createFromHostFunction(
           runtime, jsi::PropNameID::forAscii(runtime, "createObject"), 1,
           [=](jsi::Runtime& runtime, const jsi::Value& thisValue, const jsi::Value* arguments,
@@ -123,6 +153,7 @@ std::vector<jsi::PropNameID> OpenCVPlugin::getPropertyNames(jsi::Runtime& runtim
 
     result.push_back(jsi::PropNameID::forAscii(runtime, "frameBufferToMat"));
     result.push_back(jsi::PropNameID::forAscii(runtime, "base64ToMat"));
+    result.push_back(jsi::PropNameID::forAscii(runtime, "matToBuffer"));
     result.push_back(jsi::PropNameID::forAscii(runtime, "createObject"));
     result.push_back(jsi::PropNameID::forAscii(runtime, "toJSValue"));
     result.push_back(jsi::PropNameID::forAscii(runtime, "copyObjectFromVector"));

docs/pages/apidetails.md

@@ -10,7 +10,8 @@ createObject(
   type: ObjectType.Mat,
   rows: number,
   cols: number,
-  dataType: DataTypes
+  dataType: DataTypes,
+  data?: number[]
 ): Mat;
 createObject(type: ObjectType.MatVector): MatVector;
 createObject(type: ObjectType.Point, x: number, y: number): Point;
@@ -125,6 +126,21 @@ Creates an object of type Mat based on image in Base64.
 base64ToMat(data: string): Mat;
 ```
 
+### Mat to Buffer
+Convert Mat object to Uint8Array or Float32Array based on value of parameter and returns with number of cols, rows and channels.
+
+```js
+matToBuffer(
+  mat: Mat,
+  type: 'uint8'
+): { cols: number; rows: number; channels: number; buffer: Uint8Array };
+
+matToBuffer(
+  mat: Mat,
+  type: 'float32'
+): { cols: number; rows: number; channels: number; buffer: Float32Array };
+```
+
 ## Functions
 
 ### Invoke function

docs/pages/availablefunctions.md

@@ -249,7 +249,7 @@ invoke(name: 'completeSymm', m: MatVector | Mat, lowerToUpper: boolean): void;
 
 ### convertFp16
 
-Converts an array to half precision floating number.\
+Converts an array to half precision floating number.
 
 - src input array
 - dst output array
@@ -285,6 +285,18 @@ invoke(
 ): void;
 ```
 
+### convertTo
+
+Converts an array to another data type with optional scaling.
+
+- src input array
+- dst output array of the same type as src
+- rtype  desired output matrix type or, rather, the depth since the number of channels are the same as the input has; if rtype is negative, the output matrix will have the same type as the input.
+
+```js
+invoke(name: 'convertTo', src: Mat, dst: Mat, rtype: DataTypes): void;
+```
+
 ### copyMakeBorder
 
 Forms a border around an image.

src/functions/Core.ts

@@ -903,4 +903,13 @@ export type Core = {
    * @param dst output array. It has the same number of cols and depth as the src, and the sum of rows of the src. same depth
    */
   invoke(name: 'vconcat', src: MatVector, dst: Mat): void;
+
+  /**
+   * Converts an array to another data type with optional scaling.
+   * @param name Function name.
+   * @param src input array.
+   * @param dst output array of the same type as src
+   * @param rtype  desired output matrix type or, rather, the depth since the number of channels are the same as the input has; if rtype is negative, the output matrix will have the same type as the input.
+   */
+  invoke(name: 'convertTo', src: Mat, dst: Mat, rtype: DataTypes): void;
 };

src/utils/UtilsFunctions.ts

@@ -4,4 +4,12 @@ export type UtilsFunctions = {
   clearBuffers(): void;
   frameBufferToMat(rows: number, cols: number, input: Uint8Array): Mat;
   base64ToMat(data: string): Mat;
+  matToBuffer(
+    mat: Mat,
+    type: 'uint8'
+  ): { cols: number; rows: number; channels: number; buffer: Uint8Array };
+  matToBuffer(
+    mat: Mat,
+    type: 'float32'
+  ): { cols: number; rows: number; channels: number; buffer: Float32Array };
 };