react-native-yolo 0.0.3 → 0.0.5

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

@@ -8,18 +8,31 @@
 #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; }
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
+namespace VisionCamera { class HybridFrameSpec_cxx; }
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 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,
@@ -27,6 +40,29 @@ namespace Yolo { class HybridYoloSpec_cxx; }
  */
 namespace margelo::nitro::yolo::bridge::swift {
 
+  // pragma MARK: std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>
+  /**
+   * Specialized version of `std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>`.
+   */
+  using std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_ = std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>;
+  std::shared_ptr<margelo::nitro::camera::HybridFrameSpec> create_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_(std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<margelo::nitro::camera::HybridFrameSpec>
+  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>`.
@@ -56,5 +92,23 @@ namespace margelo::nitro::yolo::bridge::swift {
   inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
     return Result<void>::withError(error);
   }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  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,15 +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"
@@ -28,6 +38,8 @@ namespace margelo::nitro::yolo { class HybridYoloSpec; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridFrameSpec_cxx` to properly resolve imports.
+namespace VisionCamera { class HybridFrameSpec_cxx; }
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 namespace Yolo { class HybridYoloSpec_cxx; }
 

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

@@ -12,9 +12,19 @@
 // Forward declaration of `HybridYoloSpec_cxx` to properly resolve imports.
 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"
 
@@ -80,6 +90,22 @@ namespace margelo::nitro::yolo {
         std::rethrow_exception(__result.error());
       }
     }
+    inline std::string frameToBase64(const std::shared_ptr<margelo::nitro::camera::HybridFrameSpec>& frame) override {
+      auto __result = _swiftPart.frameToBase64(frame);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      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

@@ -5,6 +5,7 @@
 /// Copyright © Marc Rousavy @ Margelo
 ///
 
+import VisionCamera
 import NitroModules
 
 /// See ``HybridYoloSpec``
@@ -15,6 +16,8 @@ public protocol HybridYoloSpec_protocol: HybridObject {
   // Methods
   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

@@ -6,6 +6,7 @@
 ///
 
 import NitroModules
+import VisionCamera
 
 /**
  * A class implementation that bridges HybridYoloSpec over to C++.
@@ -146,4 +147,42 @@ open class HybridYoloSpec_cxx {
       return bridge.create_Result_void_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func frameToBase64(frame: bridge.std__shared_ptr_margelo__nitro__camera__HybridFrameSpec_) -> bridge.Result_std__string_ {
+    do {
+      let __result = try self.__implementation.frameToBase64(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 = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      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

@@ -16,6 +16,8 @@ namespace margelo::nitro::yolo {
     registerHybrids(this, [](Prototype& prototype) {
       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

@@ -13,9 +13,16 @@
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
 
-
+// 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 {
 
@@ -50,6 +57,8 @@ namespace margelo::nitro::yolo {
       // Methods
       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