Subdivide struct Camera into Extrinsics and Intrinsics (#165)

* Subdivide `struct Camera` into `Extrinsics` and `Intrinsics`

* lint.py: ignore target_wasm directory

Author: emilk

crates/re_log_types/src/data.rs

@@ -387,6 +387,17 @@ pub type Quaternion = [f32; 4];
 #[derive(Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct Camera {
+    pub extrinsics: Extrinsics,
+    pub intrinsics: Option<Intrinsics>,
+
+    /// The 2D space that this camera projects into.
+    pub target_space: Option<ObjPath>,
+}
+
+/// Camera pose
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Extrinsics {
     /// How is the camera rotated?
     ///
     /// This transforms world-space from camera-space.
@@ -402,7 +413,12 @@ pub struct Camera {
 
     /// What is the users camera-space coordinate system?
     pub camera_space_convention: CameraSpaceConvention,
+}
 
+/// Camera projection
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
+pub struct Intrinsics {
     /// Column-major intrinsics matrix.
     /// Image coordinates from view coordinates (via projection).
     ///
@@ -412,18 +428,22 @@ pub struct Camera {
     ///  [0.0,    1496.1, 0.0], // col 1
     ///  [980.5,  744.5,  1.0]] // col 2
     /// ```
-    pub intrinsics: Option<[[f32; 3]; 3]>,
+    pub intrinsics_matrix: [[f32; 3]; 3],
 
     /// Pixel resolution (usually integers). Width and height.
     ///
     /// Example:
     /// ```text
     /// [1920.0, 1440.0]
     /// ```
-    pub resolution: Option<[f32; 2]>,
+    pub resolution: [f32; 2],
+}
 
-    /// The 2D space that this camera projects into.
-    pub target_space: Option<ObjPath>,
+impl Intrinsics {
+    /// Field of View on the Y axis, i.e. the angle between top and bottom.
+    pub fn fov_y(&self) -> f32 {
+        2.0 * (0.5 * self.resolution[1] / self.intrinsics_matrix[1][1]).atan()
+    }
 }
 
 /// Convention for the coordinate system of the camera.

crates/re_viewer/src/misc.rs

@@ -158,7 +158,7 @@ pub fn calc_bbox_3d(objects: &re_data_store::Objects<'_>) -> macaw::BoundingBox
     }
 
     for (_, obj) in objects.camera.iter() {
-        bbox.extend(obj.camera.position.into());
+        bbox.extend(obj.camera.extrinsics.position.into());
     }
 
     bbox
@@ -174,7 +174,7 @@ pub mod cam {
     /// Rerun uses a RHS view-space with +X=right, +Y=up, -Z=fwd.
     /// This creates a transform from the Rerun view-space
     /// to the parent space of the camera.
-    pub fn world_from_view(cam: &re_log_types::Camera) -> macaw::IsoTransform {
+    pub fn world_from_view(cam: &re_log_types::Extrinsics) -> macaw::IsoTransform {
         use re_log_types::CameraSpaceConvention;
 
         let rotation = Quat::from_slice(&cam.rotation);
@@ -192,15 +192,15 @@ pub mod cam {
         macaw::IsoTransform::from_rotation_translation(rotation, translation)
     }
 
-    pub fn view_from_world(cam: &re_log_types::Camera) -> macaw::IsoTransform {
+    pub fn view_from_world(cam: &re_log_types::Extrinsics) -> macaw::IsoTransform {
         world_from_view(cam).inverse()
     }
 
     /// Projects image coordinates into world coordinates
     pub fn world_from_image(cam: &re_log_types::Camera) -> Option<glam::Affine3A> {
         cam.intrinsics.map(|intrinsics| {
-            let intrinsics = glam::Mat3::from_cols_array_2d(&intrinsics);
-            world_from_view(cam)
+            let intrinsics = glam::Mat3::from_cols_array_2d(&intrinsics.intrinsics_matrix);
+            world_from_view(&cam.extrinsics)
                 * Affine3A::from_scale([1.0, -1.0, -1.0].into()) // negate Y and Z here here because image space and view space are different.
                 * Affine3A::from_mat3(intrinsics.inverse())
         })
@@ -209,10 +209,10 @@ pub mod cam {
     /// Projects world coordinates onto 2D image coordinates
     pub fn image_from_world(cam: &re_log_types::Camera) -> Option<glam::Affine3A> {
         cam.intrinsics.map(|intrinsics| {
-            let intrinsics = glam::Mat3::from_cols_array_2d(&intrinsics);
+            let intrinsics = glam::Mat3::from_cols_array_2d(&intrinsics.intrinsics_matrix);
             Affine3A::from_mat3(intrinsics)
             * Affine3A::from_scale([1.0, -1.0, -1.0].into()) // negate Y and Z here here because image space and view space are different.
-            * view_from_world(cam)
+            * view_from_world(&cam.extrinsics)
         })
     }
 
@@ -227,7 +227,7 @@ pub mod cam {
     /// Unproject a 2D image coordinate as a ray in 3D space
     pub fn unproject_as_ray(cam: &re_log_types::Camera, pos2d: Vec2) -> Option<Ray3> {
         world_from_image(cam).map(|world_from_pixel| {
-            let origin = Vec3::from_slice(&cam.position);
+            let origin = Vec3::from_slice(&cam.extrinsics.position);
             let stop = world_from_pixel.transform_point3(pos2d.extend(1.0));
             let dir = (stop - origin).normalize();
             Ray3::from_origin_dir(origin, dir)

crates/re_viewer/src/ui/data_ui.rs

@@ -371,11 +371,8 @@ pub(crate) fn ui_data_vec(ui: &mut egui::Ui, data_vec: &DataVec) -> egui::Respon
 
 fn ui_camera(ui: &mut egui::Ui, cam: &Camera) -> egui::Response {
     let Camera {
-        rotation,
-        position,
-        camera_space_convention,
+        extrinsics,
         intrinsics,
-        resolution,
         target_space,
     } = cam;
     ui.vertical(|ui| {
@@ -385,6 +382,12 @@ fn ui_camera(ui: &mut egui::Ui, cam: &Camera) -> egui::Response {
                 .striped(true)
                 .num_columns(2)
                 .show(ui, |ui| {
+                    let Extrinsics {
+                        rotation,
+                        position,
+                        camera_space_convention,
+                    } = extrinsics;
+
                     ui.label("rotation");
                     ui.monospace(format!("{rotation:?}"));
                     ui.end_row();
@@ -397,15 +400,19 @@ fn ui_camera(ui: &mut egui::Ui, cam: &Camera) -> egui::Response {
                     ui.monospace(format!("{camera_space_convention:?}"));
                     ui.end_row();
 
-                    ui.label("intrinsics");
-                    if let Some(intrinsics) = intrinsics {
-                        ui_intrinsics(ui, intrinsics);
+                    if let Some(Intrinsics {
+                        intrinsics_matrix,
+                        resolution,
+                    }) = intrinsics
+                    {
+                        ui.label("intrinsics");
+                        ui_intrinsics_matrix(ui, intrinsics_matrix);
+                        ui.end_row();
+
+                        ui.label("resolution");
+                        ui.monospace(format!("{resolution:?}"));
+                        ui.end_row();
                     }
-                    ui.end_row();
-
-                    ui.label("resolution");
-                    ui.monospace(format!("{resolution:?}"));
-                    ui.end_row();
 
                     ui.label("target_space");
                     if let Some(target_space) = target_space {
@@ -418,7 +425,7 @@ fn ui_camera(ui: &mut egui::Ui, cam: &Camera) -> egui::Response {
     .response
 }
 
-fn ui_intrinsics(ui: &mut egui::Ui, intrinsics: &[[f32; 3]; 3]) {
+fn ui_intrinsics_matrix(ui: &mut egui::Ui, intrinsics: &[[f32; 3]; 3]) {
     egui::Grid::new("intrinsics").num_columns(3).show(ui, |ui| {
         ui.monospace(intrinsics[0][0].to_string());
         ui.monospace(intrinsics[1][0].to_string());

crates/re_viewer/src/ui/view3d.rs

@@ -459,7 +459,7 @@ fn show_projections_from_2d_space(
                         }
                     }
                     let length = if let Some(hit_pos) = hit_pos {
-                        hit_pos.distance(Vec3::from_slice(&cam.position))
+                        hit_pos.distance(Vec3::from_slice(&cam.extrinsics.position))
                     } else {
                         4.0 * state.scene_bbox.half_size().length() // should be long enough
                     };

crates/re_viewer/src/ui/view3d/eye.rs

@@ -17,14 +17,14 @@ pub struct Eye {
 
 impl Eye {
     pub fn from_camera(cam: &re_log_types::Camera) -> Eye {
-        let fov_y = if let (Some(intrinsis), Some([_w, h])) = (cam.intrinsics, cam.resolution) {
-            2.0 * (0.5 * h / intrinsis[1][1]).atan()
+        let fov_y = if let Some(intrinsis) = cam.intrinsics {
+            intrinsis.fov_y()
         } else {
             DEFAULT_FOV_Y
         };
 
         Self {
-            world_from_view: crate::misc::cam::world_from_view(cam),
+            world_from_view: crate::misc::cam::world_from_view(&cam.extrinsics),
             fov_y,
         }
     }

crates/re_viewer/src/ui/view3d/scene.rs

@@ -247,7 +247,7 @@ impl Scene {
 
                 let instance_id = InstanceIdHash::from_props(props);
 
-                let world_from_view = crate::misc::cam::world_from_view(camera);
+                let world_from_view = crate::misc::cam::world_from_view(&camera.extrinsics);
 
                 let dist_to_eye = eye_camera_plane.distance(world_from_view.translation());
                 let color = object_color(ctx, props);
@@ -281,11 +281,11 @@ impl Scene {
                 }
 
                 if ctx.options.show_camera_axes_in_3d {
-                    let world_from_view = crate::misc::cam::world_from_view(camera);
                     let center = world_from_view.translation();
                     let radius = dist_to_eye * line_radius_from_distance * 2.0;
 
                     for (axis_index, dir) in camera
+                        .extrinsics
                         .camera_space_convention
                         .axis_dirs_in_rerun_view_space()
                         .iter()
@@ -320,10 +320,12 @@ impl Scene {
         line_radius: f32,
         color: [u8; 4],
     ) {
-        if let (Some(world_from_image), Some([w, h])) =
-            (crate::misc::cam::world_from_image(cam), cam.resolution)
+        if let (Some(world_from_image), Some(intrinsics)) =
+            (crate::misc::cam::world_from_image(cam), cam.intrinsics)
         {
-            let world_from_view = crate::misc::cam::world_from_view(cam);
+            let [w, h] = intrinsics.resolution;
+
+            let world_from_view = crate::misc::cam::world_from_view(&cam.extrinsics);
 
             // At what distance do we end the frustum?
             let d = scene_bbox.size().length() * 0.3;

rerun_py/src/python_bridge.rs

@@ -409,7 +409,7 @@ fn convert_color(color: Vec<u8>) -> PyResult<[u8; 4]> {
 fn log_camera(
     obj_path: &str,
     resolution: [f32; 2],
-    intrinsics: [[f32; 3]; 3],
+    intrinsics_matrix: [[f32; 3]; 3],
     rotation_q: re_log_types::Quaternion,
     position: [f32; 3],
     camera_space_convention: &str,
@@ -436,12 +436,20 @@ fn log_camera(
         None
     };
 
-    let camera = re_log_types::Camera {
+    let extrinsics = re_log_types::Extrinsics {
         rotation: rotation_q,
         position,
-        intrinsics: Some(intrinsics),
-        resolution: Some(resolution),
         camera_space_convention: convention,
+    };
+
+    let intrinsics = re_log_types::Intrinsics {
+        intrinsics_matrix,
+        resolution,
+    };
+
+    let camera = re_log_types::Camera {
+        extrinsics,
+        intrinsics: Some(intrinsics),
         target_space,
     };
 

scripts/lint.py

@@ -99,7 +99,7 @@ def lint_file(filepath, args):
         root_dirpath = os.path.abspath(f'{script_dirpath}/..')
         os.chdir(root_dirpath)
 
-        exclude_dirs = set(['env', 'venv', 'target'])
+        exclude_dirs = set(['env', 'venv', 'target', 'target_wasm'])
 
         exclude_paths = set([
             './CONTRIBUTING.md',