react-native-executorch 0.5.2 → 0.5.4

package/common/rnexecutorch/models/embeddings/image/ImageEmbeddings.h

@@ -4,9 +4,11 @@
 #include <executorch/runtime/core/evalue.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
 
 namespace rnexecutorch {
+namespace models::embeddings {
 using executorch::extension::TensorPtr;
 using executorch::runtime::EValue;
 
@@ -19,5 +21,8 @@ public:
 private:
   cv::Size modelImageSize{0, 0};
 };
+} // namespace models::embeddings
 
+REGISTER_CONSTRUCTOR(models::embeddings::ImageEmbeddings, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/embeddings/text/TextEmbeddings.cpp

@@ -2,7 +2,7 @@
 #include <executorch/extension/tensor/tensor_ptr_maker.h>
 #include <rnexecutorch/data_processing/Numerical.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::embeddings {
 
 using namespace executorch::extension;
 
@@ -58,4 +58,4 @@ TextEmbeddings::generate(const std::string input) {
   return BaseEmbeddings::postprocess(forwardResult);
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::embeddings

package/common/rnexecutorch/models/embeddings/text/TextEmbeddings.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/TokenizerModule.h>
 #include <rnexecutorch/models/embeddings/BaseEmbeddings.h>
 
 namespace rnexecutorch {
+namespace models::embeddings {
 
 struct TokenIdsWithAttentionMask {
   std::vector<int64_t> inputIds;
@@ -22,5 +24,8 @@ private:
   TokenIdsWithAttentionMask preprocess(const std::string &input);
   std::unique_ptr<TokenizerModule> tokenizer;
 };
+} // namespace models::embeddings
 
-}; // namespace rnexecutorch
+REGISTER_CONSTRUCTOR(models::embeddings::TextEmbeddings, std::string,
+                     std::string, std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

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

@@ -3,11 +3,11 @@
 #include <array>
 #include <string_view>
 
-namespace rnexecutorch {
-inline constexpr std::array<std::string_view, 21> DEEPLABV3_RESNET50_LABELS = {
+namespace rnexecutorch::models::image_segmentation::constants {
+inline constexpr std::array<std::string_view, 21> kDeeplabV3Resnet50Labels = {
     "BACKGROUND", "AEROPLANE",   "BICYCLE", "BIRD",  "BOAT",
     "BOTTLE",     "BUS",         "CAR",     "CAT",   "CHAIR",
     "COW",        "DININGTABLE", "DOG",     "HORSE", "MOTORBIKE",
     "PERSON",     "POTTEDPLANT", "SHEEP",   "SOFA",  "TRAIN",
     "TVMONITOR"};
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::image_segmentation::constants

package/common/rnexecutorch/models/image_segmentation/ImageSegmentation.cpp

@@ -9,7 +9,7 @@
 #include <rnexecutorch/host_objects/JsiConversions.h>
 #include <rnexecutorch/models/image_segmentation/Constants.h>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::image_segmentation {
 
 ImageSegmentation::ImageSegmentation(
     const std::string &modelSource,
@@ -37,7 +37,7 @@ std::shared_ptr<jsi::Object> ImageSegmentation::generate(
     std::string imageSource,
     std::set<std::string, std::less<>> classesOfInterest, bool resize) {
   auto [inputTensor, originalSize] =
-      imageprocessing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
 
   auto forwardResult = BaseModel::forward(inputTensor);
   if (!forwardResult.ok()) {
@@ -101,8 +101,9 @@ std::shared_ptr<jsi::Object> ImageSegmentation::postprocess(
   auto buffersToReturn = std::make_shared<std::unordered_map<
       std::string_view, std::shared_ptr<OwningArrayBuffer>>>();
   for (std::size_t cl = 0; cl < numClasses; ++cl) {
-    if (classesOfInterest.contains(DEEPLABV3_RESNET50_LABELS[cl])) {
-      (*buffersToReturn)[DEEPLABV3_RESNET50_LABELS[cl]] = resultClasses[cl];
+    if (classesOfInterest.contains(constants::kDeeplabV3Resnet50Labels[cl])) {
+      (*buffersToReturn)[constants::kDeeplabV3Resnet50Labels[cl]] =
+          resultClasses[cl];
     }
   }
 
@@ -170,4 +171,4 @@ std::shared_ptr<jsi::Object> ImageSegmentation::populateDictionary(
   return dictPtr;
 }
 
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::image_segmentation

package/common/rnexecutorch/models/image_segmentation/ImageSegmentation.h

@@ -7,11 +7,13 @@
 #include <jsi/jsi.h>
 #include <opencv2/opencv.hpp>
 
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
 #include <rnexecutorch/jsi/OwningArrayBuffer.h>
 #include <rnexecutorch/models/BaseModel.h>
 #include <rnexecutorch/models/image_segmentation/Constants.h>
 
 namespace rnexecutorch {
+namespace models::image_segmentation {
 using namespace facebook;
 
 using executorch::aten::Tensor;
@@ -36,8 +38,13 @@ private:
                                          std::shared_ptr<OwningArrayBuffer>>>
           classesToOutput);
 
-  static constexpr std::size_t numClasses{DEEPLABV3_RESNET50_LABELS.size()};
+  static constexpr std::size_t numClasses{
+      constants::kDeeplabV3Resnet50Labels.size()};
   cv::Size modelImageSize;
   std::size_t numModelPixels;
 };
+} // namespace models::image_segmentation
+
+REGISTER_CONSTRUCTOR(models::image_segmentation::ImageSegmentation, std::string,
+                     std::shared_ptr<react::CallInvoker>);
 } // namespace rnexecutorch

package/common/rnexecutorch/models/llm/LLM.cpp

@@ -0,0 +1,58 @@
+#include "LLM.h"
+
+#include <executorch/extension/tensor/tensor.h>
+#include <filesystem>
+
+namespace rnexecutorch::models::llm {
+using namespace facebook;
+using executorch::extension::TensorPtr;
+using executorch::runtime::Error;
+
+LLM::LLM(const std::string &modelSource, const std::string &tokenizerSource,
+         std::shared_ptr<react::CallInvoker> callInvoker)
+    : runner(std::make_unique<example::Runner>(modelSource, tokenizerSource)),
+      callInvoker(callInvoker) {
+
+  auto loadResult = runner->load();
+  if (loadResult != Error::Ok) {
+    throw std::runtime_error("Failed to load LLM runner, error code: " +
+                             std::to_string(static_cast<int>(loadResult)));
+  }
+  memorySizeLowerBound =
+      std::filesystem::file_size(std::filesystem::path(modelSource)) +
+      std::filesystem::file_size(std::filesystem::path(tokenizerSource));
+}
+
+void LLM::generate(std::string input, std::shared_ptr<jsi::Function> callback) {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Runner is not loaded");
+  }
+
+  // Create a native callback that will invoke the JS callback on the JS thread
+  auto nativeCallback = [this, callback](const std::string &token) {
+    callInvoker->invokeAsync([callback, token](jsi::Runtime &runtime) {
+      callback->call(runtime, jsi::String::createFromUtf8(runtime, token));
+    });
+  };
+
+  auto error = runner->generate(input, nativeCallback, {}, false);
+  if (error != executorch::runtime::Error::Ok) {
+    throw std::runtime_error("Failed to generate text, error code: " +
+                             std::to_string(static_cast<int>(error)));
+  }
+}
+
+void LLM::interrupt() {
+  if (!runner || !runner->is_loaded()) {
+    throw std::runtime_error("Can't interrupt a model that's not loaded!");
+  }
+  runner->stop();
+}
+
+std::size_t LLM::getMemoryLowerBound() const noexcept {
+  return memorySizeLowerBound;
+}
+
+void LLM::unload() noexcept { runner.reset(nullptr); }
+
+} // namespace rnexecutorch::models::llm

package/common/rnexecutorch/models/llm/LLM.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "rnexecutorch/metaprogramming/ConstructorHelpers.h"
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+#include <runner/runner.h>
+
+namespace rnexecutorch {
+namespace models::llm {
+using namespace facebook;
+
+class LLM {
+public:
+  explicit LLM(const std::string &modelSource,
+               const std::string &tokenizerSource,
+               std::shared_ptr<react::CallInvoker> callInvoker);
+
+  void generate(std::string input, std::shared_ptr<jsi::Function> callback);
+  void interrupt();
+  void unload() noexcept;
+  std::size_t getMemoryLowerBound() const noexcept;
+
+private:
+  size_t memorySizeLowerBound;
+  std::unique_ptr<example::Runner> runner;
+  std::shared_ptr<react::CallInvoker> callInvoker;
+};
+} // namespace models::llm
+
+REGISTER_CONSTRUCTOR(models::llm::LLM, std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+} // namespace rnexecutorch

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

@@ -3,10 +3,10 @@
 #include <string>
 #include <unordered_map>
 
-namespace rnexecutorch {
+namespace rnexecutorch::models::object_detection::constants {
 inline constexpr float IOU_THRESHOLD = 0.55;
 
-inline const std::unordered_map<int, std::string> COCO_LABELS_MAP = {
+inline const std::unordered_map<int, std::string> kCocoLablesMap = {
     {1, "PERSON"},         {2, "BICYCLE"},       {3, "CAR"},
     {4, "MOTORCYCLE"},     {5, "AIRPLANE"},      {6, "BUS"},
     {7, "TRAIN"},          {8, "TRUCK"},         {9, "BOAT"},
@@ -38,4 +38,4 @@ inline const std::unordered_map<int, std::string> COCO_LABELS_MAP = {
     {85, "CLOCK"},         {86, "VASE"},         {87, "SCISSORS"},
     {88, "TEDDY_BEAR"},    {89, "HAIR_DRIER"},   {90, "TOOTHBRUSH"},
     {91, "HAIR_BRUSH"}};
-} // namespace rnexecutorch
+} // namespace rnexecutorch::models::object_detection::constants

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