react-native-executorch 0.5.1 → 0.5.3

package/common/rnexecutorch/models/object_detection/ObjectDetection.cpp

@@ -2,7 +2,7 @@
 
 #include <rnexecutorch/data_processing/ImageProcessing.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::object_detection {
 
 ObjectDetection::ObjectDetection(
     const std::string &modelSource,
@@ -25,7 +25,7 @@ ObjectDetection::ObjectDetection(
                             modelInputShape[modelInputShape.size() - 2]);
 }
 
-std::vector<Detection>
+std::vector<types::Detection>
 ObjectDetection::postprocess(const std::vector<EValue> &tensors,
                              cv::Size originalSize, double detectionThreshold) {
   float widthRatio =
@@ -33,7 +33,7 @@ ObjectDetection::postprocess(const std::vector<EValue> &tensors,
   float heightRatio =
       static_cast<float>(originalSize.height) / modelImageSize.height;
 
-  std::vector<Detection> detections;
+  std::vector<types::Detection> detections;
   auto bboxTensor = tensors.at(0).toTensor();
   std::span<const float> bboxes(
       static_cast<const float *>(bboxTensor.const_data_ptr()),
@@ -61,14 +61,14 @@ ObjectDetection::postprocess(const std::vector<EValue> &tensors,
                             scores[i]);
   }
 
-  std::vector<Detection> output = nonMaxSuppression(detections);
+  std::vector<types::Detection> output = utils::nonMaxSuppression(detections);
   return output;
 }
 
-std::vector<Detection> ObjectDetection::generate(std::string imageSource,
-                                                 double detectionThreshold) {
+std::vector<types::Detection>
+ObjectDetection::generate(std::string imageSource, double detectionThreshold) {
   auto [inputTensor, originalSize] =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
 
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -79,4 +79,4 @@ std::vector<Detection> ObjectDetection::generate(std::string imageSource,
 
   return postprocess(forwardResult.get(), originalSize, detectionThreshold);
 }
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::object_detection

package/common/rnexecutorch/models/object_detection/ObjectDetection.h

@@ -6,10 +6,13 @@
 #include <executorch/runtime/core/evalue.h>
 #include <opencv2/opencv.hpp>
 
+#include "Types.h"
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/BaseModel.h>
 #include <rnexecutorch/models/object_detection/Utils.h>
 
 namespace rnexecutorch {
+namespace models::object_detection {
 using executorch::extension::TensorPtr;
 using executorch::runtime::EValue;
 
@@ -17,15 +20,18 @@ class ObjectDetection : public BaseModel {
 public:
   ObjectDetection(const std::string &modelSource,
                   std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<Detection> generate(std::string imageSource,
-                                  double detectionThreshold);
+  std::vector<types::Detection> generate(std::string imageSource,
+                                         double detectionThreshold);
 
 private:
-  std::vector<Detection> postprocess(const std::vector<EValue> &tensors,
-                                     cv::Size originalSize,
-                                     double detectionThreshold);
+  std::vector<types::Detection> postprocess(const std::vector<EValue> &tensors,
+                                            cv::Size originalSize,
+                                            double detectionThreshold);
 
   cv::Size modelImageSize{0, 0};
 };
+} // namespace models::object_detection
 
+REGISTER_CONSTRUCTOR(models::object_detection::ObjectDetection, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/object_detection/Types.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace rnexecutorch::models::object_detection::types {
+struct Detection {
+  float x1;
+  float y1;
+  float x2;
+  float y2;
+  int label;
+  float score;
+};
+
+} // namespace rnexecutorch::models::object_detection::types

package/common/rnexecutorch/models/object_detection/Utils.cpp

@@ -1,8 +1,9 @@
 #include "Utils.h"
 #include "Constants.h"
 
-namespace rnexecutorch {
-float intersectionOverUnion(const Detection &a, const Detection &b) {
+namespace rnexecutorch::models::object_detection::utils {
+float intersectionOverUnion(const types::Detection &a,
+                            const types::Detection &b) {
   float x1 = std::max(a.x1, b.x1);
   float y1 = std::max(a.y1, b.y1);
   float x2 = std::min(a.x2, b.x2);
@@ -16,40 +17,41 @@ float intersectionOverUnion(const Detection &a, const Detection &b) {
   return intersectionArea / unionArea;
 }
 
-std::vector<Detection> nonMaxSuppression(std::vector<Detection> detections) {
+std::vector<types::Detection>
+nonMaxSuppression(std::vector<types::Detection> detections) {
   if (detections.empty()) {
     return {};
   }
 
   // Sort by label, then by score
   std::sort(detections.begin(), detections.end(),
-            [](const Detection &a, const Detection &b) {
+            [](const types::Detection &a, const types::Detection &b) {
               if (a.label == b.label) {
                 return a.score > b.score;
               }
               return a.label < b.label;
             });
 
-  std::vector<Detection> result;
+  std::vector<types::Detection> result;
   // Apply NMS for each label
   for (size_t i = 0; i < detections.size();) {
     float currentLabel = detections[i].label;
 
-    std::vector<Detection> labelDetections;
+    std::vector<types::Detection> labelDetections;
     while (i < detections.size() && detections[i].label == currentLabel) {
       labelDetections.push_back(detections[i]);
       ++i;
     }
 
-    std::vector<Detection> filteredLabelDetections;
+    std::vector<types::Detection> filteredLabelDetections;
     while (!labelDetections.empty()) {
-      Detection current = labelDetections.front();
+      types::Detection current = labelDetections.front();
       filteredLabelDetections.push_back(current);
       labelDetections.erase(
           std::remove_if(labelDetections.begin(), labelDetections.end(),
-                         [&current](const Detection &other) {
+                         [&current](const types::Detection &other) {
                            return intersectionOverUnion(current, other) >
-                                  IOU_THRESHOLD;
+                                  constants::IOU_THRESHOLD;
                          }),
           labelDetections.end());
     }
@@ -59,4 +61,4 @@ std::vector<Detection> nonMaxSuppression(std::vector<Detection> detections) {
   return result;
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::object_detection::utils

package/common/rnexecutorch/models/object_detection/Utils.h

@@ -1,17 +1,11 @@
 #pragma once
 
+#include "Types.h"
 #include <vector>
 
-namespace rnexecutorch {
-struct Detection {
-  float x1;
-  float y1;
-  float x2;
-  float y2;
-  int label;
-  float score;
-};
-
-float intersectionOverUnion(const Detection &a, const Detection &b);
-std::vector<Detection> nonMaxSuppression(std::vector<Detection> detections);
-} // namespace rnexecutorch
+namespace rnexecutorch::models::object_detection::utils {
+float intersectionOverUnion(const types::Detection &a,
+                            const types::Detection &b);
+std::vector<types::Detection>
+nonMaxSuppression(std::vector<types::Detection> detections);
+} // namespace rnexecutorch::models::object_detection::utils

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

@@ -2,7 +2,7 @@
 #include <algorithm>
 #include <optional>
 
-namespace rnexecutorch::ocr {
+namespace rnexecutorch::models::ocr {
 CTCLabelConverter::CTCLabelConverter(const std::string &characters)
     : ignoreIdx(0),
       character({"[blank]"}) // blank character is ignored character (index 0).
@@ -85,4 +85,4 @@ CTCLabelConverter::decodeGreedy(const std::vector<int32_t> &textIndex,
 
   return texts;
 }
-} // namespace rnexecutorch::ocr
+} // namespace rnexecutorch::models::ocr

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

@@ -3,7 +3,7 @@
 #include <string>
 #include <vector>
 
-namespace rnexecutorch::ocr {
+namespace rnexecutorch::models::ocr {
 /*
  CTC (Connectionist Temporal Classification) Label Converter
  is used for decoding the returned list of indices by Recognizer into
@@ -26,4 +26,4 @@ private:
   std::vector<std::string> character;
   int32_t ignoreIdx;
 };
-} // namespace rnexecutorch::ocr
+} // namespace rnexecutorch::models::ocr

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

@@ -3,32 +3,39 @@
 #include <cstdint>
 #include <opencv2/opencv.hpp>
 
-namespace rnexecutorch::ocr {
+namespace rnexecutorch::models::ocr::constants {
 
-inline constexpr float TEXT_THRESHOLD = 0.4;
-inline constexpr float TEXT_THRESHOLD_VERTICAL = 0.3;
-inline constexpr float LINK_THRESHOLD = 0.4;
-inline constexpr float LOW_TEXT_THRESHOLD = 0.7;
-inline constexpr float CENTER_THRESHOLD = 0.5;
-inline constexpr float DISTANCE_THRESHOLD = 2.0;
-inline constexpr float HEIGHT_THRESHOLD = 2.0;
-inline constexpr float SINGLE_CHARACTER_CENTER_THRESHOLD = 0.3;
-inline constexpr float LOW_CONFIDENCE_THRESHOLD = 0.3;
-inline constexpr float ADJUST_CONTRAST = 0.2;
-inline constexpr int32_t MIN_SIDE_THRESHOLD = 15;
-inline constexpr int32_t MAX_SIDE_THRESHOLD = 30;
-inline constexpr int32_t RECOGNIZER_HEIGHT = 64;
-inline constexpr int32_t LARGE_RECOGNIZER_WIDTH = 512;
-inline constexpr int32_t MEDIUM_RECOGNIZER_WIDTH = 256;
-inline constexpr int32_t SMALL_RECOGNIZER_WIDTH = 128;
-inline constexpr int32_t SMALL_VERTICAL_RECOGNIZER_WIDTH = 64;
-inline constexpr int32_t MAX_WIDTH =
-    LARGE_RECOGNIZER_WIDTH + (LARGE_RECOGNIZER_WIDTH * 0.15);
-inline constexpr int32_t SINGLE_CHARACTER_MIN_SIZE = 70;
-inline constexpr int32_t RECOGNIZER_IMAGE_SIZE = 1280;
-inline constexpr int32_t VERTICAL_LINE_THRESHOLD = 20;
+inline constexpr float kTextThreshold = 0.4;
+inline constexpr float kTextThresholdVertical = 0.3;
+inline constexpr float kLinkThreshold = 0.4;
+inline constexpr float kLowTextThreshold = 0.7;
+inline constexpr float kCenterThreshold = 0.5;
+inline constexpr float kDistanceThreshold = 2.0;
+inline constexpr float kHeightThreshold = 2.0;
+inline constexpr float kSingleCharacterCenterThreshold = 0.3;
+inline constexpr float kLowConfidenceThreshold = 0.3;
+inline constexpr float kAdjustContrast = 0.2;
+inline constexpr int32_t kMinSideThreshold = 15;
+inline constexpr int32_t kMaxSideThreshold = 30;
+inline constexpr int32_t kRecognizerHeight = 64;
+inline constexpr int32_t kLargeRecognizerWidth = 512;
+inline constexpr int32_t kMediumRecognizerWidth = 256;
+inline constexpr int32_t kSmallRecognizerWidth = 128;
+inline constexpr int32_t kSmallVerticalRecognizerWidth = 64;
+inline constexpr int32_t kMaxWidth =
+    kLargeRecognizerWidth + (kLargeRecognizerWidth * 0.15);
+inline constexpr int32_t kSingleCharacterMinSize = 70;
+inline constexpr int32_t kRecognizerImageSize = 1280;
+inline constexpr int32_t kVerticalLineThreshold = 20;
 
-inline const cv::Scalar MEAN(0.485, 0.456, 0.406);
-inline const cv::Scalar VARIANCE(0.229, 0.224, 0.225);
+/*
+ Mean and variance values for image normalization were used in EASYOCR pipeline
+ (see
+ https://github.com/JaidedAI/EasyOCR/blob/c4f3cd7225efd4f85451bd8b4a7646ae9a092420/easyocr/imgproc.py#L20)
+ but they originate from ImageNet dataset and they are widely use in
+ ComputerVision preprocessing.
+*/
+inline const cv::Scalar kNormalizationMean(0.485, 0.456, 0.406);
+inline const cv::Scalar kNormalizationVariance(0.229, 0.224, 0.225);
 
-} // namespace rnexecutorch::ocr
+} // namespace rnexecutorch::models::ocr::constants

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

@@ -1,9 +1,9 @@
 #include "Detector.h"
 #include <rnexecutorch/data_processing/ImageProcessing.h>
 #include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/DetectorUtils.h>
+#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 Detector::Detector(const std::string &modelSource,
                    std::shared_ptr<react::CallInvoker> callInvoker)
     : BaseModel(modelSource, callInvoker) {
@@ -24,7 +24,7 @@ Detector::Detector(const std::string &modelSource,
 
 cv::Size Detector::getModelImageSize() const noexcept { return modelImageSize; }
 
-std::vector<ocr::DetectorBBox> Detector::generate(const cv::Mat &inputImage) {
+std::vector<types::DetectorBBox> Detector::generate(const cv::Mat &inputImage) {
   /*
    Detector as an input accepts tensor with a shape of [1, 3, H, H].
    where H is a constant for model. In our supported models it is currently
@@ -34,9 +34,10 @@ std::vector<ocr::DetectorBBox> Detector::generate(const cv::Mat &inputImage) {
    */
   auto inputShapes = getAllInputShapes();
   cv::Mat resizedInputImage =
-      imageprocessing::resizePadded(inputImage, getModelImageSize());
-  TensorPtr inputTensor = imageprocessing::getTensorFromMatrix(
-      inputShapes[0], resizedInputImage, ocr::MEAN, ocr::VARIANCE);
+      image_processing::resizePadded(inputImage, getModelImageSize());
+  TensorPtr inputTensor = image_processing::getTensorFromMatrix(
+      inputShapes[0], resizedInputImage, constants::kNormalizationMean,
+      constants::kNormalizationVariance);
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
     throw std::runtime_error(
@@ -47,7 +48,7 @@ std::vector<ocr::DetectorBBox> Detector::generate(const cv::Mat &inputImage) {
   return postprocess(forwardResult->at(0).toTensor());
 }
 
-std::vector<ocr::DetectorBBox>
+std::vector<types::DetectorBBox>
 Detector::postprocess(const Tensor &tensor) const {
   /*
    The output of the model consists of two matrices (heat maps):
@@ -62,19 +63,16 @@ Detector::postprocess(const Tensor &tensor) const {
    The output of the model is a matrix half the size of the input image
    containing two channels representing the heatmaps.
    */
-  auto [scoreTextMat, scoreAffinityMat] = ocr::interleavedArrayToMats(
+  auto [scoreTextMat, scoreAffinityMat] = utils::interleavedArrayToMats(
       tensorData,
       cv::Size(modelImageSize.width / 2, modelImageSize.height / 2));
 
   /*
    Heatmaps are then converted into list of bounding boxes.
-   Too see how it is achieved see the description of this function in
-   the DetectorUtils.h source file and the implementation in the
-   DetectorUtils.cpp.
   */
-  std::vector<ocr::DetectorBBox> bBoxesList = ocr::getDetBoxesFromTextMap(
-      scoreTextMat, scoreAffinityMat, ocr::TEXT_THRESHOLD, ocr::LINK_THRESHOLD,
-      ocr::LOW_TEXT_THRESHOLD);
+  std::vector<types::DetectorBBox> bBoxesList = utils::getDetBoxesFromTextMap(
+      scoreTextMat, scoreAffinityMat, constants::kTextThreshold,
+      constants::kLinkThreshold, constants::kLowTextThreshold);
 
   /*
    Bounding boxes are at first corresponding to the 400x400 size or 640x640.
@@ -82,21 +80,21 @@ Detector::postprocess(const Tensor &tensor) const {
    1280x1280. To match this difference we has to scale  by the proper factor
    (3.2 or 2.0).
   */
-  const float restoreRatio =
-      ocr::calculateRestoreRatio(scoreTextMat.rows, ocr::RECOGNIZER_IMAGE_SIZE);
-  ocr::restoreBboxRatio(bBoxesList, restoreRatio);
+  const float restoreRatio = utils::calculateRestoreRatio(
+      scoreTextMat.rows, constants::kRecognizerImageSize);
+  utils::restoreBboxRatio(bBoxesList, restoreRatio);
   /*
    Since every bounding box is processed separately by Recognition models, we'd
    like to reduce the number of boxes. Also, grouping nearby boxes means we
    process many words / full line at once. It is not only faster but also easier
    for Recognizer models than recognition of single characters.
   */
-  bBoxesList = ocr::groupTextBoxes(
-      bBoxesList, ocr::CENTER_THRESHOLD, ocr::DISTANCE_THRESHOLD,
-      ocr::HEIGHT_THRESHOLD, ocr::MIN_SIDE_THRESHOLD, ocr::MAX_SIDE_THRESHOLD,
-      ocr::MAX_WIDTH);
+  bBoxesList = utils::groupTextBoxes(
+      bBoxesList, constants::kCenterThreshold, constants::kDistanceThreshold,
+      constants::kHeightThreshold, constants::kMinSideThreshold,
+      constants::kMaxSideThreshold, constants::kMaxWidth);
 
   return bBoxesList;
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

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

@@ -5,7 +5,7 @@
 #include <rnexecutorch/models/BaseModel.h>
 #include <rnexecutorch/models/ocr/Types.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 /*
  Detector is a model responsible for recognizing the areas where text is
  located. It returns the list of bounding boxes. The model used as detector is
@@ -20,11 +20,11 @@ class Detector final : public BaseModel {
 public:
   explicit Detector(const std::string &modelSource,
                     std::shared_ptr<react::CallInvoker> callInvoker);
-  std::vector<ocr::DetectorBBox> generate(const cv::Mat &inputImage);
+  std::vector<types::DetectorBBox> generate(const cv::Mat &inputImage);
   cv::Size getModelImageSize() const noexcept;
 
 private:
-  std::vector<ocr::DetectorBBox> postprocess(const Tensor &tensor) const;
+  std::vector<types::DetectorBBox> postprocess(const Tensor &tensor) const;
   cv::Size modelImageSize;
 };
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

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

@@ -2,7 +2,7 @@
 #include <rnexecutorch/data_processing/ImageProcessing.h>
 #include <rnexecutorch/models/ocr/Constants.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 OCR::OCR(const std::string &detectorSource,
          const std::string &recognizerSourceLarge,
          const std::string &recognizerSourceMedium,
@@ -12,8 +12,8 @@ OCR::OCR(const std::string &detectorSource,
       recognitionHandler(recognizerSourceLarge, recognizerSourceMedium,
                          recognizerSourceSmall, symbols, callInvoker) {}
 
-std::vector<OCRDetection> OCR::generate(std::string input) {
-  cv::Mat image = imageprocessing::readImage(input);
+std::vector<types::OCRDetection> OCR::generate(std::string input) {
+  cv::Mat image = image_processing::readImage(input);
   if (image.empty()) {
     throw std::runtime_error("Failed to load image from path: " + input);
   }
@@ -23,7 +23,7 @@ std::vector<OCRDetection> OCR::generate(std::string input) {
    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);
+  std::vector<types::DetectorBBox> bboxesList = detector.generate(image);
   cv::cvtColor(image, image, cv::COLOR_BGR2GRAY);
 
   /*
@@ -33,9 +33,10 @@ std::vector<OCRDetection> OCR::generate(std::string input) {
     - 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));
+  std::vector<types::OCRDetection> result =
+      recognitionHandler.recognize(bboxesList, image,
+                                   cv::Size(constants::kRecognizerImageSize,
+                                            constants::kRecognizerImageSize));
 
   return result;
 }
@@ -49,4 +50,4 @@ void OCR::unload() noexcept {
   detector.unload();
   recognitionHandler.unload();
 }
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

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

@@ -1,12 +1,15 @@
 #pragma once
 
+#include <string>
+#include <vector>
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/ocr/Detector.h>
 #include <rnexecutorch/models/ocr/RecognitionHandler.h>
 #include <rnexecutorch/models/ocr/Types.h>
-#include <string>
-#include <vector>
 
 namespace rnexecutorch {
+namespace models::ocr {
 /*
  The OCR consists of two phases:
  1. Detection - detecting text regions in the image, the result of this phase
@@ -25,7 +28,7 @@ public:
                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::vector<types::OCRDetection> generate(std::string input);
   std::size_t getMemoryLowerBound() const noexcept;
   void unload() noexcept;
 
@@ -33,4 +36,9 @@ private:
   Detector detector;
   RecognitionHandler recognitionHandler;
 };
+} // namespace models::ocr
+
+REGISTER_CONSTRUCTOR(models::ocr::OCR, std::string, std::string, std::string,
+                     std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

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

@@ -1,10 +1,9 @@
 #include "RecognitionHandler.h"
-#include "RecognitionHandlerUtils.h"
 #include <rnexecutorch/data_processing/ImageProcessing.h>
 #include <rnexecutorch/models/ocr/Constants.h>
-#include <rnexecutorch/models/ocr/RecognitionHandlerUtils.h>
+#include <rnexecutorch/models/ocr/utils/RecognitionHandlerUtils.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 RecognitionHandler::RecognitionHandler(
     const std::string &recognizerSourceLarge,
     const std::string &recognizerSourceMedium,
@@ -22,24 +21,25 @@ 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) {
+  if (image.cols >= constants::kLargeRecognizerWidth) {
     return recognizerLarge.generate(image);
   }
-  if (image.cols >= ocr::MEDIUM_RECOGNIZER_WIDTH) {
+  if (image.cols >= constants::kMediumRecognizerWidth) {
     return recognizerMedium.generate(image);
   }
   return recognizerSmall.generate(image);
 }
 
-void RecognitionHandler::processBBox(std::vector<OCRDetection> &boxList,
-                                     ocr::DetectorBBox &box, cv::Mat &imgGray,
-                                     ocr::PaddingInfo ratioAndPadding) {
+void RecognitionHandler::processBBox(std::vector<types::OCRDetection> &boxList,
+                                     types::DetectorBBox &box, cv::Mat &imgGray,
+                                     types::PaddingInfo ratioAndPadding) {
 
   /*
     Resize the cropped image to have height = 64 (height accepted by
     Recognizer).
   */
-  auto croppedImage = ocr::cropImage(box, imgGray, ocr::RECOGNIZER_HEIGHT);
+  auto croppedImage =
+      utils::cropImage(box, imgGray, constants::kRecognizerHeight);
 
   if (croppedImage.empty()) {
     return;
@@ -49,11 +49,12 @@ void RecognitionHandler::processBBox(std::vector<OCRDetection> &boxList,
     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);
+  croppedImage =
+      utils::normalizeForRecognizer(croppedImage, constants::kRecognizerHeight,
+                                    constants::kAdjustContrast, false);
 
   auto [predictionIndices, confidenceScore] = this->runModel(croppedImage);
-  if (confidenceScore < ocr::LOW_CONFIDENCE_THRESHOLD) {
+  if (confidenceScore < constants::kLowConfidenceThreshold) {
     cv::rotate(croppedImage, croppedImage, cv::ROTATE_180);
     auto [rotatedPredictionIndices, rotatedConfidenceScore] =
         runModel(croppedImage);
@@ -77,18 +78,18 @@ void RecognitionHandler::processBBox(std::vector<OCRDetection> &boxList,
       confidenceScore);
 }
 
-std::vector<OCRDetection>
-RecognitionHandler::recognize(std::vector<ocr::DetectorBBox> bboxesList,
+std::vector<types::OCRDetection>
+RecognitionHandler::recognize(std::vector<types::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);
+  types::PaddingInfo ratioAndPadding =
+      utils::calculateResizeRatioAndPaddings(imgGray.size(), desiredSize);
+  imgGray = image_processing::resizePadded(imgGray, desiredSize);
 
-  std::vector<OCRDetection> result = {};
+  std::vector<types::OCRDetection> result = {};
   for (auto &box : bboxesList) {
     processBBox(result, box, imgGray, ratioAndPadding);
   }
@@ -104,4 +105,4 @@ void RecognitionHandler::unload() noexcept {
   recognizerMedium.unload();
   recognizerLarge.unload();
 }
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

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

@@ -7,7 +7,7 @@
 #include <string>
 #include <vector>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 /*
  Recogntion Handler is responsible for:
  1. Preparing the image to be processed by Recognition Model.
@@ -22,19 +22,21 @@ public:
                               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);
+  std::vector<types::OCRDetection>
+  recognize(std::vector<types::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);
+  void processBBox(std::vector<types::OCRDetection> &boxList,
+                   types::DetectorBBox &box, cv::Mat &imgGray,
+                   types::PaddingInfo ratioAndPadding);
   std::size_t memorySizeLowerBound{0};
-  ocr::CTCLabelConverter converter;
+  CTCLabelConverter converter;
   Recognizer recognizerLarge;
   Recognizer recognizerMedium;
   Recognizer recognizerSmall;
 };
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr