braid-mvg 0.1.0

Braid's camera geometry and multi-view geometry (MVG) types and algorithms.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use cam_geom::ExtrinsicParameters;
use na::{Matrix3xX, Vector3};
use nalgebra as na;

use braid_mvg::rerun_io::AsRerunTransform3D;

fn main() -> eyre::Result<()> {
    // Create 3d points.
    #[rustfmt::skip]
    let points3d = Matrix3xX::<f64>::from_column_slice(
        &[
        0.0, 0.0, 0.0,
        1.0, 0.0, 0.0,
        1.0, 1.0, 0.0,
        0.0, 1.0, 0.0,
        0.0, 0.0, 1.0,
        1.0, 0.0, 1.0,
        1.0, 1.0, 1.0,
        0.0, 1.0, 1.0,
    ]);

    // Create rerun file
    let rec =
        re_sdk::RecordingStreamBuilder::new("export-rerun-log").save("export-rerun-log.rrd")?;

    // Log 3d points to rerun.
    let positions: Vec<[f32; 3]> = points3d
        .column_iter()
        .map(|v| [v.x as f32, v.y as f32, v.z as f32])
        .collect();
    rec.log("/", &re_types::archetypes::Points3D::new(&positions))?;

    // Create camera
    let cc = Vector3::new(3.0, 2.0, 1.0);
    let lookat = Vector3::new(0.0, 0.0, 0.0);
    let up = Vector3::new(0.0, 0.0, 1.0);
    let up_unit = na::core::Unit::new_normalize(up);

    let extrinsics = ExtrinsicParameters::from_view(&cc, &lookat, &up_unit);

    let width = 640;
    let height = 480;

    let params = cam_geom::PerspectiveParams {
        fx: 100.0,
        fy: 101.0,
        skew: 0.0,
        cx: width as f64 / 2.0,
        cy: height as f64 / 2.0,
    };
    let intrinsics: cam_geom::IntrinsicParametersPerspective<_> = params.into();

    let cam = cam_geom::Camera::new(intrinsics, extrinsics);

    // Log camera extrinsics to rerun.
    rec.log(
        "/world/camera/cam1",
        &cam.extrinsics().as_rerun_transform3d().into(),
    )
    .unwrap();

    // Log camera intrinsics to rerun.
    rec.log(
        "/world/camera/cam1/raw",
        &braid_mvg::rerun_io::cam_geom_to_rr_pinhole_archetype(cam.intrinsics(), width, height)?,
    )
    .unwrap();

    // Project camera to points
    let world = cam_geom::Points::new(points3d.transpose());
    let pixels = cam.world_to_pixel(&world);

    // Log 2D points to rerun
    let points2d: Vec<[f32; 2]> = pixels
        .data
        .row_iter()
        .map(|v| {
            let v = v.transpose();
            [v.x as f32, v.y as f32]
        })
        .collect();
    rec.log(
        "/world/camera/cam1/raw",
        &re_types::archetypes::Points2D::new(&points2d),
    )?;

    Ok(())
}