Classes
struct	point
	Point in percentage-based image coordinates. More...
struct	line
	Polyline / polygon described in percentage coordinates. More...
class	stream
	Represents a single video stream and its analytic connections. More...
struct	event
	Generic event produced by the backend. More...
struct	frame
	Video frame container. More...
class	cli_client
	Simple interactive CLI (REPL) for controlling a stream_manager. More...
class	stream_manager
	Central coordinator for streams, geometry, frame processing and events. More...

Typedefs
using	line_ptr = std::shared_ptr<line const>
	Shared, immutable line pointer.

Enumerations
enum class	tripwire_dir { any , neg_to_pos , pos_to_neg }
	Allowed crossing direction for a tripwire. More...
enum	stream_type { local , file , rtsp , http }
	Source/transport type of a video stream. More...
enum class	stream_pipeline { manual , automatic , none }
	Processing pipeline mode for a stream. More...
enum class	event_kind { motion , tripwire , roi , info }
	High-level classification of backend events. More...
enum class	pixel_format { gray8 , rgb24 , bgr24 , rgba32 , bgra32 }
	Pixel format of a frame buffer. More...

Functions
line_ptr	make_line (std::vector< point > points, std::string name, bool closed=false)
	Create and normalize a line.
std::vector< point >	parse_points (const std::string &points_str)
	Parse points from a textual representation.
std::string	normalize_str (std::string_view str)
	Remove whitespace and parentheses from a string.
float	parse_float (std::string_view num_str)
	Parse a float from a string view.

Typedef Documentation

◆ line_ptr

using yodau::backend::line_ptr = std::shared_ptr<line const>

Shared, immutable line pointer.

Definition at line 146 of file geometry.hpp.

Enumeration Type Documentation

◆ event_kind

enum class yodau::backend::event_kind

strong

High-level classification of backend events.

Events are produced by analytics / processing modules and can represent detections (e.g., motion), logical triggers (tripwire/ROI), or informational messages.

Enumerator
motion	Motion was detected in the stream.
tripwire	A tripwire (line crossing) condition was triggered.
roi	A region-of-interest related event was triggered.
info	Informational / diagnostic event that doesn't fit other categories.

Definition at line 19 of file event.hpp.

                      {
    motion,
    tripwire,
    roi,
    info
};

◆ pixel_format

enum class yodau::backend::pixel_format

strong

Pixel format of a frame buffer.

The enumerators describe the byte layout of pixels in frame::data. All formats are tightly packed without per-pixel padding.

Enumerator
gray8	8-bit grayscale, 1 byte per pixel.
rgb24	RGB, 8-bit per channel, 3 bytes per pixel.
bgr24	BGR, 8-bit per channel, 3 bytes per pixel.
rgba32	RGBA, 8-bit per channel, 4 bytes per pixel.
bgra32	BGRA, 8-bit per channel, 4 bytes per pixel.

Definition at line 16 of file frame.hpp.

                        {
    gray8,
    rgb24,
    bgr24,
    rgba32,
    bgra32
};

◆ stream_pipeline

enum class yodau::backend::stream_pipeline

strong

Processing pipeline mode for a stream.

A stream can be inactive (none), or active in either a user-managed (manual) or auto-managed (automatic) pipeline.

Enumerator
manual	Stream is active with manual/user-controlled processing.
automatic	Stream is active with automatic backend-controlled processing.
none	Stream is not active in any pipeline.

Definition at line 40 of file stream.hpp.

                           {
    manual,
    automatic,
    none
};

◆ stream_type

enum yodau::backend::stream_type

Source/transport type of a video stream.

This is a lightweight classification inferred from the stream path/URL or specified explicitly by the user.

See also: stream::identify; stream::type_name

Enumerator
local	Local capture device (e.g., /dev/video*).
file	File-based stream (path to a video file).
rtsp	RTSP network stream.
http	HTTP/HTTPS network stream.

Definition at line 23 of file stream.hpp.

                 {
    local,
    file,
    rtsp,
    http
};

◆ tripwire_dir

enum class yodau::backend::tripwire_dir

strong

Allowed crossing direction for a tripwire.

Enumerator
any	Direction is not constrained; any crossing counts.
neg_to_pos	Crossing from negative side to positive side counts.
pos_to_neg	Crossing from positive side to negative side counts.

Definition at line 62 of file geometry.hpp.

                        {
    any,
    neg_to_pos,
    pos_to_neg
};

Function Documentation

◆ make_line()

yodau::backend::line_ptr yodau::backend::make_line	(	std::vector< point >	points,
		std::string	name,
		bool	closed = false )

Create and normalize a line.

Allocates a new line, moves in points and name, sets closed, and calls line::normalize().

Parameters

points	Vertex list to move into the line.
name	Logical name to move into the line.
closed	Whether the line should be treated as closed.

Returns: A shared pointer to an immutable line instance.

Definition at line 82 of file geometry.cpp.

  {
    auto line_ptr = std::make_shared<line>();
    line_ptr->points = std::move(points);
    line_ptr->name = std::move(name);
    line_ptr->closed = closed;
    line_ptr->normalize();
    return line_ptr;
}

◆ normalize_str()

std::string yodau::backend::normalize_str ( std::string_view str )

Remove whitespace and parentheses from a string.

Used internally to simplify parsing of point lists.

Parameters

str	Input string view.

Returns: Normalized string with spaces and '(' / ')' removed.

Definition at line 133 of file geometry.cpp.

                                                              {
    std::string normalized;
    normalized.reserve(str.size());
    for (const char ch : str) {
        if (std::isspace(ch) || ch == '(' || ch == ')') {
            continue;
        }
        normalized.push_back(ch);
    }
    return normalized;
}

◆ parse_float()

float yodau::backend::parse_float ( std::string_view num_str )

Parse a float from a string view.

Uses std::from_chars for locale-independent parsing.

Parameters

num_str Number representation.

Returns: Parsed float value.

Exceptions

std::runtime_error if the input is not a valid float.

Definition at line 145 of file geometry.cpp.

                                                            {
    float value {};
    const char* first = num_str.data();
    const char* last = num_str.data() + num_str.size();
    auto [ptr, ec] = std::from_chars(first, last, value);
    if (ec != std::errc() || ptr != last) {
        throw std::runtime_error(
            "Invalid float value: " + std::string(num_str)
        );
    }
    return value;
}

◆ parse_points()

std::vector< yodau::backend::point > yodau::backend::parse_points ( const std::string & points_str )

Parse points from a textual representation.

Input format:

Points are separated by semicolons ';'
Each point is "x,y"
Whitespace and parentheses are ignored.

Examples:

"(10, 20); (30,40)"
"10,20;30,40; 50, 60"

Parameters

points_str Input string containing points.

Returns: Parsed list of points.

Exceptions

std::runtime_error if parsing fails or no valid points are found.

Definition at line 94 of file geometry.cpp.

                                                      {
    std::string normalized = normalize_str(points_str);
    std::string_view input { normalized };
    std::vector<point> points;
    size_t start = 0;
    while (start < input.size()) {
        size_t end = input.find(';', start);
        if (end == std::string_view::npos) {
            end = input.size();
        }
        std::string_view segment { input.substr(start, end - start) };
        if (!segment.empty()) {
            const size_t comma_pos = segment.find(',');
            if (comma_pos == std::string_view::npos) {
                throw std::runtime_error(
                    "Missing comma separator: " + std::string(segment)
                );
            }
            std::string_view x_str = segment.substr(0, comma_pos);
            std::string_view y_str = segment.substr(comma_pos + 1);
            if (x_str.empty() || y_str.empty()) {
                throw std::runtime_error(
                    "Empty coordinate in point: " + std::string(segment)
                );
            }
            float x = parse_float(x_str);
            float y = parse_float(y_str);
            points.emplace_back(x, y);
        }
        start = end + 1;
    }
    if (points.empty()) {
        throw std::runtime_error(
            "No valid points found in input: " + points_str
        );
    }
    return points;
}

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ line_ptr

Enumeration Type Documentation

◆ event_kind

◆ pixel_format

◆ stream_pipeline

◆ stream_type

◆ tripwire_dir

Function Documentation

◆ make_line()

◆ normalize_str()

◆ parse_float()

◆ parse_points()