Rename Film Back width/height to include millimeters.

Author: david-cattermole

lib/rust/mmcamerasolve-bin/src/write_data.rs

@@ -141,8 +141,8 @@ fn write_mmcamera_output_inner(
     let (focal_length_mm, _lens_cx, _lens_cy) =
         camera_intrinsics.to_physical_parameters();
     let focal_length_val = focal_length_mm.value();
-    let film_back_width_val = film_back.width.value();
-    let film_back_height_val = film_back.height.value();
+    let film_back_width_val = film_back.width_mm.value();
+    let film_back_height_val = film_back.height_mm.value();
 
     let mut translate_x = Vec::with_capacity(frame_list.len());
     let mut translate_y = Vec::with_capacity(frame_list.len());

lib/rust/mmsfm/src/datatype/camera_film_back.rs

@@ -56,11 +56,9 @@ use crate::datatype::millimeter_unit::MillimeterUnit;
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct CameraFilmBack<T> {
     /// Width of the film back/sensor in millimeters.
-    // TODO: Change the field name to `width_mm`.
-    pub width: MillimeterUnit<T>,
+    pub width_mm: MillimeterUnit<T>,
     /// Height of the film back/sensor in millimeters.
-    // TODO: Change the field name to `height_mm`.
-    pub height: MillimeterUnit<T>,
+    pub height_mm: MillimeterUnit<T>,
 }
 
 impl<T> CameraFilmBack<T>
@@ -81,11 +79,14 @@ where
     ///     MillimeterUnit::new(36.0),
     ///     MillimeterUnit::new(24.0)
     /// );
-    /// assert_eq!(film_back.width.value(), 36.0);
-    /// assert_eq!(film_back.height.value(), 24.0);
+    /// assert_eq!(film_back.width_mm.value(), 36.0);
+    /// assert_eq!(film_back.height_mm.value(), 24.0);
     /// ```
     pub fn new(width: MillimeterUnit<T>, height: MillimeterUnit<T>) -> Self {
-        Self { width, height }
+        Self {
+            width_mm: width,
+            height_mm: height,
+        }
     }
 
     /// Create a new camera film back from raw millimeter values.
@@ -99,13 +100,13 @@ where
     /// use mmsfm_rust::datatype::*;
     ///
     /// let film_back = CameraFilmBack::from_millimeters(36.0, 24.0);
-    /// assert_eq!(film_back.width.value(), 36.0);
-    /// assert_eq!(film_back.height.value(), 24.0);
+    /// assert_eq!(film_back.width_mm.value(), 36.0);
+    /// assert_eq!(film_back.height_mm.value(), 24.0);
     /// ```
     pub fn from_millimeters(width_mm: T, height_mm: T) -> Self {
         Self {
-            width: MillimeterUnit::new(width_mm),
-            height: MillimeterUnit::new(height_mm),
+            width_mm: MillimeterUnit::new(width_mm),
+            height_mm: MillimeterUnit::new(height_mm),
         }
     }
 }
@@ -132,7 +133,7 @@ where
     /// assert_eq!(square.aspect_ratio(), 1.0);
     /// ```
     pub fn aspect_ratio(&self) -> T {
-        self.width.value() / self.height.value()
+        self.width_mm.value() / self.height_mm.value()
     }
 }
 
@@ -141,7 +142,7 @@ where
     T: fmt::Display + Copy + fmt::Debug + PartialEq,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}mm x {}mm", self.width, self.height)
+        write!(f, "{}mm x {}mm", self.width_mm, self.height_mm)
     }
 }
 
@@ -156,15 +157,15 @@ mod tests {
             MillimeterUnit::new(36.0),
             MillimeterUnit::new(24.0),
         );
-        assert_eq!(film_back.width.value(), 36.0);
-        assert_eq!(film_back.height.value(), 24.0);
+        assert_eq!(film_back.width_mm.value(), 36.0);
+        assert_eq!(film_back.height_mm.value(), 24.0);
     }
 
     #[test]
     fn test_camera_film_back_from_millimeters() {
         let film_back = CameraFilmBack::from_millimeters(36.0, 24.0);
-        assert_eq!(film_back.width.value(), 36.0);
-        assert_eq!(film_back.height.value(), 24.0);
+        assert_eq!(film_back.width_mm.value(), 36.0);
+        assert_eq!(film_back.height_mm.value(), 24.0);
     }
 
     #[test]

lib/rust/mmsfm/src/datatype/camera_intrinsics.rs

@@ -93,8 +93,10 @@ impl CameraIntrinsics {
         film_back: CameraFilmBack<f64>,
     ) -> Self {
         // Normalize focal lengths by film back dimensions.
-        let focal_length_x = focal_length_mm.value() / film_back.width.value();
-        let focal_length_y = focal_length_mm.value() / film_back.height.value();
+        let focal_length_x =
+            focal_length_mm.value() / film_back.width_mm.value();
+        let focal_length_y =
+            focal_length_mm.value() / film_back.height_mm.value();
 
         // Convert lens center from film back coordinates to NDC coordinates.
         //
@@ -104,10 +106,10 @@ impl CameraIntrinsics {
         // normalize by film back dimensions and scale by 2.
         let principal_point = NdcPoint2::new(
             NdcValue::new(
-                (2.0 * lens_center_x_mm.value()) / film_back.width.value(),
+                (2.0 * lens_center_x_mm.value()) / film_back.width_mm.value(),
             ),
             NdcValue::new(
-                (2.0 * lens_center_y_mm.value()) / film_back.height.value(),
+                (2.0 * lens_center_y_mm.value()) / film_back.height_mm.value(),
             ),
         );
 
@@ -160,19 +162,21 @@ impl CameraIntrinsics {
         // Convert normalized focal length back to millimeters.
         // We use focal_length_x since both should give the same physical focal length.
         let focal_length_mm = MillimeterUnit::new(
-            self.focal_length_x * self.film_back.width.value(),
+            self.focal_length_x * self.film_back.width_mm.value(),
         );
 
         // Convert NDC principal point back to lens center coordinates.
         //
         // In NDC space, (0,0) is center with range [-1,1], so we
         // scale by film back dimensions and divide by 2.
         let lens_center_x_mm = MillimeterUnit::new(
-            self.principal_point.x.value() * self.film_back.width.value() * 0.5,
+            self.principal_point.x.value()
+                * self.film_back.width_mm.value()
+                * 0.5,
         );
         let lens_center_y_mm = MillimeterUnit::new(
             self.principal_point.y.value()
-                * self.film_back.height.value()
+                * self.film_back.height_mm.value()
                 * 0.5,
         );
 
@@ -184,15 +188,19 @@ impl CameraIntrinsics {
     /// # Returns
     /// Horizontal focal length in millimeters.
     pub fn horizontal_focal_length_mm(&self) -> MillimeterUnit<f64> {
-        MillimeterUnit::new(self.focal_length_x * self.film_back.width.value())
+        MillimeterUnit::new(
+            self.focal_length_x * self.film_back.width_mm.value(),
+        )
     }
 
     /// Calculate the vertical focal length in millimeters.
     ///
     /// # Returns
     /// Vertical focal length in millimeters.
     pub fn vertical_focal_length_mm(&self) -> MillimeterUnit<f64> {
-        MillimeterUnit::new(self.focal_length_y * self.film_back.height.value())
+        MillimeterUnit::new(
+            self.focal_length_y * self.film_back.height_mm.value(),
+        )
     }
 
     /// Calculate the horizontal field of view in radians.
@@ -205,8 +213,8 @@ impl CameraIntrinsics {
         // focal_length_x is normalized by width, so we need the actual focal
         // length in mm.
         let focal_length_mm =
-            self.focal_length_x * self.film_back.width.value();
-        2.0 * (self.film_back.width.value() / (2.0 * focal_length_mm)).atan()
+            self.focal_length_x * self.film_back.width_mm.value();
+        2.0 * (self.film_back.width_mm.value() / (2.0 * focal_length_mm)).atan()
     }
 
     /// Calculate the horizontal field of view in degrees.
@@ -224,8 +232,9 @@ impl CameraIntrinsics {
     pub fn vertical_fov_radians(&self) -> f64 {
         // FoV = 2 * arctan(sensor_height / (2 * focal_length))
         let focal_length_mm =
-            self.focal_length_y * self.film_back.height.value();
-        2.0 * (self.film_back.height.value() / (2.0 * focal_length_mm)).atan()
+            self.focal_length_y * self.film_back.height_mm.value();
+        2.0 * (self.film_back.height_mm.value() / (2.0 * focal_length_mm))
+            .atan()
     }
 
     /// Calculate the vertical field of view in degrees.
@@ -242,13 +251,13 @@ impl CameraIntrinsics {
     /// Diagonal field of view angle in radians
     pub fn diagonal_fov_radians(&self) -> f64 {
         // Calculate diagonal sensor dimension.
-        let diagonal_mm = (self.film_back.width.value().powi(2)
-            + self.film_back.height.value().powi(2))
+        let diagonal_mm = (self.film_back.width_mm.value().powi(2)
+            + self.film_back.height_mm.value().powi(2))
         .sqrt();
 
         // Use horizontal focal length for diagonal calculation.
         let focal_length_mm =
-            self.focal_length_x * self.film_back.width.value();
+            self.focal_length_x * self.film_back.width_mm.value();
         2.0 * (diagonal_mm / (2.0 * focal_length_mm)).atan()
     }
 
@@ -295,8 +304,8 @@ mod tests {
             -0.4,
             epsilon = 1e-10
         );
-        assert_eq!(intrinsics.film_back.width.value(), 36.0);
-        assert_eq!(intrinsics.film_back.height.value(), 24.0);
+        assert_eq!(intrinsics.film_back.width_mm.value(), 36.0);
+        assert_eq!(intrinsics.film_back.height_mm.value(), 24.0);
     }
 
     #[test]

lib/rust/mmsfm/src/visualization/reprojection.rs

@@ -218,8 +218,8 @@ pub fn visualize_marker_reprojections_2d_scatter(
         );
         mm_eprintln_debug!(
             "  Film back A: {:.1}mm x {:.1}mm (aspect: {:.3})",
-            intrinsics_a.film_back.width.value(),
-            intrinsics_a.film_back.height.value(),
+            intrinsics_a.film_back.width_mm.value(),
+            intrinsics_a.film_back.height_mm.value(),
             intrinsics_a.film_back.aspect_ratio()
         );
 
@@ -236,8 +236,8 @@ pub fn visualize_marker_reprojections_2d_scatter(
         );
         mm_eprintln_debug!(
             "  Film back B: {:.1}mm x {:.1}mm (aspect: {:.3})",
-            intrinsics_a.film_back.width.value(),
-            intrinsics_a.film_back.height.value(),
+            intrinsics_a.film_back.width_mm.value(),
+            intrinsics_a.film_back.height_mm.value(),
             intrinsics_a.film_back.aspect_ratio()
         );