react-native-executorch 0.4.8 → 0.5.0

package/android/src/main/java/com/swmansion/rnexecutorch/models/imageSegmentation/Constants.kt

@@ -1,26 +0,0 @@
-package com.swmansion.rnexecutorch.models.imagesegmentation
-
-val deeplabv3_resnet50_labels: Array<String> =
-  arrayOf(
-    "BACKGROUND",
-    "AEROPLANE",
-    "BICYCLE",
-    "BIRD",
-    "BOAT",
-    "BOTTLE",
-    "BUS",
-    "CAR",
-    "CAT",
-    "CHAIR",
-    "COW",
-    "DININGTABLE",
-    "DOG",
-    "HORSE",
-    "MOTORBIKE",
-    "PERSON",
-    "POTTEDPLANT",
-    "SHEEP",
-    "SOFA",
-    "TRAIN",
-    "TVMONITOR",
-  )

package/android/src/main/java/com/swmansion/rnexecutorch/models/imageSegmentation/ImageSegmentationModel.kt

@@ -1,142 +0,0 @@
-package com.swmansion.rnexecutorch.models.imagesegmentation
-
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReadableArray
-import com.facebook.react.bridge.WritableMap
-import com.swmansion.rnexecutorch.models.BaseModel
-import com.swmansion.rnexecutorch.utils.ArrayUtils
-import com.swmansion.rnexecutorch.utils.ImageProcessor
-import com.swmansion.rnexecutorch.utils.softmax
-import org.opencv.core.CvType
-import org.opencv.core.Mat
-import org.opencv.core.Size
-import org.opencv.imgproc.Imgproc
-import org.pytorch.executorch.EValue
-
-class ImageSegmentationModel(
-  reactApplicationContext: ReactApplicationContext,
-) : BaseModel<Triple<Mat, ReadableArray, Boolean>, WritableMap>(reactApplicationContext) {
-  private lateinit var originalSize: Size
-
-  private fun getModelImageSize(): Size {
-    val inputShape = module.getInputShape(0)
-    val width = inputShape[inputShape.lastIndex]
-    val height = inputShape[inputShape.lastIndex - 1]
-
-    return Size(height.toDouble(), width.toDouble())
-  }
-
-  fun preprocess(input: Mat): EValue {
-    originalSize = input.size()
-    Imgproc.resize(input, input, getModelImageSize())
-    return ImageProcessor.matToEValue(input, module.getInputShape(0))
-  }
-
-  private fun extractResults(
-    result: FloatArray,
-    numLabels: Int,
-    resize: Boolean,
-  ): List<FloatArray> {
-    val modelSize = getModelImageSize()
-    val numModelPixels = (modelSize.height * modelSize.width).toInt()
-
-    val extractedLabelScores = mutableListOf<FloatArray>()
-
-    for (label in 0..<numLabels) {
-      // Calls to OpenCV via JNI are very slow so we do as much as we can
-      // with pure Kotlin
-      val range = IntRange(label * numModelPixels, (label + 1) * numModelPixels - 1)
-      val pixelBuffer = result.slice(range).toFloatArray()
-
-      if (resize) {
-        // Rescale the image with OpenCV
-        val mat = Mat(modelSize, CvType.CV_32F)
-        mat.put(0, 0, pixelBuffer)
-        val resizedMat = Mat()
-        Imgproc.resize(mat, resizedMat, originalSize)
-        val resizedBuffer = FloatArray((originalSize.height * originalSize.width).toInt())
-        resizedMat.get(0, 0, resizedBuffer)
-        extractedLabelScores.add(resizedBuffer)
-      } else {
-        extractedLabelScores.add(pixelBuffer)
-      }
-    }
-    return extractedLabelScores
-  }
-
-  private fun adjustScoresPerPixel(
-    labelScores: List<FloatArray>,
-    numLabels: Int,
-    outputSize: Size,
-  ): IntArray {
-    val numPixels = (outputSize.height * outputSize.width).toInt()
-    val argMax = IntArray(numPixels)
-    for (pixel in 0..<numPixels) {
-      val scores = mutableListOf<Float>()
-      for (buffer in labelScores) {
-        scores.add(buffer[pixel])
-      }
-      val adjustedScores = softmax(scores.toTypedArray())
-      for (label in 0..<numLabels) {
-        labelScores[label][pixel] = adjustedScores[label]
-      }
-
-      val maxIndex = scores.withIndex().maxBy { it.value }.index
-      argMax[pixel] = maxIndex
-    }
-
-    return argMax
-  }
-
-  fun postprocess(
-    output: Array<EValue>,
-    classesOfInterest: ReadableArray,
-    resize: Boolean,
-  ): WritableMap {
-    val outputData = output[0].toTensor().dataAsFloatArray
-    val modelSize = getModelImageSize()
-    val numLabels = deeplabv3_resnet50_labels.size
-
-    require(outputData.count() == (numLabels * modelSize.height * modelSize.width).toInt()) { "Model generated unexpected output size." }
-
-    val outputSize = if (resize) originalSize else modelSize
-
-    val extractedResults = extractResults(outputData, numLabels, resize)
-
-    val argMax = adjustScoresPerPixel(extractedResults, numLabels, outputSize)
-
-    val labelSet = mutableSetOf<String>()
-    // Filter by the label set when base class changed
-    for (i in 0..<classesOfInterest.size()) {
-      val label = classesOfInterest.getString(i)
-      if (label != null) {
-        labelSet.add(label)
-      }
-    }
-
-    val res = Arguments.createMap()
-
-    for (label in 0..<numLabels) {
-      if (labelSet.contains(deeplabv3_resnet50_labels[label])) {
-        res.putArray(
-          deeplabv3_resnet50_labels[label],
-          ArrayUtils.createReadableArrayFromFloatArray(extractedResults[label]),
-        )
-      }
-    }
-
-    res.putArray(
-      "ARGMAX",
-      ArrayUtils.createReadableArrayFromIntArray(argMax),
-    )
-
-    return res
-  }
-
-  override fun runModel(input: Triple<Mat, ReadableArray, Boolean>): WritableMap {
-    val modelInput = preprocess(input.first)
-    val modelOutput = forward(modelInput)
-    return postprocess(modelOutput, input.second, input.third)
-  }
-}

package/android/src/main/java/com/swmansion/rnexecutorch/models/objectDetection/SSDLiteLargeModel.kt

@@ -1,74 +0,0 @@
-package com.swmansion.rnexecutorch.models.objectdetection
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.swmansion.rnexecutorch.models.BaseModel
-import com.swmansion.rnexecutorch.utils.Bbox
-import com.swmansion.rnexecutorch.utils.CocoLabel
-import com.swmansion.rnexecutorch.utils.Detection
-import com.swmansion.rnexecutorch.utils.ImageProcessor
-import com.swmansion.rnexecutorch.utils.nms
-import org.opencv.core.Mat
-import org.opencv.core.Size
-import org.opencv.imgproc.Imgproc
-import org.pytorch.executorch.EValue
-
-const val DETECTION_SCORE_THRESHOLD = .7f
-const val IOU_THRESHOLD = .55f
-
-class SSDLiteLargeModel(
-  reactApplicationContext: ReactApplicationContext,
-) : BaseModel<Mat, Array<Detection>>(reactApplicationContext) {
-  private var heightRatio: Float = 1.0f
-  private var widthRatio: Float = 1.0f
-
-  private fun getModelImageSize(): Size {
-    val inputShape = module.getInputShape(0)
-    val width = inputShape[inputShape.lastIndex]
-    val height = inputShape[inputShape.lastIndex - 1]
-
-    return Size(height.toDouble(), width.toDouble())
-  }
-
-  fun preprocess(input: Mat): EValue {
-    this.widthRatio = (input.size().width / getModelImageSize().width).toFloat()
-    this.heightRatio = (input.size().height / getModelImageSize().height).toFloat()
-    Imgproc.resize(input, input, getModelImageSize())
-    return ImageProcessor.matToEValue(input, module.getInputShape(0))
-  }
-
-  override fun runModel(input: Mat): Array<Detection> {
-    val modelInput = preprocess(input)
-    val modelOutput = forward(modelInput)
-    return postprocess(modelOutput)
-  }
-
-  fun postprocess(output: Array<EValue>): Array<Detection> {
-    val scoresTensor = output[1].toTensor()
-    val numel = scoresTensor.numel()
-    val bboxes = output[0].toTensor().dataAsFloatArray
-    val scores = scoresTensor.dataAsFloatArray
-    val labels = output[2].toTensor().dataAsFloatArray
-
-    val detections: MutableList<Detection> = mutableListOf()
-    for (idx in 0 until numel.toInt()) {
-      val score = scores[idx]
-      if (score < DETECTION_SCORE_THRESHOLD) {
-        continue
-      }
-      val bbox =
-        Bbox(
-          bboxes[idx * 4 + 0] * this.widthRatio,
-          bboxes[idx * 4 + 1] * this.heightRatio,
-          bboxes[idx * 4 + 2] * this.widthRatio,
-          bboxes[idx * 4 + 3] * this.heightRatio,
-        )
-      val label = labels[idx]
-      detections.add(
-        Detection(bbox, score, CocoLabel.fromId(label.toInt())!!),
-      )
-    }
-
-    val detectionsPostNms = nms(detections, IOU_THRESHOLD)
-    return detectionsPostNms.toTypedArray()
-  }
-}

package/android/src/main/java/com/swmansion/rnexecutorch/models/ocr/Detector.kt

@@ -1,82 +0,0 @@
-package com.swmansion.rnexecutorch.models.ocr
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.swmansion.rnexecutorch.models.BaseModel
-import com.swmansion.rnexecutorch.models.ocr.utils.Constants
-import com.swmansion.rnexecutorch.models.ocr.utils.DetectorUtils
-import com.swmansion.rnexecutorch.models.ocr.utils.OCRbBox
-import com.swmansion.rnexecutorch.utils.ImageProcessor
-import org.opencv.core.Mat
-import org.opencv.core.Size
-import org.pytorch.executorch.EValue
-
-class Detector(
-  reactApplicationContext: ReactApplicationContext,
-) : BaseModel<Mat, List<OCRbBox>>(reactApplicationContext) {
-  private lateinit var originalSize: Size
-
-  fun getModelImageSize(): Size {
-    val inputShape = module.getInputShape(0)
-    val width = inputShape[inputShape.lastIndex - 1]
-    val height = inputShape[inputShape.lastIndex]
-
-    val modelImageSize = Size(height.toDouble(), width.toDouble())
-
-    return modelImageSize
-  }
-
-  fun preprocess(input: Mat): EValue {
-    originalSize = Size(input.cols().toDouble(), input.rows().toDouble())
-    val resizedImage =
-      ImageProcessor.resizeWithPadding(
-        input,
-        getModelImageSize().width.toInt(),
-        getModelImageSize().height.toInt(),
-      )
-
-    return ImageProcessor.matToEValue(
-      resizedImage,
-      module.getInputShape(0),
-      Constants.MEAN,
-      Constants.VARIANCE,
-    )
-  }
-
-  fun postprocess(output: Array<EValue>): List<OCRbBox> {
-    val outputTensor = output[0].toTensor()
-    val outputArray = outputTensor.dataAsFloatArray
-    val modelImageSize = getModelImageSize()
-
-    val (scoreText, scoreLink) =
-      DetectorUtils.interleavedArrayToMats(
-        outputArray,
-        Size(modelImageSize.width / 2, modelImageSize.height / 2),
-      )
-    var bBoxesList =
-      DetectorUtils.getDetBoxesFromTextMap(
-        scoreText,
-        scoreLink,
-        Constants.TEXT_THRESHOLD,
-        Constants.LINK_THRESHOLD,
-        Constants.LOW_TEXT_THRESHOLD,
-      )
-
-    bBoxesList =
-      DetectorUtils.restoreBoxRatio(bBoxesList, (Constants.RECOGNIZER_RATIO * 2).toFloat())
-
-    bBoxesList =
-      DetectorUtils.groupTextBoxes(
-        bBoxesList,
-        Constants.CENTER_THRESHOLD,
-        Constants.DISTANCE_THRESHOLD,
-        Constants.HEIGHT_THRESHOLD,
-        Constants.MIN_SIDE_THRESHOLD,
-        Constants.MAX_SIDE_THRESHOLD,
-        Constants.MAX_WIDTH,
-      )
-
-    return bBoxesList.toList()
-  }
-
-  override fun runModel(input: Mat): List<OCRbBox> = postprocess(forward(preprocess(input)))
-}

package/android/src/main/java/com/swmansion/rnexecutorch/models/ocr/RecognitionHandler.kt

@@ -1,117 +0,0 @@
-package com.swmansion.rnexecutorch.models.ocr
-
-import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.WritableArray
-import com.swmansion.rnexecutorch.models.ocr.utils.CTCLabelConverter
-import com.swmansion.rnexecutorch.models.ocr.utils.Constants
-import com.swmansion.rnexecutorch.models.ocr.utils.OCRbBox
-import com.swmansion.rnexecutorch.models.ocr.utils.RecognizerUtils
-import com.swmansion.rnexecutorch.utils.ImageProcessor
-import org.opencv.core.Core
-import org.opencv.core.Mat
-
-class RecognitionHandler(
-  symbols: String,
-  reactApplicationContext: ReactApplicationContext,
-) {
-  private val recognizerLarge = Recognizer(reactApplicationContext)
-  private val recognizerMedium = Recognizer(reactApplicationContext)
-  private val recognizerSmall = Recognizer(reactApplicationContext)
-  private val converter = CTCLabelConverter(symbols)
-
-  private fun runModel(croppedImage: Mat): Pair<List<Int>, Double> {
-    val result: Pair<List<Int>, Double> =
-      if (croppedImage.cols() >= Constants.LARGE_MODEL_WIDTH) {
-        recognizerLarge.runModel(croppedImage)
-      } else if (croppedImage.cols() >= Constants.MEDIUM_MODEL_WIDTH) {
-        recognizerMedium.runModel(croppedImage)
-      } else {
-        recognizerSmall.runModel(croppedImage)
-      }
-
-    return result
-  }
-
-  fun loadRecognizers(
-    largeRecognizerPath: String,
-    mediumRecognizerPath: String,
-    smallRecognizerPath: String,
-    onComplete: (Int, Exception?) -> Unit,
-  ) {
-    try {
-      recognizerLarge.loadModel(largeRecognizerPath)
-      recognizerMedium.loadModel(mediumRecognizerPath)
-      recognizerSmall.loadModel(smallRecognizerPath)
-      onComplete(0, null)
-    } catch (e: Exception) {
-      onComplete(1, e)
-    }
-  }
-
-  fun recognize(
-    bBoxesList: List<OCRbBox>,
-    imgGray: Mat,
-    desiredWidth: Int,
-    desiredHeight: Int,
-  ): WritableArray {
-    val res: WritableArray = Arguments.createArray()
-    val ratioAndPadding =
-      RecognizerUtils.calculateResizeRatioAndPaddings(
-        imgGray.width(),
-        imgGray.height(),
-        desiredWidth,
-        desiredHeight,
-      )
-
-    val left = ratioAndPadding["left"] as Int
-    val top = ratioAndPadding["top"] as Int
-    val resizeRatio = ratioAndPadding["resizeRatio"] as Float
-    val resizedImg =
-      ImageProcessor.resizeWithPadding(
-        imgGray,
-        desiredWidth,
-        desiredHeight,
-      )
-
-    for (box in bBoxesList) {
-      var croppedImage = RecognizerUtils.getCroppedImage(box, resizedImg, Constants.MODEL_HEIGHT)
-      if (croppedImage.empty()) {
-        continue
-      }
-
-      croppedImage = RecognizerUtils.normalizeForRecognizer(croppedImage, Constants.ADJUST_CONTRAST)
-
-      var result = runModel(croppedImage)
-      var confidenceScore = result.second
-
-      if (confidenceScore < Constants.LOW_CONFIDENCE_THRESHOLD) {
-        Core.rotate(croppedImage, croppedImage, Core.ROTATE_180)
-        val rotatedResult = runModel(croppedImage)
-        val rotatedConfidenceScore = rotatedResult.second
-        if (rotatedConfidenceScore > confidenceScore) {
-          result = rotatedResult
-          confidenceScore = rotatedConfidenceScore
-        }
-      }
-
-      val predIndex = result.first
-      val decodedTexts = converter.decodeGreedy(predIndex, predIndex.size)
-
-      for (bBox in box.bBox) {
-        bBox.x = (bBox.x - left) * resizeRatio
-        bBox.y = (bBox.y - top) * resizeRatio
-      }
-
-      val resMap = Arguments.createMap()
-
-      resMap.putString("text", decodedTexts[0])
-      resMap.putArray("bbox", box.toWritableArray())
-      resMap.putDouble("score", confidenceScore)
-
-      res.pushMap(resMap)
-    }
-
-    return res
-  }
-}

package/android/src/main/java/com/swmansion/rnexecutorch/models/ocr/Recognizer.kt

@@ -1,51 +0,0 @@
-package com.swmansion.rnexecutorch.models.ocr
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.swmansion.rnexecutorch.models.BaseModel
-import com.swmansion.rnexecutorch.models.ocr.utils.RecognizerUtils
-import com.swmansion.rnexecutorch.utils.ImageProcessor
-import org.opencv.core.Mat
-import org.opencv.core.Size
-import org.pytorch.executorch.EValue
-
-class Recognizer(
-  reactApplicationContext: ReactApplicationContext,
-) : BaseModel<Mat, Pair<List<Int>, Double>>(reactApplicationContext) {
-  private fun getModelOutputSize(): Size {
-    val outputShape = module.getOutputShape(0)
-    val width = outputShape[outputShape.lastIndex]
-    val height = outputShape[outputShape.lastIndex - 1]
-
-    return Size(height.toDouble(), width.toDouble())
-  }
-
-  fun preprocess(input: Mat): EValue = ImageProcessor.matToEValueGray(input)
-
-  fun postprocess(output: Array<EValue>): Pair<List<Int>, Double> {
-    val modelOutputHeight = getModelOutputSize().height.toInt()
-    val tensor = output[0].toTensor().dataAsFloatArray
-    val numElements = tensor.size
-    val numRows = (numElements + modelOutputHeight - 1) / modelOutputHeight
-    val resultMat = Mat(numRows, modelOutputHeight, org.opencv.core.CvType.CV_32F)
-    var counter = 0
-    var currentRow = 0
-    for (num in tensor) {
-      resultMat.put(currentRow, counter, floatArrayOf(num))
-      counter++
-      if (counter >= modelOutputHeight) {
-        counter = 0
-        currentRow++
-      }
-    }
-
-    var probabilities = RecognizerUtils.softmax(resultMat)
-    val predsNorm = RecognizerUtils.sumProbabilityRows(probabilities, modelOutputHeight)
-    probabilities = RecognizerUtils.divideMatrixByVector(probabilities, predsNorm)
-    val (values, indices) = RecognizerUtils.findMaxValuesAndIndices(probabilities)
-
-    val confidenceScore = RecognizerUtils.computeConfidenceScore(values, indices)
-    return Pair(indices, confidenceScore)
-  }
-
-  override fun runModel(input: Mat): Pair<List<Int>, Double> = postprocess(module.forward(preprocess(input)))
-}

package/android/src/main/java/com/swmansion/rnexecutorch/models/ocr/VerticalDetector.kt

@@ -1,89 +0,0 @@
-package com.swmansion.rnexecutorch.models.ocr
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.swmansion.rnexecutorch.models.BaseModel
-import com.swmansion.rnexecutorch.models.ocr.utils.Constants
-import com.swmansion.rnexecutorch.models.ocr.utils.DetectorUtils
-import com.swmansion.rnexecutorch.models.ocr.utils.OCRbBox
-import com.swmansion.rnexecutorch.utils.ImageProcessor
-import org.opencv.core.Mat
-import org.opencv.core.Size
-import org.pytorch.executorch.EValue
-
-class VerticalDetector(
-  private val detectSingleCharacter: Boolean,
-  reactApplicationContext: ReactApplicationContext,
-) : BaseModel<Mat, List<OCRbBox>>(reactApplicationContext) {
-  private lateinit var originalSize: Size
-
-  fun getModelImageSize(): Size {
-    val inputShape = module.getInputShape(0)
-    val width = inputShape[inputShape.lastIndex - 1]
-    val height = inputShape[inputShape.lastIndex]
-
-    val modelImageSize = Size(height.toDouble(), width.toDouble())
-
-    return modelImageSize
-  }
-
-  fun preprocess(input: Mat): EValue {
-    originalSize = Size(input.cols().toDouble(), input.rows().toDouble())
-    val resizedImage =
-      ImageProcessor.resizeWithPadding(
-        input,
-        getModelImageSize().width.toInt(),
-        getModelImageSize().height.toInt(),
-      )
-
-    return ImageProcessor.matToEValue(
-      resizedImage,
-      module.getInputShape(0),
-      Constants.MEAN,
-      Constants.VARIANCE,
-    )
-  }
-
-  fun postprocess(output: Array<EValue>): List<OCRbBox> {
-    val outputTensor = output[0].toTensor()
-    val outputArray = outputTensor.dataAsFloatArray
-    val modelImageSize = getModelImageSize()
-
-    val (scoreText, scoreLink) =
-      DetectorUtils.interleavedArrayToMats(
-        outputArray,
-        Size(modelImageSize.width / 2, modelImageSize.height / 2),
-      )
-
-    val txtThreshold = if (detectSingleCharacter) Constants.TEXT_THRESHOLD else Constants.TEXT_THRESHOLD_VERTICAL
-    var bBoxesList =
-      DetectorUtils.getDetBoxesFromTextMapVertical(
-        scoreText,
-        scoreLink,
-        txtThreshold,
-        Constants.LINK_THRESHOLD,
-        detectSingleCharacter,
-      )
-
-    bBoxesList =
-      DetectorUtils.restoreBoxRatio(bBoxesList, (Constants.RESTORE_RATIO_VERTICAL).toFloat())
-
-    if (detectSingleCharacter) {
-      return bBoxesList
-    }
-
-    bBoxesList =
-      DetectorUtils.groupTextBoxes(
-        bBoxesList,
-        Constants.CENTER_THRESHOLD,
-        Constants.DISTANCE_THRESHOLD,
-        Constants.HEIGHT_THRESHOLD,
-        Constants.MIN_SIDE_THRESHOLD,
-        Constants.MAX_SIDE_THRESHOLD,
-        Constants.MAX_WIDTH,
-      )
-
-    return bBoxesList.toList()
-  }
-
-  override fun runModel(input: Mat): List<OCRbBox> = postprocess(forward(preprocess(input)))
-}

package/android/src/main/java/com/swmansion/rnexecutorch/models/ocr/utils/CTCLabelConverter.kt

@@ -1,58 +0,0 @@
-package com.swmansion.rnexecutorch.models.ocr.utils
-
-class CTCLabelConverter(
-  characters: String,
-) {
-  private val dict = mutableMapOf<String, Int>()
-  private val character: List<String>
-  private val ignoreIdx: List<Int>
-
-  init {
-    val mutableCharacters = mutableListOf("[blank]")
-    characters.forEachIndexed { index, char ->
-      mutableCharacters.add(char.toString())
-      dict[char.toString()] = index + 1
-    }
-    character = mutableCharacters.toList()
-
-    val ignoreIndexes = mutableListOf(0)
-
-    ignoreIdx = ignoreIndexes.toList()
-  }
-
-  fun decodeGreedy(
-    textIndex: List<Int>,
-    length: Int,
-  ): List<String> {
-    val texts = mutableListOf<String>()
-    var index = 0
-    while (index < textIndex.size) {
-      val segmentLength = minOf(length, textIndex.size - index)
-      val subArray = textIndex.subList(index, index + segmentLength)
-
-      val text = StringBuilder()
-      var lastChar: Int? = null
-      val isNotRepeated = mutableListOf(true)
-      val isNotIgnored = mutableListOf<Boolean>()
-
-      subArray.forEachIndexed { i, currentChar ->
-        if (i > 0) {
-          isNotRepeated.add(lastChar != currentChar)
-        }
-        isNotIgnored.add(!ignoreIdx.contains(currentChar))
-        lastChar = currentChar
-      }
-
-      subArray.forEachIndexed { j, charIndex ->
-        if (isNotRepeated[j] && isNotIgnored[j]) {
-          text.append(character[charIndex])
-        }
-      }
-
-      texts.add(text.toString())
-      index += segmentLength
-      if (segmentLength < length) break
-    }
-    return texts.toList()
-  }
-}

package/android/src/main/java/com/swmansion/rnexecutorch/models/ocr/utils/Constants.kt

@@ -1,31 +0,0 @@
-package com.swmansion.rnexecutorch.models.ocr.utils
-
-import org.opencv.core.Scalar
-
-class Constants {
-  companion object {
-    const val RECOGNIZER_RATIO = 1.6
-    const val RESTORE_RATIO_VERTICAL = 2.0
-    const val MODEL_HEIGHT = 64
-    const val LARGE_MODEL_WIDTH = 512
-    const val MEDIUM_MODEL_WIDTH = 256
-    const val SMALL_MODEL_WIDTH = 128
-    const val VERTICAL_SMALL_MODEL_WIDTH = 64
-    const val LOW_CONFIDENCE_THRESHOLD = 0.3
-    const val ADJUST_CONTRAST = 0.2
-    const val TEXT_THRESHOLD = 0.4
-    const val TEXT_THRESHOLD_VERTICAL = 0.3
-    const val LINK_THRESHOLD = 0.4
-    const val LOW_TEXT_THRESHOLD = 0.7
-    const val CENTER_THRESHOLD = 0.5
-    const val DISTANCE_THRESHOLD = 2.0
-    const val HEIGHT_THRESHOLD = 2.0
-    const val MIN_SIDE_THRESHOLD = 15
-    const val MAX_SIDE_THRESHOLD = 30
-    const val MAX_WIDTH = (LARGE_MODEL_WIDTH + (LARGE_MODEL_WIDTH * 0.15)).toInt()
-    const val MIN_SIZE = 20
-    const val SINGLE_CHARACTER_MIN_SIZE = 70
-    val MEAN = Scalar(0.485, 0.456, 0.406)
-    val VARIANCE = Scalar(0.229, 0.224, 0.225)
-  }
-}