react-native-executorch 0.5.1 → 0.5.3

package/common/rnexecutorch/models/ocr/{RecognizerUtils.cpp → utils/RecognizerUtils.cpp}

@@ -1,6 +1,6 @@
 #include "RecognizerUtils.h"
 
-namespace rnexecutorch::ocr {
+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);
@@ -28,9 +28,9 @@ void divideMatrixByRows(cv::Mat &matrix, const std::vector<float> &rowSums) {
   }
 }
 
-ValuesAndIndices findMaxValuesIndices(const cv::Mat &mat) {
+types::ValuesAndIndices findMaxValuesIndices(const cv::Mat &mat) {
   CV_Assert(mat.type() == CV_32F);
-  ValuesAndIndices result{};
+  types::ValuesAndIndices result{};
   result.values.reserve(mat.rows);
   result.indices.reserve(mat.rows);
 
@@ -66,7 +66,7 @@ float confidenceScore(const std::vector<float> &values,
   return std::pow(product, exponent);
 }
 
-cv::Rect extractBoundingBox(std::array<Point, 4> &points) {
+cv::Rect extractBoundingBox(std::array<types::Point, 4> &points) {
   cv::Mat pointsMat(4, 1, CV_32FC2, points.data());
   return cv::boundingRect(pointsMat);
 }
@@ -107,10 +107,11 @@ cv::Mat characterBitMask(const cv::Mat &img) {
 
   const int32_t height = thresh.rows;
   const int32_t width = thresh.cols;
-  const int32_t minX = ocr::SINGLE_CHARACTER_CENTER_THRESHOLD * width;
-  const int32_t maxX = (1 - ocr::SINGLE_CHARACTER_CENTER_THRESHOLD) * width;
-  const int32_t minY = ocr::SINGLE_CHARACTER_CENTER_THRESHOLD * height;
-  const int32_t maxY = (1 - ocr::SINGLE_CHARACTER_CENTER_THRESHOLD) * height;
+  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;
@@ -120,8 +121,8 @@ cv::Mat characterBitMask(const cv::Mat &img) {
     const double cy = centroids.at<double>(i, 1);
 
     if ((minX < cx && cx < maxX && minY < cy &&
-         cy < maxY &&                              // check if centered
-         area > ocr::SINGLE_CHARACTER_MIN_SIZE) && // check if large enough
+         cy < maxY &&                                  // check if centered
+         area > constants::kSingleCharacterMinSize) && // check if large enough
         area > maxArea) {
       selectedComponent = i;
       maxArea = area;
@@ -142,21 +143,22 @@ cv::Mat characterBitMask(const cv::Mat &img) {
   return resultImage;
 }
 
-cv::Mat cropImageWithBoundingBox(const cv::Mat &img,
-                                 const std::array<Point, 4> &bbox,
-                                 const std::array<Point, 4> &originalBbox,
-                                 const PaddingInfo &paddings,
-                                 const PaddingInfo &originalPaddings) {
+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 Point topLeft = originalBbox[0];
+  const types::Point topLeft = originalBbox[0];
 
   std::vector<cv::Point2f> points;
   points.reserve(bbox.size());
 
   for (const auto &point : bbox) {
-    Point transformedPoint = point;
+    types::Point transformedPoint = point;
 
     transformedPoint.x -= paddings.left;
     transformedPoint.y -= paddings.top;
@@ -186,17 +188,17 @@ cv::Mat cropImageWithBoundingBox(const cv::Mat &img,
 }
 
 cv::Mat prepareForRecognition(const cv::Mat &originalImage,
-                              const std::array<Point, 4> &bbox,
-                              const std::array<Point, 4> &originalBbox,
-                              const PaddingInfo &paddings,
-                              const PaddingInfo &originalPaddings) {
+                              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(ocr::SMALL_VERTICAL_RECOGNIZER_WIDTH, ocr::RECOGNIZER_HEIGHT), 0,
-      0, cv::INTER_AREA);
+  cv::resize(croppedChar, croppedChar,
+             cv::Size(constants::kSmallVerticalRecognizerWidth,
+                      constants::kRecognizerHeight),
+             0, 0, cv::INTER_AREA);
   return croppedChar;
 }
-} // namespace rnexecutorch::ocr
+} // namespace rnexecutorch::models::ocr::utils

package/common/rnexecutorch/models/ocr/{RecognizerUtils.h → utils/RecognizerUtils.h}

@@ -6,7 +6,7 @@
 #include <rnexecutorch/models/ocr/Types.h>
 #include <vector>
 
-namespace rnexecutorch::ocr {
+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
@@ -18,10 +18,10 @@ 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.
  */
-ValuesAndIndices findMaxValuesIndices(const cv::Mat &mat);
+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<Point, 4> &points);
+cv::Rect extractBoundingBox(std::array<types::Point, 4> &points);
 
 /**
  * @brief Computes confidence score for given values and indices vectors.
@@ -43,11 +43,12 @@ cv::Mat characterBitMask(const cv::Mat &img);
  * 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<Point, 4> &bbox,
-                                 const std::array<Point, 4> &originalBbox,
-                                 const PaddingInfo &paddings,
-                                 const PaddingInfo &originalPaddings);
+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
@@ -56,15 +57,15 @@ cv::Mat cropImageWithBoundingBox(const cv::Mat &img,
  * Prepare for Recognition by following steps:
  * 1. Crop image to the character bounding box,
  * 2. Convert Image to gray.
- * 3. Resize it to [SMALL_VERTICAL_RECOGNIZER_WIDTH x RECOGNIZER_HEIGHT] (64 x
+ * 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<Point, 4> &bbox,
-                              const std::array<Point, 4> &originalBbox,
-                              const PaddingInfo &paddings,
-                              const PaddingInfo &originalPaddings);
-} // namespace rnexecutorch::ocr
+                              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

package/common/rnexecutorch/models/speech_to_text/SpeechToText.cpp

@@ -2,7 +2,7 @@
 #include <rnexecutorch/models/speech_to_text/WhisperStrategy.h>
 #include <stdexcept>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::speech_to_text {
 
 using namespace ::executorch::extension;
 
@@ -61,4 +61,4 @@ SpeechToText::decode(std::vector<int64_t> prevTokens) {
   return strategy->extractOutputToken(decoderOutputTensor);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::speech_to_text

package/common/rnexecutorch/models/speech_to_text/SpeechToText.h

@@ -4,13 +4,16 @@
 #include "executorch/runtime/core/evalue.h"
 #include <cstdint>
 #include <memory>
-#include <rnexecutorch/models/EncoderDecoderBase.h>
-#include <rnexecutorch/models/speech_to_text/SpeechToTextStrategy.h>
 #include <span>
 #include <string>
 #include <vector>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
+#include <rnexecutorch/models/EncoderDecoderBase.h>
+#include <rnexecutorch/models/speech_to_text/SpeechToTextStrategy.h>
+
 namespace rnexecutorch {
+namespace models::speech_to_text {
 class SpeechToText : public EncoderDecoderBase {
 public:
   explicit SpeechToText(const std::string &encoderPath,
@@ -27,5 +30,9 @@ private:
 
   void initializeStrategy();
 };
+} // namespace models::speech_to_text
 
+REGISTER_CONSTRUCTOR(models::speech_to_text::SpeechToText, std::string,
+                     std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/speech_to_text/SpeechToTextStrategy.h

@@ -5,7 +5,7 @@
 #include <span>
 #include <vector>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::speech_to_text {
 
 using TensorPtr = ::executorch::extension::TensorPtr;
 
@@ -24,4 +24,4 @@ public:
       const executorch::aten::Tensor &decoderOutputTensor) const = 0;
 };
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::speech_to_text

package/common/rnexecutorch/models/speech_to_text/WhisperStrategy.cpp

@@ -2,7 +2,7 @@
 #include "rnexecutorch/data_processing/dsp.h"
 #include <rnexecutorch/models/speech_to_text/WhisperStrategy.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::speech_to_text {
 
 using namespace ::executorch::extension;
 using namespace ::executorch::aten;
@@ -47,4 +47,4 @@ std::shared_ptr<OwningArrayBuffer> WhisperStrategy::extractOutputToken(
   return createBuffer(modelOutput.data(), modelOutput.size_bytes());
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::speech_to_text

package/common/rnexecutorch/models/speech_to_text/WhisperStrategy.h

@@ -4,7 +4,7 @@
 #include <span>
 #include <vector>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::speech_to_text {
 
 class WhisperStrategy final : public SpeechToTextStrategy {
 public:
@@ -22,4 +22,4 @@ private:
   std::vector<int32_t> tokens32;
 };
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::speech_to_text

package/common/rnexecutorch/models/style_transfer/StyleTransfer.cpp

@@ -5,7 +5,7 @@
 #include <executorch/extension/tensor/tensor.h>
 #include <opencv2/opencv.hpp>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::style_transfer {
 using namespace facebook;
 using executorch::extension::TensorPtr;
 using executorch::runtime::Error;
@@ -32,15 +32,15 @@ StyleTransfer::StyleTransfer(const std::string &modelSource,
 
 std::string StyleTransfer::postprocess(const Tensor &tensor,
                                        cv::Size originalSize) {
-  cv::Mat mat = imageprocessing::getMatrixFromTensor(modelImageSize, tensor);
+  cv::Mat mat = image_processing::getMatrixFromTensor(modelImageSize, tensor);
   cv::resize(mat, mat, originalSize);
 
-  return imageprocessing::saveToTempFile(mat);
+  return image_processing::saveToTempFile(mat);
 }
 
 std::string StyleTransfer::generate(std::string imageSource) {
   auto [inputTensor, originalSize] =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
 
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -52,4 +52,4 @@ std::string StyleTransfer::generate(std::string imageSource) {
   return postprocess(forwardResult->at(0).toTensor(), originalSize);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::style_transfer

package/common/rnexecutorch/models/style_transfer/StyleTransfer.h

@@ -8,9 +8,11 @@
 #include <jsi/jsi.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/BaseModel.h>
 
 namespace rnexecutorch {
+namespace models::style_transfer {
 using namespace facebook;
 using executorch::aten::Tensor;
 using executorch::extension::TensorPtr;
@@ -26,4 +28,8 @@ private:
 
   cv::Size modelImageSize{0, 0};
 };
+} // namespace models::style_transfer
+
+REGISTER_CONSTRUCTOR(models::style_transfer::StyleTransfer, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/vertical_ocr/VerticalDetector.cpp

@@ -2,11 +2,11 @@
 
 #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>
 
 #include <executorch/extension/tensor/tensor_ptr.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 VerticalDetector::VerticalDetector(
     const std::string &modelSource, bool detectSingleCharacters,
     std::shared_ptr<react::CallInvoker> callInvoker)
@@ -31,13 +31,14 @@ cv::Size VerticalDetector::getModelImageSize() const noexcept {
   return modelImageSize;
 }
 
-std::vector<ocr::DetectorBBox>
+std::vector<types::DetectorBBox>
 VerticalDetector::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 @@ VerticalDetector::generate(const cv::Mat &inputImage) {
   return postprocess(forwardResult->at(0).toTensor());
 }
 
-std::vector<ocr::DetectorBBox>
+std::vector<types::DetectorBBox>
 VerticalDetector::postprocess(const Tensor &tensor) const {
   /*
    The output of the model consists of two matrices (heat maps):
@@ -64,29 +65,29 @@ VerticalDetector::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));
   float txtThreshold = this->detectSingleCharacters
-                           ? ocr::TEXT_THRESHOLD
-                           : ocr::TEXT_THRESHOLD_VERTICAL;
-  std::vector<ocr::DetectorBBox> bBoxesList =
-      ocr::getDetBoxesFromTextMapVertical(scoreTextMat, scoreAffinityMat,
-                                          txtThreshold, ocr::LINK_THRESHOLD,
-                                          this->detectSingleCharacters);
-  const float restoreRatio =
-      ocr::calculateRestoreRatio(scoreTextMat.rows, ocr::RECOGNIZER_IMAGE_SIZE);
-  ocr::restoreBboxRatio(bBoxesList, restoreRatio);
+                           ? constants::kTextThreshold
+                           : constants::kTextThresholdVertical;
+  std::vector<types::DetectorBBox> bBoxesList =
+      utils::getDetBoxesFromTextMapVertical(
+          scoreTextMat, scoreAffinityMat, txtThreshold,
+          constants::kLinkThreshold, this->detectSingleCharacters);
+  const float restoreRatio = utils::calculateRestoreRatio(
+      scoreTextMat.rows, constants::kRecognizerImageSize);
+  utils::restoreBboxRatio(bBoxesList, restoreRatio);
 
   // if this is Narrow Detector, do not group boxes.
   if (!this->detectSingleCharacters) {
-    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/vertical_ocr/VerticalDetector.h

@@ -6,7 +6,7 @@
 #include <rnexecutorch/models/BaseModel.h>
 #include <rnexecutorch/models/ocr/Types.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 
 /*
  Vertical Detector is an sligtly modified Detector tuned for detecting Vertical
@@ -38,12 +38,12 @@ public:
   explicit VerticalDetector(const std::string &modelSource,
                             bool detectSingleCharacters,
                             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:
   bool detectSingleCharacters;
-  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/vertical_ocr/VerticalOCR.cpp

@@ -5,7 +5,7 @@
 #include <rnexecutorch/models/ocr/Types.h>
 #include <tuple>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 VerticalOCR::VerticalOCR(const std::string &detectorLargeSource,
                          const std::string &detectorNarrowSource,
                          const std::string &recognizerSource,
@@ -16,21 +16,21 @@ VerticalOCR::VerticalOCR(const std::string &detectorLargeSource,
       recognizer(recognizerSource, invoker), converter(symbols),
       independentCharacters(independentChars), callInvoker(invoker) {}
 
-std::vector<OCRDetection> VerticalOCR::generate(std::string input) {
-  cv::Mat image = imageprocessing::readImage(input);
+std::vector<types::OCRDetection> VerticalOCR::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);
   }
   // 1. Large Detector
-  std::vector<ocr::DetectorBBox> largeBoxes = detectorLarge.generate(image);
+  std::vector<types::DetectorBBox> largeBoxes = detectorLarge.generate(image);
 
   cv::Size largeDetectorSize = detectorLarge.getModelImageSize();
   cv::Mat resizedImage =
-      imageprocessing::resizePadded(image, largeDetectorSize);
-  ocr::PaddingInfo imagePaddings =
-      ocr::calculateResizeRatioAndPaddings(image.size(), largeDetectorSize);
+      image_processing::resizePadded(image, largeDetectorSize);
+  types::PaddingInfo imagePaddings =
+      utils::calculateResizeRatioAndPaddings(image.size(), largeDetectorSize);
 
-  std::vector<OCRDetection> predictions;
+  std::vector<types::OCRDetection> predictions;
   predictions.reserve(largeBoxes.size());
 
   for (auto &box : largeBoxes) {
@@ -49,10 +49,10 @@ std::size_t VerticalOCR::getMemoryLowerBound() const noexcept {
 
 // Strategy 1: Recognize each character individually
 std::pair<std::string, float> VerticalOCR::_handleIndependentCharacters(
-    const ocr::DetectorBBox &box, const cv::Mat &originalImage,
-    const std::vector<ocr::DetectorBBox> &characterBoxes,
-    const ocr::PaddingInfo &paddingsBox,
-    const ocr::PaddingInfo &imagePaddings) {
+    const types::DetectorBBox &box, const cv::Mat &originalImage,
+    const std::vector<types::DetectorBBox> &characterBoxes,
+    const types::PaddingInfo &paddingsBox,
+    const types::PaddingInfo &imagePaddings) {
   std::string text;
   float confidenceScore = 0.0f;
   float totalScore = 0.0f;
@@ -65,16 +65,16 @@ std::pair<std::string, float> VerticalOCR::_handleIndependentCharacters(
      3. Resize it to [VerticalSmallRecognizerWidth x RecognizerHeight] (64 x
      64),
     */
-    auto croppedChar = ocr::prepareForRecognition(
+    auto croppedChar = utils::prepareForRecognition(
         originalImage, characterBox.bbox, box.bbox, paddingsBox, imagePaddings);
 
     /*
      To make Recognition simpler, we convert cropped character image
      to a bit mask with white character and black background.
     */
-    croppedChar = ocr::characterBitMask(croppedChar);
-    croppedChar = ocr::normalizeForRecognizer(
-        croppedChar, ocr::RECOGNIZER_HEIGHT, 0.0, true);
+    croppedChar = utils::characterBitMask(croppedChar);
+    croppedChar = utils::normalizeForRecognizer(
+        croppedChar, constants::kRecognizerHeight, 0.0, true);
 
     const auto &[predIndex, score] = recognizer.generate(croppedChar);
     if (!predIndex.empty()) {
@@ -88,10 +88,10 @@ std::pair<std::string, float> VerticalOCR::_handleIndependentCharacters(
 
 // Strategy 2: Concatenate characters and recognize as a single line
 std::pair<std::string, float> VerticalOCR::_handleJointCharacters(
-    const ocr::DetectorBBox &box, const cv::Mat &originalImage,
-    const std::vector<ocr::DetectorBBox> &characterBoxes,
-    const ocr::PaddingInfo &paddingsBox,
-    const ocr::PaddingInfo &imagePaddings) {
+    const types::DetectorBBox &box, const cv::Mat &originalImage,
+    const std::vector<types::DetectorBBox> &characterBoxes,
+    const types::PaddingInfo &paddingsBox,
+    const types::PaddingInfo &imagePaddings) {
   std::string text;
   std::vector<cv::Mat> croppedCharacters;
   croppedCharacters.reserve(characterBoxes.size());
@@ -100,22 +100,22 @@ std::pair<std::string, float> VerticalOCR::_handleJointCharacters(
      Prepare for Recognition by following steps:
      1. Crop image to the character bounding box,
      2. Convert Image to gray.
-     3. Resize it to [SMALL_VERTICAL_RECOGNIZER_WIDTH x RECOGNIZER_HEIGHT] (64 x
+     3. Resize it to [kSmallVerticalRecognizerWidth x kRecognizerHeight] (64 x
      64). The same height is required for horizontal concatenation of single
      characters into one image.
     */
-    auto croppedChar = ocr::prepareForRecognition(
+    auto croppedChar = utils::prepareForRecognition(
         originalImage, characterBox.bbox, box.bbox, paddingsBox, imagePaddings);
     croppedCharacters.push_back(croppedChar);
   }
 
   cv::Mat mergedCharacters;
   cv::hconcat(croppedCharacters, mergedCharacters);
-  mergedCharacters = imageprocessing::resizePadded(
+  mergedCharacters = image_processing::resizePadded(
       mergedCharacters,
-      cv::Size(ocr::LARGE_RECOGNIZER_WIDTH, ocr::RECOGNIZER_HEIGHT));
-  mergedCharacters = ocr::normalizeForRecognizer(
-      mergedCharacters, ocr::RECOGNIZER_HEIGHT, 0.0, false);
+      cv::Size(constants::kLargeRecognizerWidth, constants::kRecognizerHeight));
+  mergedCharacters = utils::normalizeForRecognizer(
+      mergedCharacters, constants::kRecognizerHeight, 0.0, false);
 
   const auto &[predIndex, confidenceScore] =
       recognizer.generate(mergedCharacters);
@@ -125,10 +125,10 @@ std::pair<std::string, float> VerticalOCR::_handleJointCharacters(
   return {text, confidenceScore};
 }
 
-OCRDetection VerticalOCR::_processSingleTextBox(
-    ocr::DetectorBBox &box, const cv::Mat &originalImage,
-    const cv::Mat &resizedLargeImage, const ocr::PaddingInfo &imagePaddings) {
-  cv::Rect boundingBox = ocr::extractBoundingBox(box.bbox);
+types::OCRDetection VerticalOCR::_processSingleTextBox(
+    types::DetectorBBox &box, const cv::Mat &originalImage,
+    const cv::Mat &resizedLargeImage, const types::PaddingInfo &imagePaddings) {
+  cv::Rect boundingBox = utils::extractBoundingBox(box.bbox);
 
   // Crop the image for detection of single characters.
   cv::Rect safeRect =
@@ -137,7 +137,7 @@ OCRDetection VerticalOCR::_processSingleTextBox(
   cv::Mat croppedLargeBox = resizedLargeImage(safeRect);
 
   // 2. Narrow Detector - detects single characters
-  std::vector<ocr::DetectorBBox> characterBoxes =
+  std::vector<types::DetectorBBox> characterBoxes =
       detectorNarrow.generate(croppedLargeBox);
 
   std::string text;
@@ -149,7 +149,7 @@ OCRDetection VerticalOCR::_processSingleTextBox(
     const int32_t boxHeight =
         static_cast<int32_t>(box.bbox[2].y - box.bbox[0].y);
     cv::Size narrowRecognizerSize = detectorNarrow.getModelImageSize();
-    ocr::PaddingInfo paddingsBox = ocr::calculateResizeRatioAndPaddings(
+    types::PaddingInfo paddingsBox = utils::calculateResizeRatioAndPaddings(
         cv::Size(boxWidth, boxHeight), narrowRecognizerSize);
 
     // 3. Recognition - decide between Strategy 1 and Strategy 2.
@@ -161,7 +161,7 @@ OCRDetection VerticalOCR::_processSingleTextBox(
                                      paddingsBox, imagePaddings);
   }
   // Modify the returned boxes to match the original image size
-  std::array<ocr::Point, 4> finalBbox;
+  std::array<types::Point, 4> finalBbox;
   for (size_t i = 0; i < box.bbox.size(); ++i) {
     finalBbox[i].x =
         (box.bbox[i].x - imagePaddings.left) * imagePaddings.resizeRatio;
@@ -177,4 +177,4 @@ void VerticalOCR::unload() noexcept {
   detectorNarrow.unload();
   recognizer.unload();
 }
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr