dynamsoft-capture-vision-react-native 2.4.2000-alpha.2 → 2.6.1002

package/src/cvr/CapturedResult.tsx

@@ -3,102 +3,143 @@ import type {BarcodeResultItem, DecodedBarcodesResult} from "../dbr";
 import type {ParsedResult, ParsedResultItem} from "../dcp";
 import type {RecognizedTextLinesResult, TextLineResultItem} from "../dlr";
 import type {
-    DetectedQuadResultItem,
-    DetectedQuadsResult,
-    NormalizedImageResultItem,
-    NormalizedImagesResult
+  DetectedQuadResultItem,
+  DetectedQuadsResult,
+  NormalizedImageResultItem,
+  NormalizedImagesResult
 } from "../ddn";
 
+/**
+ * The CapturedResult interface describes the basic structure of a result object returned by Dynamsoft Capture Vision Router({@link CaptureVisionRouter}).
+ *
+ * @remarks Depending on the functional module that generated the result item, the interface may vary:
+ * - dynamsoft-barcode-reader: {@link DecodedBarcodesResult}
+ * - dynamsoft-label-recognizer: {@link RecognizedTextLinesResult}
+ * - dynamsoft-document-normalizer: {@link DetectedQuadsResult} or {@link NormalizedImagesResult}
+ * - dynamsoft-code-parser: {@link ParsedResult}
+ *
+ * @see CapturedResultReceiver.onCapturedResultReceived
+ * */
 export interface CapturedResult {
-    originalImageHashId: string;
-    items?: Array<CapturedResultItem>;
-    errorCode: number;
-    errorMessage: string;
-    rotationTransformMatrix: Array<number>;
-    decodedBarcodesResult?: DecodedBarcodesResult;
-    recognizedTextLinesResult?:RecognizedTextLinesResult;
-    detectedQuadsResult?:DetectedQuadsResult;
-    normalizedImagesResult?:NormalizedImagesResult;
-    parsedResult?: ParsedResult;
+  /**
+   * The hash ID of the original image.
+   * @see IntermediateResultManager.getOriginalImage
+   * */
+  originalImageHashId: string;
+
+  /**
+   * An array of CapturedResultItem objects representing the captured result items.
+   * */
+  items?: Array<CapturedResultItem>;
+
+  /**Error code associated with the capture result.*/
+  errorCode: number;
+
+  /**Error string providing details about the error.*/
+  errorMessage: string;
+
+  /**the rotation transformation matrix of the original image relative to the rotated image.*/
+  rotationTransformMatrix: Array<number>;
+
+  /**Get a {@link DecodedBarcodesResult} object that contains all the {@link BarcodeResultItem} in this CapturedResult.*/
+  decodedBarcodesResult?: DecodedBarcodesResult;
+
+  /**Get a {@link RecognizedTextLinesResult} object that contains all the {@link TextLineResultItem} in this CapturedResult.*/
+  recognizedTextLinesResult?: RecognizedTextLinesResult;
+
+  /**Get a {@link DetectedQuadsResult} object that contains all the {@link DetectedQuadResultItem} in this CapturedResult.*/
+  detectedQuadsResult?: DetectedQuadsResult;
+
+  /**Get a {@link NormalizedImagesResult} object that contains all the {@link NormalizedImageResultItem} in this CapturedResult.*/
+  normalizedImagesResult?: NormalizedImagesResult;
+
+  /**Get a {@link ParsedResult} object that contains all the {@link ParsedResultItem} in this CapturedResult.*/
+  parsedResult?: ParsedResult;
 }
 
+/**@internal*/
 export function _populateResults(result: CapturedResult | null | undefined) {
-    if(result) {
-        result.decodedBarcodesResult = getDecodedBarcodesResult(result)
-        result.recognizedTextLinesResult = getRecognizedTextLinesResult(result)
-        result.detectedQuadsResult = getDetectedQuadsResult(result)
-        result.normalizedImagesResult = getNormalizedImagesResult(result)
-        result.parsedResult = getParsedResult(result)
-    }
+  if (result) {
+    result.decodedBarcodesResult = getDecodedBarcodesResult(result)
+    result.recognizedTextLinesResult = getRecognizedTextLinesResult(result)
+    result.detectedQuadsResult = getDetectedQuadsResult(result)
+    result.normalizedImagesResult = getNormalizedImagesResult(result)
+    result.parsedResult = getParsedResult(result)
+  }
 }
 
 
+/**@internal*/
 function getDecodedBarcodesResult(result: CapturedResult): DecodedBarcodesResult {
-    return {
-        originalImageHashId: result.originalImageHashId,
-        errorCode: result.errorCode,
-        errorMessage: result.errorMessage,
-        rotationTransformMatrix: result.rotationTransformMatrix,
-        items: result.items?.filter(item => {
-            return item.type == EnumCapturedResultItemType.CRIT_BARCODE
-        }).map(item => {
-            return item as BarcodeResultItem
-        })
-
-    } as DecodedBarcodesResult;
+  return {
+    originalImageHashId: result.originalImageHashId,
+    errorCode: result.errorCode,
+    errorMessage: result.errorMessage,
+    rotationTransformMatrix: result.rotationTransformMatrix,
+    items: result.items?.filter(item => {
+      return item.type == EnumCapturedResultItemType.CRIT_BARCODE
+    }).map(item => {
+      return item as BarcodeResultItem
+    })
+
+  } as DecodedBarcodesResult;
 }
 
+/**@internal*/
 function getRecognizedTextLinesResult(result: CapturedResult): RecognizedTextLinesResult {
-    return {
-        originalImageHashId: result.originalImageHashId,
-        errorCode: result.errorCode,
-        errorString: result.errorMessage,
-        rotationTransformMatrix: result.rotationTransformMatrix,
-        items: result.items?.filter(item => {
-            return item.type == EnumCapturedResultItemType.CRIT_TEXT_LINE
-        }).map(item => {
-            return item as TextLineResultItem
-        })
-    } as RecognizedTextLinesResult;
+  return {
+    originalImageHashId: result.originalImageHashId,
+    errorCode: result.errorCode,
+    errorString: result.errorMessage,
+    rotationTransformMatrix: result.rotationTransformMatrix,
+    items: result.items?.filter(item => {
+      return item.type == EnumCapturedResultItemType.CRIT_TEXT_LINE
+    }).map(item => {
+      return item as TextLineResultItem
+    })
+  } as RecognizedTextLinesResult;
 }
 
+/**@internal*/
 function getDetectedQuadsResult(result: CapturedResult): DetectedQuadsResult {
-    return {
-        originalImageHashId: result.originalImageHashId,
-        errorCode: result.errorCode,
-        errorString: result.errorMessage,
-        rotationTransformMatrix: result.rotationTransformMatrix,
-        items: result.items?.filter(item => {
-            return item.type == EnumCapturedResultItemType.CRIT_DETECTED_QUAD
-        }).map(item => {
-            return item as DetectedQuadResultItem
-        })
-    } as DetectedQuadsResult;
+  return {
+    originalImageHashId: result.originalImageHashId,
+    errorCode: result.errorCode,
+    errorString: result.errorMessage,
+    rotationTransformMatrix: result.rotationTransformMatrix,
+    items: result.items?.filter(item => {
+      return item.type == EnumCapturedResultItemType.CRIT_DETECTED_QUAD
+    }).map(item => {
+      return item as DetectedQuadResultItem
+    })
+  } as DetectedQuadsResult;
 }
 
+/**@internal*/
 function getNormalizedImagesResult(result: CapturedResult): NormalizedImagesResult {
-    return {
-        originalImageHashId: result.originalImageHashId,
-        errorCode: result.errorCode,
-        errorString: result.errorMessage,
-        rotationTransformMatrix: result.rotationTransformMatrix,
-        items: result.items?.filter(item => {
-            return item.type == EnumCapturedResultItemType.CRIT_NORMALIZED_IMAGE
-        }).map(item => {
-            return item as NormalizedImageResultItem
-        })
-    } as NormalizedImagesResult;
+  return {
+    originalImageHashId: result.originalImageHashId,
+    errorCode: result.errorCode,
+    errorString: result.errorMessage,
+    rotationTransformMatrix: result.rotationTransformMatrix,
+    items: result.items?.filter(item => {
+      return item.type == EnumCapturedResultItemType.CRIT_NORMALIZED_IMAGE
+    }).map(item => {
+      return item as NormalizedImageResultItem
+    })
+  } as NormalizedImagesResult;
 }
 
+/**@internal*/
 function getParsedResult(result: CapturedResult): ParsedResult {
-    return {
-        originalImageHashId: result.originalImageHashId,
-        errorCode: result.errorCode,
-        errorMessage: result.errorMessage,
-        items: result.items?.filter(item => {
-            return item.type == EnumCapturedResultItemType.CRIT_PARSED_RESULT
-        }).map(item => {
-            return item as ParsedResultItem
-        })
-    } as ParsedResult;
+  return {
+    originalImageHashId: result.originalImageHashId,
+    errorCode: result.errorCode,
+    errorMessage: result.errorMessage,
+    items: result.items?.filter(item => {
+      return item.type == EnumCapturedResultItemType.CRIT_PARSED_RESULT
+    }).map(item => {
+      return item as ParsedResultItem
+    })
+  } as ParsedResult;
 }

package/src/cvr/CapturedResultFilter.tsx

@@ -1,3 +1,10 @@
+/**
+ * The CapturedResultFilter interface represents a captured result filter, which is responsible for filtering different types of captured results,
+ * including original image, decoded barcodes, recognized text lines, detected quads, normalized images, and parsed results.
+ *
+ * @remarks Can only use specific inherited classes {@link MultiFrameResultCrossFilter} for now.
+ * @see CaptureVisionRouter.addFilter
+ * */
 export interface CapturedResultFilter {
     /**@internal*/
     _getFilterId():string;

package/src/cvr/CapturedResultReceiver.tsx

@@ -4,19 +4,75 @@ import type {DetectedQuadsResult, NormalizedImagesResult} from "../ddn";
 import type {RecognizedTextLinesResult} from "../dlr";
 import type {ParsedResult} from "../dcp";
 
+/**
+ * The CapturedResultReceiver class is designed as a standardized way for retrieving captured results in the Dynamsoft Capture Vision architecture.
+ * It adopts an event-driven approach, with events dedicated to various result types,
+ * such as the original image, decoded barcodes, recognized text lines, detected quads, normalized images, and parsed results, etc.
+ * <p>
+ *   code snippet:
+ *   ```
+ *   val router: CaptureVisionRouter
+ *   router.addResultReceiver({
+ *      onDecodedBarcodesReceived: result =>  {
+ *          //Handle barcodes. `result` is an instance of DecodedBarcodesResult.
+ *      },
+ *
+ *      onRecognizedTextLinesReceived: result => {
+ *          //Handle the result of text recognition. `result` is an instance of RecognizedTextLinesResult.
+ *      },
+ *   })
+ *   ```
+ *
+ * @see CaptureVisionRouter.addResultReceiver
+ * */
 export interface CapturedResultReceiver {
-    /**@internal*/
-    // receiverId?:string;
-
+    /**
+     * Event triggered when a generic captured result is available, occurring each time an image finishes its processing.
+     * This event can be used for any result that does not fit into the specific categories of the other callback events.
+     *
+     * @see CapturedResult
+     * */
     onCapturedResultReceived?: (result: CapturedResult) => void;
 
+    /**
+     * Event triggered when decoded barcodes are available.
+     * This event is used to handle barcodes that have been successfully decoded by Dynamsoft Barcode Reader.
+     *
+     * @see DecodedBarcodesResult
+     * */
     onDecodedBarcodesReceived?: (result: DecodedBarcodesResult) => void;
 
+    /**
+     * Event triggered when detected quads are available.
+     * This event is used to handle the detection of quadrilateral shapes, typically used as document boundaries,
+     * by Dynamsoft Document Normalizer.
+     *
+     * @see DetectedQuadsResult
+     * */
     onDetectedQuadsReceived?: (result: DetectedQuadsResult) => void;
 
+    /**
+     * Event triggered when normalized images are available.
+     * This event is used for handling images that have been processed or normalized (e.g., corrected for skew or perspective),
+     * by Dynamsoft Document Normalizer.
+     *
+     * @see NormalizedImagesResult
+     * */
     onNormalizedImagesReceived?: (result: NormalizedImagesResult) => void;
 
+    /**
+     * Event triggered when recognized text lines are available.
+     * This event is used to handle the result of text recognition by Dynamsoft Label Recognizer.
+     *
+     * @see RecognizedTextLinesResult
+     * */
     onRecognizedTextLinesReceived?: (result: RecognizedTextLinesResult) => void;
 
+    /**
+     * Event triggered when parsed results are available.
+     * This event is used for handling results that have been parsed into a structured format by Dynamsoft Code Parser.
+     *
+     * @see ParsedResult
+     * */
     onParsedResultsReceived?: (result: ParsedResult) => void;
 }

package/src/cvr/EnumPresetTemplate.tsx

@@ -1,16 +1,81 @@
 export enum EnumPresetTemplate {
-    PT_DEFAULT = "Default",//DBR + DLR + DDN-Normalize
+    /**
+     * Versatile function for barcode reading, document detection, or text recognition.
+     */
+    PT_DEFAULT = "Default",
+
+    /**
+     * Scans a single barcode.
+     * */
     PT_READ_BARCODES = "ReadBarcodes_Default",
+
+    /**
+     * Identifies and reads any text present.
+     */
     PT_RECOGNIZE_TEXT_LINES = "RecognizeTextLines_Default",
+
+    /**
+     * RIdentifies the edges of a document.
+     */
     PT_DETECT_DOCUMENT_BOUNDARIES = "DetectDocumentBoundaries_Default",
+
+    /**
+     * Detects document edges and standardizes its format.
+     */
     PT_DETECT_AND_NORMALIZE_DOCUMENT = "DetectAndNormalizeDocument_Default",
+
+    /**
+     * Adjusts a document to a standard format using detected borders.
+     */
     PT_NORMALIZE_DOCUMENT = "NormalizeDocument_Default",
+
+    /**
+     * Represents a barcode reading mode where speed is prioritized.
+     *
+     * In this mode, the barcode reader will optimize for faster barcode detection
+     * and decoding, sacrificing some level of accuracy and read rate. It is suitable
+     * for situations where a quick response time is more important than perfect
+     * barcode recognition.
+     */
     PT_READ_BARCODES_SPEED_FIRST = "ReadBarcodes_SpeedFirst",
+
+    /**
+     * Represents a barcode reading mode where barcode read rate is prioritized.
+     *
+     * In this mode, the barcode reader will optimize for higher barcode read rates,
+     * even if it may sometimes result in reduced accuracy and speed. It is suitable for
+     * scenarios where maximizing the number of successfully read barcodes is critical.
+     */
     PT_READ_BARCODES_READ_RATE_FIRST = "ReadBarcodes_ReadRateFirst",
+
+    /**
+     * Scans a single barcode.
+     * */
     PT_READ_SINGLE_BARCODE = "ReadSingleBarcode",
+
+    /**
+     * Represents a text recognition mode focused on recognizing numbers.
+     */
     PT_RECOGNIZE_NUMBERS = "RecognizeNumbers",
+
+    /**
+     * Represents a text recognition mode focused on recognizing alphabetic characters (letters).
+     *
+     */
     PT_RECOGNIZE_LETTERS = "RecognizeLetters",
+
+    /**
+     * Represents a text recognition mode that combines numbers and alphabetic characters (letters) recognition.
+     */
     PT_RECOGNIZE_NUMBERS_AND_LETTERS = "RecognizeNumbersAndLetters",
+
+    /**
+     * Represents a text recognition mode that combines numbers and uppercase letters recognition.
+     */
     PT_RECOGNIZE_NUMBERS_AND_UPPERCASE_LETTERS = "RecognizeNumbersAndUppercaseLetters",
+
+    /**
+     * Represents a text recognition mode focused on recognizing uppercase letters.
+     */
     PT_RECOGNIZE_UPPERCASE_LETTERS = "RecognizeUppercaseLetters",
 }

package/src/cvr/SimplifiedCaptureVisionSettings.tsx

@@ -3,14 +3,59 @@ import type {SimplifiedBarcodeReaderSettings} from "../dbr";
 import type {SimplifiedLabelRecognizerSettings} from "../dlr";
 import type {SimplifiedDocumentNormalizerSettings} from "../ddn";
 
+/**
+ * The SimplifiedCaptureVisionSettings interface provides a standardized way to adjust a select set of settings for a given CaptureVisionTemplate.
+ * @see CaptureVisionRouter.getSimplifiedSettings
+ * @see CaptureVisionRouter.updateSettings
+ * */
 export interface SimplifiedCaptureVisionSettings {
+    /**
+     * Specifies the types of result items that are expected to be returned. It is of type {@link EnumCapturedResultItemType}.
+     * */
     capturedResultItemTypes?: EnumCapturedResultItemType | number;
+
+    /**
+     * Designates the region of interest (ROI) within an image,
+     * limiting the image processing activities exclusively to this specified area.
+     * It is of type {@link Quadrilateral}.
+     * */
     roi?: Quadrilateral;
+
+    /**
+     * Determines if the coordinates for the region of interest (ROI) are expressed
+     * in percentage terms (true) or as exact pixel measurements (false).
+     * */
     roiMeasuredInPercentage?: boolean;
+
+    /**
+     * Specifies the maximum number of parallel tasks(in native) that can be used for image capture and recognition.
+     * */
     maxParallelTasks?:number
+
+    /**
+     * Specifies the maximum time (in milliseconds) allowed for image capture and recognition.
+     * */
     timeout?: number;
+
+    /**
+     * Specifies the shortest time span, in milliseconds, that must elapse between two successive image captures.
+     * Opting for a higher interval decreases capture frequency, which can lower the system's processing load and conserve energy.
+     * On the other hand, a smaller interval value increases the frequency of image captures, enhancing the system's responsiveness.
+     * */
     minImageCaptureInterval?: number;
+
+    /**
+     * Specifies the basic settings for the barcode reader module. It is of type {@link SimplifiedBarcodeReaderSettings}.
+     * */
     barcodeSettings?: SimplifiedBarcodeReaderSettings;
+
+    /**
+     * Specifies the basic settings for the label recognizer module. It is of type {@link SimplifiedLabelRecognizerSettings}.
+     * */
     labelSettings?: SimplifiedLabelRecognizerSettings;
+
+    /**
+     * Specifies the basic settings for the document normalizer module. It is of type {@link SimplifiedDocumentNormalizerSettings}.
+     * */
     documentSettings?: SimplifiedDocumentNormalizerSettings;
 }

package/src/dbr/BarcodeResultItem.tsx

@@ -2,15 +2,45 @@ import type {CapturedResultItem} from "../core/CapturedResultItem";
 import type {Quadrilateral} from "../core/Quadrilateral";
 import type {EnumBarcodeFormat} from "./EnumBarcodeFormat";
 
+/**
+ * Interface BarcodeResultItem extends {@link CapturedResultItem}, represents a barcode result item decoded by barcode reader engine.
+ * @see DecodedBarcodesResult
+ * @see EnumCapturedResultItemType.CRIT_BARCODE
+ * */
 export interface BarcodeResultItem extends CapturedResultItem{
+    /**
+     * The format of the barcode. It specifies the type of barcode that was recognized.
+     * @see EnumBarcodeFormat
+     * */
     format: EnumBarcodeFormat | bigint;
+
+    /**@internal*/
     _formatNumberString: string;
+
+    /**A string that describes the format of the barcode in human-readable form. It provides a textual representation of the barcode format.*/
     formatString: string;
+
+    /**The textual data decoded from the barcode. It represents the content of the barcode.*/
     text: string;
+    /**
+     * The location of the barcode in the form of a {@link Quadrilateral} (a set of coordinates defining the four corners of the detected barcode).
+     * It describes where the barcode was found within an image.
+     * @see Quadrilateral
+     * */
     location: Quadrilateral;
+
+    /**The confidence score or reliability of the barcode detection.*/
     confidence: number;
+
+    /**The angle or orientation of the barcode, indicating if the barcode was detected at an angle or rotated.*/
     angle: number;
+
+    /**The size of the individual modules or elements within the barcode.*/
     moduleSize: number;
+
+    /**Whether the barcode is mirrored or reversed from its normal orientation.*/
     isMirrored: boolean;
+
+    /**Indicates whether the barcode is a Direct Part Marking (DPM) barcode.*/
     isDPM: boolean;
-}
+}

package/src/dbr/DecodedBarcodesResult.tsx

@@ -1,9 +1,27 @@
 import type {BarcodeResultItem} from "./BarcodeResultItem";
 
+/**
+ * Interface DecodedBarcodesResult represents information of decoded barcodes from an image.
+ * @see CapturedResultReceiver.onDecodedBarcodesReceived
+ * */
 export interface DecodedBarcodesResult {
+    /**
+     * A unique identifier or hash of the original image from which the barcodes were decoded. It can be used to associate the result with a specific input image.
+     * @see IntermediateResultManager.getOriginalImage
+     * */
     originalImageHashId: string;
+
+    /**
+     * An array of {@link BarcodeResultItem} objects, representing the list of decoded barcodes found in the image.
+     * */
     items?: Array<BarcodeResultItem>;
+
+    /**The error code of the barcode reading result, if an error occurred.*/
     errorCode: number;
+
+    /**The error message of the barcode reading result, if an error occurred.*/
     errorMessage?: string;
+
+    /**the rotation transformation matrix of the original image relative to the rotated image.*/
     rotationTransformMatrix: Array<number>;
 }