react-native-executorch 0.4.8 → 0.5.0

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

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/ocr/Types.h>
+#include <span>
+
+namespace rnexecutorch::ocr {
+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<DetectorBBox> getDetBoxesFromTextMap(cv::Mat &textMap,
+                                                 cv::Mat &affinityMap,
+                                                 float textThreshold,
+                                                 float linkThreshold,
+                                                 float lowTextThreshold);
+std::vector<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<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<DetectorBBox>
+groupTextBoxes(std::vector<DetectorBBox> &boxes, float centerThreshold,
+               float distanceThreshold, float heightThreshold,
+               int32_t minSideThreshold, int32_t maxSideThreshold,
+               int32_t maxWidth);
+} // namespace rnexecutorch::ocr

package/common/rnexecutorch/models/ocr/OCR.cpp

@@ -0,0 +1,52 @@
+#include "OCR.h"
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/models/ocr/Constants.h>
+
+namespace rnexecutorch {
+OCR::OCR(const std::string &detectorSource,
+         const std::string &recognizerSourceLarge,
+         const std::string &recognizerSourceMedium,
+         const std::string &recognizerSourceSmall, std::string symbols,
+         std::shared_ptr<react::CallInvoker> callInvoker)
+    : detector(detectorSource, callInvoker),
+      recognitionHandler(recognizerSourceLarge, recognizerSourceMedium,
+                         recognizerSourceSmall, symbols, callInvoker) {}
+
+std::vector<OCRDetection> OCR::generate(std::string input) {
+  cv::Mat image = imageprocessing::readImage(input);
+  if (image.empty()) {
+    throw std::runtime_error("Failed to load image from path: " + input);
+  }
+
+  /*
+   1. Detection process returns the list of bounding boxes containing areas
+   with text. They are corresponding to the image of size 1280x1280, which
+   is a size later used by Recognition Handler.
+  */
+  std::vector<ocr::DetectorBBox> bboxesList = detector.generate(image);
+  cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
+
+  /*
+   Recognition Handler is responsible for deciding which Recognition model to
+   use for each box. It returns the list of tuples; each consisting of:
+    - recognized text
+    - coordinates of bounding box corresponding to the original image size
+    - confidence score
+  */
+  std::vector<OCRDetection> result = recognitionHandler.recognize(
+      bboxesList, image,
+      cv::Size(ocr::RECOGNIZER_IMAGE_SIZE, ocr::RECOGNIZER_IMAGE_SIZE));
+
+  return result;
+}
+
+std::size_t OCR::getMemoryLowerBound() const noexcept {
+  return detector.getMemoryLowerBound() +
+         recognitionHandler.getMemoryLowerBound();
+}
+
+void OCR::unload() noexcept {
+  detector.unload();
+  recognitionHandler.unload();
+}
+} // namespace rnexecutorch

package/common/rnexecutorch/models/ocr/OCR.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <rnexecutorch/models/ocr/Detector.h>
+#include <rnexecutorch/models/ocr/RecognitionHandler.h>
+#include <rnexecutorch/models/ocr/Types.h>
+#include <string>
+#include <vector>
+
+namespace rnexecutorch {
+/*
+ The OCR consists of two phases:
+ 1. Detection - detecting text regions in the image, the result of this phase
+ is a list of bounding boxes.
+ 2. Recognition - recognizing the text in the bounding boxes, the result is a
+ list of strings and corresponding boxes & confidence scores.
+
+ Recognition uses three models, each model is resposible for recognizing text
+ of different sizes (e.g. large - 512x64, medium - 256x64, small - 128x64).
+*/
+
+class OCR final {
+public:
+  explicit OCR(const std::string &detectorSource,
+               const std::string &recognizerSourceLarge,
+               const std::string &recognizerSourceMedium,
+               const std::string &recognizerSourceSmall, std::string symbols,
+               std::shared_ptr<react::CallInvoker> callInvoker);
+  std::vector<OCRDetection> generate(std::string input);
+  std::size_t getMemoryLowerBound() const noexcept;
+  void unload() noexcept;
+
+private:
+  Detector detector;
+  RecognitionHandler recognitionHandler;
+};
+} // namespace rnexecutorch

package/common/rnexecutorch/models/ocr/RecognitionHandler.cpp

@@ -0,0 +1,107 @@
+#include "RecognitionHandler.h"
+#include "RecognitionHandlerUtils.h"
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/models/ocr/Constants.h>
+#include <rnexecutorch/models/ocr/RecognitionHandlerUtils.h>
+
+namespace rnexecutorch {
+RecognitionHandler::RecognitionHandler(
+    const std::string &recognizerSourceLarge,
+    const std::string &recognizerSourceMedium,
+    const std::string &recognizerSourceSmall, std::string symbols,
+    std::shared_ptr<react::CallInvoker> callInvoker)
+    : converter(symbols), recognizerLarge(recognizerSourceLarge, callInvoker),
+      recognizerMedium(recognizerSourceMedium, callInvoker),
+      recognizerSmall(recognizerSourceSmall, callInvoker) {
+  memorySizeLowerBound = recognizerSmall.getMemoryLowerBound() +
+                         recognizerMedium.getMemoryLowerBound() +
+                         recognizerLarge.getMemoryLowerBound();
+}
+
+std::pair<std::vector<int32_t>, float>
+RecognitionHandler::runModel(cv::Mat image) {
+
+  // Note that the height of an  image is always equal to 64.
+  if (image.cols >= ocr::LARGE_RECOGNIZER_WIDTH) {
+    return recognizerLarge.generate(image);
+  }
+  if (image.cols >= ocr::MEDIUM_RECOGNIZER_WIDTH) {
+    return recognizerMedium.generate(image);
+  }
+  return recognizerSmall.generate(image);
+}
+
+void RecognitionHandler::processBBox(std::vector<OCRDetection> &boxList,
+                                     ocr::DetectorBBox &box, cv::Mat &imgGray,
+                                     ocr::PaddingInfo ratioAndPadding) {
+
+  /*
+    Resize the cropped image to have height = 64 (height accepted by
+    Recognizer).
+  */
+  auto croppedImage = ocr::cropImage(box, imgGray, ocr::RECOGNIZER_HEIGHT);
+
+  if (croppedImage.empty()) {
+    return;
+  }
+
+  /*
+    Cropped image is resized into the closest of on of three:
+    128x64, 256x64, 512x64.
+  */
+  croppedImage = ocr::normalizeForRecognizer(
+      croppedImage, ocr::RECOGNIZER_HEIGHT, ocr::ADJUST_CONTRAST, false);
+
+  auto [predictionIndices, confidenceScore] = this->runModel(croppedImage);
+  if (confidenceScore < ocr::LOW_CONFIDENCE_THRESHOLD) {
+    cv::rotate(croppedImage, croppedImage, cv::ROTATE_180);
+    auto [rotatedPredictionIndices, rotatedConfidenceScore] =
+        runModel(croppedImage);
+    if (rotatedConfidenceScore > confidenceScore) {
+      confidenceScore = rotatedConfidenceScore;
+      predictionIndices = rotatedPredictionIndices;
+    }
+  }
+  /*
+    Since the boxes were corresponding to the image resized to 1280x1280,
+    we want to return the boxes shifted and rescaled to match the original
+    image dimensions.
+  */
+  for (auto &point : box.bbox) {
+    point.x = (point.x - ratioAndPadding.left) * ratioAndPadding.resizeRatio;
+    point.y = (point.y - ratioAndPadding.top) * ratioAndPadding.resizeRatio;
+  }
+  boxList.emplace_back(
+      box.bbox,
+      converter.decodeGreedy(predictionIndices, predictionIndices.size())[0],
+      confidenceScore);
+}
+
+std::vector<OCRDetection>
+RecognitionHandler::recognize(std::vector<ocr::DetectorBBox> bboxesList,
+                              cv::Mat &imgGray, cv::Size desiredSize) {
+  /*
+   Recognition Handler accepts bboxesList corresponding to size
+   1280x1280, which is desiredSize.
+  */
+  ocr::PaddingInfo ratioAndPadding =
+      ocr::calculateResizeRatioAndPaddings(imgGray.size(), desiredSize);
+  imgGray = imageprocessing::resizePadded(imgGray, desiredSize);
+
+  std::vector<OCRDetection> result = {};
+  for (auto &box : bboxesList) {
+    processBBox(result, box, imgGray, ratioAndPadding);
+  }
+  return result;
+}
+
+std::size_t RecognitionHandler::getMemoryLowerBound() const noexcept {
+  return memorySizeLowerBound;
+}
+
+void RecognitionHandler::unload() noexcept {
+  recognizerSmall.unload();
+  recognizerMedium.unload();
+  recognizerLarge.unload();
+}
+} // namespace rnexecutorch

package/common/rnexecutorch/models/ocr/RecognitionHandler.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/ocr/CTCLabelConverter.h>
+#include <rnexecutorch/models/ocr/Recognizer.h>
+#include <rnexecutorch/models/ocr/Types.h>
+#include <string>
+#include <vector>
+
+namespace rnexecutorch {
+/*
+ Recogntion Handler is responsible for:
+ 1. Preparing the image to be processed by Recognition Model.
+ 2. Deciding which Recogntion Model is used for each detected bounding box.
+ 3. Returning the list of tuples (box, text, confidence) to the OCR class.
+*/
+
+class RecognitionHandler final {
+public:
+  explicit RecognitionHandler(const std::string &recognizerSourceLarge,
+                              const std::string &recognizerSourceMedium,
+                              const std::string &recognizerSourceSmall,
+                              std::string symbols,
+                              std::shared_ptr<react::CallInvoker> callInvoker);
+  std::vector<OCRDetection> recognize(std::vector<ocr::DetectorBBox> bboxesList,
+                                      cv::Mat &imgGray, cv::Size desiredSize);
+  void unload() noexcept;
+  std::size_t getMemoryLowerBound() const noexcept;
+
+private:
+  std::pair<std::vector<int32_t>, float> runModel(cv::Mat image);
+  void processBBox(std::vector<OCRDetection> &boxList, ocr::DetectorBBox &box,
+                   cv::Mat &imgGray, ocr::PaddingInfo ratioAndPadding);
+  std::size_t memorySizeLowerBound{0};
+  ocr::CTCLabelConverter converter;
+  Recognizer recognizerLarge;
+  Recognizer recognizerMedium;
+  Recognizer recognizerSmall;
+};
+} // namespace rnexecutorch

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

@@ -0,0 +1,153 @@
+#include "RecognitionHandlerUtils.h"
+#include <algorithm>
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/models/ocr/Constants.h>
+
+namespace rnexecutorch::ocr {
+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(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);
+
+  cv::Mat rectMat(4, 2, CV_32FC2);
+#pragma unroll
+  for (int32_t i = 0; i < rectMat.rows; ++i) {
+    rectMat.at<cv::Vec2f>(i, 0) = cv::Vec2f(rectPoints[i].x, rectPoints[i].y);
+  }
+  cv::transform(rectMat, rectMat, rotationMatrix);
+
+  std::vector<cv::Point2f> transformedPoints(4);
+#pragma unroll
+  for (std::size_t i = 0; i < transformedPoints.size(); ++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 >= LARGE_RECOGNIZER_WIDTH) {
+    return LARGE_RECOGNIZER_WIDTH;
+  }
+  if (img.cols >= MEDIUM_RECOGNIZER_WIDTH) {
+    return MEDIUM_RECOGNIZER_WIDTH;
+  }
+  return isVertical ? SMALL_VERTICAL_RECOGNIZER_WIDTH : SMALL_RECOGNIZER_WIDTH;
+}
+
+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 = imageprocessing::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::ocr

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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/ocr/Types.h>
+
+namespace rnexecutorch::ocr {
+/**
+ * @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.
+ */
+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(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::ocr

package/common/rnexecutorch/models/ocr/Recognizer.cpp

@@ -0,0 +1,80 @@
+#include "Recognizer.h"
+#include <numeric>
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/data_processing/Numerical.h>
+#include <rnexecutorch/models/ocr/Constants.h>
+#include <rnexecutorch/models/ocr/RecognizerUtils.h>
+#include <rnexecutorch/models/ocr/Types.h>
+
+namespace rnexecutorch {
+Recognizer::Recognizer(const std::string &modelSource,
+                       std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto inputShapes = getAllInputShapes();
+  if (inputShapes.empty()) {
+    throw std::runtime_error("Recognizer model has no input tensors.");
+  }
+  std::vector<int32_t> modelInputShape = inputShapes[0];
+  if (modelInputShape.size() < 2) {
+    throw std::runtime_error("Unexpected Recognizer model input shape.");
+  }
+  modelImageSize = cv::Size(modelInputShape[modelInputShape.size() - 1],
+                            modelInputShape[modelInputShape.size() - 2]);
+}
+
+std::pair<std::vector<int32_t>, float>
+Recognizer::generate(const cv::Mat &grayImage) {
+  /*
+   In our pipeline we use three types of Recognizer, each designated to
+   handle different image sizes:
+   - Small Recognizer - 128 x 64
+   - Medium Recognizer - 256 x 64
+   - Large Recognizer - 512 x 64
+   The `generate` function as an argument accepts an image in grayscale
+   already resized to the expected size.
+  */
+  std::vector<int32_t> tensorDims = getAllInputShapes()[0];
+  TensorPtr inputTensor =
+      imageprocessing::getTensorFromMatrixGray(tensorDims, grayImage);
+  auto forwardResult = BaseModel::forward(inputTensor);
+  if (!forwardResult.ok()) {
+    throw std::runtime_error(
+        "Failed to forward in Recognizer, error: " +
+        std::to_string(static_cast<uint32_t>(forwardResult.error())));
+  }
+
+  return postprocess(forwardResult->at(0).toTensor());
+}
+
+std::pair<std::vector<int32_t>, float>
+Recognizer::postprocess(const Tensor &tensor) const {
+  /*
+   Raw model returns a tensor with dimensions [ 1 x seqLen x alphabetSize ]
+  where:
+
+    - seqLen is the length of predicted sequence. It is constant for the model.
+   For our models it is:
+     - 31 for Small Recognizer
+     - 63 for Medium Recognizer
+     - 127 for Large Recognizer
+    Remember that usually many tokens of predicted sequences are blank, meaning
+   the predicted text is not of const size.
+
+    - alphabetSize is the length of considered alphabet. It is constant for the
+   model. Usually depends on language, e.g. for our models for english it is 97,
+   for polish it is 357 etc.
+
+  Each value of returned tensor corresponds to character logits.
+  */
+  const int32_t alphabetSize = tensor.size(2);
+  const int32_t numRows = tensor.numel() / alphabetSize;
+
+  cv::Mat resultMat(numRows, alphabetSize, CV_32F,
+                    tensor.mutable_data_ptr<float>());
+
+  auto probabilities = ocr::softmax(resultMat);
+  auto [maxVal, maxIndices] = ocr::findMaxValuesIndices(probabilities);
+  float confidence = ocr::confidenceScore(maxVal, maxIndices);
+  return {maxIndices, confidence};
+}
+} // namespace rnexecutorch

package/common/rnexecutorch/models/ocr/Recognizer.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <executorch/extension/tensor/tensor_ptr.h>
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/BaseModel.h>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace rnexecutorch {
+/*
+ Recognizer is a model responsible for interpreting detected text regions
+ into characters/words.
+
+ The model used as Recognizer is based on CRNN paper.
+ https://arxiv.org/pdf/1507.05717
+
+ It returns the list of predicted indices and a confidence value.
+*/
+
+using executorch::aten::Tensor;
+using executorch::extension::TensorPtr;
+
+class Recognizer final : public BaseModel {
+public:
+  explicit Recognizer(const std::string &modelSource,
+                      std::shared_ptr<react::CallInvoker> callInvoker);
+  std::pair<std::vector<int32_t>, float> generate(const cv::Mat &grayImage);
+
+private:
+  std::pair<std::vector<int32_t>, float>
+  postprocess(const Tensor &tensor) const;
+
+  cv::Size modelImageSize;
+};
+} // namespace rnexecutorch