lightly_edge_rs_bindings.h

/* © 2024 Lightly AI. All rights reserved. */
 
#ifndef LIGHTLY_EDGE_RS_BINDINGS_H
#define LIGHTLY_EDGE_RS_BINDINGS_H
 
/* Generated with cbindgen:0.27.0 */
 
/* WARNING: This file is autogenerated by cbindgen. Don't modify this manually. */
 
#include <cstdarg>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <ostream>
#include <new>
 
namespace lightly_edge_rs {
 
constexpr static const uint16_t SUCCESS_CODE = 0;
 
constexpr static const int32_t NO_SUBCLASS = -1;
 
enum class InferenceDeviceType {
  Auto,
  CPU,
  CUDA,
  TensorRT,
};
 
struct LightlyEdge;
 
struct CStatus {
  uint16_t code;
  const char *error_message;
};
 
struct LightlyEdgeDetectorConfig {
  bool object_detector_enable;
  bool classifiers_enable;
  uint32_t max_classifications;
};
 
struct LightlyEdgeConfig {
  LightlyEdgeDetectorConfig detector_config;
  InferenceDeviceType inference_device_type;
};
 
struct ObjectDetection {
  uint32_t class_id;
  int32_t subclass_id;
  int32_t x;
  int32_t y;
  int32_t w;
  int32_t h;
  float confidence;
};
 
struct DiversitySelectInfo {
  bool should_select;
  float min_distance;
};
 
struct SimilaritySelectInfo {
  bool should_select;
  float distance;
};
 
struct AdaptiveDiversitySelectInfo {
  bool should_select;
  float min_distance;
};
 
struct DetectionSelectInfo {
  uint32_t class_id;
  int32_t subclass_id;
  float threshold;
  bool should_select;
};
 
struct SelectionStrategiesSelectInfo {
  DiversitySelectInfo *out_diversity_buffer;
  size_t diversity_buffer_size;
  size_t *out_diversity_size;
  SimilaritySelectInfo *out_similarity_buffer;
  size_t similarity_buffer_size;
  size_t *out_similarity_size;
  AdaptiveDiversitySelectInfo *out_adaptive_diversity_buffer;
  size_t adaptive_diversity_buffer_size;
  size_t *out_adaptive_diversity_size;
  DetectionSelectInfo *out_detection_buffer;
  size_t detection_buffer_size;
  size_t *out_detection_size;
};
 
struct PatchCoordsRel {
  float x0;
  float y0;
  float w;
  float h;
};
 
extern "C" {
 
CStatus lightly_edge_new_from_tar(const char *archive_path,
                                  LightlyEdgeConfig config,
                                  LightlyEdge **out_ptr);
 
void destroy(LightlyEdge * lightly_edge);
 
CStatus embed_frame(const LightlyEdge * lightly_edge,
                    uint8_t *rgb_image_data,
                    size_t rgb_image_data_size,
                    uint32_t width,
                    uint32_t height,
                    float *out_embedding_buffer);
 
CStatus embed_texts(LightlyEdge *lightly_edge,
                    const char *const *texts,
                    size_t num_texts,
                    float **out_embeddings);
 
CStatus insert_into_embedding_database(LightlyEdge * lightly_edge,
                                       const float *embedding_buffer,
                                       size_t embedding_buffer_size);
 
CStatus register_diversity_strategy(LightlyEdge * lightly_edge, float min_distance);
 
size_t num_diversity_strategies(const LightlyEdge * lightly_edge);
 
size_t num_patches(const LightlyEdge * lightly_edge);
 
CStatus register_similarity_strategy(LightlyEdge * lightly_edge,
                                     const float *query_embedding_buffer,
                                     size_t query_embedding_buffer_size,
                                     float max_distance);
 
size_t num_similarity_strategies(const LightlyEdge * lightly_edge);
 
CStatus register_detection_strategy(LightlyEdge * lightly_edge,
                                    uint32_t class_id,
                                    int32_t subclass_id,
                                    float threshold);
 
size_t num_detection_strategies(const LightlyEdge * lightly_edge);
 
CStatus register_adaptive_diversity_strategy(LightlyEdge * lightly_edge,
                                             float target_ratio,
                                             size_t max_buffer_length);
 
size_t num_adaptive_diversity_strategies(const LightlyEdge * lightly_edge);
 
void clear_strategies(LightlyEdge * lightly_edge);
 
CStatus should_select(LightlyEdge * lightly_edge,
                      const float *embedding_buffer,
                      size_t embedding_buffer_size,
                      const ObjectDetection *detection_buffer,
                      size_t detection_buffer_size,
                      SelectionStrategiesSelectInfo *out_info);
 
CStatus should_select_with_patches(LightlyEdge * lightly_edge,
                                   const float *const *embeddings_buffer,
                                   size_t num_embeddings,
                                   size_t embedding_dim,
                                   const ObjectDetection *detection_buffer,
                                   size_t detection_buffer_size,
                                   SelectionStrategiesSelectInfo *out_info);
 
size_t embedding_dimension(const LightlyEdge * lightly_edge);
 
CStatus detect(const LightlyEdge * lightly_edge,
               uint8_t *rgb_image_data,
               size_t rgb_image_data_size,
               uint32_t width,
               uint32_t height,
               ObjectDetection *out_detections_buffer,
               size_t *out_detections_len);
 
CStatus detection_class_labels(const LightlyEdge * lightly_edge,
                               const char **out_classes_buffer,
                               size_t *out_classes_len);
 
CStatus detection_subclass_labels(const LightlyEdge * lightly_edge,
                                  uint32_t class_id,
                                  const char **out_subclasses_buffer,
                                  size_t *out_subclasses_len);
 
CStatus set_embedding_patches(LightlyEdge * lightly_edge,
                              const PatchCoordsRel *patches,
                              size_t num_patches);
 
void reset_embedding_patches(LightlyEdge * lightly_edge);
 
CStatus embed_patches(const LightlyEdge * lightly_edge,
                      uint8_t *rgb_image_data,
                      size_t rgb_image_data_size,
                      uint32_t width,
                      uint32_t height,
                      float **out_embedding_buffer);
 
CStatus create_status_impl(uint16_t code, const char *error_message);
 
void free_status_message(CStatus * status);
 
}  // extern "C"
 
}  // namespace lightly_edge_rs
 
#endif  // LIGHTLY_EDGE_RS_BINDINGS_H