object.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2025 Povl Filip Sonne-Frederiksen
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
#include <opencv2/opencv.hpp>
 
#include <optional>
#include <ostream>
#include <string>
#include <tuple>
#include <vector>
 
namespace reusex::vision::common::object {

enum class ObjectType {
  unknown = -1,       
  position = 0,       
  pose = 1,           
  obb = 2,            
  segmentation = 3,   
  depth_anything = 4, 
  depth_pro = 5,      
  track = 6,          
  detection = 7,      
};

struct Box {
  float left = 0.0f;   
  float top = 0.0f;    
  float right = 0.0f;  
  float bottom = 0.0f; 
 
  Box() = default;

  Box(float l, float t, float r, float b);

  float width() const noexcept { return right - left; }

  float height() const noexcept { return bottom - top; }

  float center_x() const noexcept { return (left + right) / 2; }

  float center_y() const noexcept { return (top + bottom) / 2; }

  float area() const noexcept { return width() * height(); }
 
  friend std::ostream &operator<<(std::ostream &os, const Box &box);
};

struct PosePoint {
  float x = 0.0f;   
  float y = 0.0f;   
  float vis = 0.0f; 
 
  PosePoint() = default;

  PosePoint(float x, float y, float vis);
 
  PosePoint &operator=(const PosePoint &other);
  friend std::ostream &operator<<(std::ostream &os, const PosePoint &point);
};

struct Pose {
  std::vector<PosePoint> points; 
 
  Pose &operator=(const Pose &other);
  friend std::ostream &operator<<(std::ostream &os, const Pose &pose);
};

struct Obb {
  float cx = 0.0f;    
  float cy = 0.0f;    
  float w = 0.0f;     
  float h = 0.0f;     
  float angle = 0.0f; 
 
  Obb() = default;

  Obb(float cx, float cy, float w, float h, float angle);
 
  Obb &operator=(const Obb &other);

  float area() const { return w * h; }
 
  friend std::ostream &operator<<(std::ostream &os, const Obb &obb);
};

struct SegmentMap {
  int width = 0;  
  int height = 0; 
  unsigned char *data = nullptr; 

  SegmentMap(int width, int height);
 
  virtual ~SegmentMap();

  SegmentMap(const SegmentMap &) = delete;
  SegmentMap &operator=(const SegmentMap &) = delete;

  SegmentMap(SegmentMap &&other) noexcept
      : width(std::exchange(other.width, 0)),
        height(std::exchange(other.height, 0)),
        data(std::exchange(other.data, nullptr)) {}

  SegmentMap &operator=(SegmentMap &&other) noexcept;
};

struct Segmentation {
  cv::Mat mask; 

  void keep_largest_part();

  Segmentation align_to_left_top(int left, int top, int width,
                                 int height) const;
 
  Segmentation &operator=(const Segmentation &other);
};

struct Depth {
  cv::Mat depth;         
  float fog_data = 0.0f; 

  float point_depth(int x, int y) const;

  float average_depth() const;

  float min_depth() const;

  float max_depth() const;

  float area_average_depth(const cv::Mat &seg) const;

  float area_average_depth(const Box &box) const;
};

struct Track {
  int track_id = -1; 

  std::optional<std::vector<Pose>> history_pose;

  std::vector<std::tuple<float, float>> track_trace;
 
  friend std::ostream &operator<<(std::ostream &os, const Track &track);
};

struct DetectionBox {
  ObjectType type = ObjectType::unknown; 
  Box box;                               
  float score = 0.0f;                    
  int class_id = -1;                     
  std::string class_name;                
 
  std::optional<Pose> pose; 
  std::optional<Obb> obb;   
  std::optional<Segmentation>
      segmentation;           
  std::optional<Depth> depth; 
  std::optional<Track> track; 
 
  friend std::ostream &operator<<(std::ostream &os, const DetectionBox &box);
};

cv::Mat segment_map_to_mat(const std::shared_ptr<SegmentMap> &map);

using DetectionBoxArray = std::vector<DetectionBox>;
 
} // namespace reusex::vision::common::object