react-native-executorch 0.4.9 → 0.5.0-nightly-6f4dd53-20251211

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

@@ -0,0 +1,82 @@
+#include "ObjectDetection.h"
+
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+
+namespace rnexecutorch::models::object_detection {
+
+ObjectDetection::ObjectDetection(
+    const std::string &modelSource,
+    std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto inputTensors = getAllInputShapes();
+  if (inputTensors.size() == 0) {
+    throw std::runtime_error("Model seems to not take any input tensors.");
+  }
+  std::vector<int32_t> modelInputShape = inputTensors[0];
+  if (modelInputShape.size() < 2) {
+    char errorMessage[100];
+    std::snprintf(errorMessage, sizeof(errorMessage),
+                  "Unexpected model input size, expected at least 2 dimentions "
+                  "but got: %zu.",
+                  modelInputShape.size());
+    throw std::runtime_error(errorMessage);
+  }
+  modelImageSize = cv::Size(modelInputShape[modelInputShape.size() - 1],
+                            modelInputShape[modelInputShape.size() - 2]);
+}
+
+std::vector<types::Detection>
+ObjectDetection::postprocess(const std::vector<EValue> &tensors,
+                             cv::Size originalSize, double detectionThreshold) {
+  float widthRatio =
+      static_cast<float>(originalSize.width) / modelImageSize.width;
+  float heightRatio =
+      static_cast<float>(originalSize.height) / modelImageSize.height;
+
+  std::vector<types::Detection> detections;
+  auto bboxTensor = tensors.at(0).toTensor();
+  std::span<const float> bboxes(
+      static_cast<const float *>(bboxTensor.const_data_ptr()),
+      bboxTensor.numel());
+
+  auto scoreTensor = tensors.at(1).toTensor();
+  std::span<const float> scores(
+      static_cast<const float *>(scoreTensor.const_data_ptr()),
+      scoreTensor.numel());
+
+  auto labelTensor = tensors.at(2).toTensor();
+  std::span<const float> labels(
+      static_cast<const float *>(labelTensor.const_data_ptr()),
+      labelTensor.numel());
+
+  for (std::size_t i = 0; i < scores.size(); ++i) {
+    if (scores[i] < detectionThreshold) {
+      continue;
+    }
+    float x1 = bboxes[i * 4] * widthRatio;
+    float y1 = bboxes[i * 4 + 1] * heightRatio;
+    float x2 = bboxes[i * 4 + 2] * widthRatio;
+    float y2 = bboxes[i * 4 + 3] * heightRatio;
+    detections.emplace_back(x1, y1, x2, y2, static_cast<int>(labels[i]),
+                            scores[i]);
+  }
+
+  std::vector<types::Detection> output = utils::nonMaxSuppression(detections);
+  return output;
+}
+
+std::vector<types::Detection>
+ObjectDetection::generate(std::string imageSource, double detectionThreshold) {
+  auto [inputTensor, originalSize] =
+      image_processing::readImageToTensor(imageSource, getAllInputShapes()[0]);
+
+  auto forwardResult = BaseModel::forward(inputTensor);
+  if (!forwardResult.ok()) {
+    throw std::runtime_error(
+        "Failed to forward, error: " +
+        std::to_string(static_cast<uint32_t>(forwardResult.error())));
+  }
+
+  return postprocess(forwardResult.get(), originalSize, detectionThreshold);
+}
+} // namespace rnexecutorch::models::object_detection

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

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <unordered_map>
+
+#include <executorch/extension/tensor/tensor_ptr.h>
+#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;
+
+class ObjectDetection : public BaseModel {
+public:
+  ObjectDetection(const std::string &modelSource,
+                  std::shared_ptr<react::CallInvoker> callInvoker);
+  std::vector<types::Detection> generate(std::string imageSource,
+                                         double detectionThreshold);
+
+private:
+  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/{ios/RnExecutorch/utils/ObjectDetectionUtils.mm → common/rnexecutorch/models/object_detection/Utils.cpp}

@@ -1,30 +1,9 @@
-#include "ObjectDetectionUtils.hpp"
+#include "Utils.h"
 #include "Constants.h"
 
-NSString *floatLabelToNSString(float label) {
-  int intLabel = static_cast<int>(label);
-  auto it = cocoLabelsMap.find(intLabel);
-  if (it != cocoLabelsMap.end()) {
-    return [NSString stringWithUTF8String:it->second.c_str()];
-  } else {
-    return [NSString stringWithUTF8String:"unknown"];
-  }
-}
-
-NSDictionary *detectionToNSDictionary(const Detection &detection) {
-  return @{
-    @"bbox" : @{
-      @"x1" : @(detection.x1),
-      @"y1" : @(detection.y1),
-      @"x2" : @(detection.x2),
-      @"y2" : @(detection.y2),
-    },
-    @"label" : floatLabelToNSString(detection.label),
-    @"score" : @(detection.score)
-  };
-}
-
-float iou(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);
@@ -36,42 +15,43 @@ float iou(const Detection &a, const Detection &b) {
   float unionArea = areaA + areaB - intersectionArea;
 
   return intersectionArea / unionArea;
-};
+}
 
-std::vector<Detection> nms(std::vector<Detection> detections,
-                           float iouThreshold) {
+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(),
-                         [&](const Detection &other) {
-                           return iou(current, other) > iouThreshold;
+                         [&current](const types::Detection &other) {
+                           return intersectionOverUnion(current, other) >
+                                  constants::IOU_THRESHOLD;
                          }),
           labelDetections.end());
     }
@@ -80,3 +60,5 @@ std::vector<Detection> nms(std::vector<Detection> detections,
   }
   return result;
 }
+
+} // namespace rnexecutorch::models::object_detection::utils

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

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Types.h"
+#include <vector>
+
+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

@@ -0,0 +1,88 @@
+#include "CTCLabelConverter.h"
+#include <algorithm>
+#include <optional>
+
+namespace rnexecutorch::models::ocr {
+CTCLabelConverter::CTCLabelConverter(const std::string &characters)
+    : ignoreIdx(0),
+      character({"[blank]"}) // blank character is ignored character (index 0).
+{
+  for (size_t i = 0; i < characters.length();) {
+    size_t char_len = 0;
+    unsigned char first_byte = characters[i];
+
+    if ((first_byte & 0x80) == 0) { // 0xxxxxxx -> 1-byte character
+      char_len = 1;
+    } else if ((first_byte & 0xE0) == 0xC0) { // 110xxxxx -> 2-byte character
+      char_len = 2;
+    } else if ((first_byte & 0xF0) == 0xE0) { // 1110xxxx -> 3-byte character
+      char_len = 3;
+    } else if ((first_byte & 0xF8) == 0xF0) { // 11110xxx -> 4-byte character
+      char_len = 4;
+    } else {
+      // Invalid UTF-8 start byte, treat as a single byte character to avoid
+      // infinite loop
+      char_len = 1;
+    }
+
+    // Ensure we don't read past the end of the string
+    if (i + char_len <= characters.length()) {
+      character.push_back(characters.substr(i, char_len));
+    }
+    i += char_len;
+  }
+}
+
+std::vector<std::string>
+CTCLabelConverter::decodeGreedy(const std::vector<int32_t> &textIndex,
+                                size_t length) {
+  /*
+   The current strategy used for decoding is greedy approach
+   which iterates through the list of indices and process
+   each index using following steps:
+    1. Ignore if idx == 0
+    2. Ignore if idx is the same as last idx
+    3. decode idx -> char and append it to returned text.
+
+   Note that ignoring repeated indices, does not mean decoding
+   won't handle repeated letters in a word, since in most cases
+   actual chars are already seperated by blank tokens.
+  */
+  std::vector<std::string> texts;
+  size_t index = 0;
+
+  while (index < textIndex.size()) {
+    size_t segmentLength = std::min(length, textIndex.size() - index);
+
+    std::vector<int32_t> subArray(textIndex.begin() + index,
+                                  textIndex.begin() + index + segmentLength);
+
+    std::string text;
+
+    if (!subArray.empty()) {
+      std::optional<int32_t> lastChar;
+      for (int32_t currentChar : subArray) {
+        bool isRepeated =
+            lastChar.has_value() && lastChar.value() == currentChar;
+        bool isIgnored = currentChar == ignoreIdx;
+        lastChar = currentChar;
+
+        if (currentChar >= 0 &&
+            currentChar < static_cast<int32_t>(character.size()) &&
+            !isRepeated && !isIgnored) {
+          text += character[currentChar];
+        }
+      }
+    }
+
+    texts.push_back(std::move(text));
+    index += segmentLength;
+
+    if (segmentLength < length) {
+      break;
+    }
+  }
+
+  return texts;
+}
+} // namespace rnexecutorch::models::ocr

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

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace rnexecutorch::models::ocr {
+/*
+ CTC (Connectionist Temporal Classification) Label Converter
+ is used for decoding the returned list of indices by Recognizer into
+ actual characters.
+ For each Recognizer there is an 1:1 correspondence between
+ an index and a character. CTC Label Converter operates on this
+ mapping. Symbol corresponding to the first index is a [blank]
+ character, meaning "no character to decode here".
+ The decoder ignores [blank] char.
+*/
+
+class CTCLabelConverter final {
+public:
+  explicit CTCLabelConverter(const std::string &characters);
+
+  std::vector<std::string> decodeGreedy(const std::vector<int32_t> &textIndex,
+                                        size_t length);
+
+private:
+  int32_t ignoreIdx;
+  std::vector<std::string> character;
+};
+} // namespace rnexecutorch::models::ocr

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cstdint>
+#include <opencv2/opencv.hpp>
+
+namespace rnexecutorch::models::ocr::constants {
+
+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;
+
+/*
+ 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::models::ocr::constants

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

@@ -0,0 +1,100 @@
+#include "Detector.h"
+#include <rnexecutorch/data_processing/ImageProcessing.h>
+#include <rnexecutorch/models/ocr/Constants.h>
+#include <rnexecutorch/models/ocr/utils/DetectorUtils.h>
+
+namespace rnexecutorch::models::ocr {
+Detector::Detector(const std::string &modelSource,
+                   std::shared_ptr<react::CallInvoker> callInvoker)
+    : BaseModel(modelSource, callInvoker) {
+  auto inputShapes = getAllInputShapes();
+  if (inputShapes.empty()) {
+    throw std::runtime_error(
+        "Detector model seems to not take any input tensors.");
+  }
+  std::vector<int32_t> modelInputShape = inputShapes[0];
+  if (modelInputShape.size() < 2) {
+    throw std::runtime_error("Unexpected detector model input size, expected "
+                             "at least 2 dimensions but got: " +
+                             std::to_string(modelInputShape.size()) + ".");
+  }
+  modelImageSize = cv::Size(modelInputShape[modelInputShape.size() - 1],
+                            modelInputShape[modelInputShape.size() - 2]);
+}
+
+cv::Size Detector::getModelImageSize() const noexcept { return modelImageSize; }
+
+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
+   either H=800 or H=1280.
+   Due to big influence of resize to quality of recognition the image preserves
+   original aspect ratio and the missing parts are filled with padding.
+   */
+  auto inputShapes = getAllInputShapes();
+  cv::Mat resizedInputImage =
+      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(
+        "Failed to forward, error: " +
+        std::to_string(static_cast<uint32_t>(forwardResult.error())));
+  }
+
+  return postprocess(forwardResult->at(0).toTensor());
+}
+
+std::vector<types::DetectorBBox>
+Detector::postprocess(const Tensor &tensor) const {
+  /*
+   The output of the model consists of two matrices (heat maps):
+   1. ScoreText(Score map) - The probability of a region containing character.
+   2. ScoreAffinity(Affinity map) - affinity between characters, used to to
+   group each character into a single instance (sequence) Both matrices are
+   H/2xW/2 (400x400 or 640x640).
+   */
+  std::span<const float> tensorData(tensor.const_data_ptr<float>(),
+                                    tensor.numel());
+  /*
+   The output of the model is a matrix half the size of the input image
+   containing two channels representing the heatmaps.
+   */
+  auto [scoreTextMat, scoreAffinityMat] = utils::interleavedArrayToMats(
+      tensorData,
+      cv::Size(modelImageSize.width / 2, modelImageSize.height / 2));
+
+  /*
+   Heatmaps are then converted into list of bounding boxes.
+  */
+  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.
+   RecognitionHandler in the later part of processing works on images of size
+   1280x1280. To match this difference we has to scale  by the proper factor
+   (3.2 or 2.0).
+  */
+  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 = utils::groupTextBoxes(
+      bBoxesList, constants::kCenterThreshold, constants::kDistanceThreshold,
+      constants::kHeightThreshold, constants::kMinSideThreshold,
+      constants::kMaxSideThreshold, constants::kMaxWidth);
+
+  return bBoxesList;
+}
+
+} // namespace rnexecutorch::models::ocr

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <executorch/extension/tensor/tensor_ptr.h>
+#include <opencv2/opencv.hpp>
+#include <rnexecutorch/models/BaseModel.h>
+#include <rnexecutorch/models/ocr/Types.h>
+
+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
+ based on CRAFT (Character Region Awareness for Text Detection) paper.
+ https://arxiv.org/pdf/1904.01941
+*/
+
+using executorch::aten::Tensor;
+using executorch::extension::TensorPtr;
+
+class Detector final : public BaseModel {
+public:
+  explicit Detector(const std::string &modelSource,
+                    std::shared_ptr<react::CallInvoker> callInvoker);
+  std::vector<types::DetectorBBox> generate(const cv::Mat &inputImage);
+  cv::Size getModelImageSize() const noexcept;
+
+private:
+  std::vector<types::DetectorBBox> postprocess(const Tensor &tensor) const;
+  cv::Size modelImageSize;
+};
+} // namespace rnexecutorch::models::ocr

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

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

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

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