react-native-executorch 0.5.2 → 0.5.4

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

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

@@ -3,10 +3,10 @@
 #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>
+#include <rnexecutorch/models/ocr/utils/RecognizerUtils.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 Recognizer::Recognizer(const std::string &modelSource,
                        std::shared_ptr<react::CallInvoker> callInvoker)
     : BaseModel(modelSource, callInvoker) {
@@ -35,7 +35,7 @@ Recognizer::generate(const cv::Mat &grayImage) {
   */
   std::vector<int32_t> tensorDims = getAllInputShapes()[0];
   TensorPtr inputTensor =
-      imageprocessing::getTensorFromMatrixGray(tensorDims, grayImage);
+      image_processing::getTensorFromMatrixGray(tensorDims, grayImage);
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
     throw std::runtime_error(
@@ -72,9 +72,9 @@ Recognizer::postprocess(const Tensor &tensor) const {
   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);
+  auto probabilities = utils::softmax(resultMat);
+  auto [maxVal, maxIndices] = utils::findMaxValuesIndices(probabilities);
+  float confidence = utils::confidenceScore(maxVal, maxIndices);
   return {maxIndices, confidence};
 }
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

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

@@ -7,7 +7,7 @@
 #include <utility>
 #include <vector>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::ocr {
 /*
  Recognizer is a model responsible for interpreting detected text regions
  into characters/words.
@@ -33,4 +33,4 @@ private:
 
   cv::Size modelImageSize;
 };
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::ocr

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

@@ -4,9 +4,7 @@
 #include <string>
 #include <vector>
 
-namespace rnexecutorch {
-namespace ocr {
-
+namespace rnexecutorch::models::ocr::types {
 struct Point {
   float x;
   float y;
@@ -27,11 +25,11 @@ struct PaddingInfo {
   int32_t top;
   int32_t left;
 };
-} // namespace ocr
 
 struct OCRDetection {
-  std::array<ocr::Point, 4> bbox;
+  std::array<types::Point, 4> bbox;
   std::string text;
   float score;
 };
-} // namespace rnexecutorch
+
+} // namespace rnexecutorch::models::ocr::types

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

@@ -7,9 +7,9 @@
 #include <rnexecutorch/models/ocr/Types.h>
 #include <unordered_set>
 
-namespace rnexecutorch::ocr {
+namespace rnexecutorch::models::ocr::utils {
 std::array<cv::Point2f, 4>
-cvPointsFromPoints(const std::array<Point, 4> &points) {
+cvPointsFromPoints(const std::array<types::Point, 4> &points) {
   std::array<cv::Point2f, 4> cvPoints;
 #pragma unroll
   for (std::size_t i = 0; i < cvPoints.size(); ++i) {
@@ -18,8 +18,8 @@ cvPointsFromPoints(const std::array<Point, 4> &points) {
   return cvPoints;
 }
 
-std::array<Point, 4> pointsFromCvPoints(cv::Point2f cvPoints[4]) {
-  std::array<Point, 4> points;
+std::array<types::Point, 4> pointsFromCvPoints(cv::Point2f cvPoints[4]) {
+  std::array<types::Point, 4> points;
 #pragma unroll
   for (std::size_t i = 0; i < points.size(); ++i) {
     points[i] = {.x = cvPoints[i].x, .y = cvPoints[i].y};
@@ -92,19 +92,19 @@ void morphologicalOperations(
   cv::dilate(roiSegMap, roiSegMap, kernel, anchor, iterations);
 }
 
-DetectorBBox
+types::DetectorBBox
 extractMinAreaBBoxFromContour(const std::vector<cv::Point> contour) {
   cv::RotatedRect minRect = cv::minAreaRect(contour);
 
   std::array<cv::Point2f, 4> vertices;
   minRect.points(vertices.data());
 
-  std::array<Point, 4> points = pointsFromCvPoints(vertices.data());
+  std::array<types::Point, 4> points = pointsFromCvPoints(vertices.data());
   return {.bbox = points, .angle = minRect.angle};
 }
 
 void getBoxFromContour(cv::Mat &segMap,
-                       std::vector<DetectorBBox> &detectedBoxes) {
+                       std::vector<types::DetectorBBox> &detectedBoxes) {
   std::vector<std::vector<cv::Point>> contours;
   cv::findContours(segMap, contours, cv::RETR_EXTERNAL,
                    cv::CHAIN_APPROX_SIMPLE);
@@ -118,7 +118,8 @@ void getBoxFromContour(cv::Mat &segMap,
 // param lowTextThreshold is used only by standard OCR.
 void processComponent(const cv::Mat &textMap, const cv::Mat &labels,
                       const cv::Mat &stats, int32_t i, int32_t imgW,
-                      int32_t imgH, std::vector<DetectorBBox> &detectedBoxes,
+                      int32_t imgH,
+                      std::vector<types::DetectorBBox> &detectedBoxes,
                       bool isVertical, int32_t minimalAreaThreshold,
                       int32_t dilationIter, float lowTextThreshold = 0.0) {
   const int32_t area = stats.at<int32_t>(i, cv::CC_STAT_AREA);
@@ -150,11 +151,10 @@ void processComponent(const cv::Mat &textMap, const cv::Mat &labels,
   getBoxFromContour(segMap, detectedBoxes);
 }
 
-std::vector<DetectorBBox> getDetBoxesFromTextMap(cv::Mat &textMap,
-                                                 cv::Mat &affinityMap,
-                                                 float textThreshold,
-                                                 float linkThreshold,
-                                                 float lowTextThreshold) {
+std::vector<types::DetectorBBox>
+getDetBoxesFromTextMap(cv::Mat &textMap, cv::Mat &affinityMap,
+                       float textThreshold, float linkThreshold,
+                       float lowTextThreshold) {
   // Ensure input mats are of the correct type for processing
   CV_Assert(textMap.type() == CV_32F && affinityMap.type() == CV_32F);
 
@@ -184,7 +184,7 @@ std::vector<DetectorBBox> getDetBoxesFromTextMap(cv::Mat &textMap,
   const int32_t nLabels = cv::connectedComponentsWithStats(
       binaryMat, labels, stats, centroids, connectivityType);
 
-  std::vector<DetectorBBox> detectedBoxes;
+  std::vector<types::DetectorBBox> detectedBoxes;
   detectedBoxes.reserve(nLabels); // Pre-allocate memory
 
   // number of dilation iterations performed in some
@@ -203,7 +203,7 @@ std::vector<DetectorBBox> getDetBoxesFromTextMap(cv::Mat &textMap,
   return detectedBoxes;
 }
 
-std::vector<DetectorBBox>
+std::vector<types::DetectorBBox>
 getDetBoxesFromTextMapVertical(cv::Mat &textMap, cv::Mat &affinityMap,
                                float textThreshold, float linkThreshold,
                                bool independentCharacters) {
@@ -265,7 +265,7 @@ getDetBoxesFromTextMapVertical(cv::Mat &textMap, cv::Mat &affinityMap,
   const int32_t nLabels = cv::connectedComponentsWithStats(
       binaryMat, labels, stats, centroids, connectivityType);
 
-  std::vector<DetectorBBox> detectedBoxes;
+  std::vector<types::DetectorBBox> detectedBoxes;
   detectedBoxes.reserve(nLabels);
 
   // number of dilation iterations performed in some
@@ -293,7 +293,8 @@ float calculateRestoreRatio(int32_t currentSize, int32_t desiredSize) {
   return desiredSize / static_cast<float>(currentSize);
 }
 
-void restoreBboxRatio(std::vector<DetectorBBox> &boxes, float restoreRatio) {
+void restoreBboxRatio(std::vector<types::DetectorBBox> &boxes,
+                      float restoreRatio) {
   for (auto &box : boxes) {
     for (auto &point : box.bbox) {
       point.x *= restoreRatio;
@@ -302,7 +303,7 @@ void restoreBboxRatio(std::vector<DetectorBBox> &boxes, float restoreRatio) {
   }
 }
 
-float distanceFromPoint(const Point &p1, const Point &p2) {
+float distanceFromPoint(const types::Point &p1, const types::Point &p2) {
   const float xDist = p2.x - p1.x;
   const float yDist = p2.y - p1.y;
   return std::hypot(xDist, yDist);
@@ -312,17 +313,19 @@ float normalizeAngle(float angle) {
   return (angle > 45.0f) ? (angle - 90.0f) : angle;
 }
 
-Point midpointBetweenPoint(const Point &p1, const Point &p2) {
+types::Point midpointBetweenPoint(const types::Point &p1,
+                                  const types::Point &p2) {
   return {.x = std::midpoint(p1.x, p2.x), .y = std::midpoint(p1.y, p2.y)};
 }
 
-Point centerOfBox(const std::array<Point, 4> &box) {
+types::Point centerOfBox(const std::array<types::Point, 4> &box) {
   return midpointBetweenPoint(box[0], box[2]);
 }
 
 // function for both; finding maximal side length and minimal side length
 template <typename Compare>
-float findExtremeSideLength(const std::array<Point, 4> &points, Compare comp) {
+float findExtremeSideLength(const std::array<types::Point, 4> &points,
+                            Compare comp) {
   float extremeLength = distanceFromPoint(points[0], points[1]);
 
 #pragma unroll
@@ -339,11 +342,11 @@ float findExtremeSideLength(const std::array<Point, 4> &points, Compare comp) {
   return extremeLength;
 }
 
-float minSideLength(const std::array<Point, 4> &points) {
+float minSideLength(const std::array<types::Point, 4> &points) {
   return findExtremeSideLength(points, std::less<float>{});
 }
 
-float maxSideLength(const std::array<Point, 4> &points) {
+float maxSideLength(const std::array<types::Point, 4> &points) {
   return findExtremeSideLength(points, std::greater<float>{});
 }
 
@@ -364,9 +367,9 @@ float maxSideLength(const std::array<Point, 4> &points) {
  * considered vertical.
  */
 std::tuple<float, float, bool>
-fitLineToShortestSides(const std::array<Point, 4> &points) {
+fitLineToShortestSides(const std::array<types::Point, 4> &points) {
   std::array<std::pair<float, float>, 4> sides;
-  std::array<Point, 4> midpoints;
+  std::array<types::Point, 4> midpoints;
 #pragma unroll
   for (std::size_t i = 0; i < midpoints.size(); i++) {
     const auto p1 = points[i];
@@ -380,8 +383,8 @@ fitLineToShortestSides(const std::array<Point, 4> &points) {
   // Sort the sides by length ascending
   std::ranges::sort(sides);
 
-  const Point midpoint1 = midpoints[sides[0].second];
-  const Point midpoint2 = midpoints[sides[1].second];
+  const types::Point midpoint1 = midpoints[sides[0].second];
+  const types::Point midpoint2 = midpoints[sides[1].second];
   const float dx = std::fabs(midpoint2.x - midpoint1.x);
 
   float m, c;
@@ -398,7 +401,7 @@ fitLineToShortestSides(const std::array<Point, 4> &points) {
   constexpr double accuracy =
       0.01; // sufficient accuracy. Value proposed by OPENCV
 
-  isVertical = dx < VERTICAL_LINE_THRESHOLD;
+  isVertical = dx < constants::kVerticalLineThreshold;
   if (isVertical) {
     for (auto &pt : cvMidPoints) {
       std::swap(pt.x, pt.y);
@@ -411,14 +414,15 @@ fitLineToShortestSides(const std::array<Point, 4> &points) {
   return {m, c, isVertical};
 }
 
-std::array<Point, 4> rotateBox(const std::array<Point, 4> &box, float angle) {
-  const Point center = centerOfBox(box);
+std::array<types::Point, 4> rotateBox(const std::array<types::Point, 4> &box,
+                                      float angle) {
+  const types::Point center = centerOfBox(box);
 
   const float radians = angle * M_PI / 180.0f;
 
-  std::array<Point, 4> rotatedPoints;
+  std::array<types::Point, 4> rotatedPoints;
   for (std::size_t i = 0; i < box.size(); ++i) {
-    const Point &point = box[i];
+    const types::Point &point = box[i];
     const float translatedX = point.x - center.x;
     const float translatedY = point.y - center.y;
 
@@ -433,11 +437,12 @@ std::array<Point, 4> rotateBox(const std::array<Point, 4> &box, float angle) {
   return rotatedPoints;
 }
 
-float calculateMinimalDistanceBetweenBox(const std::array<Point, 4> &box1,
-                                         const std::array<Point, 4> &box2) {
+float calculateMinimalDistanceBetweenBox(
+    const std::array<types::Point, 4> &box1,
+    const std::array<types::Point, 4> &box2) {
   float minDistance = std::numeric_limits<float>::max();
-  for (const Point &corner1 : box1) {
-    for (const Point &corner2 : box2) {
+  for (const types::Point &corner1 : box1) {
+    for (const types::Point &corner2 : box2) {
       const float distance = distanceFromPoint(corner1, corner2);
       minDistance = std::min(distance, minDistance);
     }
@@ -461,8 +466,9 @@ float calculateMinimalDistanceBetweenBox(const std::array<Point, 4> &box1,
  * 4. The points are ordered starting from the top-left in a clockwise manner:
  * top-left, top-right, bottom-right, bottom-left.
  */
-std::array<Point, 4> orderPointsClockwise(const std::array<Point, 4> &points) {
-  Point topLeft, topRight, bottomRight, bottomLeft;
+std::array<types::Point, 4>
+orderPointsClockwise(const std::array<types::Point, 4> &points) {
+  types::Point topLeft, topRight, bottomRight, bottomLeft;
   float minSum = std::numeric_limits<float>::max();
   float maxSum = std::numeric_limits<float>::lowest();
   float minDiff = std::numeric_limits<float>::max();
@@ -493,8 +499,9 @@ std::array<Point, 4> orderPointsClockwise(const std::array<Point, 4> &points) {
   return {topLeft, topRight, bottomRight, bottomLeft};
 }
 
-std::array<Point, 4> mergeRotatedBoxes(std::array<Point, 4> &box1,
-                                       std::array<Point, 4> &box2) {
+std::array<types::Point, 4>
+mergeRotatedBoxes(std::array<types::Point, 4> &box1,
+                  std::array<types::Point, 4> &box2) {
   box1 = orderPointsClockwise(box1);
   box2 = orderPointsClockwise(box2);
 
@@ -546,21 +553,21 @@ std::array<Point, 4> mergeRotatedBoxes(std::array<Point, 4> &box1,
  * If no suitable box is found the optional is null.
  */
 std::optional<std::pair<std::size_t, float>>
-findClosestBox(const std::vector<DetectorBBox> &boxes,
+findClosestBox(const std::vector<types::DetectorBBox> &boxes,
                const std::unordered_set<std::size_t> &ignoredIdxs,
-               const std::array<Point, 4> &currentBox, bool isVertical, float m,
-               float c, float centerThreshold) {
+               const std::array<types::Point, 4> &currentBox, bool isVertical,
+               float m, float c, float centerThreshold) {
   float smallestDistance = std::numeric_limits<float>::max();
   ssize_t idx = -1;
   float boxHeight = 0.0f;
-  const Point centerOfCurrentBox = centerOfBox(currentBox);
+  const types::Point centerOfCurrentBox = centerOfBox(currentBox);
 
   for (std::size_t i = 0; i < boxes.size(); i++) {
     if (ignoredIdxs.contains(i)) {
       continue;
     }
-    std::array<Point, 4> bbox = boxes[i].bbox;
-    const Point centerOfProcessedBox = centerOfBox(bbox);
+    std::array<types::Point, 4> bbox = boxes[i].bbox;
+    const types::Point centerOfProcessedBox = centerOfBox(bbox);
     const float distanceBetweenCenters =
         distanceFromPoint(centerOfCurrentBox, centerOfProcessedBox);
 
@@ -593,10 +600,10 @@ findClosestBox(const std::vector<DetectorBBox> &boxes,
  *   - Its longer side is **greater than** `maxSideThreshold`.
  * Otherwise, the box is excluded from the result.
  */
-std::vector<DetectorBBox>
-removeSmallBoxesFromArray(const std::vector<DetectorBBox> &boxes,
+std::vector<types::DetectorBBox>
+removeSmallBoxesFromArray(const std::vector<types::DetectorBBox> &boxes,
                           float minSideThreshold, float maxSideThreshold) {
-  std::vector<DetectorBBox> filteredBoxes;
+  std::vector<types::DetectorBBox> filteredBoxes;
 
   for (const auto &box : boxes) {
     const float maxSide = maxSideLength(box.bbox);
@@ -609,24 +616,24 @@ removeSmallBoxesFromArray(const std::vector<DetectorBBox> &boxes,
   return filteredBoxes;
 }
 
-static float minimumYFromBox(const std::array<Point, 4> &box) {
-  return std::ranges::min_element(box,
-                                  [](Point a, Point b) { return a.y < b.y; })
+static float minimumYFromBox(const std::array<types::Point, 4> &box) {
+  return std::ranges::min_element(
+             box, [](types::Point a, types::Point b) { return a.y < b.y; })
       ->y;
 }
 
-std::vector<DetectorBBox>
-groupTextBoxes(std::vector<DetectorBBox> &boxes, float centerThreshold,
+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) {
   // Sort boxes descending by maximum side length
-  std::ranges::sort(boxes,
-                    [](const DetectorBBox &lhs, const DetectorBBox &rhs) {
-                      return maxSideLength(lhs.bbox) > maxSideLength(rhs.bbox);
-                    });
+  std::ranges::sort(boxes, [](const types::DetectorBBox &lhs,
+                              const types::DetectorBBox &rhs) {
+    return maxSideLength(lhs.bbox) > maxSideLength(rhs.bbox);
+  });
 
-  std::vector<DetectorBBox> mergedVec;
+  std::vector<types::DetectorBBox> mergedVec;
   float lineAngle;
   std::unordered_set<std::size_t> ignoredIdxs;
   while (!boxes.empty()) {
@@ -652,7 +659,7 @@ groupTextBoxes(std::vector<DetectorBBox> &boxes, float centerThreshold,
         break;
       }
       const auto [candidateIdx, candidateHeight] = closestBoxInfo.value();
-      DetectorBBox candidateBox = boxes[candidateIdx];
+      types::DetectorBBox candidateBox = boxes[candidateIdx];
 
       if ((numerical::isClose(candidateBox.angle, 90.0f) && !isVertical) ||
           (numerical::isClose(candidateBox.angle, 0.0f) && isVertical)) {
@@ -690,9 +697,9 @@ groupTextBoxes(std::vector<DetectorBBox> &boxes, float centerThreshold,
     return minY1 < minY2;
   });
 
-  std::vector<DetectorBBox> orderedSortedBoxes;
+  std::vector<types::DetectorBBox> orderedSortedBoxes;
   orderedSortedBoxes.reserve(mergedVec.size());
-  for (DetectorBBox bbox : mergedVec) {
+  for (types::DetectorBBox bbox : mergedVec) {
     bbox.bbox = orderPointsClockwise(bbox.bbox);
     orderedSortedBoxes.push_back(std::move(bbox));
   }
@@ -700,4 +707,4 @@ groupTextBoxes(std::vector<DetectorBBox> &boxes, float centerThreshold,
   return orderedSortedBoxes;
 }
 
-} // namespace rnexecutorch::ocr
+} // namespace rnexecutorch::models::ocr::utils