Struct StereoCameraSystem 

pub struct StereoCameraSystem {
    pub left: CameraIntrinsics,
    pub right: CameraIntrinsics,
    pub baseline: f64,
    pub r: [[f64; 3]; 3],
    pub t: [f64; 3],
}

A stereo camera rig consisting of left and right pinhole cameras.

The stereo geometry is described by a relative rotation R and translation T such that a point P_l in the left-camera frame maps to the right frame as P_r = R * P_l + T.

For a typical horizontal stereo setup T ≈ [-baseline, 0, 0].

Fields

left: CameraIntrinsics

Left camera intrinsics.

right: CameraIntrinsics

Right camera intrinsics.

baseline: f64

Baseline distance between optical centres (metres).

r: [[f64; 3]; 3]

Rotation from left to right camera frame.

t: [f64; 3]

Translation from left to right camera frame (metres).

Implementations

impl StereoCameraSystem

pub fn new( left: CameraIntrinsics, right: CameraIntrinsics, r: [[f64; 3]; 3], t: [f64; 3], ) -> Self

Create a new stereo system. The baseline is derived from ‖T‖.

pub fn disparity_to_depth(&self, disparity: f64) -> Option<f64>

Convert disparity to metric depth using depth = baseline * fx / disparity.

Returns None when disparity ≤ 0.

let cam = CameraIntrinsics::ideal(800.0, 800.0, 320.0, 240.0);
let stereo = StereoCameraSystem::new(
    cam.clone(), cam,
    [[1.0,0.0,0.0],[0.0,1.0,0.0],[0.0,0.0,1.0]],
    [-0.1, 0.0, 0.0],
);
let depth = stereo.disparity_to_depth(80.0).unwrap();
assert!((depth - 1.0).abs() < 1e-9);

pub fn triangulate( &self, left_px: [f64; 2], right_px: [f64; 2], ) -> Option<[f64; 3]>

Triangulate a 3-D point from stereo pixel correspondences using the Direct Linear Transform (mid-point method on the two rays).

Both pixels are assumed to be in a rectified coordinate frame so that epipolar lines are horizontal.

Returns None when the rays are nearly parallel.

let cam = CameraIntrinsics::ideal(800.0, 800.0, 320.0, 240.0);
let stereo = StereoCameraSystem::new(
    cam.clone(), cam,
    [[1.0,0.0,0.0],[0.0,1.0,0.0],[0.0,0.0,1.0]],
    [-0.1, 0.0, 0.0],
);
// A point at (0, 0, 1 m): left pixel = (320, 240), right pixel = (240, 240)
let pt = stereo.triangulate([320.0, 240.0], [240.0, 240.0]).unwrap();
assert!((pt[2] - 1.0).abs() < 0.05);

pub fn compute_disparity_map( &self, left_img: &[Vec<f64>], right_img: &[Vec<f64>], max_disparity: usize, block_size: usize, ) -> Vec<Vec<f64>>

Compute a disparity map from a rectified stereo pair using block matching.

Both images must have the same dimensions. Returns a disparity map of identical dimensions; pixels where no match was found carry value 0.0.

Arguments

• left_img – Row-major grayscale image [row][col].
• right_img – Row-major grayscale image [row][col].
• max_disparity – Maximum disparity to search (pixels).
• block_size – Half-window radius (full window = 2r+1 × 2r+1).

Trait Implementations

impl Clone for StereoCameraSystem

fn clone(&self) -> StereoCameraSystem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StereoCameraSystem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.