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

package/ios/RnExecutorch/models/classification/ClassificationModel.mm

@@ -1,53 +0,0 @@
-#import "ClassificationModel.h"
-#import "../../utils/ImageProcessor.h"
-#import "../../utils/Numerical.h"
-#import "Constants.h"
-
-@implementation ClassificationModel
-
-- (cv::Size)getModelImageSize {
-  NSArray *inputShape = [module getInputShape:0];
-  NSNumber *widthNumber = inputShape.lastObject;
-  NSNumber *heightNumber = inputShape[inputShape.count - 2];
-
-  int height = [heightNumber intValue];
-  int width = [widthNumber intValue];
-
-  return cv::Size(height, width);
-}
-
-- (NSArray *)preprocess:(cv::Mat &)input {
-  cv::Size modelImageSize = [self getModelImageSize];
-  cv::resize(input, input, modelImageSize);
-
-  NSArray *modelInput = [ImageProcessor matToNSArray:input];
-  return modelInput;
-}
-
-- (NSDictionary *)postprocess:(NSArray *)output {
-  output = output[0]; // take the first output tensor
-  std::vector<double> outputVector(output.count);
-
-  for (NSUInteger i = 0; i < output.count; ++i) {
-    outputVector[i] = [output[i] doubleValue];
-  }
-
-  std::vector<double> probabilities = softmax(outputVector);
-  NSMutableDictionary *result = [NSMutableDictionary dictionary];
-
-  for (int i = 0; i < probabilities.size(); ++i) {
-    NSString *className = @(imagenet1k_v1_labels[i].c_str());
-    NSNumber *probability = @(probabilities[i]);
-    result[className] = probability;
-  }
-
-  return result;
-}
-
-- (NSDictionary *)runModel:(cv::Mat &)input {
-  NSArray *modelInput = [self preprocess:input];
-  NSArray *modelOutput = [self forward:@[ modelInput ]];
-  return [self postprocess:modelOutput];
-}
-
-@end

package/ios/RnExecutorch/models/classification/Constants.h

@@ -1,3 +0,0 @@
-#import <string>
-
-extern const std::string imagenet1k_v1_labels[];

package/ios/RnExecutorch/models/image_segmentation/Constants.h

@@ -1,4 +0,0 @@
-#import <string>
-#import <vector>
-
-extern const std::vector<std::string> deeplabv3_resnet50_labels;

package/ios/RnExecutorch/models/image_segmentation/ImageSegmentationModel.h

@@ -1,10 +0,0 @@
-#import "../BaseModel.h"
-#import "opencv2/opencv.hpp"
-
-@interface ImageSegmentationModel : BaseModel
-- (cv::Size)getModelImageSize;
-- (NSDictionary *)runModel:(cv::Mat &)input
-             returnClasses:(NSArray *)classesOfInterest
-                    resize:(BOOL)resize;
-
-@end

package/ios/RnExecutorch/models/image_segmentation/ImageSegmentationModel.mm

@@ -1,146 +0,0 @@
-#import "ImageSegmentationModel.h"
-#import "../../utils/Conversions.h"
-#import "../../utils/ImageProcessor.h"
-#import "../../utils/Numerical.h"
-#import "Constants.h"
-#import <unordered_set>
-
-@interface ImageSegmentationModel ()
-- (NSArray *)preprocess:(cv::Mat &)input;
-- (NSDictionary *)postprocess:(NSArray *)output
-                returnClasses:(NSArray *)classesOfInterest
-                       resize:(BOOL)resize;
-@end
-
-@implementation ImageSegmentationModel {
-  cv::Size originalSize;
-}
-
-- (cv::Size)getModelImageSize {
-  NSArray *inputShape = [module getInputShape:@0];
-  NSNumber *widthNumber = inputShape.lastObject;
-  NSNumber *heightNumber = inputShape[inputShape.count - 2];
-
-  int height = [heightNumber intValue];
-  int width = [widthNumber intValue];
-
-  return cv::Size(height, width);
-}
-
-- (NSArray *)preprocess:(cv::Mat &)input {
-  originalSize = cv::Size(input.cols, input.rows);
-
-  cv::Size modelImageSize = [self getModelImageSize];
-  cv::Mat output;
-  cv::resize(input, output, modelImageSize);
-
-  NSArray *modelInput = [ImageProcessor matToNSArray:output];
-  return modelInput;
-}
-
-std::vector<cv::Mat> extractResults(NSArray *result, std::size_t numLabels,
-                                    cv::Size modelImageSize,
-                                    cv::Size originalSize, BOOL resize) {
-  std::size_t numModelPixels = modelImageSize.height * modelImageSize.width;
-
-  std::vector<cv::Mat> resizedLabelScores(numLabels);
-  for (std::size_t label = 0; label < numLabels; ++label) {
-    cv::Mat labelMat = cv::Mat(modelImageSize, CV_64F);
-
-    for (std::size_t pixel = 0; pixel < numModelPixels; ++pixel) {
-      int row = pixel / modelImageSize.width;
-      int col = pixel % modelImageSize.width;
-      labelMat.at<double>(row, col) =
-          [result[label * numModelPixels + pixel] doubleValue];
-    }
-
-    if (resize) {
-      cv::resize(labelMat, resizedLabelScores[label], originalSize);
-    } else {
-      resizedLabelScores[label] = std::move(labelMat);
-    }
-  }
-  return resizedLabelScores;
-}
-
-void adjustScoresPerPixel(std::vector<cv::Mat> &labelScores, cv::Mat &argMax,
-                          cv::Size outputSize, std::size_t numLabels) {
-  std::size_t numOutputPixels = outputSize.height * outputSize.width;
-  for (std::size_t pixel = 0; pixel < numOutputPixels; ++pixel) {
-    int row = pixel / outputSize.width;
-    int col = pixel % outputSize.width;
-    std::vector<double> scores;
-    scores.reserve(numLabels);
-    for (const auto &mat : labelScores) {
-      scores.push_back(mat.at<double>(row, col));
-    }
-
-    std::vector<double> adjustedScores = softmax(scores);
-
-    for (std::size_t label = 0; label < numLabels; ++label) {
-      labelScores[label].at<double>(row, col) = adjustedScores[label];
-    }
-
-    auto maxIt = std::max_element(scores.begin(), scores.end());
-    argMax.at<int>(row, col) = std::distance(scores.begin(), maxIt);
-  }
-}
-
-- (NSDictionary *)postprocess:(NSArray *)output
-                returnClasses:(NSArray *)classesOfInterest
-                       resize:(BOOL)resize {
-  cv::Size modelImageSize = [self getModelImageSize];
-
-  std::size_t numLabels = deeplabv3_resnet50_labels.size();
-
-  NSAssert((std::size_t)output.count ==
-               numLabels * modelImageSize.height * modelImageSize.width,
-           @"Model generated unexpected output size.");
-
-  // For each label extract it's matrix,
-  // and rescale it to the original size if `resize`
-  std::vector<cv::Mat> resizedLabelScores =
-      extractResults(output, numLabels, modelImageSize, originalSize, resize);
-
-  cv::Size outputSize = resize ? originalSize : modelImageSize;
-  cv::Mat argMax = cv::Mat(outputSize, CV_32S);
-
-  // For each pixel apply softmax across all the labels and calculate the argMax
-  adjustScoresPerPixel(resizedLabelScores, argMax, outputSize, numLabels);
-
-  std::unordered_set<std::string> labelSet;
-
-  for (id label in classesOfInterest) {
-    labelSet.insert(std::string([label UTF8String]));
-  }
-
-  NSMutableDictionary *result = [NSMutableDictionary dictionary];
-
-  // Convert to NSArray and populate the final dictionary
-  for (std::size_t label = 0; label < numLabels; ++label) {
-    if (labelSet.contains(deeplabv3_resnet50_labels[label])) {
-      NSString *labelString = @(deeplabv3_resnet50_labels[label].c_str());
-      NSArray *arr = simpleMatToNSArray<double>(resizedLabelScores[label]);
-      result[labelString] = arr;
-    }
-  }
-
-  result[@"ARGMAX"] = simpleMatToNSArray<int>(argMax);
-
-  return result;
-}
-
-- (NSDictionary *)runModel:(cv::Mat &)input
-             returnClasses:(NSArray *)classesOfInterest
-                    resize:(BOOL)resize {
-  NSArray *modelInput = [self preprocess:input];
-  NSArray *result = [self forward:@[ modelInput ]];
-
-  NSDictionary *output = [self postprocess:result[0]
-                             returnClasses:classesOfInterest
-                                    resize:resize];
-
-  return output;
-}
-
-@end

package/ios/RnExecutorch/models/object_detection/SSDLiteLargeModel.hpp

@@ -1,11 +0,0 @@
-#import "../BaseModel.h"
-#import <UIKit/UIKit.h>
-#include <opencv2/opencv.hpp>
-
-@interface SSDLiteLargeModel : BaseModel
-
-- (NSArray *)runModel:(cv::Mat)input;
-- (NSArray *)preprocess:(cv::Mat)input;
-- (NSArray *)postprocess:(NSArray *)input;
-
-@end

package/ios/RnExecutorch/models/object_detection/SSDLiteLargeModel.mm

@@ -1,64 +0,0 @@
-#include "SSDLiteLargeModel.hpp"
-#include "../../utils/ObjectDetectionUtils.hpp"
-#include "ImageProcessor.h"
-
-float constexpr iouThreshold = 0.55;
-float constexpr detectionThreshold = 0.7;
-int constexpr modelInputWidth = 320;
-int constexpr modelInputHeight = 320;
-
-@implementation SSDLiteLargeModel
-
-- (NSArray *)preprocess:(cv::Mat)input {
-  cv::resize(input, input, cv::Size(modelInputWidth, modelInputHeight));
-  NSArray *modelInput = [ImageProcessor matToNSArray:input];
-  return modelInput;
-}
-
-- (NSArray *)postprocess:(NSArray *)input
-              widthRatio:(float)widthRatio
-             heightRatio:(float)heightRatio {
-  NSArray *bboxes = [input objectAtIndex:0];
-  NSArray *scores = [input objectAtIndex:1];
-  NSArray *labels = [input objectAtIndex:2];
-
-  std::vector<Detection> detections;
-
-  for (NSUInteger idx = 0; idx < scores.count; idx++) {
-    float score = [scores[idx] floatValue];
-    float label = [labels[idx] floatValue];
-    if (score < detectionThreshold) {
-      continue;
-    }
-    float x1 = [bboxes[idx * 4] floatValue] * widthRatio;
-    float y1 = [bboxes[idx * 4 + 1] floatValue] * heightRatio;
-    float x2 = [bboxes[idx * 4 + 2] floatValue] * widthRatio;
-    float y2 = [bboxes[idx * 4 + 3] floatValue] * heightRatio;
-
-    Detection det = {x1, y1, x2, y2, label, score};
-    detections.push_back(det);
-  }
-  std::vector<Detection> nms_output = nms(detections, iouThreshold);
-
-  NSMutableArray *output = [NSMutableArray array];
-  for (Detection &detection : nms_output) {
-    [output addObject:detectionToNSDictionary(detection)];
-  }
-
-  return output;
-}
-
-- (NSArray *)runModel:(cv::Mat)input {
-  cv::Size size = input.size();
-  int inputImageWidth = size.width;
-  int inputImageHeight = size.height;
-  NSArray *modelInput = [self preprocess:input];
-  NSArray *forwardResult = [self forward:@[ modelInput ]];
-  NSArray *output =
-      [self postprocess:forwardResult
-             widthRatio:inputImageWidth / (float)modelInputWidth
-            heightRatio:inputImageHeight / (float)modelInputHeight];
-  return output;
-}
-
-@end

package/ios/RnExecutorch/models/ocr/Detector.h

@@ -1,9 +0,0 @@
-#import "BaseModel.h"
-#import "opencv2/opencv.hpp"
-
-@interface Detector : BaseModel
-
-- (cv::Size)getModelImageSize;
-- (NSArray *)runModel:(cv::Mat &)input;
-
-@end

package/ios/RnExecutorch/models/ocr/Detector.mm

@@ -1,101 +0,0 @@
-#import "Detector.h"
-#import "../../utils/ImageProcessor.h"
-#import "utils/Constants.h"
-#import "utils/DetectorUtils.h"
-#import "utils/OCRUtils.h"
-
-/*
- The model used as detector is based on CRAFT (Character Region Awareness for
- Text Detection) paper. https://arxiv.org/pdf/1904.01941
- */
-
-@implementation Detector {
-  cv::Size originalSize;
-  cv::Size modelSize;
-}
-
-- (cv::Size)getModelImageSize {
-  if (!modelSize.empty()) {
-    return modelSize;
-  }
-
-  NSArray *inputShape = [module getInputShape:@0];
-  NSNumber *widthNumber = inputShape[inputShape.count - 2];
-  NSNumber *heightNumber = inputShape.lastObject;
-
-  const int height = [heightNumber intValue];
-  const int width = [widthNumber intValue];
-  modelSize = cv::Size(height, width);
-
-  return cv::Size(height, width);
-}
-
-- (NSArray *)preprocess:(cv::Mat &)input {
-  /*
-   Detector as an input accepts tensor with a shape of [1, 3, 800, 800].
-   Due to big influence of resize to quality of recognition the image preserves
-   original aspect ratio and the missing parts are filled with padding.
-   */
-  self->originalSize = cv::Size(input.cols, input.rows);
-  cv::Size modelImageSize = [self getModelImageSize];
-  cv::Mat resizedImage;
-  resizedImage = [OCRUtils resizeWithPadding:input
-                                desiredWidth:modelImageSize.width
-                               desiredHeight:modelImageSize.height];
-  NSArray *modelInput = [ImageProcessor matToNSArray:resizedImage
-                                                mean:mean
-                                            variance:variance];
-  return modelInput;
-}
-
-- (NSArray *)postprocess:(NSArray *)output {
-  /*
-   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
-   400x400
-
-   The result of this step is a list of bounding boxes that contain text.
-   */
-  NSArray *predictions = [output objectAtIndex:0];
-
-  cv::Size modelImageSize = [self getModelImageSize];
-  cv::Mat scoreTextCV, scoreAffinityCV;
-  /*
-   The output of the model is a matrix in size of input image containing two
-   matrices representing heatmap. Those two matrices are in the size of half of
-   the input  image, that's why the width and height is divided by 2.
-   */
-  [DetectorUtils interleavedArrayToMats:predictions
-                             outputMat1:scoreTextCV
-                             outputMat2:scoreAffinityCV
-                               withSize:cv::Size(modelImageSize.width / 2,
-                                                 modelImageSize.height / 2)];
-  NSArray *bBoxesList = [DetectorUtils getDetBoxesFromTextMap:scoreTextCV
-                                                  affinityMap:scoreAffinityCV
-                                           usingTextThreshold:textThreshold
-                                                linkThreshold:linkThreshold
-                                             lowTextThreshold:lowTextThreshold];
-  bBoxesList = [DetectorUtils restoreBboxRatio:bBoxesList
-                             usingRestoreRatio:restoreRatio];
-
-  bBoxesList = [DetectorUtils groupTextBoxes:bBoxesList
-                             centerThreshold:centerThreshold
-                           distanceThreshold:distanceThreshold
-                             heightThreshold:heightThreshold
-                            minSideThreshold:minSideThreshold
-                            maxSideThreshold:maxSideThreshold
-                                    maxWidth:maxWidth];
-
-  return bBoxesList;
-}
-
-- (NSArray *)runModel:(cv::Mat &)input {
-  NSArray *modelInput = [self preprocess:input];
-  NSArray *modelResult = [self forward:@[ modelInput ]];
-  NSArray *result = [self postprocess:modelResult];
-  return result;
-}
-
-@end

package/ios/RnExecutorch/models/ocr/RecognitionHandler.h

@@ -1,16 +0,0 @@
-#import "opencv2/opencv.hpp"
-
-@interface RecognitionHandler : NSObject
-
-- (instancetype)initWithSymbols:(NSString *)symbols;
-
-- (NSNumber *)loadRecognizers:(NSString *)largeRecognizerPath
-         mediumRecognizerPath:(NSString *)mediumRecognizerPath
-          smallRecognizerPath:(NSString *)smallRecognizerPath;
-
-- (NSArray *)recognize:(NSArray<NSDictionary *> *)bBoxesList
-               imgGray:(cv::Mat)imgGray
-          desiredWidth:(int)desiredWidth
-         desiredHeight:(int)desiredHeight;
-
-@end

package/ios/RnExecutorch/models/ocr/RecognitionHandler.mm

@@ -1,135 +0,0 @@
-#import "RecognitionHandler.h"
-#import "./utils/CTCLabelConverter.h"
-#import "./utils/Constants.h"
-#import "./utils/OCRUtils.h"
-#import "./utils/RecognizerUtils.h"
-#import "Recognizer.h"
-
-/*
- RecognitionHandler class is responsible for loading and choosing the
- appropriate recognizer model based on the input image size, it also handles
- converting the model output to text.
- */
-
-@implementation RecognitionHandler {
-  Recognizer *recognizerLarge;
-  Recognizer *recognizerMedium;
-  Recognizer *recognizerSmall;
-  CTCLabelConverter *converter;
-}
-
-- (instancetype)initWithSymbols:(NSString *)symbols {
-  self = [super init];
-  if (self) {
-    recognizerLarge = [[Recognizer alloc] init];
-    recognizerMedium = [[Recognizer alloc] init];
-    recognizerSmall = [[Recognizer alloc] init];
-
-    converter = [[CTCLabelConverter alloc] initWithCharacters:symbols
-                                                separatorList:@{}];
-  }
-  return self;
-}
-
-- (NSNumber *)loadRecognizers:(NSString *)largeRecognizerPath
-         mediumRecognizerPath:(NSString *)mediumRecognizerPath
-          smallRecognizerPath:(NSString *)smallRecognizerPath {
-  NSArray<Recognizer *> *recognizers =
-      @[ recognizerLarge, recognizerMedium, recognizerSmall ];
-
-  NSArray<NSString *> *paths =
-      @[ largeRecognizerPath, mediumRecognizerPath, smallRecognizerPath ];
-
-  for (NSInteger i = 0; i < recognizers.count; i++) {
-    Recognizer *recognizer = recognizers[i];
-    NSString *path = paths[i];
-
-    NSNumber *errorCode = [recognizer loadModel:path];
-    if ([errorCode intValue] != 0) {
-      return errorCode;
-    }
-  }
-
-  return @0;
-}
-
-- (NSArray *)runModel:(cv::Mat)croppedImage {
-  NSArray *result;
-  if (croppedImage.cols >= largeRecognizerWidth) {
-    result = [recognizerLarge runModel:croppedImage];
-  } else if (croppedImage.cols >= mediumRecognizerWidth) {
-    result = [recognizerMedium runModel:croppedImage];
-  } else {
-    result = [recognizerSmall runModel:croppedImage];
-  }
-
-  return result;
-}
-
-- (NSArray *)recognize:(NSArray<NSDictionary *> *)bBoxesList
-               imgGray:(cv::Mat)imgGray
-          desiredWidth:(int)desiredWidth
-         desiredHeight:(int)desiredHeight {
-  NSDictionary *ratioAndPadding =
-      [RecognizerUtils calculateResizeRatioAndPaddings:imgGray.cols
-                                                height:imgGray.rows
-                                          desiredWidth:desiredWidth
-                                         desiredHeight:desiredHeight];
-  const int left = [ratioAndPadding[@"left"] intValue];
-  const int top = [ratioAndPadding[@"top"] intValue];
-  const CGFloat resizeRatio = [ratioAndPadding[@"resizeRatio"] floatValue];
-  imgGray = [OCRUtils resizeWithPadding:imgGray
-                           desiredWidth:desiredWidth
-                          desiredHeight:desiredHeight];
-
-  NSMutableArray *predictions = [NSMutableArray array];
-  for (NSDictionary *box in bBoxesList) {
-    cv::Mat croppedImage = [RecognizerUtils getCroppedImage:box
-                                                      image:imgGray
-                                                modelHeight:recognizerHeight];
-    if (croppedImage.empty()) {
-      continue;
-    }
-    croppedImage = [RecognizerUtils normalizeForRecognizer:croppedImage
-                                            adjustContrast:adjustContrast
-                                                isVertical:NO];
-    NSArray *result = [self runModel:croppedImage];
-
-    NSNumber *confidenceScore = [result objectAtIndex:1];
-    if ([confidenceScore floatValue] < lowConfidenceThreshold) {
-      cv::rotate(croppedImage, croppedImage, cv::ROTATE_180);
-
-      NSArray *rotatedResult = [self runModel:croppedImage];
-      NSNumber *rotatedConfidenceScore = [rotatedResult objectAtIndex:1];
-
-      if ([rotatedConfidenceScore floatValue] > [confidenceScore floatValue]) {
-        result = rotatedResult;
-        confidenceScore = rotatedConfidenceScore;
-      }
-    }
-
-    NSArray *predIndex = [result objectAtIndex:0];
-    NSArray *decodedTexts = [converter decodeGreedy:predIndex
-                                             length:(int)(predIndex.count)];
-
-    NSMutableArray *bbox = [NSMutableArray arrayWithCapacity:4];
-    for (NSValue *coords in box[@"bbox"]) {
-      const CGPoint point = [coords CGPointValue];
-      [bbox addObject:@{
-        @"x" : @((point.x - left) * resizeRatio),
-        @"y" : @((point.y - top) * resizeRatio)
-      }];
-    }
-
-    NSDictionary *res = @{
-      @"text" : decodedTexts[0],
-      @"bbox" : bbox,
-      @"score" : confidenceScore
-    };
-    [predictions addObject:res];
-  }
-
-  return predictions;
-}
-
-@end

package/ios/RnExecutorch/models/ocr/Recognizer.h

@@ -1,8 +0,0 @@
-#import "BaseModel.h"
-#import "opencv2/opencv.hpp"
-
-@interface Recognizer : BaseModel
-
-- (NSArray *)runModel:(cv::Mat &)input;
-
-@end

package/ios/RnExecutorch/models/ocr/Recognizer.mm

@@ -1,77 +0,0 @@
-#import "Recognizer.h"
-#import "../../utils/ImageProcessor.h"
-#import "RecognizerUtils.h"
-
-/*
- The model used as detector is based on CRNN paper.
- https://arxiv.org/pdf/1507.05717
- */
-
-@implementation Recognizer {
-  cv::Size originalSize;
-}
-
-- (cv::Size)getModelImageSize {
-  NSArray *inputShape = [module getInputShape:@0];
-  NSNumber *widthNumber = inputShape.lastObject;
-  NSNumber *heightNumber = inputShape[inputShape.count - 2];
-
-  const int height = [heightNumber intValue];
-  const int width = [widthNumber intValue];
-  return cv::Size(height, width);
-}
-
-- (cv::Size)getModelOutputSize {
-  NSArray *outputShape = [module getOutputShape:@0];
-  NSNumber *widthNumber = outputShape.lastObject;
-  NSNumber *heightNumber = outputShape[outputShape.count - 2];
-
-  const int height = [heightNumber intValue];
-  const int width = [widthNumber intValue];
-  return cv::Size(height, width);
-}
-
-- (NSArray *)preprocess:(cv::Mat &)input {
-  return [ImageProcessor matToNSArrayGray:input];
-}
-
-- (NSArray *)postprocess:(NSArray *)output {
-  const int modelOutputHeight = [self getModelOutputSize].height;
-  NSInteger numElements = [output.firstObject count];
-  NSInteger numRows = (numElements + modelOutputHeight - 1) / modelOutputHeight;
-  cv::Mat resultMat = cv::Mat::zeros(numRows, modelOutputHeight, CV_32F);
-  NSInteger counter = 0;
-  NSInteger currentRow = 0;
-  for (NSNumber *num in output.firstObject) {
-    resultMat.at<float>(currentRow, counter) = [num floatValue];
-    counter++;
-    if (counter >= modelOutputHeight) {
-      counter = 0;
-      currentRow++;
-    }
-  }
-
-  cv::Mat probabilities = [RecognizerUtils softmax:resultMat];
-  NSMutableArray *predsNorm =
-      [RecognizerUtils sumProbabilityRows:probabilities
-                        modelOutputHeight:modelOutputHeight];
-  probabilities = [RecognizerUtils divideMatrix:probabilities
-                                       byVector:predsNorm];
-  NSArray *maxValuesIndices =
-      [RecognizerUtils findMaxValuesAndIndices:probabilities];
-  const CGFloat confidenceScore =
-      [RecognizerUtils computeConfidenceScore:maxValuesIndices[0]
-                                 indicesArray:maxValuesIndices[1]];
-
-  return @[ maxValuesIndices[1], @(confidenceScore) ];
-}
-
-- (NSArray *)runModel:(cv::Mat &)input {
-  NSArray *modelInput = [self preprocess:input];
-  NSArray *modelResult = [self forward:@[ modelInput ]];
-  NSArray *result = [self postprocess:modelResult];
-
-  return result;
-}
-
-@end

package/ios/RnExecutorch/models/ocr/VerticalDetector.h

@@ -1,10 +0,0 @@
-#import "BaseModel.h"
-#import "opencv2/opencv.hpp"
-
-@interface VerticalDetector : BaseModel
-
-- (instancetype)initWithDetectSingleCharacters:(BOOL)detectSingleCharacters;
-- (cv::Size)getModelImageSize;
-- (NSArray *)runModel:(cv::Mat &)input;
-
-@end