common.h

#pragma once
#include "API_EXPORT.h"
#include <iostream>
#include <vector>
 
namespace DaoAI
{
    namespace DeepLearning
    {
        enum class Device_Type
        {
            CPU, GPU
        };
 
        class  Point
        {
        public:
            DAOAI_API Point(const float& x, const float& y);
            DAOAI_API Point();
            DAOAI_API ~Point();
 
            // overload operator<< to print out polygon object
            friend DAOAI_API std::ostream& operator<<(std::ostream& ss, const Point& point);
 
            DAOAI_API Point operator+(const Point& point) const;
            DAOAI_API Point operator-(const Point& point) const;
 
            float x = 0, y = 0;
        };
 
        class Polygon
        {
        public:
            DAOAI_API Polygon(const std::vector<Point>& points);
            DAOAI_API Polygon();
            DAOAI_API ~Polygon();
 
            // overload operator<< to print out polygon object
            friend DAOAI_API std::ostream& operator<<(std::ostream& ss, const Polygon& polygon);
 
            // overload operator<< to print out polygon object
            friend DAOAI_API std::stringstream& operator<<(std::stringstream& ss, const Polygon& polygon);
 
            std::vector<Point> points;
        };
 
        class Box
        {
        public:
 
            enum class Type
            {
                XYXY, XYWH
            };
 
            DAOAI_API Box(const Point& p1, const Point& p2, const float& angle = 0);
 
            DAOAI_API Box(const float& a1, const float& a2, const float& a3, const float& a4, const float& angle = 0, const Type& type = Type::XYXY);
 
            DAOAI_API ~Box();
 
            DAOAI_API Polygon toPolygon() const;
 
            DAOAI_API std::string toString() const;
 
            // overload operator<< to print out polygon object
            friend DAOAI_API std::ostream& operator<<(std::ostream& ss, const Box& box);
 
            // overload operator<< to print out polygon object
            friend DAOAI_API std::stringstream& operator<<(std::stringstream& ss, const Box& box);
 
            DAOAI_API const float& h() const;
 
            DAOAI_API const float& w() const;
 
            DAOAI_API const float& x1() const;
 
            DAOAI_API const float& y1() const;
 
            DAOAI_API const float& x2() const;
 
            DAOAI_API const float& y2() const;
 
            DAOAI_API const float& angle() const;
 
            DAOAI_API Box toType(const Type& type) const;
 
            std::vector<float> data;
            Type type;
        };
 
        class Image
        {
        public:
            enum class Type
            {
                RGB, BGR, GRAYSCALE
            };
 
            // create an image object from headers with a new deep copy of data buffer
            DAOAI_API Image(const int& image_height, const int& image_width, const Image::Type& type, void* data);
 
            DAOAI_API ~Image();
 
            // create a deep copy of the Image object
            DAOAI_API Image clone() const;
 
            std::shared_ptr<uint8_t[]> data;
            int width, height;
            Type type;
        };
 
        namespace Utils
        {
            DAOAI_API std::vector<Polygon> convertMaskToPolygons(const Image& mask);
 
            DAOAI_API Image convertPolygonsToMask(const std::vector<Polygon>& polygons, const int& image_height, const int& image_width);
        }
    }
}