react-native-executorch 0.4.7 → 0.5.0

package/common/rnexecutorch/RnExecutorchInstaller.cpp

@@ -0,0 +1,78 @@
+#include "RnExecutorchInstaller.h"
+
+#include <rnexecutorch/TokenizerModule.h>
+#include <rnexecutorch/host_objects/JsiConversions.h>
+#include <rnexecutorch/models/classification/Classification.h>
+#include <rnexecutorch/models/embeddings/image/ImageEmbeddings.h>
+#include <rnexecutorch/models/embeddings/text/TextEmbeddings.h>
+#include <rnexecutorch/models/image_segmentation/ImageSegmentation.h>
+#include <rnexecutorch/models/object_detection/ObjectDetection.h>
+#include <rnexecutorch/models/ocr/OCR.h>
+#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
+#include <rnexecutorch/models/style_transfer/StyleTransfer.h>
+#include <rnexecutorch/models/vertical_ocr/VerticalOCR.h>
+
+namespace rnexecutorch {
+
+// This function fetches data from a url address. It is implemented in
+// Kotlin/ObjectiveC++ and then bound to this variable. It's done to not handle
+// SSL intricacies manually, as it is done automagically in ObjC++/Kotlin.
+FetchUrlFunc_t fetchUrlFunc;
+
+void RnExecutorchInstaller::injectJSIBindings(
+    jsi::Runtime *jsiRuntime, std::shared_ptr<react::CallInvoker> jsCallInvoker,
+    FetchUrlFunc_t fetchDataFromUrl) {
+  fetchUrlFunc = fetchDataFromUrl;
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadStyleTransfer",
+      RnExecutorchInstaller::loadModel<StyleTransfer>(jsiRuntime, jsCallInvoker,
+                                                      "loadStyleTransfer"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadImageSegmentation",
+      RnExecutorchInstaller::loadModel<ImageSegmentation>(
+          jsiRuntime, jsCallInvoker, "loadImageSegmentation"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadClassification",
+      RnExecutorchInstaller::loadModel<Classification>(
+          jsiRuntime, jsCallInvoker, "loadClassification"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadObjectDetection",
+      RnExecutorchInstaller::loadModel<ObjectDetection>(
+          jsiRuntime, jsCallInvoker, "loadObjectDetection"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadExecutorchModule",
+      RnExecutorchInstaller::loadModel<BaseModel>(jsiRuntime, jsCallInvoker,
+                                                  "loadExecutorchModule"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadTokenizerModule",
+      RnExecutorchInstaller::loadModel<TokenizerModule>(
+          jsiRuntime, jsCallInvoker, "loadTokenizerModule"));
+
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadImageEmbeddings",
+      RnExecutorchInstaller::loadModel<ImageEmbeddings>(
+          jsiRuntime, jsCallInvoker, "loadImageEmbeddings"));
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadTextEmbeddings",
+      RnExecutorchInstaller::loadModel<TextEmbeddings>(
+          jsiRuntime, jsCallInvoker, "loadTextEmbeddings"));
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadSpeechToText",
+      RnExecutorchInstaller::loadModel<SpeechToText>(jsiRuntime, jsCallInvoker,
+                                                     "loadSpeechToText"));
+
+  jsiRuntime->global().setProperty(*jsiRuntime, "loadOCR",
+                                   RnExecutorchInstaller::loadModel<OCR>(
+                                       jsiRuntime, jsCallInvoker, "loadOCR"));
+  jsiRuntime->global().setProperty(
+      *jsiRuntime, "loadVerticalOCR",
+      RnExecutorchInstaller::loadModel<VerticalOCR>(jsiRuntime, jsCallInvoker,
+                                                    "loadVerticalOCR"));
+}
+} // namespace rnexecutorch

package/common/rnexecutorch/RnExecutorchInstaller.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <memory>
+#include <rnexecutorch/models/speech_to_text/SpeechToText.h>
+#include <string>
+
+#include <ReactCommon/CallInvoker.h>
+#include <jsi/jsi.h>
+
+#include <rnexecutorch/host_objects/JsiConversions.h>
+#include <rnexecutorch/host_objects/ModelHostObject.h>
+#include <rnexecutorch/metaprogramming/ConstructorHelpers.h>
+#include <rnexecutorch/metaprogramming/FunctionHelpers.h>
+#include <rnexecutorch/metaprogramming/TypeConcepts.h>
+
+namespace rnexecutorch {
+
+using FetchUrlFunc_t = std::function<std::vector<std::byte>(std::string)>;
+extern FetchUrlFunc_t fetchUrlFunc;
+
+REGISTER_CONSTRUCTOR(StyleTransfer, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(ImageSegmentation, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(Classification, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(ObjectDetection, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(BaseModel, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(TokenizerModule, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(ImageEmbeddings, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(TextEmbeddings, std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(SpeechToText, std::string, std::string, std::string,
+                     std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(OCR, std::string, std::string, std::string, std::string,
+                     std::string, std::shared_ptr<react::CallInvoker>);
+REGISTER_CONSTRUCTOR(VerticalOCR, std::string, std::string, std::string,
+                     std::string, bool, std::shared_ptr<react::CallInvoker>);
+
+using namespace facebook;
+
+class RnExecutorchInstaller {
+public:
+  static void
+  injectJSIBindings(jsi::Runtime *jsiRuntime,
+                    std::shared_ptr<react::CallInvoker> jsCallInvoker,
+                    FetchUrlFunc_t fetchDataFromUrl);
+
+private:
+  template <typename ModelT>
+    requires meta::ValidConstructorTraits<ModelT> &&
+             meta::CallInvokerLastInConstructor<ModelT> &&
+             meta::ProvidesMemoryLowerBound<ModelT>
+  static jsi::Function
+  loadModel(jsi::Runtime *jsiRuntime,
+            std::shared_ptr<react::CallInvoker> jsCallInvoker,
+            const std::string &loadFunctionName) {
+    return jsi::Function::createFromHostFunction(
+        *jsiRuntime, jsi::PropNameID::forAscii(*jsiRuntime, loadFunctionName),
+        0,
+        [jsCallInvoker](jsi::Runtime &runtime, const jsi::Value &thisValue,
+                        const jsi::Value *args, size_t count) -> jsi::Value {
+          constexpr std::size_t expectedCount = std::tuple_size_v<
+              typename meta::ConstructorTraits<ModelT>::arg_types>;
+          // count doesn't account for the JSCallInvoker
+          if (count != expectedCount - 1) {
+            char errorMessage[100];
+            std::snprintf(
+                errorMessage, sizeof(errorMessage),
+                "Argument count mismatch, was expecting: %zu but got: %zu",
+                expectedCount, count);
+            throw jsi::JSError(runtime, errorMessage);
+          }
+          try {
+            auto constructorArgs =
+                meta::createConstructorArgsWithCallInvoker<ModelT>(
+                    args, runtime, jsCallInvoker);
+
+            auto modelImplementationPtr = std::make_shared<ModelT>(
+                std::make_from_tuple<ModelT>(constructorArgs));
+            auto modelHostObject = std::make_shared<ModelHostObject<ModelT>>(
+                modelImplementationPtr, jsCallInvoker);
+
+            auto jsiObject =
+                jsi::Object::createFromHostObject(runtime, modelHostObject);
+            jsiObject.setExternalMemoryPressure(
+                runtime, modelImplementationPtr->getMemoryLowerBound());
+            return jsiObject;
+          } catch (const std::runtime_error &e) {
+            // This catch should be merged with the next one
+            // (std::runtime_error inherits from std::exception) HOWEVER react
+            // native has broken RTTI which breaks proper exception type
+            // checking. Remove when the following change is present in our
+            // version:
+            // https://github.com/facebook/react-native/commit/3132cc88dd46f95898a756456bebeeb6c248f20e
+            throw jsi::JSError(runtime, e.what());
+            return jsi::Value();
+          } catch (const std::exception &e) {
+            throw jsi::JSError(runtime, e.what());
+            return jsi::Value();
+          } catch (...) {
+            throw jsi::JSError(runtime, "Unknown error");
+            return jsi::Value();
+          }
+        });
+  }
+};
+} // namespace rnexecutorch

package/common/rnexecutorch/TokenizerModule.cpp

@@ -0,0 +1,52 @@
+#include "TokenizerModule.h"
+#include <executorch/extension/module/module.h>
+#include <filesystem>
+#include <rnexecutorch/data_processing/FileUtils.h>
+
+namespace rnexecutorch {
+using namespace facebook;
+
+TokenizerModule::TokenizerModule(
+    std::string source, std::shared_ptr<react::CallInvoker> callInvoker)
+    : memorySizeLowerBound(std::filesystem::file_size(source)),
+      tokenizer(tokenizers::Tokenizer::FromBlobJSON(
+          fileutils::loadBytesFromFile(source))) {}
+
+void TokenizerModule::ensureTokenizerLoaded(
+    const std::string &methodName) const {
+  if (!tokenizer) {
+    throw std::runtime_error(
+        methodName + " function was called on an uninitialized tokenizer!");
+  }
+}
+
+std::vector<int32_t> TokenizerModule::encode(std::string s) const {
+  ensureTokenizerLoaded("encode");
+  return tokenizer->Encode(s);
+}
+
+std::string TokenizerModule::decode(std::vector<int32_t> vec,
+                                    bool skipSpecialTokens) const {
+  ensureTokenizerLoaded("decode");
+  return tokenizer->Decode(vec, skipSpecialTokens);
+}
+
+size_t TokenizerModule::getVocabSize() const {
+  ensureTokenizerLoaded("getVocabSize");
+  return tokenizer->GetVocabSize();
+}
+
+std::string TokenizerModule::idToToken(int32_t tokenId) const {
+  ensureTokenizerLoaded("idToToken");
+  return tokenizer->IdToToken(tokenId);
+}
+
+int32_t TokenizerModule::tokenToId(std::string token) const {
+  ensureTokenizerLoaded("tokenToId");
+  return tokenizer->TokenToId(token);
+}
+std::size_t TokenizerModule::getMemoryLowerBound() const noexcept {
+  return memorySizeLowerBound;
+}
+
+} // namespace rnexecutorch

package/common/rnexecutorch/TokenizerModule.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <string>
+#include <tokenizers-cpp/tokenizers_cpp.h>
+
+namespace rnexecutorch {
+using namespace facebook;
+
+class TokenizerModule {
+public:
+  explicit TokenizerModule(std::string source,
+                           std::shared_ptr<react::CallInvoker> callInvoker);
+  std::vector<int32_t> encode(std::string s) const;
+  std::string decode(std::vector<int32_t> vec, bool skipSpecialTokens) const;
+  std::string idToToken(int32_t tokenId) const;
+  int32_t tokenToId(std::string token) const;
+  std::size_t getVocabSize() const;
+  std::size_t getMemoryLowerBound() const noexcept;
+
+private:
+  void ensureTokenizerLoaded(const std::string &methodName) const;
+  std::unique_ptr<tokenizers::Tokenizer> tokenizer;
+  const std::size_t memorySizeLowerBound{0};
+};
+} // namespace rnexecutorch

package/common/rnexecutorch/data_processing/FFT.cpp

@@ -0,0 +1,21 @@
+#include <rnexecutorch/data_processing/FFT.h>
+
+namespace rnexecutorch::dsp {
+
+FFT::FFT(int size) : size_(size) {
+  pffftSetup_ = pffft_new_setup(size_, PFFFT_REAL);
+  work_ = static_cast<float *>(pffft_aligned_malloc(size_ * sizeof(float)));
+}
+
+FFT::~FFT() {
+  pffft_destroy_setup(pffftSetup_);
+  pffft_aligned_free(work_);
+}
+
+void FFT::doFFT(float *in, std::vector<std::complex<float>> &out) {
+  pffft_transform_ordered(pffftSetup_, in,
+                          reinterpret_cast<float *>(out.data()), work_,
+                          PFFFT_FORWARD);
+}
+
+} // namespace rnexecutorch::dsp

package/common/rnexecutorch/data_processing/FFT.h

@@ -0,0 +1,23 @@
+#pragma once
+extern "C" {
+#include <pfft/pfft.h>
+}
+#include <complex>
+#include <vector>
+
+namespace rnexecutorch::dsp {
+
+class FFT final {
+public:
+  explicit FFT(int size);
+  ~FFT();
+  void doFFT(float *in, std::vector<std::complex<float>> &out);
+
+private:
+  int size_;
+
+  PFFFT_Setup *pffftSetup_;
+  float *work_;
+};
+
+} // namespace rnexecutorch::dsp

package/common/rnexecutorch/data_processing/FileUtils.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <chrono>
+#include <filesystem>
+#include <fstream>
+#include <string>
+
+namespace rnexecutorch::fileutils {
+
+inline std::string getTimeID() {
+  return std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(
+                            std::chrono::system_clock::now().time_since_epoch())
+                            .count());
+}
+
+inline std::string loadBytesFromFile(const std::string &path) {
+  std::ifstream fs(path, std::ios::in | std::ios::binary);
+  if (fs.fail()) {
+    throw std::runtime_error("Failed to open tokenizer file");
+  }
+  std::string data;
+  fs.seekg(0, std::ios::end);
+  size_t size = static_cast<size_t>(fs.tellg());
+  fs.seekg(0, std::ios::beg);
+  data.resize(size);
+  fs.read(data.data(), size);
+  return data;
+};
+
+} // namespace rnexecutorch::fileutils

package/common/rnexecutorch/data_processing/ImageProcessing.cpp

@@ -0,0 +1,240 @@
+#include "ImageProcessing.h"
+
+#include <filesystem>
+
+#include <ada/ada.h>
+
+#include <rnexecutorch/RnExecutorchInstaller.h>
+#include <rnexecutorch/data_processing/FileUtils.h>
+#include <rnexecutorch/data_processing/base64.h>
+
+namespace rnexecutorch {
+// This is defined in RnExecutorchInstaller.cpp. This function fetches data
+// from a url address. It is implemented in Kotlin/ObjectiveC++ and then bound
+// to this variable. It's done to not handle SSL intricacies manually, as it is
+// done automagically in ObjC++/Kotlin.
+extern FetchUrlFunc_t fetchUrlFunc;
+namespace imageprocessing {
+std::vector<float> colorMatToVector(const cv::Mat &mat) {
+  return colorMatToVector(mat, cv::Scalar(0.0, 0.0, 0.0),
+                          cv::Scalar(1.0, 1.0, 1.0));
+}
+
+std::vector<float> colorMatToVector(const cv::Mat &mat, cv::Scalar mean,
+                                    cv::Scalar variance) {
+  int pixelCount = mat.cols * mat.rows;
+  std::vector<float> v(pixelCount * 3);
+
+  for (int i = 0; i < pixelCount; i++) {
+    int row = i / mat.cols;
+    int col = i % mat.cols;
+    cv::Vec3b pixel = mat.at<cv::Vec3b>(row, col);
+    v[0 * pixelCount + i] =
+        (pixel[0] - mean[0] * 255.0) / (variance[0] * 255.0);
+    v[1 * pixelCount + i] =
+        (pixel[1] - mean[1] * 255.0) / (variance[1] * 255.0);
+    v[2 * pixelCount + i] =
+        (pixel[2] - mean[2] * 255.0) / (variance[2] * 255.0);
+  }
+
+  return v;
+}
+
+cv::Mat bufferToColorMat(const std::span<const float> &buffer,
+                         cv::Size matSize) {
+  cv::Mat mat(matSize, CV_8UC3);
+
+  int pixelCount = matSize.width * matSize.height;
+  for (int i = 0; i < pixelCount; i++) {
+    int row = i / matSize.width;
+    int col = i % matSize.width;
+
+    float r = buffer[0 * pixelCount + i];
+    float g = buffer[1 * pixelCount + i];
+    float b = buffer[2 * pixelCount + i];
+
+    cv::Vec3b color(static_cast<uchar>(b * 255), static_cast<uchar>(g * 255),
+                    static_cast<uchar>(r * 255));
+    mat.at<cv::Vec3b>(row, col) = color;
+  }
+
+  return mat;
+}
+
+std::string saveToTempFile(const cv::Mat &image) {
+  std::string filename = "rn_executorch_" + fileutils::getTimeID() + ".png";
+
+  std::filesystem::path tempDir = std::filesystem::temp_directory_path();
+  std::filesystem::path filePath = tempDir / filename;
+
+  if (!cv::imwrite(filePath.string(), image)) {
+    throw std::runtime_error("Failed to save the image: " + filePath.string());
+  }
+
+  return "file://" + filePath.string();
+}
+
+cv::Mat readImage(const std::string &imageURI) {
+  cv::Mat image;
+
+  if (imageURI.starts_with("data")) {
+    // base64
+    std::stringstream uriStream(imageURI);
+    std::string stringData;
+    std::size_t segmentIndex{0};
+    while (std::getline(uriStream, stringData, ',')) {
+      ++segmentIndex;
+    }
+    if (segmentIndex != 1) {
+      throw std::runtime_error("Read image error: invalid base64 URI");
+    }
+    auto data = base64_decode(stringData);
+    cv::Mat encodedData(1, data.size(), CV_8UC1, (void *)data.data());
+    image = cv::imdecode(encodedData, cv::IMREAD_COLOR);
+  } else if (imageURI.starts_with("file")) {
+    // local file
+    auto url = ada::parse(imageURI);
+    image = cv::imread(std::string{url->get_pathname()}, cv::IMREAD_COLOR);
+  } else if (imageURI.starts_with("http")) {
+    // remote file
+    std::vector<std::byte> imageData = fetchUrlFunc(imageURI);
+    image = cv::imdecode(
+        cv::Mat(1, imageData.size(), CV_8UC1, (void *)imageData.data()),
+        cv::IMREAD_COLOR);
+  } else {
+    throw std::runtime_error("Read image error: unknown protocol");
+  }
+
+  if (image.empty()) {
+    throw std::runtime_error("Read image error: invalid argument");
+  }
+
+  return image;
+}
+
+TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
+                              const cv::Mat &matrix) {
+  return executorch::extension::make_tensor_ptr(tensorDims,
+                                                colorMatToVector(matrix));
+}
+
+TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
+                              const cv::Mat &matrix, cv::Scalar mean,
+                              cv::Scalar variance) {
+  return executorch::extension::make_tensor_ptr(
+      tensorDims, colorMatToVector(matrix, mean, variance));
+}
+
+TensorPtr getTensorFromMatrixGray(const std::vector<int32_t> &tensorDims,
+                                  const cv::Mat &matrix) {
+  return executorch::extension::make_tensor_ptr(tensorDims,
+                                                grayMatToVector(matrix));
+}
+
+std::vector<float> grayMatToVector(const cv::Mat &mat) {
+  CV_Assert(mat.type() == CV_32F);
+  if (mat.isContinuous()) {
+    return {mat.ptr<float>(), mat.ptr<float>() + mat.total()};
+  }
+
+  std::vector<float> v;
+  v.reserve(mat.total());
+  for (int i = 0; i < mat.rows; ++i) {
+    v.insert(v.end(), mat.ptr<float>(i), mat.ptr<float>(i) + mat.cols);
+  }
+  return v;
+}
+
+cv::Mat getMatrixFromTensor(cv::Size size, const Tensor &tensor) {
+  auto resultData = static_cast<const float *>(tensor.const_data_ptr());
+  return bufferToColorMat(std::span<const float>(resultData, tensor.numel()),
+                          size);
+}
+
+cv::Mat resizePadded(const cv::Mat inputImage, cv::Size targetSize) {
+  cv::Size inputSize = inputImage.size();
+  const float heightRatio =
+      static_cast<float>(targetSize.height) / inputSize.height;
+  const float widthRatio =
+      static_cast<float>(targetSize.width) / inputSize.width;
+  const float resizeRatio = std::min(heightRatio, widthRatio);
+  const int newWidth = inputSize.width * resizeRatio;
+  const int newHeight = inputSize.height * resizeRatio;
+  cv::Mat resizedImg;
+  cv::resize(inputImage, resizedImg, cv::Size(newWidth, newHeight), 0, 0,
+             cv::INTER_AREA);
+  constexpr int minCornerPatchSize = 1;
+  constexpr int cornerPatchFractionSize = 30;
+  int cornerPatchSize =
+      std::min(inputSize.height, inputSize.width) / cornerPatchFractionSize;
+  cornerPatchSize = std::max(minCornerPatchSize, cornerPatchSize);
+
+  const std::array<cv::Mat, 4> corners = {
+      inputImage(cv::Rect(0, 0, cornerPatchSize, cornerPatchSize)),
+      inputImage(cv::Rect(inputSize.width - cornerPatchSize, 0, cornerPatchSize,
+                          cornerPatchSize)),
+      inputImage(cv::Rect(0, inputSize.height - cornerPatchSize,
+                          cornerPatchSize, cornerPatchSize)),
+      inputImage(cv::Rect(inputSize.width - cornerPatchSize,
+                          inputSize.height - cornerPatchSize, cornerPatchSize,
+                          cornerPatchSize))};
+
+  // We choose the color of the padding based on a mean of colors in the corners
+  // of an image.
+  cv::Scalar backgroundScalar = cv::mean(corners[0]);
+#pragma unroll
+  for (size_t i = 1; i < corners.size(); i++) {
+    backgroundScalar += cv::mean(corners[i]);
+  }
+  backgroundScalar /= static_cast<double>(corners.size());
+
+  constexpr size_t numChannels = 3;
+#pragma unroll
+  for (size_t i = 0; i < numChannels; ++i) {
+    backgroundScalar[i] = cvFloor(backgroundScalar[i]);
+  }
+
+  const int deltaW = targetSize.width - newWidth;
+  const int deltaH = targetSize.height - newHeight;
+  const int top = deltaH / 2;
+  const int bottom = deltaH - top;
+  const int left = deltaW / 2;
+  const int right = deltaW - left;
+
+  cv::Mat centeredImg;
+  cv::copyMakeBorder(resizedImg, centeredImg, top, bottom, left, right,
+                     cv::BORDER_CONSTANT, backgroundScalar);
+
+  return centeredImg;
+}
+
+std::pair<TensorPtr, cv::Size>
+readImageToTensor(const std::string &path,
+                  const std::vector<int32_t> &tensorDims,
+                  bool maintainAspectRatio) {
+  cv::Mat input = imageprocessing::readImage(path);
+  cv::Size imageSize = input.size();
+
+  if (tensorDims.size() < 2) {
+    char errorMessage[100];
+    std::snprintf(errorMessage, sizeof(errorMessage),
+                  "Unexpected tensor size, expected at least 2 dimentions "
+                  "but got: %zu.",
+                  tensorDims.size());
+    throw std::runtime_error(errorMessage);
+  }
+  cv::Size tensorSize = cv::Size(tensorDims[tensorDims.size() - 1],
+                                 tensorDims[tensorDims.size() - 2]);
+
+  if (maintainAspectRatio) {
+    input = resizePadded(input, tensorSize);
+  } else {
+    cv::resize(input, input, tensorSize);
+  }
+
+  cv::cvtColor(input, input, cv::COLOR_BGR2RGB);
+
+  return {imageprocessing::getTensorFromMatrix(tensorDims, input), imageSize};
+}
+} // namespace imageprocessing
+} // namespace rnexecutorch

package/common/rnexecutorch/data_processing/ImageProcessing.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <executorch/extension/tensor/tensor.h>
+#include <executorch/extension/tensor/tensor_ptr.h>
+#include <opencv2/opencv.hpp>
+#include <optional>
+#include <span>
+#include <string>
+#include <vector>
+
+namespace rnexecutorch::imageprocessing {
+using executorch::aten::Tensor;
+using executorch::extension::TensorPtr;
+
+/// @brief Convert a OpenCV matrix to channel-first vector representation
+std::vector<float> colorMatToVector(const cv::Mat &mat, cv::Scalar mean,
+                                    cv::Scalar variance);
+/// @brief Convert a OpenCV matrix to channel-first vector representation
+std::vector<float> colorMatToVector(const cv::Mat &mat);
+/// @brief Convert a channel-first representation of an RGB image to OpenCV
+/// matrix
+cv::Mat bufferToColorMat(const std::span<const float> &buffer,
+                         cv::Size matSize);
+std::string saveToTempFile(const cv::Mat &image);
+/// @brief Read image in a BGR format to a cv::Mat
+cv::Mat readImage(const std::string &imageURI);
+TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
+                              const cv::Mat &mat);
+TensorPtr getTensorFromMatrix(const std::vector<int32_t> &tensorDims,
+                              const cv::Mat &matrix, cv::Scalar mean,
+                              cv::Scalar variance);
+cv::Mat getMatrixFromTensor(cv::Size size, const Tensor &tensor);
+TensorPtr getTensorFromMatrixGray(const std::vector<int32_t> &tensorDims,
+                                  const cv::Mat &matrix);
+std::vector<float> grayMatToVector(const cv::Mat &mat);
+/**
+ * @brief Resizes an image to fit within target dimensions while preserving
+ * aspect ratio, adding padding if needed. Padding color is derived from the
+ * image's corner pixels for seamless blending.
+ */
+cv::Mat resizePadded(const cv::Mat inputImage, cv::Size targetSize);
+/// @brief Read image, resize it and copy it to an ET tensor to store it.
+/// @param path Path to the image to be resized. Could be base64, local file or
+/// remote URL
+/// @param tensorDims The dimensions of the result tensor. The two last
+/// dimensions are taken as the image resolution.
+/// @param maintainAspectRatio If set to true the image will be resized to
+/// maintain the original aspect ratio. The rest of the tensor will be filled
+/// padding.
+/// @return Returns a tensor pointer and the original size of the image.
+std::pair<TensorPtr, cv::Size>
+readImageToTensor(const std::string &path,
+                  const std::vector<int32_t> &tensorDims,
+                  bool maintainAspectRatio = false);
+} // namespace rnexecutorch::imageprocessing