model.h

Go to the documentation of this file.

#pragma once
#include "managed_object.h"
#include "common.h"
#include "prediction.h"
#include "../daoai_dl_sdk/include/export/model.h"
#include "../daoai_dl_sdk/include/export/component_memory.h"
 
using namespace System;
using namespace System::Collections::Generic;
namespace DaoAI
{
 namespace DeepLearningCLI
 {
 public ref class Application 
 {
 public:
 // Initialize DaoAI Deep Learning SDK
 static void initialize(bool use_shared_memory, int resevered_vram_size);
 
 static int getNumCUDADevices();
 };
 
 public enum class ModelType : int
 {
 Object_Detection = DaoAI::DeepLearning::ModelType::Object_Detection,
 Instance_Segmentation = DaoAI::DeepLearning::ModelType::Instance_Segmentation,
 Keypoint_Detection = DaoAI::DeepLearning::ModelType::Keypoint_Detection,
 Classification = DaoAI::DeepLearning::ModelType::Classification,
 OCR = DaoAI::DeepLearning::ModelType::OCR,
 Supervised_Defect_Segmentation = DaoAI::DeepLearning::ModelType::Supervised_Defect_Segmentation,
 Auto_Segmentation = DaoAI::DeepLearning::ModelType::Auto_Segmentation,
#ifdef INDUSTRIAL
 Presence_Checking = DaoAI::DeepLearning::ModelType::Presence_Checking,
 Positioning = DaoAI::DeepLearning::ModelType::Positioning,
 Unsupervised_Defect_Segmentation = DaoAI::DeepLearning::ModelType::Unsupervised_Defect_Segmentation
#endif // INDUSTRIAL
 };
 
 public enum class DeviceType {
 CPU = DaoAI::DeepLearning::DeviceType::CPU,
 GPU = DaoAI::DeepLearning::DeviceType::GPU
 };
 
 public enum class DetectionLevel {
 PIXEL = DaoAI::DeepLearning::DetectionLevel::PIXEL,
 IMAGE = DaoAI::DeepLearning::DetectionLevel::IMAGE
 };
 
 
 public ref class ModelInfo
 {
 public:
 ModelType^ model_type;
 DeviceType^ device;
 cli::array<String^>^ class_labels;
 cli::array<int>^ num_keypoints;
 cli::array<String^>^ keypoint_labels;
 };
 
 namespace Vision
 {
 public ref class ObjectDetection : public ManagedObject<DaoAI::DeepLearning::Vision::ObjectDetection>
 {
 public:
 
 ObjectDetection(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 ObjectDetection(String^ model_file_path, DeviceType device, int device_idx);
 
 
 ObjectDetectionResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 void setConfidenceThreshold(float threshold);
 
 float getConfidenceThreshold();
 
 void setIOUThreshold(float threshold);
 
 float getIOUThreshold();
 };
 
 public ref class InstanceSegmentation : public ManagedObject<DaoAI::DeepLearning::Vision::InstanceSegmentation>
 {
 public:
 
 InstanceSegmentation(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 InstanceSegmentation(String^ model_file_path, DeviceType device, int device_idx);
 
 InstanceSegmentationResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 void setConfidenceThreshold(float threshold);
 
 float getConfidenceThreshold();
 
 void setIOUThreshold(float threshold);
 
 float getIOUThreshold();
 };
 
 public ref class KeypointDetection : public ManagedObject<DaoAI::DeepLearning::Vision::KeypointDetection>
 {
 public:
 
 KeypointDetection(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 KeypointDetection(String^ model_file_path, DeviceType device, int device_idx);
 
 KeypointDetectionResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 void setConfidenceThreshold(float threshold);
 
 float getConfidenceThreshold();
 
 void setIOUThreshold(float threshold);
 
 float getIOUThreshold();
 };
 
 public ref class OCR : public ManagedObject<DaoAI::DeepLearning::Vision::OCR>
 {
 public:
 
 OCR(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 OCR(String^ model_file_path, DeviceType device, int device_idx);
 
 
 OCRResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 };
 
 public ref class Classification : public ManagedObject<DaoAI::DeepLearning::Vision::Classification>
 {
 public:
 
 Classification(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 Classification(String^ model_file_path, DeviceType device, int device_idx);
 
 
 ClassificationResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 };
 
 public ref class SupervisedDefectSegmentation : public ManagedObject<DaoAI::DeepLearning::Vision::SupervisedDefectSegmentation>
 {
 public:
 
 SupervisedDefectSegmentation(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 SupervisedDefectSegmentation(String^ model_file_path, DeviceType device, int device_idx);
 
 
 SupervisedDefectSegmentationResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 };
 
 public ref class AutoSegmentation : public ManagedObject<DaoAI::DeepLearning::Vision::AutoSegmentation>
 {
 public:
 AutoSegmentation(String^ model_file_path, DeviceType device, int device_idx);
 
 AutoSegmentationResult^ inference(ImageEmbedding^ embedding, cli::array<Point^>^ points);
 
 AutoSegmentationResult^ inference(ImageEmbedding^ embedding, cli::array<Box^>^ boxes, cli::array<Point^>^ points);
 
 cli::array<AutoSegmentationResult^>^ inference(cli::array<ImageEmbedding^>^ embeddings, cli::array<cli::array<Box^>^>^ boxes, cli::array<cli::array<Point^>^>^ points);
 
 cli::array<ImageEmbedding^>^ generateImageEmbeddings(cli::array<Image^>^ images);
 
 ImageEmbedding^ generateImageEmbeddings(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 };
 
#ifdef INDUSTRIAL
 public ref class PresenceChecking : public ManagedObject<DaoAI::DeepLearning::Vision::PresenceChecking>
 {
 public:
 
 PresenceChecking(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 PresenceChecking(String^ model_file_path, DeviceType device, int device_idx);
 
 
 PresenceCheckingResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 void setConfidenceThreshold(float threshold);
 
 float getConfidenceThreshold();
 
 void setIOUThreshold(float threshold);
 
 float getIOUThreshold();
 };
 
 public ref class Positioning : public ManagedObject<DaoAI::DeepLearning::Vision::Positioning>
 {
 public:
 
 Positioning(String^ model_config_path, String^ model_weight_path, DeviceType device, int device_idx);
 
 Positioning(String^ model_file_path, DeviceType device, int device_idx);
 
 
 PositioningResult^ inference(Image^ image);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 void setConfidenceThreshold(float threshold);
 
 float getConfidenceThreshold();
 
 void setIOUThreshold(float threshold);
 
 float getIOUThreshold();
 };
 
 public ref class ComponentMemory : public ManagedObject<DaoAI::DeepLearning::ComponentMemory>
 {
 public:
 
 ComponentMemory(String^ file_path);
 
 ComponentMemory(const DaoAI::DeepLearning::ComponentMemory& component_memory);
 
 void save(String^ file_path);
 
 void load(String^ file_path);
 };
 
 public ref class UnsupervisedDefectSegmentation : public ManagedObject<DaoAI::DeepLearning::Vision::UnsupervisedDefectSegmentation>
 {
 public:
 
 UnsupervisedDefectSegmentation(DeviceType device);
 
 
 UnsupervisedDefectSegmentationResult^ inference(Image^ image);
 
 UnsupervisedDefectSegmentationResult^ inference(Image^ image, String^ component_name, float sensitivity);
 
 cli::array<UnsupervisedDefectSegmentationResult^>^ inference(cli::array<Image^>^ images, cli::array<String^>^ component_names, cli::array<float>^ sensitivities);
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 
 void addComponentMemory(String^ component_name, String^ component_memory_file_path);
 
 void addComponentMemory(String^ component_name, ComponentMemory^ component_memory);
 
 void addComponentArchive(String^ archive_path);
 
 void removeComponentMemory(String^ component_name);
 
 Dictionary<String^, ComponentMemory^>^ listComponentMemory();
 
 void setDetectionLevel(DetectionLevel value);
 
 ComponentMemory^ createComponentMemory(String^ component_name, cli::array<Image^>^ good_images, cli::array<Image^>^ bad_images, cli::array<Image^>^ masks, bool append_memory);
 };
#endif // INDUSTRIAL
 }
 }
}