Image

use horus::prelude::*;

// Create a 640x480 RGB image
let mut img = Image::new(640, 480, ImageEncoding::Rgb8)?;

// Fill with red
img.fill(&[255, 0, 0]);

// Set metadata (chainable)
img.set_frame_id("camera_front")
   .set_timestamp_ns(1_700_000_000_000_000_000);

// Publish on a topic — zero-copy, only the descriptor is sent
let topic: Topic<Image> = Topic::new("camera.rgb")?;
topic.send(&img);

// Receiver side
let topic: Topic<Image> = Topic::new("camera.rgb")?;

if let Some(img) = topic.recv() {
    println!("{}x{} {:?}", img.width(), img.height(), img.encoding());
    println!("Frame: {}, Timestamp: {}ns", img.frame_id(), img.timestamp_ns());

    // Direct pixel access — zero-copy
    if let Some(px) = img.pixel(0, 0) {
        println!("Top-left pixel: R={} G={} B={}", px[0], px[1], px[2]);
    }
}

use horus::prelude::*;

let mut img = Image::new(640, 480, ImageEncoding::Rgb8)?;

// Read a pixel — returns None if out of bounds
if let Some(pixel) = img.pixel(100, 200) {
    println!("R={} G={} B={}", pixel[0], pixel[1], pixel[2]);
}

// Write a pixel — no-op if out of bounds, chainable
img.set_pixel(100, 200, &[255, 128, 0])
   .set_pixel(101, 200, &[255, 128, 0]);

// Fill entire image with a single color
img.fill(&[0, 0, 0]); // Black

// Extract a region of interest (returns raw bytes)
if let Some(roi_data) = img.roi(10, 10, 100, 100) {
    println!("ROI: {} bytes", roi_data.len());
}

use horus::prelude::*;

let mut img = Image::new(640, 480, ImageEncoding::Rgb8)?;

// Zero-copy read access to the underlying buffer
let data: &[u8] = img.data();
println!("Total bytes: {}", data.len()); // 640 * 480 * 3

// Mutable access for bulk operations
let data_mut: &mut [u8] = img.data_mut();
data_mut[0] = 255; // Set first byte directly

// Copy from an external buffer
let pixels: Vec<u8> = vec![128; 640 * 480 * 3];
img.copy_from(&pixels);

use horus::prelude::*;

struct CameraNode {
    raw_sub: Topic<Image>,
    processed_pub: Topic<Image>,
}

impl Node for CameraNode {
    fn name(&self) -> &str { "CameraProcessor" }

    fn tick(&mut self) {
        if let Some(raw) = self.raw_sub.recv() {
            // Create output image with same dimensions
            let mut out = Image::new(
                raw.width(), raw.height(), ImageEncoding::Mono8
            ).unwrap();

            // Convert RGB to grayscale (simple luminance)
            let src = raw.data();
            let dst = out.data_mut();
            for i in 0..((raw.width() * raw.height()) as usize) {
                let r = src[i * 3] as f32;
                let g = src[i * 3 + 1] as f32;
                let b = src[i * 3 + 2] as f32;
                dst[i] = (0.299 * r + 0.587 * g + 0.114 * b) as u8;
            }

            out.set_frame_id(raw.frame_id())
               .set_timestamp_ns(raw.timestamp_ns());

            self.processed_pub.send(&out);
        }
    }
}

use horus::prelude::*;

// Create a 16-bit depth image (values in millimeters)
let mut depth = Image::new(640, 480, ImageEncoding::Depth16)?;

// Each pixel is 2 bytes (u16 little-endian)
let data = depth.data_mut();
let distance_mm: u16 = 1500; // 1.5 meters
data[0] = (distance_mm & 0xFF) as u8;
data[1] = (distance_mm >> 8) as u8;

println!("Depth image: {}x{}, {} bytes/pixel, step={}",
    depth.width(), depth.height(),
    depth.encoding().bytes_per_pixel(),
    depth.step());

pub fn new(width: u32, height: u32, encoding: ImageEncoding) -> Result<Image>

let img = Image::new(640, 480, ImageEncoding::Rgb8)?;
assert_eq!(img.width(), 640);
assert_eq!(img.height(), 480);
assert_eq!(img.channels(), 3);

pub fn pixel(&self, x: u32, y: u32) -> Option<&[u8]>

if let Some(rgb) = img.pixel(100, 200) {
    println!("R={} G={} B={}", rgb[0], rgb[1], rgb[2]);
}

pub fn set_pixel(&mut self, x: u32, y: u32, value: &[u8]) -> &mut Self

img.set_pixel(100, 200, &[255, 0, 0])   // red
   .set_pixel(101, 200, &[0, 255, 0]);  // green (chained)

pub fn fill(&mut self, value: &[u8]) -> &mut Self

img.fill(&[0, 0, 0]);  // black

pub fn roi(&self, x: u32, y: u32, w: u32, h: u32) -> Option<Vec<u8>>

// Extract 100x100 region from top-left corner
if let Some(region) = img.roi(0, 0, 100, 100) {
    println!("Region: {} bytes", region.len());
}

// Zero-copy access to pixel buffer
let bytes: &[u8] = img.data();
println!("{} bytes total", bytes.len());

// Copy from an external source (e.g., camera capture)
let camera_data: Vec<u8> = capture_frame();
img.copy_from(&camera_data);

import horus

# Create an empty image (height, width, encoding)
img = horus.Image(480, 640, encoding="rgb8")

# From a NumPy array — encoding auto-detected from shape
import numpy as np
arr = np.zeros((480, 640, 3), dtype=np.uint8)
img = horus.Image.from_numpy(arr, encoding="rgb8")

# From a PyTorch tensor
import torch
t = torch.zeros(480, 640, 3, dtype=torch.uint8)
img = horus.Image.from_torch(t, encoding="rgb8")

# From raw bytes
data = bytes(480 * 640 * 3)
img = horus.Image.from_bytes(data, height=480, width=640, encoding="rgb8")

# To NumPy — zero-copy view
arr = img.to_numpy()  # shape: (480, 640, 3), dtype: uint8

# To PyTorch — zero-copy via DLPack
tensor = img.to_torch()

# To JAX — zero-copy via DLPack
jax_arr = img.to_jax()

# Read pixel at (x, y)
r, g, b = img.pixel(100, 200)

# Write pixel
img.set_pixel(100, 200, [255, 0, 0])

# Fill entire image
img.fill([128, 128, 128])

# Extract region of interest
roi_bytes = img.roi(0, 0, 100, 100)

img.set_frame_id("camera_front")
img.set_timestamp_ns(1_700_000_000_000_000_000)