react-native-yolo 0.0.4 → 0.0.5

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

@@ -18,11 +18,26 @@ 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 {
@@ -33,7 +48,7 @@ class HybridYolo : HybridYoloSpec() {
         val context =
                 NitroModules.applicationContext ?: throw IllegalStateException("Context is null")
 
-        Log.d("YOLO_TAG", "Trying to load: $modelPath")
+        Log.d(TAG, "Trying to load: $modelPath")
 
         try {
             val modelBuffer = modelLoader.load(modelPath)
@@ -41,9 +56,25 @@ class HybridYolo : HybridYoloSpec() {
             interpreter?.close()
             interpreter = Interpreter(modelBuffer)
 
-            Log.d("YOLO_TAG", "✅ Model loaded successfully!")
+            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("YOLO_TAG", "❌ Failed to load model: ${e.message}", e)
+            Log.e(TAG, "❌ Failed to load model: ${e.message}", e)
         }
     }
     override fun frameToBase64(frame: HybridFrameSpec): String {
@@ -57,9 +88,178 @@ class HybridYolo : HybridYoloSpec() {
 
             Base64.encodeToString(jpegBytes, Base64.NO_WRAP)
         } catch (e: Exception) {
-            Log.e("YOLO_TAG", "❌ frameToBase64 failed", e)
+            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/loader/YoloModelLoader.kt

@@ -10,6 +10,12 @@ import java.nio.MappedByteBuffer
 import java.nio.channels.FileChannel
 import org.tensorflow.lite.support.common.FileUtil
 
+import org.tensorflow.lite.DataType
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.roundToInt
+import org.tensorflow.lite.Interpreter
+
 
 
 /**
@@ -127,4 +133,29 @@ class YoloModelLoader {
 
         return file
     }
+
+
+    fun makeInputBuffer(interpreter: Interpreter): ByteBuffer {
+        val inputTensor = interpreter.getInputTensor(0)
+        val shape = inputTensor.shape() // usually [1, 640, 640, 3]
+        val dataType = inputTensor.dataType()
+
+        val batch = shape[0]
+        val height = shape[1]
+        val width = shape[2]
+        val channels = shape[3]
+
+        require(batch == 1)
+        require(channels == 3)
+
+        val bytesPerValue = when (dataType) {
+            DataType.FLOAT32 -> 4
+            DataType.UINT8 -> 1
+            else -> error("Unsupported input type: $dataType")
+        }
+
+        return ByteBuffer
+            .allocateDirect(batch * width * height * channels * bytesPerValue)
+            .order(ByteOrder.nativeOrder())
+    }
 }

package/lib/typescript/src/specs/yolo.nitro.d.ts

@@ -1,5 +1,16 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 import type { Frame } from 'react-native-vision-camera';
+type Detection = {
+    classId: number;
+    score: number;
+    boundingBox: BoundingBox;
+};
+type BoundingBox = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
 export interface Yolo extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
@@ -7,5 +18,7 @@ export interface Yolo extends HybridObject<{
     sum(num1: number, num2: number): number;
     loadModel(modelPath: string): void;
     frameToBase64(frame: Frame): string;
+    detect(frame: Frame): Detection[];
 }
+export {};
 //# sourceMappingURL=yolo.nitro.d.ts.map

package/lib/typescript/src/specs/yolo.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"yolo.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/yolo.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAA;AAEvD,MAAM,WAAW,IAAK,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAC7E,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACvC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;CACpC"}
+{"version":3,"file":"yolo.nitro.d.ts","sourceRoot":"","sources":["../../../../src/specs/yolo.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,4BAA4B,CAAA;AAEvD,KAAK,SAAS,GAAG;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,WAAW,CAAA;CACzB,CAAA;AACD,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,MAAM,WAAW,IAAK,SAAQ,YAAY,CAAC;IACzC,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACvC,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;IACnC,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE,CAAA;CAClC"}

package/nitrogen/generated/android/c++/JBoundingBox.hpp

@@ -0,0 +1,69 @@
+///
+/// JBoundingBox.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "BoundingBox.hpp"
+
+
+
+namespace margelo::nitro::yolo {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "BoundingBox" and the the Kotlin data class "BoundingBox".
+   */
+  struct JBoundingBox final: public jni::JavaClass<JBoundingBox> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/yolo/BoundingBox;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct BoundingBox by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    BoundingBox toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldX1 = clazz->getField<double>("x1");
+      double x1 = this->getFieldValue(fieldX1);
+      static const auto fieldY1 = clazz->getField<double>("y1");
+      double y1 = this->getFieldValue(fieldY1);
+      static const auto fieldX2 = clazz->getField<double>("x2");
+      double x2 = this->getFieldValue(fieldX2);
+      static const auto fieldY2 = clazz->getField<double>("y2");
+      double y2 = this->getFieldValue(fieldY2);
+      return BoundingBox(
+        x1,
+        y1,
+        x2,
+        y2
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JBoundingBox::javaobject> fromCpp(const BoundingBox& value) {
+      using JSignature = JBoundingBox(double, double, double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.x1,
+        value.y1,
+        value.x2,
+        value.y2
+      );
+    }
+  };
+
+} // namespace margelo::nitro::yolo

package/nitrogen/generated/android/c++/JDetection.hpp

@@ -0,0 +1,66 @@
+///
+/// JDetection.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "Detection.hpp"
+
+#include "BoundingBox.hpp"
+#include "JBoundingBox.hpp"
+
+namespace margelo::nitro::yolo {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "Detection" and the the Kotlin data class "Detection".
+   */
+  struct JDetection final: public jni::JavaClass<JDetection> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/yolo/Detection;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct Detection by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    Detection toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldClassId = clazz->getField<double>("classId");
+      double classId = this->getFieldValue(fieldClassId);
+      static const auto fieldScore = clazz->getField<double>("score");
+      double score = this->getFieldValue(fieldScore);
+      static const auto fieldBoundingBox = clazz->getField<JBoundingBox>("boundingBox");
+      jni::local_ref<JBoundingBox> boundingBox = this->getFieldValue(fieldBoundingBox);
+      return Detection(
+        classId,
+        score,
+        boundingBox->toCpp()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JDetection::javaobject> fromCpp(const Detection& value) {
+      using JSignature = JDetection(double, double, jni::alias_ref<JBoundingBox>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.classId,
+        value.score,
+        JBoundingBox::fromCpp(value.boundingBox)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::yolo

package/nitrogen/generated/android/c++/JHybridYoloSpec.cpp

@@ -7,10 +7,19 @@
 
 #include "JHybridYoloSpec.hpp"
 
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
 
 #include <string>
+#include "Detection.hpp"
+#include <vector>
+#include "JDetection.hpp"
+#include "BoundingBox.hpp"
+#include "JBoundingBox.hpp"
 #include <memory>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <VisionCamera/JHybridFrameSpec.hpp>
@@ -62,5 +71,19 @@ namespace margelo::nitro::yolo {
     auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
     return __result->toStdString();
   }
+  std::vector<Detection> JHybridYoloSpec::detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JDetection>>(jni::alias_ref<margelo::nitro::camera::JHybridFrameSpec::JavaPart> /* frame */)>("detect");
+    auto __result = method(_javaPart, std::dynamic_pointer_cast<margelo::nitro::camera::JHybridFrameSpec>(frame)->getJavaPart());
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<Detection> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }(__result);
+  }
 
 } // namespace margelo::nitro::yolo

package/nitrogen/generated/android/c++/JHybridYoloSpec.hpp

@@ -57,6 +57,7 @@ namespace margelo::nitro::yolo {
     double sum(double num1, double num2) override;
     void loadModel(const std::string& modelPath) override;
     std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
+    std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override;
 
   private:
     jni::global_ref<JHybridYoloSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/BoundingBox.kt

@@ -0,0 +1,66 @@
+///
+/// BoundingBox.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.yolo
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "BoundingBox".
+ */
+@DoNotStrip
+@Keep
+data class BoundingBox(
+  @DoNotStrip
+  @Keep
+  val x1: Double,
+  @DoNotStrip
+  @Keep
+  val y1: Double,
+  @DoNotStrip
+  @Keep
+  val x2: Double,
+  @DoNotStrip
+  @Keep
+  val y2: Double
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is BoundingBox) return false
+    return Objects.deepEquals(this.x1, other.x1)
+      && Objects.deepEquals(this.y1, other.y1)
+      && Objects.deepEquals(this.x2, other.x2)
+      && Objects.deepEquals(this.y2, other.y2)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      x1,
+      y1,
+      x2,
+      y2
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(x1: Double, y1: Double, x2: Double, y2: Double): BoundingBox {
+      return BoundingBox(x1, y1, x2, y2)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/Detection.kt

@@ -0,0 +1,61 @@
+///
+/// Detection.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.yolo
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import java.util.Objects
+
+
+/**
+ * Represents the JavaScript object/struct "Detection".
+ */
+@DoNotStrip
+@Keep
+data class Detection(
+  @DoNotStrip
+  @Keep
+  val classId: Double,
+  @DoNotStrip
+  @Keep
+  val score: Double,
+  @DoNotStrip
+  @Keep
+  val boundingBox: BoundingBox
+) {
+  /* primary constructor */
+
+  override fun equals(other: Any?): Boolean {
+    if (this === other) return true
+    if (other !is Detection) return false
+    return Objects.deepEquals(this.classId, other.classId)
+      && Objects.deepEquals(this.score, other.score)
+      && Objects.deepEquals(this.boundingBox, other.boundingBox)
+  }
+
+  override fun hashCode(): Int {
+    return arrayOf<Any?>(
+      classId,
+      score,
+      boundingBox
+    ).contentDeepHashCode()
+  }
+
+  companion object {
+    /**
+     * Constructor called from C++
+     */
+    @DoNotStrip
+    @Keep
+    @Suppress("unused")
+    @JvmStatic
+    private fun fromCpp(classId: Double, score: Double, boundingBox: BoundingBox): Detection {
+      return Detection(classId, score, boundingBox)
+    }
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/yolo/HybridYoloSpec.kt

@@ -40,6 +40,10 @@ abstract class HybridYoloSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun frameToBase64(frame: com.margelo.nitro.camera.HybridFrameSpec): String
+  
+  @DoNotStrip
+  @Keep
+  abstract fun detect(frame: com.margelo.nitro.camera.HybridFrameSpec): Array<Detection>
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Bridge.hpp

@@ -8,6 +8,10 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
 // Forward declaration of `HybridYoloSpec` to properly resolve imports.
@@ -20,12 +24,15 @@ namespace VisionCamera { class HybridFrameSpec_cxx; }
 namespace Yolo { class HybridYoloSpec_cxx; }
 
 // Include C++ defined types
+#include "BoundingBox.hpp"
+#include "Detection.hpp"
 #include "HybridYoloSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <exception>
 #include <memory>
 #include <string>
+#include <vector>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -45,6 +52,17 @@ namespace margelo::nitro::yolo::bridge::swift {
   using std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>;
   inline std__weak_ptr_margelo__nitro__camera__HybridFrameSpec_ weakify_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& strong) noexcept { return strong; }
   
+  // pragma MARK: std::vector<Detection>
+  /**
+   * Specialized version of `std::vector<Detection>`.
+   */
+  using std__vector_Detection_ = std::vector<Detection>;
+  inline std::vector<Detection> create_std__vector_Detection_(size_t size) noexcept {
+    std::vector<Detection> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
   // pragma MARK: std::shared_ptr<HybridYoloSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridYoloSpec>`.
@@ -83,5 +101,14 @@ namespace margelo::nitro::yolo::bridge::swift {
   inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
     return Result<std::string>::withError(error);
   }
+  
+  // pragma MARK: Result<std::vector<Detection>>
+  using Result_std__vector_Detection__ = Result<std::vector<Detection>>;
+  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::vector<Detection>& value) noexcept {
+    return Result<std::vector<Detection>>::withValue(value);
+  }
+  inline Result_std__vector_Detection__ create_Result_std__vector_Detection__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<Detection>>::withError(error);
+  }
 
 } // namespace margelo::nitro::yolo::bridge::swift

package/nitrogen/generated/ios/Yolo-Swift-Cxx-Umbrella.hpp

@@ -8,18 +8,25 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
 // Forward declaration of `HybridYoloSpec` to properly resolve imports.
 namespace margelo::nitro::yolo { class HybridYoloSpec; }
 
 // Include C++ defined types
+#include "BoundingBox.hpp"
+#include "Detection.hpp"
 #include "HybridYoloSpec.hpp"
 #include <NitroModules/Result.hpp>
 #include <VisionCamera/HybridFrameSpec.hpp>
 #include <exception>
 #include <memory>
 #include <string>
+#include <vector>
 
 // C++ helpers for Swift
 #include "Yolo-Swift-Cxx-Bridge.hpp"

package/nitrogen/generated/ios/c++/HybridYoloSpecSwift.hpp

@@ -14,10 +14,17 @@ namespace Yolo { class HybridYoloSpec_cxx; }
 
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
 
 #include <string>
 #include <memory>
 #include <VisionCamera/HybridFrameSpec.hpp>
+#include "Detection.hpp"
+#include <vector>
+#include "BoundingBox.hpp"
 
 #include "Yolo-Swift-Cxx-Umbrella.hpp"
 
@@ -91,6 +98,14 @@ namespace margelo::nitro::yolo {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override {
+      auto __result = _swiftPart.detect(frame);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     Yolo::HybridYoloSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/BoundingBox.swift

@@ -0,0 +1,44 @@
+///
+/// BoundingBox.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `BoundingBox`, backed by a C++ struct.
+ */
+public typealias BoundingBox = margelo.nitro.yolo.BoundingBox
+
+public extension BoundingBox {
+  private typealias bridge = margelo.nitro.yolo.bridge.swift
+
+  /**
+   * Create a new instance of `BoundingBox`.
+   */
+  init(x1: Double, y1: Double, x2: Double, y2: Double) {
+    self.init(x1, y1, x2, y2)
+  }
+
+  @inline(__always)
+  var x1: Double {
+    return self.__x1
+  }
+  
+  @inline(__always)
+  var y1: Double {
+    return self.__y1
+  }
+  
+  @inline(__always)
+  var x2: Double {
+    return self.__x2
+  }
+  
+  @inline(__always)
+  var y2: Double {
+    return self.__y2
+  }
+}

package/nitrogen/generated/ios/swift/Detection.swift

@@ -0,0 +1,39 @@
+///
+/// Detection.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `Detection`, backed by a C++ struct.
+ */
+public typealias Detection = margelo.nitro.yolo.Detection
+
+public extension Detection {
+  private typealias bridge = margelo.nitro.yolo.bridge.swift
+
+  /**
+   * Create a new instance of `Detection`.
+   */
+  init(classId: Double, score: Double, boundingBox: BoundingBox) {
+    self.init(classId, score, boundingBox)
+  }
+
+  @inline(__always)
+  var classId: Double {
+    return self.__classId
+  }
+  
+  @inline(__always)
+  var score: Double {
+    return self.__score
+  }
+  
+  @inline(__always)
+  var boundingBox: BoundingBox {
+    return self.__boundingBox
+  }
+}

package/nitrogen/generated/ios/swift/HybridYoloSpec.swift

@@ -17,6 +17,7 @@ public protocol HybridYoloSpec_protocol: HybridObject {
   func sum(num1: Double, num2: Double) throws -> Double
   func loadModel(modelPath: String) throws -> Void
   func frameToBase64(frame: (any HybridFrameSpec)) throws -> String
+  func detect(frame: (any HybridFrameSpec)) throws -> [Detection]
 }
 
 public extension HybridYoloSpec_protocol {

package/nitrogen/generated/ios/swift/HybridYoloSpec_cxx.swift

@@ -163,4 +163,26 @@ open class HybridYoloSpec_cxx {
       return bridge.create_Result_std__string_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func detect(frame: bridge.std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_) -> bridge.Result_std__vector_Detection__ {
+    do {
+      let __result = try self.__implementation.detect(frame: { () -> any HybridFrameSpec in
+        let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(frame)
+        let __instance = HybridFrameSpec_cxx.fromUnsafe(__unsafePointer)
+        return __instance.getHybridFrameSpec()
+      }())
+      let __resultCpp = { () -> bridge.std__vector_Detection_ in
+        var __vector = bridge.create_std__vector_Detection_(__result.count)
+        for __item in __result {
+          __vector.push_back(__item)
+        }
+        return __vector
+      }()
+      return bridge.create_Result_std__vector_Detection__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_Detection__(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/shared/c++/BoundingBox.hpp

@@ -0,0 +1,95 @@
+///
+/// BoundingBox.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+
+
+namespace margelo::nitro::yolo {
+
+  /**
+   * A struct which can be represented as a JavaScript object (BoundingBox).
+   */
+  struct BoundingBox final {
+  public:
+    double x1     SWIFT_PRIVATE;
+    double y1     SWIFT_PRIVATE;
+    double x2     SWIFT_PRIVATE;
+    double y2     SWIFT_PRIVATE;
+
+  public:
+    BoundingBox() = default;
+    explicit BoundingBox(double x1, double y1, double x2, double y2): x1(x1), y1(y1), x2(x2), y2(y2) {}
+
+  public:
+    friend bool operator==(const BoundingBox& lhs, const BoundingBox& rhs) = default;
+  };
+
+} // namespace margelo::nitro::yolo
+
+namespace margelo::nitro {
+
+  // C++ BoundingBox <> JS BoundingBox (object)
+  template <>
+  struct JSIConverter<margelo::nitro::yolo::BoundingBox> final {
+    static inline margelo::nitro::yolo::BoundingBox fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::yolo::BoundingBox(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x1"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "y1"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x2"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "y2")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::yolo::BoundingBox& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "x1"), JSIConverter<double>::toJSI(runtime, arg.x1));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "y1"), JSIConverter<double>::toJSI(runtime, arg.y1));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "x2"), JSIConverter<double>::toJSI(runtime, arg.x2));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "y2"), JSIConverter<double>::toJSI(runtime, arg.y2));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x1")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "y1")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "x2")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "y2")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/Detection.hpp

@@ -0,0 +1,92 @@
+///
+/// Detection.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `BoundingBox` to properly resolve imports.
+namespace margelo::nitro::yolo { struct BoundingBox; }
+
+#include "BoundingBox.hpp"
+
+namespace margelo::nitro::yolo {
+
+  /**
+   * A struct which can be represented as a JavaScript object (Detection).
+   */
+  struct Detection final {
+  public:
+    double classId     SWIFT_PRIVATE;
+    double score     SWIFT_PRIVATE;
+    BoundingBox boundingBox     SWIFT_PRIVATE;
+
+  public:
+    Detection() = default;
+    explicit Detection(double classId, double score, BoundingBox boundingBox): classId(classId), score(score), boundingBox(boundingBox) {}
+
+  public:
+    friend bool operator==(const Detection& lhs, const Detection& rhs) = default;
+  };
+
+} // namespace margelo::nitro::yolo
+
+namespace margelo::nitro {
+
+  // C++ Detection <> JS Detection (object)
+  template <>
+  struct JSIConverter<margelo::nitro::yolo::Detection> final {
+    static inline margelo::nitro::yolo::Detection fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::yolo::Detection(
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "classId"))),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "score"))),
+        JSIConverter<margelo::nitro::yolo::BoundingBox>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "boundingBox")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::yolo::Detection& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "classId"), JSIConverter<double>::toJSI(runtime, arg.classId));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "score"), JSIConverter<double>::toJSI(runtime, arg.score));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "boundingBox"), JSIConverter<margelo::nitro::yolo::BoundingBox>::toJSI(runtime, arg.boundingBox));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "classId")))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "score")))) return false;
+      if (!JSIConverter<margelo::nitro::yolo::BoundingBox>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "boundingBox")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/HybridYoloSpec.cpp

@@ -17,6 +17,7 @@ namespace margelo::nitro::yolo {
       prototype.registerHybridMethod("sum", &HybridYoloSpec::sum);
       prototype.registerHybridMethod("loadModel", &HybridYoloSpec::loadModel);
       prototype.registerHybridMethod("frameToBase64", &HybridYoloSpec::frameToBase64);
+      prototype.registerHybridMethod("detect", &HybridYoloSpec::detect);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridYoloSpec.hpp

@@ -15,10 +15,14 @@
 
 // Forward declaration of `HybridFrameSpec` to properly resolve imports.
 namespace margelo::nitro::camera { class HybridFrameSpec; }
+// Forward declaration of `Detection` to properly resolve imports.
+namespace margelo::nitro::yolo { struct Detection; }
 
 #include <string>
 #include <memory>
 #include <VisionCamera/HybridFrameSpec.hpp>
+#include "Detection.hpp"
+#include <vector>
 
 namespace margelo::nitro::yolo {
 
@@ -54,6 +58,7 @@ namespace margelo::nitro::yolo {
       virtual double sum(double num1, double num2) = 0;
       virtual void loadModel(const std::string& modelPath) = 0;
       virtual std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) = 0;
+      virtual std::vector<Detection> detect(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-yolo",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "react-native-yolo is a react native package built with Nitro",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/module/index.js",

package/src/specs/yolo.nitro.ts

@@ -1,8 +1,24 @@
 import type { HybridObject } from 'react-native-nitro-modules'
 import type { Frame } from 'react-native-vision-camera'
 
-export interface Yolo extends HybridObject<{ ios: 'swift', android: 'kotlin' }> {
+export type Detection = {
+  classId: number
+  score: number
+  boundingBox: BoundingBox
+}
+export type BoundingBox = {
+  x1: number
+  y1: number
+  x2: number
+  y2: number
+}
+
+export interface Yolo extends HybridObject<{
+  ios: 'swift'
+  android: 'kotlin'
+}> {
   sum(num1: number, num2: number): number
   loadModel(modelPath: string): void
   frameToBase64(frame: Frame): string
-}
+  detect(frame: Frame): Detection[]
+}