react-native-yolo 0.0.4 → 0.0.7

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

@@ -1,65 +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
 
 
-
-
 class HybridYolo : HybridYoloSpec() {
-    private var interpreter: Interpreter? = null
-    private val modelLoader = YoloModelLoader()
-
-    override fun sum(num1: Double, num2: Double): Double {
-        return num1 + num2
+    companion object {
+        private const val TAG = "YOLO_TAG"
     }
-
-    override fun loadModel(modelPath: String) {
-        val context =
-                NitroModules.applicationContext ?: throw IllegalStateException("Context is null")
-
-        Log.d("YOLO_TAG", "Trying to load: $modelPath")
-
-        try {
-            val modelBuffer = modelLoader.load(modelPath)
-
-            interpreter?.close()
-            interpreter = Interpreter(modelBuffer)
-
-            Log.d("YOLO_TAG", "✅ Model loaded successfully!")
-        } catch (e: Exception) {
-            Log.e("YOLO_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("YOLO_TAG", "❌ frameToBase64 failed", e)
+            Log.e(TAG, "❌ frameToBase64 failed", e)
             ""
         }
     }
-
 }

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

@@ -0,0 +1,212 @@
+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
+
+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 = 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()
+    }
+}

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/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/lib/commonjs/index.js

@@ -7,12 +7,13 @@ exports.Yolo = void 0;
 var _reactNativeNitroModules = require("react-native-nitro-modules");
 var _reactNative = require("react-native");
 const NativeYolo = _reactNativeNitroModules.NitroModules.createHybridObject('Yolo');
-const Yolo = exports.Yolo = Object.assign(NativeYolo, {
-  loadModelTest(modelAssetId) {
+const Yolo = exports.Yolo = {
+  ...NativeYolo,
+  loadModel(modelAssetId) {
     const {
       uri
     } = _reactNative.Image.resolveAssetSource(modelAssetId);
     return NativeYolo.loadModel(uri);
   }
-});
+};
 //# sourceMappingURL=index.js.map

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNativeNitroModules","require","_reactNative","NativeYolo","NitroModules","createHybridObject","Yolo","exports","Object","assign","loadModelTest","modelAssetId","uri","Image","resolveAssetSource","loadModel"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAEA,IAAAC,YAAA,GAAAD,OAAA;AAEA,MAAME,UAAU,GAAGC,qCAAY,CAACC,kBAAkB,CAAW,MAAM,CAAC;AAE7D,MAAMC,IAAI,GAAAC,OAAA,CAAAD,IAAA,GAAGE,MAAM,CAACC,MAAM,CAACN,UAAU,EAAE;EAC5CO,aAAaA,CAACC,YAAoB,EAAC;IACjC,MAAM;MAAEC;IAAI,CAAC,GAAGC,kBAAK,CAACC,kBAAkB,CAACH,YAAY,CAAC;IACtD,OAAOR,UAAU,CAACY,SAAS,CAACH,GAAG,CAAC;EAClC;AACF,CAAC,CAAC","ignoreList":[]}
+{"version":3,"names":["_reactNativeNitroModules","require","_reactNative","NativeYolo","NitroModules","createHybridObject","Yolo","exports","loadModel","modelAssetId","uri","Image","resolveAssetSource"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;;;;;AAAA,IAAAA,wBAAA,GAAAC,OAAA;AAEA,IAAAC,YAAA,GAAAD,OAAA;AAEA,MAAME,UAAU,GAAGC,qCAAY,CAACC,kBAAkB,CAAW,MAAM,CAAC;AAG7D,MAAMC,IAAI,GAAAC,OAAA,CAAAD,IAAA,GAAG;EAClB,GAAGH,UAAU;EAEbK,SAASA,CAACC,YAAoB,EAAE;IAC9B,MAAM;MAAEC;IAAI,CAAC,GAAGC,kBAAK,CAACC,kBAAkB,CAACH,YAAY,CAAC;IACtD,OAAON,UAAU,CAACK,SAAS,CAACE,GAAG,CAAC;EAClC;AACF,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -3,12 +3,13 @@
 import { NitroModules } from 'react-native-nitro-modules';
 import { Image } from 'react-native';
 const NativeYolo = NitroModules.createHybridObject('Yolo');
-export const Yolo = Object.assign(NativeYolo, {
-  loadModelTest(modelAssetId) {
+export const Yolo = {
+  ...NativeYolo,
+  loadModel(modelAssetId) {
     const {
       uri
     } = Image.resolveAssetSource(modelAssetId);
     return NativeYolo.loadModel(uri);
   }
-});
+};
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","Image","NativeYolo","createHybridObject","Yolo","Object","assign","loadModelTest","modelAssetId","uri","resolveAssetSource","loadModel"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,KAAK,QAAQ,cAAc;AAEpC,MAAMC,UAAU,GAAGF,YAAY,CAACG,kBAAkB,CAAW,MAAM,CAAC;AAEpE,OAAO,MAAMC,IAAI,GAAGC,MAAM,CAACC,MAAM,CAACJ,UAAU,EAAE;EAC5CK,aAAaA,CAACC,YAAoB,EAAC;IACjC,MAAM;MAAEC;IAAI,CAAC,GAAGR,KAAK,CAACS,kBAAkB,CAACF,YAAY,CAAC;IACtD,OAAON,UAAU,CAACS,SAAS,CAACF,GAAG,CAAC;EAClC;AACF,CAAC,CAAC","ignoreList":[]}
+{"version":3,"names":["NitroModules","Image","NativeYolo","createHybridObject","Yolo","loadModel","modelAssetId","uri","resolveAssetSource"],"sourceRoot":"..\\..\\src","sources":["index.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAEzD,SAASC,KAAK,QAAQ,cAAc;AAEpC,MAAMC,UAAU,GAAGF,YAAY,CAACG,kBAAkB,CAAW,MAAM,CAAC;AAGpE,OAAO,MAAMC,IAAI,GAAG;EAClB,GAAGF,UAAU;EAEbG,SAASA,CAACC,YAAoB,EAAE;IAC9B,MAAM;MAAEC;IAAI,CAAC,GAAGN,KAAK,CAACO,kBAAkB,CAACF,YAAY,CAAC;IACtD,OAAOJ,UAAU,CAACG,SAAS,CAACE,GAAG,CAAC;EAClC;AACF,CAAC","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -1,5 +1,14 @@
-import type { Yolo as YoloSpec } from './specs/yolo.nitro';
-export declare const Yolo: YoloSpec & {
-    loadModelTest(modelAssetId: number): void;
+export declare const Yolo: {
+    loadModel(modelAssetId: number): import("./specs/yolo.nitro").YoloModel;
+    frameToBase64(frame: import("react-native-vision-camera").Frame): string;
+    __type?: string;
+    name: string;
+    toString(): string;
+    equals(other: import("react-native-nitro-modules").HybridObject<{
+        ios: "swift";
+        android: "kotlin";
+    }>): boolean;
+    dispose(): void;
 };
+export type { Detection, BoundingBox, YoloModel, } from './specs/yolo.nitro';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,IAAI,QAAQ,EAAE,MAAM,oBAAoB,CAAA;AAK1D,eAAO,MAAM,IAAI;gCACa,MAAM;CAIlC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,IAAI;4BAGS,MAAM;;;;;;;;;;CAI/B,CAAA;AACD,YAAY,EACV,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,oBAAoB,CAAA"}

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

@@ -1,11 +1,28 @@
 import type { HybridObject } from 'react-native-nitro-modules';
 import type { Frame } from 'react-native-vision-camera';
+export type Detection = {
+    classId: number;
+    score: number;
+    boundingBox: BoundingBox;
+};
+export type BoundingBox = {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+export interface YoloModel extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    detect(frame: Frame): Detection[];
+    close(): void;
+}
 export interface Yolo extends HybridObject<{
     ios: 'swift';
     android: 'kotlin';
 }> {
-    sum(num1: number, num2: number): number;
-    loadModel(modelPath: string): void;
+    loadModel(modelPath: string): YoloModel;
     frameToBase64(frame: Frame): string;
 }
 //# 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,MAAM,MAAM,SAAS,GAAG;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,WAAW,CAAA;CACzB,CAAA;AACD,MAAM,MAAM,WAAW,GAAG;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,MAAM,WAAW,SAAU,SAAQ,YAAY,CAAC;IAC9C,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE,CAAA;IACjC,KAAK,IAAI,IAAI,CAAA;CAEd;AAED,MAAM,WAAW,IAAK,SAAQ,YAAY,CAAC;IACzC,GAAG,EAAE,OAAO,CAAA;IACZ,OAAO,EAAE,QAAQ,CAAA;CAClB,CAAC;IACA,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;IACvC,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;CACpC"}

package/nitrogen/generated/android/Yolo+autolinking.cmake

@@ -33,8 +33,10 @@ target_sources(
   # Autolinking Setup
   ../nitrogen/generated/android/YoloOnLoad.cpp
   # Shared Nitrogen C++ sources
+  ../nitrogen/generated/shared/c++/HybridYoloModelSpec.cpp
   ../nitrogen/generated/shared/c++/HybridYoloSpec.cpp
   # Android-specific Nitrogen C++ sources
+  ../nitrogen/generated/android/c++/JHybridYoloModelSpec.cpp
   ../nitrogen/generated/android/c++/JHybridYoloSpec.cpp
 )
 

package/nitrogen/generated/android/YoloOnLoad.cpp

@@ -15,6 +15,7 @@
 #include <fbjni/fbjni.h>
 #include <NitroModules/HybridObjectRegistry.hpp>
 
+#include "JHybridYoloModelSpec.hpp"
 #include "JHybridYoloSpec.hpp"
 #include <NitroModules/DefaultConstructableObject.hpp>
 
@@ -40,6 +41,7 @@ void registerAllNatives() {
   using namespace margelo::nitro::yolo;
 
   // Register native JNI methods
+  margelo::nitro::yolo::JHybridYoloModelSpec::CxxPart::registerNatives();
   margelo::nitro::yolo::JHybridYoloSpec::CxxPart::registerNatives();
 
   // Register Nitro Hybrid Objects

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