dynamsoft-capture-vision-react-native 3.0.5200 → 3.2.3000

package/android/src/main/cpp/JsiUtility.cpp

@@ -3,14 +3,19 @@
 //
 
 #include "JsiUtility.h"
+#include "RawBuffer.h"
+
 jobject jImageManagerModule = nullptr;
 jclass jclzQuad = nullptr;
 jclass jclzPoint = nullptr;
+jclass jclzDSRect = nullptr;
+
+using namespace facebook::jsi;
 
 jobject jsPointToJobject(Runtime &rt, JNIEnv *env, Object jsPoint) {
-    if(jsPoint.hasProperty(rt,"x") && jsPoint.hasProperty(rt,"y")) {
-        int x = jsPoint.getProperty(rt,"x").asNumber();
-        int y = jsPoint.getProperty(rt,"y").asNumber();
+    if (jsPoint.hasProperty(rt, "x") && jsPoint.hasProperty(rt, "y")) {
+        int x = jsPoint.getProperty(rt, "x").asNumber();
+        int y = jsPoint.getProperty(rt, "y").asNumber();
         jmethodID init = env->GetMethodID(jclzPoint, "<init>", "(II)V");
         jobject jPoint = env->NewObject(jclzPoint, init, x, y);
         return jPoint;
@@ -19,8 +24,8 @@ jobject jsPointToJobject(Runtime &rt, JNIEnv *env, Object jsPoint) {
 }
 
 jobject jsQuadToJobject(Runtime &rt, JNIEnv *env, Object &jsQuad) {
-    if(jsQuad.hasProperty(rt,"points")) {
-        auto jsPoints = jsQuad.getProperty(rt,"points").asObject(rt).asArray(rt);
+    if (jsQuad.hasProperty(rt, "points")) {
+        auto jsPoints = jsQuad.getProperty(rt, "points").asObject(rt).asArray(rt);
         int count = jsPoints.length(rt);
         auto jPoints = env->NewObjectArray(count, jclzPoint, nullptr);
         for (int i = 0; i < count; ++i) {
@@ -49,6 +54,22 @@ jobjectArray jsQuadArrayToJobjectArray(Runtime &rt, JNIEnv *env, Array &jsQuads)
     return jQuads;
 }
 
+jobject jsDsRectToJobject(Runtime &rt, JNIEnv *env, Object &jsDSRect) {
+    if (!jsDSRect.hasProperty(rt, "left") || !jsDSRect.hasProperty(rt, "top") || !jsDSRect.hasProperty(rt, "right") || !jsDSRect.hasProperty(rt, "bottom") ||
+        !jsDSRect.hasProperty(rt, "measuredInPercentage")) {
+        return nullptr;
+    }
+    float top = (float) jsDSRect.getProperty(rt, "top").asNumber();
+    float left = (float) jsDSRect.getProperty(rt, "left").asNumber();
+    float bottom = (float) jsDSRect.getProperty(rt, "bottom").asNumber();
+    float right = (float) jsDSRect.getProperty(rt, "right").asNumber();
+    bool measuredInPercentage = jsDSRect.getProperty(rt, "measuredInPercentage").asBool();
+    jmethodID init = env->GetMethodID(jclzDSRect, "<init>", "(FFFFZ)V");
+    jobject jDSRect = env->NewObject(jclzDSRect, init, left, top, right, bottom, measuredInPercentage);
+    return jDSRect;
+}
+
+
 void saveImageDataHOToFile(Runtime &rt, ImageDataHostObject &imageDataHO, string filePath, bool overWrite) {
     JNIEnv *env;
     bool needDetach = false;
@@ -68,6 +89,74 @@ void saveImageDataHOToFile(Runtime &rt, ImageDataHostObject &imageDataHO, string
     }
 }
 
+ImageDataHostObject readImageDataHOFromFile(Runtime &rt, string filePath) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "readFromFileCalledInJsi", "(Ljava/lang/String;)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    jstring jFilePath = env->NewStringUTF(filePath.c_str());
+    auto jImageData = env->CallObjectMethod(jImageManagerModule, methodId, jFilePath);
+    ImageDataHostObject imageHO;
+    jsiConversion::core::getHOFromJImageData(env, jImageData, imageHO);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jFilePath);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHO;
+}
+
+ImageDataHostObject readImageDataHOFromMemory(Runtime &rt, unsigned char *buffer, int bufferSize) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "readFromMemoryCalledInJsi", "([B)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jBuffer = env->NewByteArray(bufferSize);
+    env->SetByteArrayRegion(jBuffer, 0, bufferSize, (jbyte *) buffer);
+    auto jImageData = env->CallObjectMethod(jImageManagerModule, methodId, jBuffer);
+    ImageDataHostObject imageHO;
+    jsiConversion::core::getHOFromJImageData(env, jImageData, imageHO);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jBuffer);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHO;
+}
+
+ArrayBuffer saveImageDataHOToMemory(Runtime &rt, ImageDataHostObject &imageDataHO, int fileFormat) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "saveToMemoryCalledInJsi", "(Lcom/dynamsoft/core/basic_structures/ImageData;I)[B");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jBuffer = (jbyteArray) env->CallObjectMethod(jImageManagerModule, methodId, jImageData, fileFormat);
+    auto pBuffer = (uint8_t *) env->GetByteArrayElements(jBuffer, nullptr);
+    int bufferSize = env->GetArrayLength(jBuffer);
+    auto mutableBuffer = std::make_shared<MutableRawBuffer>(pBuffer, bufferSize, false);
+    ArrayBuffer arrayBuffer(rt, mutableBuffer);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    return arrayBuffer;
+}
+
 ImageDataHostObject drawOnImage(Runtime &rt, ImageDataHostObject &imageDataHO, Array &jsQuads, int color, int thickness) {
     JNIEnv *env;
     bool needDetach = false;
@@ -94,7 +183,7 @@ ImageDataHostObject drawOnImage(Runtime &rt, ImageDataHostObject &imageDataHO, A
     return imageHOAfterDraw;
 }
 
-ImageDataHostObject cropImage(Runtime &rt, ImageDataHostObject &imageDataHO, Object &jsQuad) {
+ImageDataHostObject cropImage(Runtime &rt, ImageDataHostObject &imageDataHO, Object &jsDSRect) {
     JNIEnv *env;
     bool needDetach = false;
     int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
@@ -104,13 +193,13 @@ ImageDataHostObject cropImage(Runtime &rt, ImageDataHostObject &imageDataHO, Obj
     }
     jclass clz = env->GetObjectClass(jImageManagerModule);
     jmethodID methodId = env->GetMethodID(clz, "cropImageCalledInJsi",
-                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;Lcom/dynamsoft/core/basic_structures/Quadrilateral;)Lcom/dynamsoft/core/basic_structures/ImageData;");
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;Lcom/dynamsoft/core/basic_structures/DSRect;)Lcom/dynamsoft/core/basic_structures/ImageData;");
     auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
-    auto jQuad = jsQuadToJobject(rt, env, jsQuad);
-    auto jImageDataAfterCrop = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jQuad);
+    auto jDSRect = jsDsRectToJobject(rt, env, jsDSRect);
+    auto jImageDataAfterCrop = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jDSRect);
     ImageDataHostObject imageHOAfterCrop;
     jsiConversion::core::getHOFromJImageData(env, jImageDataAfterCrop, imageHOAfterCrop);
-    env->DeleteLocalRef(jQuad);
+    env->DeleteLocalRef(jDSRect);
     env->DeleteLocalRef(jImageDataAfterCrop);
     env->DeleteLocalRef(clz);
     env->DeleteLocalRef(jImageData);
@@ -120,62 +209,378 @@ ImageDataHostObject cropImage(Runtime &rt, ImageDataHostObject &imageDataHO, Obj
     return imageHOAfterCrop;
 }
 
+ImageDataHostObject cropAndDeskewImage(Runtime &rt, ImageDataHostObject &imageDataHO, Object &jsQuad, int dstWidth, int dstHeight, int padding) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "cropAndDeskewImageCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;Lcom/dynamsoft/core/basic_structures/Quadrilateral;III)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jQuad = jsQuadToJobject(rt, env, jsQuad);
+    auto jImageDataAfterCropAndDeskew = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, jQuad, dstWidth, dstHeight, padding);
+    ImageDataHostObject imageHOAfterCrop;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterCropAndDeskew, imageHOAfterCrop);
+    env->DeleteLocalRef(jQuad);
+    env->DeleteLocalRef(jImageDataAfterCropAndDeskew);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterCrop;
+}
+
+
+const int type_adjust_brightness = 0;
+const int type_adjust_contrast = 1;
+const int type_filter = 2;
+
+ImageDataHostObject adjustOrFilter(Runtime &rt, ImageDataHostObject &imageDataHO, int value, int type) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId;
+    switch (type) {
+        case type_adjust_brightness:
+            methodId = env->GetMethodID(clz, "adjustBrightnessCalledInJsi",
+                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
+            break;
+        case type_adjust_contrast:
+            methodId = env->GetMethodID(clz, "adjustContrastCalledInJsi",
+                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
+            break;
+        case type_filter:
+        default:
+            methodId = env->GetMethodID(clz, "filterImageCalledInJsi",
+                                        "(Lcom/dynamsoft/core/basic_structures/ImageData;I)Lcom/dynamsoft/core/basic_structures/ImageData;");
+            break;
+    }
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfter = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, value);
+    ImageDataHostObject imageHOAfter;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfter, imageHOAfter);
+    env->DeleteLocalRef(jImageDataAfter);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfter;
+}
+
+ImageDataHostObject convertToGray(Runtime &rt, ImageDataHostObject &imageDataHO, float r, float g, float b) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "convertToGrayCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;FFF)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, r, g, b);
+    ImageDataHostObject imageHOAfterConvert;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
+    env->DeleteLocalRef(jImageDataAfterConvert);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterConvert;
+}
+
+ImageDataHostObject convertToBinaryGlobal(Runtime &rt, ImageDataHostObject &imageDataHO, int threshold, bool invert) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "convertToBinaryGlobalCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;IZ)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, threshold, invert);
+    ImageDataHostObject imageHOAfterConvert;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
+    env->DeleteLocalRef(jImageDataAfterConvert);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterConvert;
+}
+
+ImageDataHostObject convertToBinaryLocal(Runtime &rt, ImageDataHostObject &imageDataHO, int blockSize, int compensation, bool invert) {
+    JNIEnv *env;
+    bool needDetach = false;
+    int state = gJvm->GetEnv((void **) &env, JNI_VERSION_1_6);
+    if (state == JNI_EDETACHED || env == nullptr) {
+        gJvm->AttachCurrentThread(&env, nullptr);
+        needDetach = true;
+    }
+    jclass clz = env->GetObjectClass(jImageManagerModule);
+    jmethodID methodId = env->GetMethodID(clz, "convertToBinaryLocalCalledInJsi",
+                                          "(Lcom/dynamsoft/core/basic_structures/ImageData;IIZ)Lcom/dynamsoft/core/basic_structures/ImageData;");
+    auto jImageData = jsiConversion::core::getJImageDataFromHO(env, imageDataHO);
+    auto jImageDataAfterConvert = env->CallObjectMethod(jImageManagerModule, methodId, jImageData, blockSize, compensation, invert);
+    ImageDataHostObject imageHOAfterConvert;
+    jsiConversion::core::getHOFromJImageData(env, jImageDataAfterConvert, imageHOAfterConvert);
+    env->DeleteLocalRef(jImageDataAfterConvert);
+    env->DeleteLocalRef(clz);
+    env->DeleteLocalRef(jImageData);
+    if (needDetach) {
+        gJvm->DetachCurrentThread();
+    }
+    return imageHOAfterConvert;
+}
+
 
 #define JSI_FUNC [](Runtime &runtime, const Value &thisValue, const Value *arguments, size_t count) -> Value
 
 namespace jsi_install::utility {
-void install_imageManager_saveToFile(Runtime &jsiRuntime) {
-    auto nameID = PropNameID::forAscii(jsiRuntime, "imageManager_saveToFile");
-    if(!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-        auto saveToFileFcn = Function::createFromHostFunction(jsiRuntime, nameID, 3, JSI_FUNC {
-            auto imageDataObj = arguments[0].asObject(runtime);
-            auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-            auto filePath = arguments[1].asString(runtime).utf8(runtime);
-            bool overWrite = arguments[2].asBool();
-            saveImageDataHOToFile(runtime, imageDataHostObject, filePath, overWrite);
-            return {};
-        });
-        jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(saveToFileFcn));
-    }
-}
-void install_imageManager_drawOnImage(Runtime &jsiRuntime){
-    auto nameID = PropNameID::forAscii(jsiRuntime, "imageManager_drawOnImage");
-    if(!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-        auto drawOnImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 4, JSI_FUNC {
-            auto imageDataObj = arguments[0].asObject(runtime);
-            auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-            auto jsQuads = arguments[1].asObject(runtime).asArray(runtime);
-            auto color = arguments[2].asNumber();
-            auto thickness = arguments[3].asNumber();
-            ImageDataHostObject imageHOAfterDraw = drawOnImage(runtime, imageDataHostObject, jsQuads, (int) color, (int) thickness);
-            return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterDraw));
-        });
-        jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(drawOnImageFcn));
-    }
-}
-
-void install_imageManager_cropImage(Runtime &jsiRuntime){
-    auto nameID = PropNameID::forAscii(jsiRuntime, "imageManager_cropImage");
-    if(!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
-        auto cropImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 4, JSI_FUNC {
-            auto imageDataObj = arguments[0].asObject(runtime);
-            auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
-            auto jsQuads = arguments[1].asObject(runtime);
-            ImageDataHostObject imageHOAfterCrop = cropImage(runtime, imageDataHostObject, jsQuads);
-            if(imageHOAfterCrop.buffer == nullptr) {
-                return Value::undefined();
-            }
-            return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
-        });
-        jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropImageFcn));
-    }
-}
-}//namespace jsi_install::dce
+    void install_imageIO_saveToFile(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_saveToFile");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto saveToFileFcn = Function::createFromHostFunction(jsiRuntime, nameID, 3, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto filePath = arguments[1].asString(runtime).utf8(runtime);
+                bool overWrite = arguments[2].asBool();
+                saveImageDataHOToFile(runtime, imageDataHostObject, filePath, overWrite);
+                return {};
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(saveToFileFcn));
+        }
+    }
+
+    void install_imageIO_readFromFile(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_readFromFile");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto readFromFileFcn = Function::createFromHostFunction(jsiRuntime, nameID, 1, JSI_FUNC {
+                auto filePath = arguments[0].asString(runtime).utf8(runtime);
+                auto imageDataHostObject = readImageDataHOFromFile(runtime, filePath);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageDataHostObject));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(readFromFileFcn));
+        }
+    }
+
+    void install_imageIO_readFromMemory(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_readFromMemory");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto readFromMemoryFcn = Function::createFromHostFunction(jsiRuntime, nameID, 1, JSI_FUNC {
+                auto buffer = arguments[0].asObject(runtime).getArrayBuffer(runtime);
+                auto pBuffer = (unsigned char *) buffer.data(runtime);
+                auto len = (int) buffer.length(runtime);
+                auto imageDataHostObject = readImageDataHOFromMemory(runtime, pBuffer, len);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageDataHostObject));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(readFromMemoryFcn));
+        }
+    }
+
+    void install_imageIO_saveToMemory(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageIO_saveToMemory");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto saveToMemoryFcn = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                int fileFormat = arguments[1].asNumber();
+                auto arrayBuffer = saveImageDataHOToMemory(runtime, imageDataHostObject, fileFormat);
+                return arrayBuffer;
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(saveToMemoryFcn));
+        }
+    }
+
+    void install_imageDrawer_drawOnImage(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageDrawer_drawOnImage");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto drawOnImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 4, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto jsQuads = arguments[1].asObject(runtime).asArray(runtime);
+                auto color = arguments[2].asNumber();
+                auto thickness = arguments[3].asNumber();
+                ImageDataHostObject imageHOAfterDraw = drawOnImage(runtime, imageDataHostObject, jsQuads, (int) color, (int) thickness);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterDraw));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(drawOnImageFcn));
+        }
+    }
+
+    void install_imageProcessor_cropImage(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageProcessor_cropImage");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto cropImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto jsDsRect = arguments[1].asObject(runtime);
+                ImageDataHostObject imageHOAfterCrop = cropImage(runtime, imageDataHostObject, jsDsRect);
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropImageFcn));
+        }
+    }
+
+    void install_imageProcessor_cropAndDeskewImage(Runtime &jsiRuntime) {
+        auto nameID = PropNameID::forAscii(jsiRuntime, "imageProcessor_cropAndDeskewImage");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameID)) {
+            auto cropAndDeskewImageFcn = Function::createFromHostFunction(jsiRuntime, nameID, 5, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto jsQuads = arguments[1].asObject(runtime);
+                int dstWidth = arguments[2].asNumber();
+                int dstHeight = arguments[3].asNumber();
+                int padding = arguments[4].asNumber();
+                ImageDataHostObject imageHOAfterCrop = cropAndDeskewImage(runtime, imageDataHostObject, jsQuads, dstWidth, dstHeight, padding);
+                if (imageHOAfterCrop.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfterCrop));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameID, std::move(cropAndDeskewImageFcn));
+        }
+    }
+
+    void install_imageProcessor_adjustBrightness(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_adjustBrightness");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto value = arguments[1].asNumber();
+                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_adjust_brightness);
+                if (imageHOAfter.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
+        }
+    }
+
+    void install_imageProcessor_adjustContrast(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_adjustContrast");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto value = arguments[1].asNumber();
+                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_adjust_contrast);
+                if (imageHOAfter.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
+        }
+    }
+
+    void install_imageProcessor_filterImage(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_filterImage");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto adjustOrFilterFcn = Function::createFromHostFunction(jsiRuntime, nameId, 2, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                auto value = arguments[1].asNumber();
+                ImageDataHostObject imageHOAfter = adjustOrFilter(runtime, imageDataHostObject, (int) value, type_filter);
+                if (imageHOAfter.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(imageHOAfter));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(adjustOrFilterFcn));
+        }
+    }
+
+    void install_imageProcessor_convertToGray(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToGray");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto convertToGrayFcn = Function::createFromHostFunction(jsiRuntime, nameId, 4, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                float r = arguments[1].asNumber();
+                float g = arguments[2].asNumber();
+                float b = arguments[3].asNumber();
+                ImageDataHostObject grayImageHO = convertToGray(runtime, imageDataHostObject, r, g, b);
+                if (grayImageHO.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(grayImageHO));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToGrayFcn));
+        }
+    }
+
+    void install_imageProcessor_convertToBinaryGlobal(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToBinaryGlobal");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto convertToBinaryGlobalFcn = Function::createFromHostFunction(jsiRuntime, nameId, 3, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                int threshold = arguments[1].asNumber();
+                bool isInvert = arguments[2].asBool();
+                ImageDataHostObject binaryImageHO = convertToBinaryGlobal(runtime, imageDataHostObject, threshold, isInvert);
+                if (binaryImageHO.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(binaryImageHO));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToBinaryGlobalFcn));
+        }
+    }
+
+    void install_imageProcessor_convertToBinaryLocal(Runtime &jsiRuntime) {
+        PropNameID nameId = PropNameID::forAscii(jsiRuntime, "imageProcessor_convertToBinaryLocal");
+        if (!jsiRuntime.global().hasProperty(jsiRuntime, nameId)) {
+            auto convertToBinaryLocalFcn = Function::createFromHostFunction(jsiRuntime, nameId, 4, JSI_FUNC {
+                auto imageDataObj = arguments[0].asObject(runtime);
+                auto imageDataHostObject = ImageDataHostObject::getHOFromObject(runtime, std::move(imageDataObj));
+                int blockSize = arguments[1].asNumber();
+                int compensation = arguments[2].asNumber();
+                bool isInvert = arguments[3].asBool();
+                ImageDataHostObject binaryImageHO = convertToBinaryLocal(runtime, imageDataHostObject, blockSize, compensation, isInvert);
+                if (binaryImageHO.buffer == nullptr) {
+                    return Value::undefined();
+                }
+                return Object::createFromHostObject(runtime, std::make_shared<ImageDataHostObject>(binaryImageHO));
+            });
+            jsiRuntime.global().setProperty(jsiRuntime, nameId, std::move(convertToBinaryLocalFcn));
+        }
+    }
+} //namespace jsi_install::utility
 
 void install_imageManager_methods(Runtime &jsiRuntime) {
-    jsi_install::utility::install_imageManager_saveToFile(jsiRuntime);
-    jsi_install::utility::install_imageManager_drawOnImage(jsiRuntime);
-    jsi_install::utility::install_imageManager_cropImage(jsiRuntime);
+    jsi_install::utility::install_imageIO_saveToFile(jsiRuntime);
+    jsi_install::utility::install_imageIO_readFromFile(jsiRuntime);
+    jsi_install::utility::install_imageIO_readFromMemory(jsiRuntime);
+    jsi_install::utility::install_imageIO_saveToMemory(jsiRuntime);
+    jsi_install::utility::install_imageDrawer_drawOnImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_cropImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_cropAndDeskewImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_adjustBrightness(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_adjustContrast(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_filterImage(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_convertToGray(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_convertToBinaryGlobal(jsiRuntime);
+    jsi_install::utility::install_imageProcessor_convertToBinaryLocal(jsiRuntime);
 }
 
 
@@ -185,12 +590,15 @@ Java_com_dynamsoft_reactnativelib_utility_ImageManagerModuleImpl_nativeInstall(J
     if (!env->IsSameObject(jImageManagerModule, thiz)) {
         jImageManagerModule = env->NewWeakGlobalRef(thiz);
     }
-    if(jclzQuad == nullptr) {
+    if (jclzQuad == nullptr) {
         jclzQuad = (jclass) env->NewWeakGlobalRef(env->FindClass("com/dynamsoft/core/basic_structures/Quadrilateral"));
     }
-    if(jclzPoint == nullptr) {
+    if (jclzPoint == nullptr) {
         jclzPoint = (jclass) env->NewWeakGlobalRef(env->FindClass("android/graphics/Point"));
     }
+    if (jclzDSRect == nullptr) {
+        jclzDSRect = (jclass) env->NewWeakGlobalRef(env->FindClass("com/dynamsoft/core/basic_structures/DSRect"));
+    }
     auto rt = reinterpret_cast<Runtime *>(jsiPtr);
     install_imageManager_methods(*rt);
 }

package/android/src/main/cpp/JsiUtility.h

@@ -8,9 +8,19 @@
 
 
 namespace jsi_install::utility {
-void install_imageManager_saveToFile(Runtime &jsiRuntime);
-void install_imageManager_drawOnImage(Runtime &jsiRuntime);
-void install_imageManager_cropImage(Runtime &jsiRuntime);
+void install_imageIO_saveToFile(Runtime &jsiRuntime);
+void install_imageIO_readFromFile(Runtime &jsiRuntime);
+void install_imageIO_readFromMemory(Runtime &jsiRuntime);
+void install_imageIO_saveToMemory(Runtime &jsiRuntime);
+void install_imageDrawer_drawOnImage(Runtime &jsiRuntime);
+void install_imageProcessor_cropImage(Runtime &jsiRuntime);
+void install_imageProcessor_cropAndDeskewImage(Runtime &jsiRuntime);
+void install_imageProcessor_adjustBrightness(Runtime &jsiRuntime);
+void install_imageProcessor_adjustContrast(Runtime &jsiRuntime);
+void install_imageProcessor_filterImage(Runtime &jsiRuntime);
+void install_imageProcessor_convertToGray(Runtime &jsiRuntime);
+void install_imageProcessor_convertToBinaryGlobal(Runtime &jsiRuntime);
+void install_imageProcessor_convertToBinaryLocal(Runtime &jsiRuntime);
 }//namespace jsi_install::dce
 
 #endif //REACT_NATIVE_DCV_ANDROID_SRC_MAIN_CPP_UTILITY_JSIUTILITY_H_