yodau::backend::line Struct Reference

Polyline / polygon described in percentage coordinates. More...

#include <backend/include/geometry.hpp>

Public Member Functions
void	dump (std::ostream &out) const
	Print a human-readable representation of the line.
void	normalize ()
	Canonicalize point order.
bool	operator== (const line &other) const
	Equality check using canonical point comparison.

Public Attributes
std::string	name
	Logical name of the line (e.g., "entrance_tripwire").
std::vector< point >	points
	Vertex list in percentage coordinates.
bool	closed { false }
	Whether the chain is closed.
tripwire_dir	dir { tripwire_dir::any }
	Optional tripwire direction constraint.

Detailed Description

Polyline / polygon described in percentage coordinates.

A line can represent:

• an open polyline (when closed == false),
• or a closed polygon-like chain (when closed == true).

The points may be reordered by normalize() to provide a canonical representation for equality checks and stable processing.

Definition at line 81 of file geometry.hpp.

Member Function Documentation

dump()

void yodau::backend::line::dump

(

std::ostream &

out

)

const

Print a human-readable representation of the line.

Parameters

out	Output stream to write to.

Definition at line 17 of file geometry.cpp.

                                                 {
    out << "Line(name=" << name << ", closed=" << (closed ? "true" : "false")
        << ", points=[";
    for (size_t i = 0; i < points.size(); i++) {
        out << "(" << points[i].x << ", " << points[i].y << ")";
        if (i < points.size() - 1) {
            out << "; ";
        }
    }
    out << "])";
}

normalize()

void yodau::backend::line::normalize

(

)

Canonicalize point order.

Behavior (as per implementation):

• If closed is true, rotates points so the vertex closest to (0,0) becomes the first element.
• Then ensures a consistent direction by comparing distances of first/last vertices to a reference point and reversing if needed.

Note

This operation may reorder points but does not change their values.

Definition at line 29 of file geometry.cpp.

                                 {
    const size_t n = points.size();
    if (n < 2) {
        return;
    }
    constexpr point origin { 0.0f, 0.0f };
    constexpr point east { 100.0f, 0.0f };
 
    if (closed) {
        size_t best_idx = 0;
        float best_distance = points[0].distance_to(origin);
 
        for (size_t i = 1; i < n; i++) {
            float distance = points[i].distance_to(origin);
            if (distance < best_distance) {
                best_distance = distance;
                best_idx = i;
            }
        }
 
        if (best_idx != 0) {
            const auto it
                = points.begin() + static_cast<std::ptrdiff_t>(best_idx);
            std::ranges::rotate(points, it);
        }
    }
 
    const size_t front = closed ? 1 : 0;
 
    if (n >= 2 + front) {
        const float first = points[front].distance_to(closed ? east : origin);
        const float last = points.back().distance_to(closed ? east : origin);
        if (last < first) {
            std::reverse(
                points.begin() + static_cast<std::ptrdiff_t>(front),
                points.end()
            );
        }
    }
}

References closed.

operator==()

bool yodau::backend::line::operator==

(

const line &

other

)

const

Equality check using canonical point comparison.

Two lines are equal if:

• their closed flags match,
• they have the same number of points,
• and all points compare equal via point::compare.

Note

The name and dir fields are intentionally NOT compared.

Parameters

other

Line to compare with.

Returns

true if geometrically equal within tolerance.

Definition at line 70 of file geometry.cpp.

                                                         {
    if (closed != other.closed || points.size() != other.points.size()) {
        return false;
    }
    for (size_t i = 0; i < points.size(); i++) {
        if (!points[i].compare(other.points[i])) {
            return false;
        }
    }
    return true;
}

Member Data Documentation

closed

bool yodau::backend::line::closed { false }

Whether the chain is closed.

If true, the first point is considered connected to the last point.

Definition at line 97 of file geometry.hpp.

{ false };

Referenced by normalize().

dir

tripwire_dir yodau::backend::line::dir { tripwire_dir::any }

Optional tripwire direction constraint.

Used by line-crossing logic. Defaults to tripwire_dir::any.

Definition at line 104 of file geometry.hpp.

{ tripwire_dir::any };

name

std::string yodau::backend::line::name

Logical name of the line (e.g., "entrance_tripwire").

Definition at line 85 of file geometry.hpp.

points

std::vector<point> yodau::backend::line::points

Vertex list in percentage coordinates.

Definition at line 90 of file geometry.hpp.

---

The documentation for this struct was generated from the following files:

• geometry.hpp
• geometry.cpp