react-native-yolo 0.0.5 → 0.0.8

package/Yolo.podspec

@@ -27,5 +27,8 @@ Pod::Spec.new do |s|
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
+  s.dependency 'VisionCamera'
+  s.dependency 'TensorFlowLiteSwift'
+  
   install_modules_dependencies(s)
 end

package/android/src/main/java/com/yolo/HybridYolo.kt

@@ -1,265 +1,42 @@
 package com.yolo
 
-import android.net.Uri
+import android.util.Base64
 import android.util.Log
-import com.margelo.nitro.NitroModules
-import com.margelo.nitro.yolo.HybridYoloSpec
-import java.io.File
-import java.io.RandomAccessFile
-import java.net.URL
-import java.nio.MappedByteBuffer
-import java.nio.channels.FileChannel
-import org.tensorflow.lite.Interpreter
-import org.tensorflow.lite.support.common.FileUtil
-import yolo.com.loader.YoloModelLoader
+
 import com.margelo.nitro.camera.HybridFrameSpec
+import com.margelo.nitro.yolo.HybridYoloModelSpec
+import com.margelo.nitro.yolo.HybridYoloSpec
 
-import android.util.Base64
 import com.yolo.utils.FrameJpegConverter
 import com.yolo.utils.FrameValidator
 
-import com.margelo.nitro.yolo.Detection
-import com.margelo.nitro.yolo.BoundingBox
-
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import org.tensorflow.lite.DataType
-import kotlin.math.roundToInt
-
 
 class HybridYolo : HybridYoloSpec() {
     companion object {
         private const val TAG = "YOLO_TAG"
     }
-    private var interpreter: Interpreter? = null
-
-    private var inputBuffer: ByteBuffer? = null
-    private var inputWidth = 0
-    private var inputHeight = 0
-    private var inputDataType: DataType? = null
-
-    private val modelLoader = YoloModelLoader()
-
-    override fun sum(num1: Double, num2: Double): Double {
-        return num1 + num2
-    }
-
-    override fun loadModel(modelPath: String) {
-        val context =
-                NitroModules.applicationContext ?: throw IllegalStateException("Context is null")
-
-        Log.d(TAG, "Trying to load: $modelPath")
-
-        try {
-            val modelBuffer = modelLoader.load(modelPath)
-
-            interpreter?.close()
-            interpreter = Interpreter(modelBuffer)
-
-            val inputTensor = interpreter!!.getInputTensor(0)
-            val shape = inputTensor.shape()
-
-            inputHeight = shape[1]
-            inputWidth = shape[2]
-            inputDataType = inputTensor.dataType()
-            inputBuffer = modelLoader.makeInputBuffer(interpreter!!)
-
-            val outputTensor = interpreter!!.getOutputTensor(0)
-            Log.d(TAG, "✅ YOLO model loaded")
-            Log.d(TAG, "📥 Input shape: ${inputTensor.shape().contentToString()}")
-            Log.d(TAG, "📤 Output shape: ${outputTensor.shape().contentToString()}")
-            Log.d(TAG, "📥 Input type: ${inputTensor.dataType()}")
-            Log.d(TAG, "📤 Output type: ${outputTensor.dataType()}")
-
-            Log.d(TAG, "Input shape=${shape.contentToString()} type=$inputDataType")
-            Log.d(TAG, "✅ Model loaded successfully!")
-        } catch (e: Exception) {
-            Log.e(TAG, "❌ Failed to load model: ${e.message}", e)
-        }
+    override fun loadModel(modelPath: String): HybridYoloModelSpec {
+        Log.d(TAG, "Trying to load model object: $modelPath")
+        return HybridYoloModel(modelPath)
     }
     override fun frameToBase64(frame: HybridFrameSpec): String {
+        Log.d(TAG, "Trying to convert frame to base64")
         return try {
+            Log.d(TAG, "frameToBase64: frame: $frame")
             if (!FrameValidator.isValidYuv(frame)) return ""
+            Log.d(TAG, "frameToBase64: frame is valid YUV")
 
             val jpegBytes = FrameJpegConverter.toJpegBytes(
             frame = frame,
             quality = 80
             )
+            Log.d(TAG, "frameToBase64: jpegBytes size: ${jpegBytes.size}")
 
             Base64.encodeToString(jpegBytes, Base64.NO_WRAP)
+            
         } catch (e: Exception) {
             Log.e(TAG, "❌ frameToBase64 failed", e)
             ""
         }
     }
-
-    override fun detect(frame: HybridFrameSpec): Array<Detection> {
-        val localInterpreter = interpreter ?: run {
-            Log.e(TAG, "❌ Model is not loaded. Please call loadModel() first.")
-            return emptyArray()
-        }
-
-        if (!FrameValidator.isValidYuv(frame)) {
-            Log.e(TAG, "❌ Invalid frame provided for detection.")
-            return emptyArray()
-        }
-
-        val input = inputBuffer ?: return emptyArray()
-
-        fillInputFromYuvFrame(
-            frame = frame,
-            input = input,
-            dstWidth = inputWidth,
-            dstHeight = inputHeight,
-            dataType = inputDataType ?: DataType.FLOAT32
-        )
-
-        val output = Array(1) { Array(300) { FloatArray(6) } }
-
-        localInterpreter.run(input, output)
-
-        val detections = parseNmsOutput(output, confidenceThreshold = 0.5f)
-        if (detections.isEmpty()) {
-            val best = output[0].maxByOrNull { it[4] }
-            Log.d(TAG, "No detections. Best row=${best?.contentToString()}")
-        } else {
-            Log.d(TAG, "✅ Detections: ${detections.size}")
-        }
-
-
-        return detections.toTypedArray()
-    }
-
-    private fun parseNmsOutput(
-        output: Array<Array<FloatArray>>,
-        confidenceThreshold: Float = 0.5f
-    ): List<Detection> {
-        val detections = mutableListOf<Detection>()
-
-        val batchMatrix = output[0]
-
-        for (i in batchMatrix.indices) {
-            val row = batchMatrix[i]
-
-            val score = row[4]
-            if (score < confidenceThreshold) continue
-
-            val x1 = row[0].toDouble()
-            val y1 = row[1].toDouble()
-            val x2 = row[2].toDouble()
-            val y2 = row[3].toDouble()
-            val classId = row[5].toDouble()
-
-            detections.add(
-                Detection(
-                    boundingBox = BoundingBox(
-                        x1 = x1,
-                        y1 = y1,
-                        x2 = x2,
-                        y2 = y2
-                    ),
-                    score = score.toDouble(),
-                    classId = classId
-                )
-            )
-        }
-
-        return detections
-    }
-
-
-
-    private fun fillInputFromYuvFrame(
-        frame: HybridFrameSpec,
-        input: ByteBuffer,
-        dstWidth: Int,
-        dstHeight: Int,
-        dataType: DataType
-    ) {
-        val srcWidth = frame.width.toInt()
-        val srcHeight = frame.height.toInt()
-
-        val planes = frame.getPlanes()
-
-        val yPlane = planes[0]
-        val uPlane = planes[1]
-        val vPlane = planes[2]
-
-        val yBytes = yPlane.getPixelBuffer().toByteArray()
-        val uBytes = uPlane.getPixelBuffer().toByteArray()
-        val vBytes = vPlane.getPixelBuffer().toByteArray()
-
-        val yRowStride = yPlane.bytesPerRow.roundToInt()
-        val uRowStride = uPlane.bytesPerRow.roundToInt()
-        val vRowStride = vPlane.bytesPerRow.roundToInt()
-
-        input.rewind()
-
-        for (dy in 0 until dstHeight) {
-            // val sy = dy * srcHeight / dstHeight
-
-            for (dx in 0 until dstWidth) {
-                val srcX = dy * srcWidth / dstHeight
-                val srcY = srcHeight - 1 - (dx * srcHeight / dstWidth)
-
-                val yIndex = srcY * yRowStride + srcX
-
-                val uvX = srcX / 2
-                val uvY = srcY / 2
-
-                val uIndex = uvY * uRowStride + uvX * 2
-                val vIndex = uvY * vRowStride + uvX * 2
-
-                if (
-                    yIndex >= yBytes.size ||
-                    uIndex >= uBytes.size ||
-                    vIndex >= vBytes.size
-                ) {
-                    continue
-                }
-
-                val y = yBytes[yIndex].toInt() and 0xFF
-                val u = uBytes[uIndex].toInt() and 0xFF
-                val v = vBytes[vIndex].toInt() and 0xFF
-
-                val rFloat = y + 1.402f * (v - 128)
-                val gFloat = y - 0.344136f * (u - 128) - 0.714136f * (v - 128)
-                val bFloat = y + 1.772f * (u - 128)
-
-                val r = rFloat.roundToInt().coerceIn(0, 255)
-                val g = gFloat.roundToInt().coerceIn(0, 255)
-                val b = bFloat.roundToInt().coerceIn(0, 255)
-
-                when (dataType) {
-                    DataType.FLOAT32 -> {
-                        input.putFloat(r / 255f)
-                        input.putFloat(g / 255f)
-                        input.putFloat(b / 255f)
-                    }
-
-                    DataType.UINT8 -> {
-                        input.put(r.toByte())
-                        input.put(g.toByte())
-                        input.put(b.toByte())
-                    }
-
-                    else -> error("Unsupported input type: $dataType")
-                }
-            }
-        }
-        input.rewind()
-    }
-
-    private fun yuvToRgb(y: Int, u: Int, v: Int): IntArray {
-        val yf = y.toFloat()
-        val uf = u.toFloat() - 128f
-        val vf = v.toFloat() - 128f
-
-        val r = (yf + 1.402f * vf).roundToInt().coerceIn(0, 255)
-        val g = (yf - 0.344136f * uf - 0.714136f * vf).roundToInt().coerceIn(0, 255)
-        val b = (yf + 1.772f * uf).roundToInt().coerceIn(0, 255)
-
-        return intArrayOf(r, g, b)
-    }
-
 }

package/android/src/main/java/com/yolo/HybridYoloModel.kt

@@ -0,0 +1,259 @@
+package com.yolo
+
+import android.util.Log
+import com.margelo.nitro.yolo.HybridYoloModelSpec
+import com.margelo.nitro.yolo.Detection
+import com.margelo.nitro.yolo.BoundingBox
+import com.margelo.nitro.camera.HybridFrameSpec
+import com.yolo.utils.FrameValidator
+import java.nio.ByteBuffer
+import org.tensorflow.lite.DataType
+import org.tensorflow.lite.Interpreter
+import yolo.com.loader.YoloModelLoader
+import kotlin.math.roundToInt
+import com.margelo.nitro.camera.CameraOrientation
+
+class HybridYoloModel(
+    modelPath: String
+) : HybridYoloModelSpec() {
+
+    companion object {
+        private const val TAG = "YOLO_MODEL_TAG"
+    }
+
+    private val modelLoader = YoloModelLoader()
+
+    private var interpreter: Interpreter? = null
+    private var inputBuffer: ByteBuffer? = null
+    private var inputWidth = 0
+    private var inputHeight = 0
+    private var inputDataType: DataType? = null
+
+    private val lock = Any()
+
+    init {
+        load(modelPath)
+    }
+
+    private fun load(modelPath: String) {
+        try {
+            val modelBuffer = modelLoader.load(modelPath)
+
+            interpreter = Interpreter(modelBuffer)
+
+            val localInterpreter = interpreter!!
+
+            val inputTensor = localInterpreter.getInputTensor(0)
+            val outputTensor = localInterpreter.getOutputTensor(0)
+
+            val shape = inputTensor.shape()
+
+            inputHeight = shape[1]
+            inputWidth = shape[2]
+            inputDataType = inputTensor.dataType()
+            inputBuffer = modelLoader.makeInputBuffer(localInterpreter)
+
+            Log.d(TAG, "✅ YOLO model instance loaded")
+            Log.d(TAG, "📥 Input shape: ${inputTensor.shape().contentToString()}")
+            Log.d(TAG, "📤 Output shape: ${outputTensor.shape().contentToString()}")
+            Log.d(TAG, "📥 Input type: ${inputTensor.dataType()}")
+            Log.d(TAG, "📤 Output type: ${outputTensor.dataType()}")
+        } catch (e: Exception) {
+            Log.e(TAG, "❌ Failed to load model instance", e)
+        }
+    }
+
+    override fun detect(frame: HybridFrameSpec): Array<Detection> {
+        val localInterpreter = interpreter ?: run {
+            Log.e(TAG, "❌ This model instance is not loaded.")
+            return emptyArray()
+        }
+
+        if (!FrameValidator.isValidYuv(frame)) {
+            Log.e(TAG, "❌ Invalid frame provided for detection.")
+            return emptyArray()
+        }
+
+        val input = inputBuffer ?: return emptyArray()
+
+        synchronized(lock) {
+            input.rewind()
+
+            fillInputFromYuvFrame(
+                frame = frame,
+                input = input,
+                dstWidth = inputWidth,
+                dstHeight = inputHeight,
+                dataType = inputDataType ?: DataType.FLOAT32
+            )
+
+            val output = Array(1) { Array(300) { FloatArray(6) } }
+
+            localInterpreter.run(input, output)
+
+            val detections = parseNmsOutput(output, confidenceThreshold = 0.5f)
+
+            return detections.toTypedArray()
+        }
+    }
+
+    override fun close() {
+        interpreter?.close()
+        interpreter = null
+        inputBuffer = null
+        Log.d(TAG, "🧹 YOLO model disposed")
+    }
+
+    private fun parseNmsOutput(
+        output: Array<Array<FloatArray>>,
+        confidenceThreshold: Float = 0.5f
+    ): List<Detection> {
+        val detections = mutableListOf<Detection>()
+
+        for (row in output[0]) {
+            val score = row[4]
+            if (score < confidenceThreshold) continue
+
+            detections.add(
+                Detection(
+                    boundingBox = BoundingBox(
+                        x1 = row[0].toDouble(),
+                        y1 = row[1].toDouble(),
+                        x2 = row[2].toDouble(),
+                        y2 = row[3].toDouble()
+                    ),
+                    score = score.toDouble(),
+                    classId = row[5].toDouble()
+                )
+            )
+        }
+
+        return detections
+    }
+
+    private fun fillInputFromYuvFrame(
+        frame: HybridFrameSpec,
+        input: ByteBuffer,
+        dstWidth: Int,
+        dstHeight: Int,
+        dataType: DataType
+    ) {
+        val srcWidth = frame.width.toInt()
+        val srcHeight = frame.height.toInt()
+
+        val planes = frame.getPlanes()
+
+        val yPlane = planes[0]
+        val uPlane = planes[1]
+        val vPlane = planes[2]
+
+        val yBytes = yPlane.getPixelBuffer().toByteArray()
+        val uBytes = uPlane.getPixelBuffer().toByteArray()
+        val vBytes = vPlane.getPixelBuffer().toByteArray()
+
+        val yRowStride = yPlane.bytesPerRow.roundToInt()
+        val uRowStride = uPlane.bytesPerRow.roundToInt()
+        val vRowStride = vPlane.bytesPerRow.roundToInt()
+
+        input.rewind()
+
+        for (dy in 0 until dstHeight) {
+            for (dx in 0 until dstWidth) {
+                val (srcX, srcY) = mapModelPixelToFramePixel(
+                    dx = dx,
+                    dy = dy,
+                    dstWidth = dstWidth,
+                    dstHeight = dstHeight,
+                    srcWidth = srcWidth,
+                    srcHeight = srcHeight,
+                    orientation = frame.orientation
+                )
+
+                val yIndex = srcY * yRowStride + srcX
+
+                val uvX = srcX / 2
+                val uvY = srcY / 2
+
+                val uIndex = uvY * uRowStride + uvX * 2
+                val vIndex = uvY * vRowStride + uvX * 2
+
+                if (
+                    yIndex >= yBytes.size ||
+                    uIndex >= uBytes.size ||
+                    vIndex >= vBytes.size
+                ) {
+                    continue
+                }
+
+                val y = yBytes[yIndex].toInt() and 0xFF
+                val u = uBytes[uIndex].toInt() and 0xFF
+                val v = vBytes[vIndex].toInt() and 0xFF
+
+                val rFloat = y + 1.402f * (v - 128)
+                val gFloat = y - 0.344136f * (u - 128) - 0.714136f * (v - 128)
+                val bFloat = y + 1.772f * (u - 128)
+
+                val r = rFloat.roundToInt().coerceIn(0, 255)
+                val g = gFloat.roundToInt().coerceIn(0, 255)
+                val b = bFloat.roundToInt().coerceIn(0, 255)
+
+                when (dataType) {
+                    DataType.FLOAT32 -> {
+                        input.putFloat(r / 255f)
+                        input.putFloat(g / 255f)
+                        input.putFloat(b / 255f)
+                    }
+
+                    DataType.UINT8 -> {
+                        input.put(r.toByte())
+                        input.put(g.toByte())
+                        input.put(b.toByte())
+                    }
+
+                    else -> error("Unsupported input type: $dataType")
+                }
+            }
+        }
+
+        input.rewind()
+    }
+
+    private fun mapModelPixelToFramePixel(
+        dx: Int,
+        dy: Int,
+        dstWidth: Int,
+        dstHeight: Int,
+        srcWidth: Int,
+        srcHeight: Int,
+        orientation: CameraOrientation
+    ): Pair<Int, Int> {
+        val nx = dx.toFloat() / dstWidth
+        val ny = dy.toFloat() / dstHeight
+
+        return when (orientation) {
+            CameraOrientation.UP -> {
+                val srcX = (nx * srcWidth).toInt()
+                val srcY = (ny * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+
+            CameraOrientation.DOWN -> {
+                val srcX = ((1f - nx) * srcWidth).toInt()
+                val srcY = ((1f - ny) * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+
+            CameraOrientation.LEFT -> {
+                val srcX = (ny * srcWidth).toInt()
+                val srcY = ((1f - nx) * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+
+            CameraOrientation.RIGHT -> {
+                val srcX = ((1f - ny) * srcWidth).toInt()
+                val srcY = (nx * srcHeight).toInt()
+                srcX.coerceIn(0, srcWidth - 1) to srcY.coerceIn(0, srcHeight - 1)
+            }
+        }
+    }
+}

package/android/src/main/java/com/yolo/utils/BitmapOrientationFixer.kt

@@ -4,6 +4,7 @@ import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.graphics.Matrix
 import com.margelo.nitro.camera.HybridFrameSpec
+import com.margelo.nitro.camera.CameraOrientation
 import java.io.ByteArrayOutputStream
 
 
@@ -20,7 +21,13 @@ object BitmapOrientationFixer {
       jpegBytes.size
     ) ?: return jpegBytes
 
-    val rotationDegrees = 90f //TODO: Get the actual rotation degrees from the frame metadata if available
+    val rotationDegrees = when (frame.orientation) {
+      CameraOrientation.LEFT -> 90f
+      CameraOrientation.RIGHT -> 270f
+      CameraOrientation.UP -> 0f
+      CameraOrientation.DOWN -> 180f
+      else -> 0f
+    }
 
     val matrix = Matrix().apply {
       postRotate(rotationDegrees)

package/ios/HybridYolo.swift

@@ -1,14 +1,56 @@
-//
-//  HybridYolo.swift
-//  Pods
-//
-//  Created by Khaoula-Ghalimi on 22/06/2026.
-//
-
 import Foundation
+import NitroModules
+import VisionCamera
 
-class HybridYolo: HybridYoloSpec {
-    func sum(num1: Double, num2: Double) throws -> Double {
-        return num1 + num2
+public class HybridYolo: HybridYoloSpec {
+    private static let tag = "YOLO_TAG"
+    
+    // Initialisateur obligatoire pour les modules Nitro
+    public required init() {
+        super.init()
+    }
+    
+    /**
+     * Charge l'objet modèle YOLO spécifié par son chemin.
+     * Implémente la méthode obligatoire du protocole Nitro TypeScript.
+     */
+    public override func loadModel(modelPath: String) throws -> any HybridYoloModelSpec {
+        NSLog("[%@]: Trying to load model object: %@", HybridYolo.tag, modelPath)
+        
+        // Initialise et retourne votre sous-classe de modèle Nitro (assurez-vous qu'elle s'appelle bien HybridYoloModel)
+        return try HybridYoloModel(modelPath: modelPath)
+    }
+    
+    /**
+     * Valide un Frame de la caméra, le convertit en JPEG permanent (NV12 -> JPEG -> Fix Rotation),
+     * puis l'encode instantanément en chaîne de caractères Base64 standard.
+     */
+    public override func frameToBase64(frame: any HybridFrameSpec) throws -> String {
+        NSLog("[%@]: Trying to convert frame to base64", HybridYolo.tag)
+        
+        do {
+            // 1. Validation du buffer vidéo via notre validateur adapté à iOS (NV12 à 2 plans minimum)
+            guard FrameValidator.isValidYuv(frame: frame) else {
+                return ""
+            }
+            NSLog("[%@]: frameToBase64: frame is valid YUV", HybridYolo.tag)
+            
+            // 2. Traitement complet de l'image (Conversion NV12 -> Encodage GPU JPEG -> Rendu de sécurité)
+            let jpegBytes = FrameJpegConverter.toJpegBytes(frame: frame, quality: 80)
+            
+            guard !jpegBytes.isEmpty else {
+                NSLog("[%@]: ❌ frameToBase64 failed: converted JPEG bytes array is empty", HybridYolo.tag)
+                return ""
+            }
+            NSLog("[%@]: frameToBase64: jpegBytes size: %d bytes", HybridYolo.tag, jpegBytes.count)
+            
+            // 3. Encapsulation dans un conteneur Data pour un encodage Base64 matériel (sans sauts de ligne, équivalent de NO_WRAP)
+            let data = Data(jpegBytes)
+            return data.base64EncodedString(options: [])
+            
+        } catch {
+            NSLog("[%@]: ❌ frameToBase64 failed: %@", HybridYolo.tag, error.localizedDescription)
+            return ""
+        }
     }
 }