TensorPool, Image & PointCloud API

#include <horus/pool.hpp>

horus::TensorPool pool(
    uint32_t pool_id,         // unique pool identifier
    size_t   pool_size_bytes, // total SHM region size
    size_t   max_slots        // maximum concurrent allocations
);

// 16 MB pool with up to 64 concurrent allocations
auto pool = horus::TensorPool(1, 16 * 1024 * 1024, 64);

TensorPool::Stats stats() const;

auto s = pool.stats();
horus::log::info("pool", ("used: " + std::to_string(s.used_bytes) +
    " free: " + std::to_string(s.free_bytes)).c_str());

auto pool2 = std::move(pool);  // OK -- transfers ownership
if (!pool2) {
    horus::log::error("init", "Failed to create tensor pool");
}

horus::Tensor tensor(
    const TensorPool& pool,     // pool to allocate from
    const uint64_t*   shape,    // dimension sizes array
    size_t            ndim,     // number of dimensions
    Dtype             dtype     // element data type
);

enum class Dtype : uint8_t {
    F32,   // 32-bit float
    F64,   // 64-bit float
    U8,    // unsigned 8-bit integer
    I32,   // signed 32-bit integer
};

horus::Image img(
    const TensorPool& pool,
    uint32_t          width,
    uint32_t          height,
    Encoding          enc = Encoding::Rgb8  // optional, defaults to RGB8
);

enum class Encoding : uint8_t {
    Rgb8,    // 3 bytes per pixel: red, green, blue
    Rgba8,   // 4 bytes per pixel: red, green, blue, alpha
    Gray8,   // 1 byte per pixel: grayscale
    Bgr8,    // 3 bytes per pixel: blue, green, red (OpenCV default)
};

horus::PointCloud pc(
    const TensorPool& pool,
    uint32_t          num_points,
    uint32_t          fields_per_point
);

#include <horus/node.hpp>
#include <horus/pool.hpp>

auto pool = horus::TensorPool(1, 32 * 1024 * 1024, 32);
auto cam_topic = horus::Topic<horus::Image>("camera.rgb");

// Inside tick():
auto frame = horus::Image(pool, 1280, 720, horus::Encoding::Rgb8);
if (frame) {
    // Fill frame data from hardware driver...
    // data_size() = 1280 * 720 * 3 = 2,764,800 bytes
    cam_topic.send(std::move(frame));
    // Subscriber receives a pointer into the same SHM -- zero copies
}

#include <horus/pool.hpp>

auto pool = horus::TensorPool(2, 64 * 1024 * 1024, 16);

// Allocate a [1, 3, 224, 224] input tensor for a vision model
uint64_t shape[] = {1, 3, 224, 224};
auto input = horus::Tensor(pool, shape, 4, horus::Dtype::F32);

if (input) {
    float* data = reinterpret_cast<float*>(input.data());
    // Fill with preprocessed image data...
    // nbytes() = 1 * 3 * 224 * 224 * 4 = 602,112 bytes
}