Merge pull request #12 from martinbooth/PerspectiveWarp

feat: add getPerspectiveTransform and warpPerspective

Author: lukaszkurantdev

cpp/FOCV_Function.cpp

@@ -1080,6 +1080,16 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum
 
         return FOCV_JsiObject::wrap(runtime, "mat", id);
       } break;
+      case hashString("getPerspectiveTransform", 23): {
+        auto src = args.asPoint2fVectorPtr(1);
+        auto dest = args.asPoint2fVectorPtr(2);
+        auto solveMethod = args.asNumber(3);
+
+        cv::Mat result = cv::getPerspectiveTransform(*src, *dest, solveMethod);
+        std::string id = FOCV_Storage::save(result);
+
+        return FOCV_JsiObject::wrap(runtime, "mat", id);
+      } break;
       case hashString("getStructuringElement", 21): {
         auto shape = args.asNumber(1);
         auto ksize = args.asSizePtr(2);
@@ -1339,6 +1349,17 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum
 
         (*src).convertTo(*dst, rtype);
       } break;
+      case hashString("warpPerspective", 15): {
+        auto src = args.asMatPtr(1);
+        auto dst = args.asMatPtr(2);
+        auto M = args.asMatPtr(3);
+        auto size = args.asSizePtr(4);
+        auto flags = args.asNumber(5);
+        auto borderMode = args.asNumber(6);
+        auto borderValue = args.asScalarPtr(7);
+
+        cv::warpPerspective(*src, *dst, *M, *size, flags, borderMode, *borderValue);
+      } break;
     }
   } catch (cv::Exception& e) {
     std::cout << "Fast OpenCV Invoke Error: " << e.what() << "\n";

cpp/FOCV_FunctionArguments.cpp

@@ -43,6 +43,10 @@ std::shared_ptr<std::vector<cv::Point>> FOCV_FunctionArguments::asPointVectorPtr
     return FOCV_Storage::get<std::vector<cv::Point>>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
 }
 
+std::shared_ptr<std::vector<cv::Point2f>> FOCV_FunctionArguments::asPoint2fVectorPtr(int index) {
+    return FOCV_Storage::get<std::vector<cv::Point2f>>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
+}
+
 std::shared_ptr<std::vector<std::vector<cv::Point>>> FOCV_FunctionArguments::asPointVectorOfVectorsPtr(int index) {
     return FOCV_Storage::get<std::vector<std::vector<cv::Point>>>(FOCV_JsiObject::id_from_wrap(*this->runtime, arguments[index]));
 }

cpp/FOCV_FunctionArguments.hpp

@@ -43,6 +43,7 @@ class FOCV_FunctionArguments {
     std::shared_ptr<std::vector<cv::Mat>> asMatVectorPtr(int index);
     std::shared_ptr<cv::Point> asPointPtr(int index);
     std::shared_ptr<std::vector<cv::Point>> asPointVectorPtr(int index);
+    std::shared_ptr<std::vector<cv::Point2f>> asPoint2fVectorPtr(int index);
     std::shared_ptr<std::vector<std::vector<cv::Point>>> asPointVectorOfVectorsPtr(int index);
     std::shared_ptr<cv::Rect> asRectPtr(int index);
     std::shared_ptr<std::vector<cv::Rect>> asRectVectorPtr(int index);

cpp/FOCV_Object.cpp

@@ -88,6 +88,31 @@ jsi::Object FOCV_Object::create(jsi::Runtime& runtime, const jsi::Value* argumen
             std::vector<cv::Point> object;
             id = FOCV_Storage::save(object);
         } break;
+        case hashString("point2f", 7): {
+            int x = arguments[1].asNumber();
+            int y = arguments[2].asNumber();
+            cv::Point2f object(x, y);
+            id = FOCV_Storage::save(object);
+        } break;
+        case hashString("point2f_vector", 14): {
+            std::vector<cv::Point2f> vec;
+            if (arguments[1].isObject()) {
+                auto rawArray = arguments[1].asObject(runtime);
+                auto array = rawArray.asArray(runtime);
+                
+                auto rawLength = rawArray.getProperty(runtime, "length");
+                auto length = rawLength.asNumber();
+
+                for(auto i = 0; i < length; i++) {
+                    jsi::Value value = array.getValueAtIndex(runtime, i);
+                    std::string id = FOCV_JsiObject::id_from_wrap(runtime, value);
+                    auto point2fPtr = FOCV_Storage::get<cv::Point2f>(id);
+
+                    vec.push_back(*point2fPtr);
+                }
+            }
+            id = FOCV_Storage::save(vec);
+        } break;
         case hashString("point_vector_vector", 19): {
             std::vector<std::vector<cv::Point>> object;
             id = FOCV_Storage::save(object);

docs/pages/availablefunctions.md

@@ -1793,6 +1793,22 @@ invoke(
 ): Mat;
 ```
 
+### getPerspectiveTransform
+Calculates a perspective transform from four pairs of the corresponding points.
+- name Function name.
+- src Coordinates of quadrangle vertices in the source image.
+- dst Coordinates of the corresponding quadrangle vertices in the destination image.
+- solveMethod method passed to cv::solve (DecompTypes)
+
+```js
+invoke(
+  name: 'getPerspectiveTransform',
+  src: PointVector,
+  dst: PointVector,
+  solveMethod: DecompTypes
+): Mat;
+```
+
 ### getStructuringElement
 
 Returns a structuring element of the specified size and shape for morphological operations.
@@ -2198,4 +2214,29 @@ Finds a rotated rectangle of the minimum area enclosing the input 2D point set.
 
 ```js
 invoke(name: 'minAreaRect', points: Mat): RotatedRect;
+```
+
+
+### warpPerspective
+Applies a perspective transformation to an image.
+- name Function name.
+- src input image.
+- dst output image that has the size dsize and the same type as src .
+- M 3x3 transformation matrix
+- size size of the output image
+- flags combination of interpolation methods (INTER_LINEAR or INTER_NEAREST) and the optional flag WARP_INVERSE_MAP, that sets M as the inverse transformation
+- borderMode pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).
+- borderValue value used in case of a constant border; by default, it equals 0.
+
+```js
+invoke(
+  name: 'warpPerspective',
+  src: Mat,
+  dst: Mat,
+  M: Mat,
+  size: Size,
+  flags: InterpolationFlags,
+  borderMode: BorderTypes.BORDER_CONSTANT | BorderTypes.BORDER_REPLICATE,
+  borderValue: Scalar
+): void;
 ```

src/constants/ImageTransform.ts

@@ -0,0 +1,13 @@
+export enum InterpolationFlags {
+  INTER_NEAREST = 0,
+  INTER_LINEAR = 1,
+  INTER_CUBIC = 2,
+  INTER_AREA = 3,
+  INTER_LANCZOS4 = 4,
+  INTER_LINEAR_EXACT = 5,
+  INTER_NEAREST_EXACT = 6,
+  INTER_MAX = 7,
+  WARP_FILL_OUTLIERS = 8,
+  WARP_INVERSE_MAP = 16,
+  WARP_RELATIVE_MAP = 32,
+}

src/functions/ImageProcessing/ImageTransform.ts

@@ -0,0 +1,41 @@
+import type { BorderTypes, DecompTypes } from '../../constants/Core';
+import type { InterpolationFlags } from '../../constants/ImageTransform';
+import type { Mat, PointVector, Scalar, Size } from '../../objects/Objects';
+
+export type ImageTransform = {
+  /**
+   * Calculates a perspective transform from four pairs of the corresponding points.
+   * @param name Function name.
+   * @param src Coordinates of quadrangle vertices in the source image.
+   * @param dst Coordinates of the corresponding quadrangle vertices in the destination image.
+   * @param solveMethod method passed to cv::solve (DecompTypes)
+   */
+  invoke(
+    name: 'getPerspectiveTransform',
+    src: PointVector,
+    dst: PointVector,
+    solveMethod: DecompTypes
+  ): Mat;
+
+  /**
+   * Applies a perspective transformation to an image.
+   * @param name Function name.
+   * @param src input image.
+   * @param dst output image that has the size dsize and the same type as src .
+   * @param M 3x3 transformation matrix
+   * @param size size of the output image
+   * @param flags combination of interpolation methods (INTER_LINEAR or INTER_NEAREST) and the optional flag WARP_INVERSE_MAP, that sets M as the inverse transformation
+   * @param borderMode pixel extrapolation method (BORDER_CONSTANT or BORDER_REPLICATE).
+   * @param borderValue value used in case of a constant border; by default, it equals 0.
+   */
+  invoke(
+    name: 'warpPerspective',
+    src: Mat,
+    dst: Mat,
+    M: Mat,
+    size: Size,
+    flags: InterpolationFlags,
+    borderMode: BorderTypes.BORDER_CONSTANT | BorderTypes.BORDER_REPLICATE,
+    borderValue: Scalar
+  ): void;
+};

src/index.tsx

@@ -10,6 +10,7 @@ import type { ColorConversion } from './functions/ColorConversion';
 import type { Core } from './functions/Core';
 import type { UtilsFunctions } from './utils/UtilsFunctions';
 import type { Objects } from './objects/Objects';
+import type { ImageTransform } from './functions/ImageProcessing/ImageTransform';
 
 const LINKING_ERROR =
   `The package 'react-native-fast-opencv' doesn't seem to be linked. Make sure: \n\n` +
@@ -53,6 +54,7 @@ export type OpenCVModel = ColorMap &
   Drawing &
   Feature &
   ImageFiltering &
+  ImageTransform &
   Misc &
   ObjectDetection &
   Shape &
@@ -66,4 +68,5 @@ export type * from './objects/Objects';
 export * from './constants/ColorConversionsCodes';
 export * from './constants/DataTypes';
 export * from './constants/ImageProcessing';
+export * from './constants/ImageTransform';
 export * from './constants/Core';

src/objects/ObjectType.ts

@@ -2,8 +2,10 @@ export enum ObjectType {
   Mat = 'mat',
   MatVector = 'mat_vector',
   Point = 'point',
+  Point2f = 'point2f',
   PointVector = 'point_vector',
   PointVectorOfVectors = 'point_vector_vector',
+  Point2fVector = 'point2f_vector',
   Rect = 'rect',
   RectVector = 'rect_vector',
   Size = 'size',

src/objects/Objects.ts

@@ -5,6 +5,8 @@ export type Mat = { id: string; type: ObjectType.Mat };
 export type MatVector = { id: string; type: ObjectType.MatVector };
 export type Point = { id: string; type: ObjectType.Point };
 export type PointVector = { id: string; type: ObjectType.PointVector };
+export type Point2f = { id: string; type: ObjectType.Point2f };
+export type Point2fVector = { id: string; type: ObjectType.Point2fVector };
 export type PointVectorOfVectors = {
   id: string;
   type: ObjectType.PointVectorOfVectors;
@@ -31,6 +33,8 @@ export type Objects = {
   createObject(type: ObjectType.MatVector): MatVector;
   createObject(type: ObjectType.Point, x: number, y: number): Point;
   createObject(type: ObjectType.PointVector): PointVector;
+  createObject(type: ObjectType.Point2f, x: number, y: number): Point2f;
+  createObject(type: ObjectType.Point2fVector, points: Point2f[]): PointVector;
   createObject(type: ObjectType.PointVectorOfVectors): PointVectorOfVectors;
   createObject(
     type: ObjectType.Rect,
@@ -105,6 +109,13 @@ export type Objects = {
     c?: number;
     d?: number;
   };
+  toJSValue(scalar: RotatedRect): {
+    centerX: number;
+    centerY: number;
+    width: number;
+    height: number;
+    angle: number;
+  };
 
   copyObjectFromVector(vector: MatVector, itemIndex: number): Mat;
   copyObjectFromVector(vector: PointVector, itemIndex: number): Point;