From 278c7cfcee31d9c8d562e0c27fb4507c7b3f3dc8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Kurant?= Date: Sat, 12 Oct 2024 12:38:19 +0200 Subject: [PATCH] feat: additional fields in gaussianBlur, getStructuringElement and morphologyEx --- cpp/FOCV_Function.cpp | 63 +++++++++++++++---- cpp/FOCV_FunctionArguments.cpp | 10 +++ cpp/FOCV_FunctionArguments.hpp | 2 + docs/pages/availablefunctions.md | 60 ++++++++++++++---- example/ios/Podfile.lock | 4 +- .../ImageProcessing/ImageFiltering.ts | 49 +++++++++++++++ 6 files changed, 163 insertions(+), 25 deletions(-) diff --git a/cpp/FOCV_Function.cpp b/cpp/FOCV_Function.cpp index 8c48076..c90f568 100644 --- a/cpp/FOCV_Function.cpp +++ b/cpp/FOCV_Function.cpp @@ -1058,10 +1058,21 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum auto dst = args.asMatPtr(2); auto ksize = args.asSizePtr(3); auto sigmaX = args.asNumber(4); - auto sigmaY = args.asNumber(5); - auto borderType = args.asNumber(6); - cv::GaussianBlur(*src, *dst, *ksize, sigmaX, sigmaY, borderType); + if(args.isNumber(5)) { + auto sigmaY = args.asNumber(5); + + if(args.isNumber(6)) { + auto borderType = args.asNumber(6); + cv::GaussianBlur(*src, *dst, *ksize, sigmaX, sigmaY, borderType); + break; + } + + cv::GaussianBlur(*src, *dst, *ksize, sigmaX, sigmaY); + break; + } + + cv::GaussianBlur(*src, *dst, *ksize, sigmaX); } break; case hashString("getGaborKernel", 14): { auto ksize = args.asSizePtr(1); @@ -1098,12 +1109,19 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum return FOCV_JsiObject::wrap(runtime, "mat", id); } break; case hashString("getStructuringElement", 21): { + std::string id; + auto shape = args.asNumber(1); auto ksize = args.asSizePtr(2); - auto anchor = args.asPointPtr(3); - cv::Mat result = cv::getStructuringElement(shape, *ksize, *anchor); - std::string id = FOCV_Storage::save(result); + if (args.isPoint(3)) { + auto anchor = args.asPointPtr(3); + cv::Mat result = cv::getStructuringElement(shape, *ksize, *anchor); + id = FOCV_Storage::save(result); + } else { + cv::Mat result = cv::getStructuringElement(shape, *ksize); + id = FOCV_Storage::save(result); + } return FOCV_JsiObject::wrap(runtime, "mat", id); } break; @@ -1136,12 +1154,35 @@ jsi::Object FOCV_Function::invoke(jsi::Runtime& runtime, const jsi::Value* argum auto dst = args.asMatPtr(2); auto op = args.asNumber(3); auto kernel = args.asMatPtr(4); - auto anchor = args.asPointPtr(5); - auto iterations = args.asNumber(6); - auto borderType = args.asNumber(7); - auto borderValue = args.asScalarPtr(8); - cv::morphologyEx(*src, *dst, op, *kernel, *anchor, iterations, borderType, *borderValue); + if(args.isPoint(5)) { + auto anchor = args.asPointPtr(5); + + if(args.isNumber(6)) { + auto iterations = args.asNumber(6); + + if(args.isNumber(7)) { + auto borderType = args.asNumber(7); + + if(args.isScalar(8)) { + auto borderValue = args.asScalarPtr(8); + cv::morphologyEx(*src, *dst, op, *kernel, *anchor, iterations, borderType, *borderValue); + break; + } + + cv::morphologyEx(*src, *dst, op, *kernel, *anchor, iterations, borderType); + break; + } + + cv::morphologyEx(*src, *dst, op, *kernel, *anchor, iterations); + break; + } + + cv::morphologyEx(*src, *dst, op, *kernel, *anchor); + break; + } + + cv::morphologyEx(*src, *dst, op, *kernel); } break; case hashString("adaptiveThreshold", 17): { auto src = args.asMatPtr(1); diff --git a/cpp/FOCV_FunctionArguments.cpp b/cpp/FOCV_FunctionArguments.cpp index 485f3e9..f26566a 100644 --- a/cpp/FOCV_FunctionArguments.cpp +++ b/cpp/FOCV_FunctionArguments.cpp @@ -94,3 +94,13 @@ bool FOCV_FunctionArguments::isMat(int index) { bool FOCV_FunctionArguments::isMatVector(int index) { return FOCV_JsiObject::type_from_wrap(*this->runtime, arguments[index]) == "mat_vector"; } + +bool FOCV_FunctionArguments::isPoint(int index) { + return FOCV_JsiObject::type_from_wrap(*this->runtime, arguments[index]) == "point"; +} + +bool FOCV_FunctionArguments::isScalar(int index) { + return FOCV_JsiObject::type_from_wrap(*this->runtime, arguments[index]) == "scalar"; +} + + diff --git a/cpp/FOCV_FunctionArguments.hpp b/cpp/FOCV_FunctionArguments.hpp index 4213e9c..038d019 100644 --- a/cpp/FOCV_FunctionArguments.hpp +++ b/cpp/FOCV_FunctionArguments.hpp @@ -57,6 +57,8 @@ class FOCV_FunctionArguments { bool isObject(int index); bool isMat(int index); bool isMatVector(int index); + bool isPoint(int index); + bool isScalar(int index); }; #endif /* FOCV_FunctionArguments_hpp */ diff --git a/docs/pages/availablefunctions.md b/docs/pages/availablefunctions.md index 8920026..98b3897 100644 --- a/docs/pages/availablefunctions.md +++ b/docs/pages/availablefunctions.md @@ -1758,14 +1758,28 @@ Blurs an image using a Gaussian filter. ```js invoke( - name: 'GaussianBlur', - src: Mat, - dst: Mat, - ksize: Size, - sigmaX: number, - sigmaY: number, - borderType: BorderTypes -): void; + name: 'GaussianBlur', + src: Mat, + dst: Mat, + ksize: Size, + sigmaX: number + ): void; + invoke( + name: 'GaussianBlur', + src: Mat, + dst: Mat, + ksize: Size, + sigmaX: number + ): void; + invoke( + name: 'GaussianBlur', + src: Mat, + dst: Mat, + ksize: Size, + sigmaX: number, + sigmaY: number, + borderType: BorderTypes + ): void; ``` ### getGaborKernel @@ -1831,11 +1845,12 @@ Returns a structuring element of the specified size and shape for morphological - anchor Anchor position within the element. The default value means that the anchor is at the center. Note that only the shape of a cross-shaped element depends on the anchor position. In other cases the anchor just regulates how much the result of the morphological operation is shifted.. ```js +invoke(name: 'getStructuringElement', shape: MorphShapes, ksize: Size): Mat; invoke( - name: 'getGaussianKernel', - shape: MorphShapes, - ksize: Size, - anchor: Point + name: 'getStructuringElement', + shape: MorphShapes, + ksize: Size, + anchor: Point ): Mat; ``` @@ -1898,6 +1913,27 @@ Any of the operations can be done in-place. In case of multi-channel images, eac - borderValue Border value in case of a constant border. The default value has a special meaning. ```js +invoke( name: 'morphologyEx', src: Mat, dst: Mat, op: MorphTypes, kernel: Mat): void; +invoke( name: 'morphologyEx', src: Mat, dst: Mat, op: MorphTypes, kernel: Mat, anchor: Point): void; +invoke( + name: 'morphologyEx', + src: Mat, + dst: Mat, + op: MorphTypes, + kernel: Mat, + anchor: Point, + iterations: number +): void; +invoke( + name: 'morphologyEx', + src: Mat, + dst: Mat, + op: MorphTypes, + kernel: Mat, + anchor: Point, + iterations: number, + borderType: BorderTypes +): void; invoke( name: 'morphologyEx', src: Mat, diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock index 20e351f..eb7c1d4 100644 --- a/example/ios/Podfile.lock +++ b/example/ios/Podfile.lock @@ -936,7 +936,7 @@ PODS: - React-Mapbuffer (0.74.4): - glog - React-debug - - react-native-fast-opencv (0.2.4): + - react-native-fast-opencv (0.2.7): - DoubleConversion - glog - hermes-engine @@ -1594,7 +1594,7 @@ SPEC CHECKSUMS: React-jsitracing: 4e9c99e73a6269b27b0d4cbab277dd90df3e5ac0 React-logger: fbfb50e2a2b1b46ee087f0a52739fadecc5e81a4 React-Mapbuffer: d39610dff659d8cf1fea485abae08bbf6f9c8279 - react-native-fast-opencv: 52cb988f5dee40a599381c4617b8560977ed983c + react-native-fast-opencv: 8e853bb378f92221c4b47fe98fc9283aedcf95fb react-native-image-picker: c3afe5472ef870d98a4b28415fc0b928161ee5f7 react-native-safe-area-context: 851c62c48dce80ccaa5637b6aa5991a1bc36eca9 react-native-skia: 8da84ea9410504bf27f0db229539a43f6caabb6a diff --git a/src/functions/ImageProcessing/ImageFiltering.ts b/src/functions/ImageProcessing/ImageFiltering.ts index a2c7f3c..c946738 100644 --- a/src/functions/ImageProcessing/ImageFiltering.ts +++ b/src/functions/ImageProcessing/ImageFiltering.ts @@ -148,6 +148,20 @@ export type ImageFiltering = { * @param sigmaY Gaussian kernel standard deviation in Y direction; if sigmaY is zero, it is set to be equal to sigmaX, if both sigmas are zeros, they are computed from ksize.width and ksize.height, respectively (see getGaussianKernel for details); to fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ksize, sigmaX, and sigmaY. * @param borderType pixel extrapolation method, see BorderTypes. BORDER_WRAP is not supported. */ + invoke( + name: 'GaussianBlur', + src: Mat, + dst: Mat, + ksize: Size, + sigmaX: number + ): void; + invoke( + name: 'GaussianBlur', + src: Mat, + dst: Mat, + ksize: Size, + sigmaX: number + ): void; invoke( name: 'GaussianBlur', src: Mat, @@ -198,6 +212,7 @@ export type ImageFiltering = { * @param ksize Size of the structuring element. * @param anchor Anchor position within the element. The default value means that the anchor is at the center. Note that only the shape of a cross-shaped element depends on the anchor position. In other cases the anchor just regulates how much the result of the morphological operation is shifted. */ + invoke(name: 'getStructuringElement', shape: MorphShapes, ksize: Size): Mat; invoke( name: 'getStructuringElement', shape: MorphShapes, @@ -256,6 +271,40 @@ export type ImageFiltering = { * @param borderType Pixel extrapolation method, see BorderTypes. BORDER_WRAP is not supported. * @param borderValue Border value in case of a constant border. The default value has a special meaning. */ + invoke( + name: 'morphologyEx', + src: Mat, + dst: Mat, + op: MorphTypes, + kernel: Mat + ): void; + invoke( + name: 'morphologyEx', + src: Mat, + dst: Mat, + op: MorphTypes, + kernel: Mat, + anchor: Point + ): void; + invoke( + name: 'morphologyEx', + src: Mat, + dst: Mat, + op: MorphTypes, + kernel: Mat, + anchor: Point, + iterations: number + ): void; + invoke( + name: 'morphologyEx', + src: Mat, + dst: Mat, + op: MorphTypes, + kernel: Mat, + anchor: Point, + iterations: number, + borderType: BorderTypes + ): void; invoke( name: 'morphologyEx', src: Mat,