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/dwsdk/model.h"
#include "../daoai_dl_sdk/include/export/dwsdk/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();
 
 static int getNumCUDADevices();
 };
 
 public enum class ModelType : int
 {
 Object_Detection = DaoAI::DeepLearning::ModelType::Object_Detection,
 Multilabel_Detection = DaoAI::DeepLearning::ModelType::Multilabel_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,
 Rotated_Object_Detection = DaoAI::DeepLearning::ModelType::Rotated_Object_Detection,
#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_FAST = DaoAI::DeepLearning::Vision::DetectionLevel::PIXEL_FAST,
 PIXEL_ACCURATE = DaoAI::DeepLearning::Vision::DetectionLevel::PIXEL_ACCURATE,
 IMAGE = DaoAI::DeepLearning::Vision::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_file_path, DeviceType device, int device_idx);
 
 
 ObjectDetectionResult^ inference(Image^ image);
 
 cli::array<ObjectDetectionResult^>^ inference(cli::array<Image^>^ images);
 
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 void setConfidenceThreshold(float threshold);
 
 float getConfidenceThreshold();
 
 void setIOUThreshold(float threshold);
 
 float getIOUThreshold();
 };
 public ref class RotatedObjectDetection : public ManagedObject<DaoAI::DeepLearning::Vision::RotatedObjectDetection>
 {
 public:
 RotatedObjectDetection(String^ model_file_path, DeviceType device, int device_idx);
 
 
 RotatedObjectDetectionResult^ inference(Image^ image);
 
 cli::array<RotatedObjectDetectionResult^>^ inference(cli::array<Image^>^ images);
 
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 
 void setConfidenceThreshold(float threshold);
 
 float getConfidenceThreshold();
 
 void setIOUThreshold(float threshold);
 
 float getIOUThreshold();
 };
 
 public ref class MultilabelDetection : public ManagedObject<DaoAI::DeepLearning::Vision::MultilabelDetection>
 {
 public:
 MultilabelDetection(String^ model_file_path, DeviceType device, int device_idx);
 
 
 MultilabelDetectionResult^ inference(Image^ image);
 
 cli::array<MultilabelDetectionResult^>^ inference(cli::array<Image^>^ images);
 
 
 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_file_path, DeviceType device, int device_idx);
 
 InstanceSegmentationResult^ inference(Image^ image);
 
 cli::array<InstanceSegmentationResult^>^ inference(cli::array<Image^>^ images);
 
 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_file_path, DeviceType device, int device_idx);
 
 KeypointDetectionResult^ inference(Image^ image);
 
 cli::array<KeypointDetectionResult^>^ inference(cli::array<Image^>^ images);
 
 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_file_path, DeviceType device, int device_idx);
 
 
 OCRResult^ inference(Image^ image);
 
 cli::array<OCRResult^>^ inference(cli::array<Image^>^ images);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 };
 
 public ref class Classification : public ManagedObject<DaoAI::DeepLearning::Vision::Classification>
 {
 public:
 Classification(String^ model_file_path, DeviceType device, int device_idx);
 
 
 ClassificationResult^ inference(Image^ image);
 
 cli::array<ClassificationResult^>^ inference(cli::array<Image^>^ images);
 
 ModelInfo^ getModelInfo();
 
 void setBatchSize(int batch_size);
 
 int getBatchSize();
 };
 
 public ref class SupervisedDefectSegmentation : public ManagedObject<DaoAI::DeepLearning::Vision::SupervisedDefectSegmentation>
 {
 public:
 SupervisedDefectSegmentation(String^ model_file_path, DeviceType device, int device_idx);
 
 
 SupervisedDefectSegmentationResult^ inference(Image^ image);
 
 cli::array<SupervisedDefectSegmentationResult^>^ inference(cli::array<Image^>^ images);
 
 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_file_path, DeviceType device, int device_idx);
 
 
 PresenceCheckingResult^ inference(Image^ image);
 
 cli::array<PresenceCheckingResult^>^ inference(cli::array<Image^>^ images);
 
 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_file_path, DeviceType device, int device_idx);
 
 
 PositioningResult^ inference(Image^ image);
 
 cli::array<PositioningResult^>^ inference(cli::array<Image^>^ images);
 
 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 setImageThreshold(float value);
 
 float getImageThreshold();
 
 void setPixelThreshold(float value);
 
 float getPixelThreshold();
 
 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);
 
 cli::array<UnsupervisedDefectSegmentationResult^>^ inference(cli::array<Image^>^ images);
 
 UnsupervisedDefectSegmentationResult^ inference(Image^ image, String^ component_name);
 
 cli::array<UnsupervisedDefectSegmentationResult^>^ inference(cli::array<Image^>^ images, cli::array<String^>^ component_names);
 
 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
 }
 }
}