react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

package/common/rnexecutorch/models/ocr/utils/DetectorUtils.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/ocr/Types.h>
+#include <span>
+
+namespace rnexecutorch::models::ocr::utils {
+std::pair<cv::Mat, cv::Mat> interleavedArrayToMats(std::span<const float> data,
+                                                   cv::Size size);
+/**
+ * This method applies a series of image processing operations to identify
+ * likely areas of text in the textMap and return the bounding boxes for single
+ * words.
+ *
+ * @param textMap A cv::Mat representing a heat map of the characters of text
+ * being present in an image.
+ * @param affinityMap A cv::Mat representing a heat map of the affinity between
+ * characters.
+ * @param textThreshold A float representing the threshold for the text map.
+ * @param linkThreshold A float representing the threshold for the affinity
+ * map.
+ * @param lowTextThreshold A float representing the low text.
+ *
+ * @return A vector containing DetectorBBox bounding boxes. Each DetectorBBox
+ * includes:
+ *  - "bbox": an array of Point values representing the vertices of the
+ * detected text box.
+ *  - "angle": a float representing the rotation angle of the box.
+ */
+std::vector<types::DetectorBBox> getDetBoxesFromTextMap(cv::Mat &textMap,
+                                                        cv::Mat &affinityMap,
+                                                        float textThreshold,
+                                                        float linkThreshold,
+                                                        float lowTextThreshold);
+std::vector<types::DetectorBBox>
+getDetBoxesFromTextMapVertical(cv::Mat &textMap, cv::Mat &affinityMap,
+                               float textThreshold, float linkThreshold,
+                               bool independentCharacters);
+
+float calculateRestoreRatio(int32_t currentSize, int32_t desiredSize);
+
+void restoreBboxRatio(std::vector<types::DetectorBBox> &boxes,
+                      float restoreRatio);
+/**
+ * This method processes a vector of DetectorBBox bounding boxes, each
+ * containing details about individual text boxes, and attempts to group and
+ * merge these boxes based on specified criteria including proximity, alignment,
+ * and size thresholds. It prioritizes merging of boxes that are aligned closely
+ * in angle, are near each other, and whose sizes are compatible based on the
+ * given thresholds.
+ *
+ * @param boxes A vector of DetectorBBoxes where each bounding box
+ * represents a text box.
+ * @param centerThreshold A float representing the threshold for considering
+ * the distance between center and fitted line.
+ * @param distanceThreshold A float that defines the maximum allowed distance
+ * between boxes for them to be considered for merging.
+ * @param heightThreshold A float representing the maximum allowed difference
+ * in height between boxes for merging.
+ * @param minSideThreshold An int that defines the minimum dimension threshold
+ * to filter out small boxes after grouping.
+ * @param maxSideThreshold An int that specifies the maximum dimension threshold
+ * for filtering boxes post-grouping.
+ * @param maxWidth An int that represents the maximum width allowable for a
+ * merged box.
+ *
+ * @return A vector of DetectorBBoxes representing the merged boxes.
+ *
+ * Processing Steps:
+ * 1. Sort initial boxes based on their maximum side length.
+ * 2. Sequentially merge boxes considering alignment, proximity, and size
+ * compatibility.
+ * 3. Post-processing to remove any boxes that are too small.
+ * 4. Sort the final array of boxes by their vertical positions.
+ */
+std::vector<types::DetectorBBox>
+groupTextBoxes(std::vector<types::DetectorBBox> &boxes, float centerThreshold,
+               float distanceThreshold, float heightThreshold,
+               int32_t minSideThreshold, int32_t maxSideThreshold,
+               int32_t maxWidth);
+} // namespace rnexecutorch::models::ocr::utils

package/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.cpp

@@ -0,0 +1,159 @@
+#include "RecognitionHandlerUtils.h"
+#include <algorithm>
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/models/ocr/Constants.h>
+
+namespace rnexecutorch::models::ocr::utils {
+types::PaddingInfo calculateResizeRatioAndPaddings(cv::Size size,
+                                                   cv::Size desiredSize) {
+  const auto newRatioH = static_cast<float>(desiredSize.height) / size.height;
+  const auto newRatioW = static_cast<float>(desiredSize.width) / size.width;
+  auto resizeRatio = std::min(newRatioH, newRatioW);
+
+  const auto newHeight = static_cast<int32_t>(size.height * resizeRatio);
+  const auto newWidth = static_cast<int32_t>(size.width * resizeRatio);
+
+  const int32_t deltaH = desiredSize.height - newHeight;
+  const int32_t deltaW = desiredSize.width - newWidth;
+
+  const int32_t top = deltaH / 2;
+  const int32_t left = deltaW / 2;
+
+  const auto heightRatio = static_cast<float>(size.height) / desiredSize.height;
+  const auto widthRatio = static_cast<float>(size.width) / desiredSize.width;
+
+  resizeRatio = std::max(heightRatio, widthRatio);
+  return {resizeRatio, top, left};
+}
+
+void computeRatioAndResize(cv::Mat &img, cv::Size size, int32_t modelHeight) {
+  auto ratio =
+      static_cast<double>(size.width) / static_cast<double>(size.height);
+  cv::Size resizedSize;
+  if (ratio < 1.0) {
+    resizedSize =
+        cv::Size(modelHeight, static_cast<int32_t>(modelHeight / ratio));
+  } else {
+    resizedSize =
+        cv::Size(static_cast<int32_t>(modelHeight * ratio), modelHeight);
+  }
+  cv::resize(img, img, resizedSize, 0.0, 0.0, cv::INTER_LANCZOS4);
+}
+
+cv::Mat cropImage(types::DetectorBBox box, cv::Mat &image,
+                  int32_t modelHeight) {
+  // Convert custom points to cv::Point2f
+  std::array<cv::Point2f, 4> points;
+#pragma unroll
+  for (std::size_t i = 0; i < points.size(); ++i) {
+    points[i] = cv::Point2f(box.bbox[i].x, box.bbox[i].y);
+  }
+
+  cv::RotatedRect rotatedRect = cv::minAreaRect(points);
+  cv::Point2f rectPoints[4];
+  rotatedRect.points(rectPoints);
+
+  // Rotate the image
+  cv::Point2f imageCenter(image.cols / 2.0f, image.rows / 2.0f);
+  cv::Mat rotationMatrix = cv::getRotationMatrix2D(imageCenter, box.angle, 1.0);
+  cv::Mat rotatedImage;
+  cv::warpAffine(image, rotatedImage, rotationMatrix, image.size(),
+                 cv::INTER_LINEAR);
+
+  constexpr int32_t rows = 4;
+  constexpr int32_t cols = 2;
+  cv::Mat rectMat(rows, cols, CV_32FC2);
+#pragma unroll
+  for (int32_t i = 0; i < rows; ++i) {
+    rectMat.at<cv::Vec2f>(i, 0) = cv::Vec2f(rectPoints[i].x, rectPoints[i].y);
+  }
+  cv::transform(rectMat, rectMat, rotationMatrix);
+
+  constexpr size_t transformedPointsSize = 4;
+  std::vector<cv::Point2f> transformedPoints(transformedPointsSize);
+#pragma unroll
+  for (std::size_t i = 0; i < transformedPointsSize; ++i) {
+    cv::Vec2f point = rectMat.at<cv::Vec2f>(i, 0);
+    transformedPoints[i] = cv::Point2f(point[0], point[1]);
+  }
+
+  cv::Rect boundingBox = cv::boundingRect(transformedPoints);
+
+  cv::Rect validRegion(0, 0, rotatedImage.cols, rotatedImage.rows);
+
+  boundingBox = boundingBox & validRegion; // OpenCV's built-in intersection
+
+  if (boundingBox.empty()) {
+    return {};
+  }
+
+  cv::Mat croppedImage = rotatedImage(boundingBox).clone();
+
+  computeRatioAndResize(croppedImage,
+                        cv::Size(boundingBox.width, boundingBox.height),
+                        modelHeight);
+
+  return croppedImage;
+}
+
+void adjustContrastGrey(cv::Mat &img, double target) {
+  constexpr double minValue = 0.0;
+  constexpr double maxValue = 255.0;
+
+  // calculate the brightest and the darkest point from the img
+  double highDouble;
+  double lowDouble;
+  cv::minMaxLoc(img, &lowDouble, &highDouble);
+  const auto low = static_cast<int32_t>(lowDouble);
+  const auto high = static_cast<int32_t>(highDouble);
+
+  double contrast = (highDouble - lowDouble) / maxValue;
+  if (contrast < target) {
+    constexpr double maxStretchIntensity = 200.0;
+    constexpr int32_t minRangeClamp = 10;
+    // Defines how much the contrast will actually stretch.
+    // Formula obtained empirically.
+    double ratio = maxStretchIntensity / std::max(minRangeClamp, high - low);
+    cv::Mat tempImg;
+    img.convertTo(tempImg, CV_32F);
+    constexpr int32_t histogramShift = 25;
+
+    tempImg -= (low - histogramShift);
+    tempImg *= ratio;
+
+    cv::threshold(tempImg, tempImg, maxValue, maxValue, cv::THRESH_TRUNC);
+    cv::threshold(tempImg, tempImg, minValue, maxValue, cv::THRESH_TOZERO);
+
+    tempImg.convertTo(img, CV_8U);
+  }
+}
+
+int32_t getDesiredWidth(const cv::Mat &img, bool isVertical) {
+
+  if (img.cols >= constants::kLargeRecognizerWidth) {
+    return constants::kLargeRecognizerWidth;
+  }
+  if (img.cols >= constants::kMediumRecognizerWidth) {
+    return constants::kMediumRecognizerWidth;
+  }
+  return isVertical ? constants::kSmallVerticalRecognizerWidth
+                    : constants::kSmallRecognizerWidth;
+}
+
+cv::Mat normalizeForRecognizer(const cv::Mat &image, int32_t modelHeight,
+                               double adjustContrast, bool isVertical) {
+  auto img = image.clone();
+  if (adjustContrast > 0.0) {
+    adjustContrastGrey(img, adjustContrast);
+  }
+
+  int32_t desiredWidth = getDesiredWidth(image, isVertical);
+
+  img =
+      image_processing::resizePadded(img, cv::Size(desiredWidth, modelHeight));
+  img.convertTo(img, CV_32F, 1.0f / 255.0f);
+  img -= 0.5f;
+  img *= 2.0f;
+  return img;
+}
+} // namespace rnexecutorch::models::ocr::utils

package/common/rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/ocr/Types.h>
+
+namespace rnexecutorch::models::ocr::utils {
+/**
+ * @brief Calculates the resize ratio and padding offsets needed to fit an image
+ *  into a target size while maintaining aspect ratio.
+ * @param size Original dimensions of the image.
+ * @param desiredSize Target size.
+ * @return Struct containing the scaling factor and top/left padding amounts for
+ * centering the image.
+ */
+types::PaddingInfo calculateResizeRatioAndPaddings(cv::Size size,
+                                                   cv::Size desiredSize);
+/**
+ * @brief Resizes an image proportionally to match a target height while
+ * maintaining aspect ratio.
+ * @param img Input/output image to resize.
+ * @param size Original dimensions of the image.
+ * @param modelHeight Target height for the output image.
+ */
+void computeRatioAndResize(cv::Mat &img, cv::Size size, int32_t modelHeight);
+/**
+ * @brief Crops and aligns a rotated bounding box region from an image, then
+ * resizes it to target height.
+ *
+ * Handles rotated boxes by:
+ * 1. Calculating minimum area rectangle around detected points
+ * 2. Rotating the entire image to align the box horizontally
+ * 3. Transforming the box coordinates to match the rotated image
+ * 4. Cropping the aligned region
+ *
+ * Resizing:
+ * - Maintains original aspect ratio while scaling to specified modelHeight
+ * - Uses high-quality interpolation for both rotation and resizing
+ *
+ * @param box Detected bounding box with rotation angle and corner points
+ * @param image Source image to crop from
+ * @param modelHeight Target height for output (width scales proportionally)
+ * @return Cropped, aligned and resized image region (empty if invalid box)
+ */
+cv::Mat cropImage(types::DetectorBBox box, cv::Mat &image, int32_t modelHeight);
+void adjustContrastGrey(cv::Mat &img, double target);
+/**
+ * @brief Prepares an image for recognition models by standardizing size,
+ * contrast, and pixel values.
+ *
+ * Performs the following processing pipeline:
+ * 1. Adjusts contrast (if coefficient > 0)
+ * 2. Resizes to target height while:
+ *    - Preserving aspect ratio (using padding if needed)
+ *    - Selecting width to match one of the Recognizer accepted
+ *      widths; (Large,Medium or Small RecognizerWidth)
+ * 3. Normalizes pixel values to [-1, 1] range (from [0,255] input)
+ *
+ * @param image Input image to process (any size, will be cloned)
+ * @param modelHeight Target output height in pixels
+ * @param adjustContrast Contrast adjustment coefficient (0.0 = no adjustment)
+ * @param isVertical Whether the image is in portrait orientation (affects width
+ * selection)
+ *
+ * @return Processed image with:
+ *   - Standardized dimensions (selected width × modelHeight)
+ *   - Adjusted contrast (if requested)
+ *   - Normalized float32 values in [-1, 1] range
+ */
+cv::Mat normalizeForRecognizer(const cv::Mat &image, int32_t modelHeight,
+                               double adjustContrast = 0.0,
+                               bool isVertical = false);
+} // namespace rnexecutorch::models::ocr::utils

package/common/rnexecutorch/models/ocr/utils/RecognizerUtils.cpp

@@ -0,0 +1,204 @@
+#include "RecognizerUtils.h"
+
+namespace rnexecutorch::models::ocr::utils {
+cv::Mat softmax(const cv::Mat &inputs) {
+  cv::Mat maxVal;
+  cv::reduce(inputs, maxVal, 1, cv::REDUCE_MAX, CV_32F);
+  cv::Mat expInputs;
+  cv::exp(inputs - cv::repeat(maxVal, 1, inputs.cols), expInputs);
+  cv::Mat sumExp;
+  cv::reduce(expInputs, sumExp, 1, cv::REDUCE_SUM, CV_32F);
+  cv::Mat softmaxOutput = expInputs / cv::repeat(sumExp, 1, inputs.cols);
+
+  return softmaxOutput;
+}
+
+std::vector<float> sumProbabilityRows(const cv::Mat &matrix) {
+  std::vector<float> sums;
+  sums.reserve(matrix.rows);
+  for (int32_t i = 0; i < matrix.rows; ++i) {
+    sums.push_back(cv::sum(matrix.row(i))[0]);
+  }
+  return sums;
+}
+
+void divideMatrixByRows(cv::Mat &matrix, const std::vector<float> &rowSums) {
+  for (int32_t i = 0; i < matrix.rows; ++i) {
+    matrix.row(i) /= rowSums[i];
+  }
+}
+
+types::ValuesAndIndices findMaxValuesIndices(const cv::Mat &mat) {
+  CV_Assert(mat.type() == CV_32F);
+  types::ValuesAndIndices result{};
+  result.values.reserve(mat.rows);
+  result.indices.reserve(mat.rows);
+
+  for (int32_t i = 0; i < mat.rows; ++i) {
+    double maxVal;
+    cv::Point maxLoc;
+    cv::minMaxLoc(mat.row(i), nullptr, &maxVal, nullptr, &maxLoc);
+    result.values.push_back(static_cast<float>(maxVal));
+    result.indices.push_back(maxLoc.x);
+  }
+
+  return result;
+}
+
+float confidenceScore(const std::vector<float> &values,
+                      const std::vector<int32_t> &indices) {
+  float product = 1.0f;
+  int32_t count = 0;
+
+  for (size_t i = 0; i < indices.size(); ++i) {
+    if (indices[i] != 0) {
+      product *= values[i];
+      count++;
+    }
+  }
+
+  if (count == 0) {
+    return 0.0f;
+  }
+
+  const float n = static_cast<float>(count);
+  const float exponent = 2.0f / std::sqrt(n);
+  return std::pow(product, exponent);
+}
+
+cv::Rect extractBoundingBox(std::array<types::Point, 4> &points) {
+  cv::Mat pointsMat(4, 1, CV_32FC2, points.data());
+  return cv::boundingRect(pointsMat);
+}
+
+cv::Mat characterBitMask(const cv::Mat &img) {
+  // 1. Determine if character is darker/lighter than background.
+  cv::Mat histogram;
+  int32_t histSize = 256;
+  float range[] = {0.0f, 256.0f};
+  const float *histRange = {range};
+  bool uniform = true;
+  bool accumulate = false;
+
+  cv::calcHist(&img, 1, 0, cv::Mat(), histogram, 1, &histSize, &histRange,
+               uniform, accumulate);
+
+  // Compare sum of darker (left half) vs brighter (right half) pixels.
+  const int32_t midPoint = histSize / 2;
+  double sumLeft = 0.0;
+  double sumRight = 0.0;
+  for (int32_t i = 0; i < midPoint; i++) {
+    sumLeft += histogram.at<float>(i);
+  }
+  for (int32_t i = midPoint; i < histSize; i++) {
+    sumRight += histogram.at<float>(i);
+  }
+  const int32_t thresholdType =
+      (sumLeft < sumRight) ? cv::THRESH_BINARY_INV : cv::THRESH_BINARY;
+
+  // 2. Binarize using Otsu's method (auto threshold).
+  cv::Mat thresh;
+  cv::threshold(img, thresh, 0, 255, thresholdType + cv::THRESH_OTSU);
+
+  // 3. Find the largest connected component near the center.
+  cv::Mat labels, stats, centroids;
+  const int32_t numLabels = cv::connectedComponentsWithStats(
+      thresh, labels, stats, centroids, 8, CV_32S);
+
+  const int32_t height = thresh.rows;
+  const int32_t width = thresh.cols;
+  const int32_t minX = constants::kSingleCharacterCenterThreshold * width;
+  const int32_t maxX = (1 - constants::kSingleCharacterCenterThreshold) * width;
+  const int32_t minY = constants::kSingleCharacterCenterThreshold * height;
+  const int32_t maxY =
+      (1 - constants::kSingleCharacterCenterThreshold) * height;
+
+  int32_t selectedComponent = -1;
+  int32_t maxArea = -1;
+  for (int32_t i = 1; i < numLabels; i++) { // Skip background (label 0)
+    const int32_t area = stats.at<int32_t>(i, cv::CC_STAT_AREA);
+    const double cx = centroids.at<double>(i, 0);
+    const double cy = centroids.at<double>(i, 1);
+
+    if ((minX < cx && cx < maxX && minY < cy &&
+         cy < maxY &&                                  // check if centered
+         area > constants::kSingleCharacterMinSize) && // check if large enough
+        area > maxArea) {
+      selectedComponent = i;
+      maxArea = area;
+    }
+  }
+  // 4. Extract the character and invert to white-on-black.
+  cv::Mat resultImage;
+  cv::Mat mask;
+  if (selectedComponent != -1) {
+    mask = (labels == selectedComponent);
+    img.copyTo(resultImage, mask);
+  } else {
+    resultImage = cv::Mat::zeros(img.size(), img.type());
+  }
+
+  cv::bitwise_not(resultImage, resultImage);
+
+  return resultImage;
+}
+
+cv::Mat
+cropImageWithBoundingBox(const cv::Mat &img,
+                         const std::array<types::Point, 4> &bbox,
+                         const std::array<types::Point, 4> &originalBbox,
+                         const types::PaddingInfo &paddings,
+                         const types::PaddingInfo &originalPaddings) {
+  if (originalBbox.empty()) {
+    throw std::runtime_error("Original bounding box cannot be empty.");
+  }
+  const types::Point topLeft = originalBbox[0];
+
+  std::vector<cv::Point2f> points;
+  points.reserve(bbox.size());
+
+  for (const auto &point : bbox) {
+    types::Point transformedPoint = point;
+
+    transformedPoint.x -= paddings.left;
+    transformedPoint.y -= paddings.top;
+
+    transformedPoint.x *= paddings.resizeRatio;
+    transformedPoint.y *= paddings.resizeRatio;
+
+    transformedPoint.x += topLeft.x;
+    transformedPoint.y += topLeft.y;
+
+    transformedPoint.x -= originalPaddings.left;
+    transformedPoint.y -= originalPaddings.top;
+
+    transformedPoint.x *= originalPaddings.resizeRatio;
+    transformedPoint.y *= originalPaddings.resizeRatio;
+
+    points.emplace_back(transformedPoint.x, transformedPoint.y);
+  }
+
+  cv::Rect rect = cv::boundingRect(points);
+  rect &= cv::Rect(0, 0, img.cols, img.rows);
+  if (rect.empty()) {
+    return {};
+  }
+  auto croppedImage = img(rect).clone();
+  return croppedImage;
+}
+
+cv::Mat prepareForRecognition(const cv::Mat &originalImage,
+                              const std::array<types::Point, 4> &bbox,
+                              const std::array<types::Point, 4> &originalBbox,
+                              const types::PaddingInfo &paddings,
+                              const types::PaddingInfo &originalPaddings) {
+  auto croppedChar = cropImageWithBoundingBox(originalImage, bbox, originalBbox,
+                                              paddings, originalPaddings);
+  cv::cvtColor(croppedChar, croppedChar, cv::COLOR_BGR2GRAY);
+  cv::resize(croppedChar, croppedChar,
+             cv::Size(constants::kSmallVerticalRecognizerWidth,
+                      constants::kRecognizerHeight),
+             0, 0, cv::INTER_AREA);
+  return croppedChar;
+}
+} // namespace rnexecutorch::models::ocr::utils

package/common/rnexecutorch/models/ocr/utils/RecognizerUtils.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include <array>
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/ocr/Constants.h>
+#include <rnexecutorch/models/ocr/Types.h>
+#include <vector>
+
+namespace rnexecutorch::models::ocr::utils {
+/**
+ * @brief Computes per row softmax funcion.
+ * Formula: softmax(x_i) = exp(x_i - max(x)) / sum(exp(x_j - max(x))) for each
+ * row.
+ */
+cv::Mat softmax(const cv::Mat &inputs);
+
+/**
+ * @brief For each row of matrix computes {maxValue, index} pair. Returns a list
+ * of maxValues and a list of corresponding indices.
+ */
+types::ValuesAndIndices findMaxValuesIndices(const cv::Mat &mat);
+std::vector<float> sumProbabilityRows(const cv::Mat &matrix);
+void divideMatrixByRows(cv::Mat &matrix, const std::vector<float> &rowSums);
+cv::Rect extractBoundingBox(std::array<types::Point, 4> &points);
+
+/**
+ * @brief Computes confidence score for given values and indices vectors.
+ * Omits blank tokens.
+ * Formula: pow(\prod_{i=1}^{n}(p_i), 2/sqrt(n)), where n is a number of
+ * non-blank tokens, and p_i is the probability of i-th non-blank token.
+ * @details Formula derived from line 14 of
+ * https://github.com/JaidedAI/EasyOCR/blob/c4f3cd7225efd4f85451bd8b4a7646ae9a092420/easyocr/recognition.py#L14
+ * @details 'Some say that it's a code, sent to us from god'
+ */
+float confidenceScore(const std::vector<float> &values,
+                      const std::vector<int32_t> &indices);
+
+cv::Mat characterBitMask(const cv::Mat &img);
+
+/**
+ * @brief Perform cropping of an image to a single character detector box.
+ * This function utilizes info about external bounding box and padding combined
+ * with internal bounding box and padding.
+ * It does so to preserve the best possible image quality.
+ */
+cv::Mat
+cropImageWithBoundingBox(const cv::Mat &img,
+                         const std::array<types::Point, 4> &bbox,
+                         const std::array<types::Point, 4> &originalBbox,
+                         const types::PaddingInfo &paddings,
+                         const types::PaddingInfo &originalPaddings);
+
+/**
+ * @brief Perform cropping, resizing and convert to grayscale to prepare image
+ * for Recognizer.
+ *
+ * Prepare for Recognition by following steps:
+ * 1. Crop image to the character bounding box,
+ * 2. Convert Image to gray.
+ * 3. Resize it to [kSmallVerticalRecognizerWidth x kRecognizerHeight] (64 x
+ * 64).
+ *
+ * @details it utilizes cropImageWithBoundingBox to perform specific cropping.
+ */
+
+cv::Mat prepareForRecognition(const cv::Mat &originalImage,
+                              const std::array<types::Point, 4> &bbox,
+                              const std::array<types::Point, 4> &originalBbox,
+                              const types::PaddingInfo &paddings,
+                              const types::PaddingInfo &originalPaddings);
+} // namespace rnexecutorch::models::ocr::utils