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

package/src/utility/ImageManager.tsx

@@ -1,5 +1,6 @@
 import {type ColorValue, NativeModules, processColor} from "react-native";
-import type {ImageData, Quadrilateral} from "../core";
+import type {ImageData, Quadrilateral, EnumImageFileFormat, DSRect} from "../core";
+import type {EnumFilterType} from "./EnumFilterType";
 
 // @ts-ignore Check whether __turboModuleProxy exists, it may not
 const isTurboModuleEnabled = global.__turboModuleProxy != null;
@@ -9,11 +10,20 @@ const DynamsoftImageManagerModule = isTurboModuleEnabled ?
   NativeModules.DynamsoftImageManagerModule;
 
 declare global {
-  function imageManager_saveToFile(imageData: ImageData, path: string, overWrite: boolean): void;
+  function imageIO_saveToFile(imageData: ImageData, path: string, overWrite: boolean): void;
+  function imageIO_readFromFile(path: string): ImageData;
+  function imageIO_readFromMemory(data: ArrayBuffer): ImageData;
+  function imageIO_saveToMemory(imageData: ImageData, format: number): ArrayBuffer;
+  function imageDrawer_drawOnImage(imageData: ImageData, quads: Quadrilateral[], colour: number, thickness: number): ImageData;
+  function imageProcessor_cropImage(imageData: ImageData, rect: DSRect): ImageData | undefined;
+  function imageProcessor_cropAndDeskewImage(imageData: ImageData, quad: Quadrilateral, dstWidth: number, dstHeight: number, padding: number): ImageData | undefined;
+  function imageProcessor_adjustBrightness(imageData: ImageData, brightness: number) : ImageData | undefined;
+  function imageProcessor_adjustContrast(imageData: ImageData, contrast: number) : ImageData | undefined;
+  function imageProcessor_filterImage(imageData: ImageData, filterType: number) : ImageData | undefined;
+  function imageProcessor_convertToGray(imageData: ImageData, r: number, g: number, b: number) : ImageData | undefined;
+  function imageProcessor_convertToBinaryGlobal(imageData: ImageData, threshold: number, invert: boolean) : ImageData | undefined;
+  function imageProcessor_convertToBinaryLocal(imageData: ImageData, blockSize: number, compensation: number, invert: boolean): ImageData | undefined;
 
-  function imageManager_drawOnImage(imageData: ImageData, quads: Quadrilateral[], colour: number, thickness: number): ImageData;
-
-  function imageManager_cropImage(imageData: ImageData, quads: Quadrilateral): ImageData | undefined;
 }
 
 let isInstalled = false
@@ -27,8 +37,68 @@ const installMethods = () => {
 /**
  * The ImageManager class is a utility class for managing and manipulating images.
  * It provides functionality for saving images to files and drawing various shapes on images.
+ * @deprecated use {@link ImageIO}, {@link ImageDrawer}, {@link ImageProcessor} instead
  * */
 export class ImageManager {
+  /**
+   * Saves an image to the specified path and format.
+   * The desired file format is inferred from the file extension provided in the path parameter.
+   *
+   * @param imageData - The image to be saved, of type {@link ImageData}.
+   * @param path - The absolute file path, name and extension name, as a string, under which the image will be saved.
+   * @param overWrite - A flag indicating whether to overwrite the file if it already exists. Defaults to true.
+   * @deprecated use {@link ImageIO.saveToFile} instead
+   * */
+  saveToFile(imageData: ImageData | null | undefined, path: string | null | undefined, overWrite: boolean): void {
+    new ImageIO().saveToFile(imageData, path, overWrite);
+  }
+
+  /**
+   * Add quadrilaterals on the image.
+   *
+   * @param imageData - The {@link ImageData} to modify.
+   * @param quads - An array of {@link Quadrilateral} objects to be added on the image.
+   * @param colour - An ColorValue as an ARGB colour.
+   * @param thickness - The width of the border.
+   *
+   * @return {ImageData|null|undefined} - The modified ImageData.
+   * @deprecated use {@link ImageDrawer.drawOnImage} instead
+   * */
+  drawOnImage(imageData: ImageData | null | undefined, quads: Quadrilateral[] | null | undefined, colour: number | ColorValue, thickness: number): ImageData | null | undefined {
+    return new ImageDrawer().drawOnImage(imageData, quads, colour, thickness);
+  }
+
+
+  /**
+   * Crops an image using a quadrilateral.
+   * @param {ImageData} imageData - The image data to crop.
+   * @param {Quadrilateral} quad - The quadrilateral to use for cropping.
+   *
+   * @returns {ImageData|null|undefined} - The cropped image data.
+   * @deprecated use {@link ImageProcessor.cropAndDeskewImage} instead
+   * */
+  cropImage(imageData: ImageData | null | undefined, quad: Quadrilateral | null | undefined): ImageData | undefined | null {
+    return new ImageProcessor().cropAndDeskewImage(imageData, quad);
+  }
+}
+
+export class ImageIO {
+
+  /**
+   * Reads an image from the specified path.
+   *
+   * @param path - The absolute file path, name and extension name, as a string, of the image to be read.
+   *
+   * @return {ImageData|null|undefined} - The image data, of type {@link ImageData}, or null if the image cannot be read.
+   * */
+  readFromFile(path: string | null | undefined): ImageData | null | undefined {
+    installMethods();
+    if (path && path.length > 0) {
+      return global.imageIO_readFromFile(path);
+    }
+    return null;
+  }
+
   /**
    * Saves an image to the specified path and format.
    * The desired file format is inferred from the file extension provided in the path parameter.
@@ -41,11 +111,44 @@ export class ImageManager {
     installMethods();
     if (imageData && path) {
       if (path.length > 0) {
-        global.imageManager_saveToFile(imageData, path, overWrite);
+        global.imageIO_saveToFile(imageData, path, overWrite);
       }
     }
   }
 
+  /**
+   * Reads an image from ArrayBuffer memory.
+   *
+   * @param data - The image data, of type ArrayBuffer.
+   *
+   * @return {ImageData|null|undefined} - The image data, of type {@link ImageData}, or null if the image cannot be read.
+   * */
+  readFromMemory(data: ArrayBuffer | null | undefined): ImageData | null | undefined {
+    installMethods();
+    if (data) {
+      return global.imageIO_readFromMemory(data);
+    }
+    return null;
+  }
+
+  /**
+   * Saves an image to the specified path and format.
+   * The desired file format is inferred from the file extension provided in the path parameter.
+   *
+   * @param imageData - The image to be saved, of type {@link ImageData}.
+   * @param format - The format of the image data, of type {@link EnumImageFileFormat}.
+   * */
+  saveToMemory(imageData: ImageData | null | undefined, format: EnumImageFileFormat): ArrayBuffer | null | undefined {
+    installMethods();
+    if (imageData) {
+      return global.imageIO_saveToMemory(imageData, format);
+    }
+    return null;
+  }
+
+}
+
+export class ImageDrawer {
   /**
    * Add quadrilaterals on the image.
    *
@@ -65,27 +168,142 @@ export class ImageManager {
         if (quads.length == 0 || thickness <= 0 || alpha == 0) {
           return imageData;
         }
-        return global.imageManager_drawOnImage(imageData, quads, colorNumber, thickness);
+        return global.imageDrawer_drawOnImage(imageData, quads, colorNumber, thickness);
       }
     }
     return imageData;
   }
+}
+
+export class ImageProcessor {
+
+  /**
+   * Crops an image using a rectangle.
+   * @param {ImageData} imageData - The image data to crop.
+   * @param {DSRect} rect - The rectangle to use for cropping.
+   *
+   * @returns {ImageData|null|undefined} - The cropped image data.
+   * */
+  cropImage(imageData: ImageData | null | undefined, rect: DSRect | null | undefined): ImageData | null | undefined {
+    installMethods()
+    if (!rect || !imageData) {
+      return imageData;
+    }
+    // convert to boolean
+    rect.measuredInPercentage = !!rect.measuredInPercentage;
+    return global.imageProcessor_cropImage(imageData, rect);
+  }
 
 
   /**
    * Crops an image using a quadrilateral.
    * @param {ImageData} imageData - The image data to crop.
    * @param {Quadrilateral} quad - The quadrilateral to use for cropping.
+   * @param {number} dstWidth - The width of the cropped image.
+   * @param {number} dstHeight - The height of the cropped image.
+   * @param {number} padding - The padding size.
    *
    * @returns {ImageData|null|undefined} - The cropped image data.
    * */
-  cropImage(imageData: ImageData | null | undefined, quad: Quadrilateral | null | undefined): ImageData | undefined | null {
+  cropAndDeskewImage(imageData: ImageData | null | undefined, quad: Quadrilateral | null | undefined, dstWidth: number = 0, dstHeight: number = 0, padding: number = 0): ImageData | undefined | null {
     installMethods();
     if (!quad || !imageData) {
       return imageData;
     }
-    return global.imageManager_cropImage(imageData, quad);
+    return global.imageProcessor_cropAndDeskewImage(imageData, quad, dstWidth, dstHeight, padding);
+  }
+
+  /**
+   * Adjusts the brightness of an image.
+   *
+   * @param imageData - The image data to adjust the brightness of.
+   * @param brightness - The brightness adjustment value. Must be between -100 and 100.
+   *
+   * @return {ImageData|null|undefined} - The adjusted image data.
+   * */
+  adjustBrightness(imageData: ImageData | null | undefined, brightness: number): ImageData | null | undefined {
+    installMethods();
+    if(!imageData || brightness < -100 || brightness > 100) {
+      return imageData;
+    }
+    return global.imageProcessor_adjustBrightness(imageData, brightness);
   }
 
+  /**
+   * Adjusts the contrast of an image.
+   *
+   * @param imageData - The image data to adjust the contrast of.
+   * @param contrast - The contrast adjustment value. Must be between -100 and 100.
+   *
+   * @return {ImageData|null|undefined} - The adjusted image data.
+   * */
+  adjustContrast(imageData: ImageData | null | undefined, contrast: number): ImageData | null | undefined {
+    installMethods();
+    if(!imageData || contrast < -100 || contrast > 100) {
+      return imageData;
+    }
+    return global.imageProcessor_adjustContrast(imageData, contrast);
+  }
 
+  filterImage(imageData: ImageData | null | undefined, filterType: EnumFilterType): ImageData | null | undefined {
+    installMethods();
+    if(!imageData) {
+      return imageData;
+    }
+    return global.imageProcessor_filterImage(imageData, filterType);
+  }
+
+  /**
+   * Converts an image to grayscale.
+   *
+   * @param imageData - The image data to convert to grayscale.
+   * @param r - The weight of the red channel. Must be between 0 and 1.
+   * @param g - The weight of the green channel. Must be between 0 and 1.
+   * @param b - The weight of the blue channel. Must be between 0 and 1.
+   *
+   * @return {ImageData|null|undefined} - The grayscale image data.
+   * */
+  convertToGray(imageData: ImageData | null | undefined, r: number = 0.3, g: number = 0.59, b: number = 0.11): ImageData | null | undefined {
+    installMethods();
+    if(!imageData || r < 0 || r > 1 || g < 0 || g > 1 || b < 0 || b > 1) {
+      return imageData;
+    }
+    return global.imageProcessor_convertToGray(imageData, r, g, b);
+  }
+
+  /**
+   * Converts an image to binary using a global threshold.
+   *
+   * @param imageData - The image data to convert to binary.
+   * @param threshold - The threshold value. Must be between -1 and 255.(default is -1, automatic calculate the threshold).
+   * @param invert - If true, invert the binary image (black becomes white and white becomes black).
+   *
+   * @return {ImageData|null|undefined} - The binary image data.
+   * */
+  convertToBinaryGlobal(imageData: ImageData | null | undefined, threshold: number = -1, invert: boolean = false) {
+    installMethods();
+    if(!imageData || threshold < -1 || threshold > 255) {
+      return imageData;
+    }
+    return global.imageProcessor_convertToBinaryGlobal(imageData, threshold, invert);
+  }
+
+
+  /**
+   * Converts an image to binary using a local threshold.
+   *
+   * @param imageData - The image data to convert to binary.
+   * @param blockSize - Size of the block for local binarization(default is 0).
+   * @param compensation - Adjustment value to modify the threshold (default is 0).
+   * @param invert - If true, invert the binary image (black becomes white and white becomes black).
+   *
+   * @return {ImageData|null|undefined} - The binary image data.
+   * */
+  convertToBinaryLocal(imageData: ImageData | null | undefined, blockSize: number = 0, compensation: number = 0, invert: boolean = false) {
+    installMethods();
+    if(!imageData) {
+      return imageData;
+    }
+    return global.imageProcessor_convertToBinaryLocal(imageData, blockSize, compensation, invert);
+  }
 }

package/src/utility/index.tsx

@@ -1,3 +1,4 @@
 export * from "./UtilityModule"
 export * from "./MultiFrameResultCrossFilter"
 export * from "./ImageManager"
+export * from "./EnumFilterType"