#include <bounding_box.hpp>

Public Member Functions
bool	overlaps (const BoundingBox &other, float iou_threshold) const

float	intersection_area (const BoundingBox &other) const

std::vector< BoundingBoxVertex >	rectangle_vertices () const

Public Attributes
std::array< float, 2 >	center
	XY center in metres.

float	z = 0.0f
	Z center in metres.

float	length = 0.0f
	Length along the local X axis.

float	width = 0.0f
	Width along the local Y axis.

float	height = 0.0f
	Height along the Z axis.

float	yaw = 0.0f
	Heading in radians.

float	existence_probability = 0.0f
	Detection confidence.

std::vector< ClassificationEntry >	classification
	Ranked semantic predictions.

bool	has_velocity = false
	Whether velocity components are valid.

float	v_x = 0.0f
	X velocity when has_velocity is true.

float	v_y = 0.0f
	Y velocity when has_velocity is true.

Detailed Description

Oriented three-dimensional detection box and its semantic attributes.

Definition at line 63 of file bounding_box.hpp.

Member Function Documentation

◆ intersection_area()

float pcod_common::BoundingBox::intersection_area ( const BoundingBox & other ) const

Parameters

other Box to compare.

Returns: XY intersection area.

Definition at line 11 of file bounding_box.cpp.

                                                                   {
  auto rect1 = rectangle_vertices();
  auto rect2 = other.rectangle_vertices();
 
  std::vector<BoundingBoxVertex> intersection = rect1;
 
  for (std::size_t i = 0; i < rect2.size(); ++i) {
    if (intersection.size() <= 2) {
      break;
    }
 
    Line line(rect2[i], rect2[(i + 1) % rect2.size()]);
    std::vector<BoundingBoxVertex> new_intersection;
    std::vector<float> line_values;
 
    for (const auto& t : intersection) {
      line_values.push_back(line(t));
    }
 
    for (std::size_t j = 0; j < intersection.size(); ++j) {
      const BoundingBoxVertex& s = intersection[j];
      const BoundingBoxVertex& t = intersection[(j + 1) % intersection.size()];
      float s_value = line_values[j];
      float t_value = line_values[(j + 1) % line_values.size()];
 
      if (s_value <= 0) {
        new_intersection.push_back(s);
      }
 
      if (s_value * t_value < 0) {
        BoundingBoxVertex intersection_point = line.intersection(Line(s, t));
        new_intersection.push_back(intersection_point);
      }
    }
 
    intersection = new_intersection;
  }
 
  if (intersection.size() <= 2) {
    return 0.0F;
  }
 
  float area = 0.0F;
  for (std::size_t i = 0; i < intersection.size(); ++i) {
    const BoundingBoxVertex& p = intersection[i];
    const BoundingBoxVertex& q = intersection[(i + 1) % intersection.size()];
    area += p.cross(q);
  }
 
  return 0.5F * std::abs(area);
}

References pcod_common::BoundingBoxVertex::cross(), pcod_common::Line::intersection(), and rectangle_vertices().

Referenced by main(), and overlaps().

◆ overlaps()

bool pcod_common::BoundingBox::overlaps	(	const BoundingBox &	other,
		float	iou_threshold ) const

Parameters

other	Box to compare.
iou_threshold	Required IoU.

Returns: Whether the boxes overlap sufficiently.

Definition at line 63 of file bounding_box.cpp.

                                                                              {
  float intersection = intersection_area(other);
  float union_area = length * width + other.length * other.width - intersection;
  float iou = intersection / union_area;
  return iou > iou_threshold;
}

References intersection_area(), length, and width.

Referenced by main().

◆ rectangle_vertices()

std::vector< BoundingBoxVertex > pcod_common::BoundingBox::rectangle_vertices ( ) const

Return the four XY vertices in rectangle order.

Definition at line 70 of file bounding_box.cpp.

                                                                   {
  float angle = yaw;
  float dx = length / 2.0F;
  float dy = width / 2.0F;
  float dxcos = dx * std::cos(angle);
  float dxsin = dx * std::sin(angle);
  float dycos = dy * std::cos(angle);
  float dysin = dy * std::sin(angle);
 
  std::vector<BoundingBoxVertex> vertices;
  vertices.emplace_back(center[0] + (-dxcos - -dysin), center[1] + (-dxsin + -dycos));
  vertices.emplace_back(center[0] + (dxcos - -dysin), center[1] + (dxsin + -dycos));
  vertices.emplace_back(center[0] + (dxcos - dysin), center[1] + (dxsin + dycos));
  vertices.emplace_back(center[0] + (-dxcos - dysin), center[1] + (-dxsin + dycos));
  return vertices;
}

References center, length, width, and yaw.

Referenced by intersection_area().

Member Data Documentation

◆ center

std::array<float, 2> pcod_common::BoundingBox::center

XY center in metres.

Definition at line 64 of file bounding_box.hpp.

Referenced by pcod_common::DecodePbod(), main(), and rectangle_vertices().

◆ classification

std::vector<ClassificationEntry> pcod_common::BoundingBox::classification

Ranked semantic predictions.

Definition at line 71 of file bounding_box.hpp.

Referenced by pcod_common::DecodePbod(), and main().

◆ existence_probability

float pcod_common::BoundingBox::existence_probability = 0.0f

Detection confidence.

Definition at line 70 of file bounding_box.hpp.

Referenced by pcod_common::DecodePbod(), and main().

◆ has_velocity

bool pcod_common::BoundingBox::has_velocity = false

Whether velocity components are valid.

Definition at line 72 of file bounding_box.hpp.

◆ height

float pcod_common::BoundingBox::height = 0.0f

Height along the Z axis.

Definition at line 68 of file bounding_box.hpp.

Referenced by pcod_common::DecodePbod().

◆ length

float pcod_common::BoundingBox::length = 0.0f

Length along the local X axis.

Definition at line 66 of file bounding_box.hpp.

Referenced by pcod_common::DecodePbod(), main(), overlaps(), and rectangle_vertices().

◆ v_x

float pcod_common::BoundingBox::v_x = 0.0f

X velocity when has_velocity is true.

Definition at line 73 of file bounding_box.hpp.

◆ v_y

float pcod_common::BoundingBox::v_y = 0.0f

Y velocity when has_velocity is true.

Definition at line 74 of file bounding_box.hpp.

◆ width

float pcod_common::BoundingBox::width = 0.0f

Width along the local Y axis.

Definition at line 67 of file bounding_box.hpp.

Referenced by pcod_common::DecodePbod(), main(), overlaps(), and rectangle_vertices().

◆ yaw

float pcod_common::BoundingBox::yaw = 0.0f

Heading in radians.

Definition at line 69 of file bounding_box.hpp.

Referenced by pcod_common::DecodePbod(), and rectangle_vertices().

◆ z

float pcod_common::BoundingBox::z = 0.0f

Z center in metres.

Definition at line 65 of file bounding_box.hpp.