sophus_renderer 0.14.0

wgpu-based renderer
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

use sophus_autodiff::linalg::VecF64;
use sophus_image::ImageSize;
use sophus_lie::prelude::IsVector;
use sophus_sensor::{
    DynCameraF64,
    EnhancedUnifiedCameraF64,
    PerspectiveCameraEnum,
    PinholeCameraF64,
};

/// Camera intrinsics
#[derive(Clone, Debug)]
pub enum RenderIntrinsics {
    /// Pinhole camera model
    Pinhole(PinholeCameraF64),
    /// Unified camera model
    UnifiedExtended(EnhancedUnifiedCameraF64),
}

impl RenderIntrinsics {
    /// Create a new RenderIntrinsics from a DynCameraF64
    pub fn new(camera: &DynCameraF64) -> RenderIntrinsics {
        match camera.model_enum() {
            PerspectiveCameraEnum::Pinhole(pinhole) => RenderIntrinsics::Pinhole(*pinhole),
            PerspectiveCameraEnum::KannalaBrandt(_camera) => todo!(),
            PerspectiveCameraEnum::BrownConrady(_camera) => todo!(),
            PerspectiveCameraEnum::EnhancedUnified(camera) => {
                RenderIntrinsics::UnifiedExtended(*camera)
            }
        }
    }

    /// Get the image size
    pub fn image_size(&self) -> ImageSize {
        match self {
            RenderIntrinsics::Pinhole(pinhole) => pinhole.image_size(),
            RenderIntrinsics::UnifiedExtended(unified) => unified.image_size(),
        }
    }

    /// Unproject a point from the image plane with a given depth
    pub fn cam_unproj_with_z(&self, uv: &VecF64<2>, z: f64) -> VecF64<3> {
        match self {
            RenderIntrinsics::Pinhole(pinhole) => pinhole.cam_unproj_with_z(uv, z),
            RenderIntrinsics::UnifiedExtended(unified) => unified.cam_unproj_with_z(uv, z),
        }
    }

    /// Return pinhole model
    pub fn pinhole_model(&self) -> PinholeCameraF64 {
        match self {
            RenderIntrinsics::Pinhole(camera) => *camera,
            RenderIntrinsics::UnifiedExtended(camera) => PinholeCameraF64::new(
                VecF64::<4>::from_array([
                    0.5 * camera.params()[0],
                    0.5 * camera.params()[1],
                    camera.params()[2],
                    camera.params()[3],
                ]),
                camera.image_size(),
            ),
        }
    }
}