common.h

Go to the documentation of this file.

#pragma once
#include "managed_object.h"
#include "../daoai_dl_sdk/include/export/model.h"
 
using namespace System;
namespace DaoAI
{
 namespace DeepLearningCLI
 {
 public ref class Point : public ManagedObject<DaoAI::DeepLearning::Point>
 {
 public:
 Point(float x, float y, float confidence, String^ label);
 Point(float x, float y, String^ label);
 Point(float x, float y);
 Point();
 
 static Point^ operator+(Point^ lhs, Point^ rhs);
 static Point^ operator-(Point^ lhs, Point^ rhs);
 Point(const DaoAI::DeepLearning::Point& point) : ManagedObject(new DaoAI::DeepLearning::Point(point)) {}
 property float X
 {
 float get() {
 return m_Instance->x;
 }
 void set(float value) {
 m_Instance->x = value;
 }
 }
 property float Y
 {
 float get() {
 return m_Instance->y;
 }
 void set(float value){
 m_Instance->y = value;
 }
 }
 
 };
 
 public ref class Polygon : public ManagedObject<DaoAI::DeepLearning::Polygon>
 {
 public:
 Polygon(cli::array<Point^>^ points);
 Polygon();
 // Copy constructor from native object
 Polygon(const DaoAI::DeepLearning::Polygon& polygon);
 
 property cli::array<Point^>^ Points
 {
 cli::array<Point^>^ get() {
 cli::array<Point^>^ points = gcnew cli::array<Point^>(m_Instance->points.size());
 for (int i = 0; i < m_Instance->points.size(); i++) {
 points[i] = gcnew Point(m_Instance->points[i].x, m_Instance->points[i].y);
 }
 return points;
 }
 void set(cli::array<Point^>^ value) {
 m_Instance->points.clear();
 for (int i = 0; i < value->Length; i++) {
 m_Instance->points.push_back(DaoAI::DeepLearning::Point(value[i]->X, value[i]->Y));
 }
 }
 }
 
 };
 
 public ref class Box : public ManagedObject<DaoAI::DeepLearning::Box>
 {
 public:
 enum class Type { XYXY, XYWH };
 Box(Point^ p1, Point^ p2, float angle);
 
 Box(float a1, float a2, float a3, float a4, float angle, Type type);
 // Copy constructor from native object
 Box(const DaoAI::DeepLearning::Box& box);
 
 Polygon^ toPolygon();
 
 String^ toString();
 
 float h();
 
 float w();
 
 float x1();
 
 
 float y1();
 
 float x2();
 
 float y2();
 
 float angle();
 
 Box^ toType(Type type);
 
 property cli::array<float>^ data
 {
 cli::array<float>^ get() {
 cli::array<float>^ data = gcnew cli::array<float>(m_Instance->data.size());
 for (int i = 0; i < m_Instance->data.size(); i++) {
 data[i] = m_Instance->data[i];
 }
 return data;
 }
 void set(cli::array<float>^ value) {
 m_Instance->data.clear();
 for (int i = 0; i < value->Length; i++) {
 float v = value[i];
 m_Instance->data.push_back(v);
 }
 }
 }
 property Type type
 {
 Type get() {
 return (Type)m_Instance->type;
 }
 void set(Type value) {
 m_Instance->type = (DaoAI::DeepLearning::Box::Type)value;
 }
 }
 
 };
 
 public ref class Image : public ManagedObject<DaoAI::DeepLearning::Image>
 {
 public:
 enum class Type
 {
 RGB, BGR, GRAYSCALE
 };
 
 // create an image object from headers with a new deep copy of data buffer
 Image(int image_height, int image_width, Image::Type type, cli::array<uint8_t>^ data);
 Image(const DaoAI::DeepLearning::Image& image);
 Image(String^ image);
 // create a deep copy of the Image object
 Image^ clone();
 
 void save(String^ file_path);
 
 property int height
 {
 int get() {
 return m_Instance->height;
 }
 void set(int value) {
 m_Instance->height = value;
 }
 }
 property int width
 {
 int get() {
 return m_Instance->width;
 }
 void set(int value) {
 m_Instance->width = value;
 }
 }
 
 property Type type
 {
 Type get() {
 return (Type)m_Instance->type;
 }
 void set(Type value) {
 m_Instance->type = (DaoAI::DeepLearning::Image::Type)value;
 }
 }
 
 property cli::array<uint8_t>^ data
 {
 cli::array<uint8_t>^ get() {
 int channels = (type == Type::GRAYSCALE) ? 1 : 3;
 cli::array<uint8_t>^ data = gcnew cli::array<uint8_t>(m_Instance->width * m_Instance->height * channels);
 for (int i = 0; i < m_Instance->width * m_Instance->height * channels; i++) {
 data[i] = m_Instance->getData()[i];
 }
 return data;
 }
 }
 };
 
 public ref class Mask : public ManagedObject<DaoAI::DeepLearning::Mask>
 {
 public:
 Mask(Image^ image);
 Mask(DaoAI::DeepLearning::Mask mask);
 
 Mask^ merge(Mask^ mask);
 
 cli::array<Polygon^>^ toPolygons();
 
 Image^ toImage();
 
 property int width
 {
 int get() {
 
 return m_Instance->width;
 }
 }
 property int height
 {
 int get() {
 return m_Instance->height;
 }
 }
 internal:
 
 };
 }
}