common.h

Go to the documentation of this file.

// Copyright (c) 2024, DaoAI Robotics. All rights reserved.
// Version: 2025.3.0
 
#pragma once
#include "API_EXPORT.h"
#include <iostream>
#include <vector>
#include "config.h"
#include <memory>
#include <variant>
#include <cmath>
#include <map>
namespace DaoAI
{
 namespace DeepLearning
 {
 enum class DeviceType
 {
 CPU, GPU
 };
 
 namespace Vision
 {
 enum class DetectionLevel
 {
 PIXEL_FAST, PIXEL_ACCURATE, IMAGE
 };
 };
 
 class Point
 {
 public:
 DAOAI_API Point(const float& x, const float& y, const float& confidence = 0, const std::string& label = "");
 DAOAI_API Point(const float& x, const float& y, const std::string& label);
 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, confidence = 0;
 std::string label = "";
 };
 
 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();
 
 DAOAI_API Box(const Point& p1, const Point& p2, const float& angle = NAN);
 
 DAOAI_API Box(const float& a1, const float& a2, const float& a3, const float& a4, const float& angle = NAN, const Type& type = Type::XYXY);
 
 DAOAI_API ~Box();
 
#ifndef BUILD_INFERNCE_CLIENT
 DAOAI_API Polygon toPolygon() const;
#endif // !BUILD_INFERNCE_CLIENT
 
 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 float h() const;
 
 DAOAI_API float w() const;
 
 DAOAI_API float x1() const;
 
 DAOAI_API float y1() const;
 
 DAOAI_API float x2() const;
 
 DAOAI_API float y2() const;
 
 DAOAI_API float angle() const;
 
 DAOAI_API float area() const;
 
#ifndef BUILD_INFERENCE_CLIENT
 DAOAI_API float iou(const Box& box) const;
 
 DAOAI_API Box intersect(const Box& box) const;
 
 DAOAI_API Box merge(const Box& box) const;
 
 
 DAOAI_API bool contains(const Box& box) const;
 
#endif // !BUILD_INFERENCE_CLIENT
 
 DAOAI_API Box toType(const Type& type) const;
 
 std::vector<float> data;
 Type type;
 };
 
#ifndef BUILD_INFERENCE_CLIENT
 class Image
 {
 public:
 enum class Type
 {
 RGB, BGR, GRAYSCALE
 };
 
 DAOAI_API Image();
 
 DAOAI_API Image(const int& image_height, const int& image_width, const Image::Type& type, void* data);
 
 DAOAI_API Image(const int& image_height, const int& image_width, const Image::Type& type, std::shared_ptr<uint8_t[]> data_ptr);
 
 
 DAOAI_API Image(const std::string& file_path);
 
 DAOAI_API virtual ~Image();
 
 DAOAI_API Image toType(const Image::Type& type) const;
 
 DAOAI_API void save(const std::string& file_path) const;
 
 DAOAI_API Image clone() const;
 
 DAOAI_API uint8_t* getData() const;
 
 DAOAI_API bool empty() const;
 
 int width, height;
 Type type;
 private:
 uint8_t *data;
 std::shared_ptr<uint8_t[]> data_ptr;
 
 };
 
 class Mask
 {
 public:
 DAOAI_API Mask();
 
 DAOAI_API Mask(const Image& image);
 
 Mask(const Image& image, const Box& location, const int& image_height, const int& image_width);
 
 DAOAI_API ~Mask();
 
 DAOAI_API Mask merge(const Mask& mask) const;
 
 DAOAI_API std::vector<Polygon> toPolygons() const;
 
 DAOAI_API long long area() const;
 
 DAOAI_API Image toImage() const;
 
 DAOAI_API bool empty() const;
 
 Mask getMergedMask() const;
 
 std::vector<Image>& getImageData();
 
 std::vector<Box>& getLocations();
 
 int width, height;
 private:
 std::vector<Image> image_data;
 std::vector<Box> locations;
 };
#else
 class Mask
 {
 public:
 Mask();
 Mask(const std::string& base64_image_data);
 Mask(const std::vector<Polygon> polygon_data);
 
 // either polygon_data or base64_image_data should be non-null
 std::unique_ptr<std::vector<Polygon>> polygon_data;
 std::unique_ptr<std::string> base64_image_data;
 };
#endif // !BUILD_INFERENCE_CLIENT
 } 
}