Implement getter methods on AffineTransform to access internal elements

geo/src/algorithm/affine_ops.rs

@@ -115,6 +115,19 @@ impl<T: CoordNum, M: MapCoordsInPlace<T> + MapCoords<T, T, Output = Self>> Affin
 ///     (x: -0.5688687, y: 5.5688687)
 /// ], max_relative = 1.0);
 /// ```
+///
+/// ## Create affine transform manually, and access elements using getter methods
+/// ```
+/// let transform = AffineTransform::new(10.0, 0.0, 400_000.0, 0.0, -10.0, 500_000.0);
+///
+/// let a: f64 = transform.a();
+/// let b: f64 = transform.b();
+/// let c: f64 = transform.xoff();
+/// let d: f64 = transform.d();
+/// let e: f64 = transform.e();
+/// let f: f64 = transform.yoff();
+/// ```
+
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub struct AffineTransform<T: CoordNum = f64>([[T; 3]; 3]);
 
@@ -300,12 +313,37 @@ impl<T: CoordNum> AffineTransform<T> {
     /// The argument order matches that of the affine transform matrix:
     ///```ignore
     /// [[a, b, xoff],
-    /// [d, e, yoff],
-    /// [0, 0, 1]] <-- not part of the input arguments
+    ///  [d, e, yoff],
+    ///  [0, 0, 1]] <-- not part of the input arguments
     /// ```
     pub fn new(a: T, b: T, xoff: T, d: T, e: T, yoff: T) -> Self {
         Self([[a, b, xoff], [d, e, yoff], [T::zero(), T::zero(), T::one()]])
     }
+
+    /// Get the x-resolution value.
+    pub fn a(&self) -> &T {
+        &self.0[0][0]
+    }
+    /// Get the x-rotation value.
+    pub fn b(&self) -> &T {
+        &self.0[0][1]
+    }
+    /// Get the x-offset value.
+    pub fn xoff(&self) -> &T {
+        &self.0[0][2]
+    }
+    /// Get the y-rotation value.
+    pub fn d(&self) -> &T {
+        &self.0[1][0]
+    }
+    /// Get the y-resolution value.
+    pub fn e(&self) -> &T {
+        &self.0[1][1]
+    }
+    /// Get the y-offset value.
+    pub fn yoff(&self) -> &T {
+        &self.0[1][2]
+    }
 }
 
 impl<T: CoordNum + Neg> AffineTransform<T> {
@@ -585,4 +623,14 @@ mod tests {
         poly.affine_transform_mut(&identity);
         assert_eq!(expected, poly);
     }
+    #[test]
+    fn test_affine_transform_indexing() {
+        let transform = AffineTransform::new(10.0, 0.0, 400_000.0, 0.0, -10.0, 500_000.0);
+        assert_eq!(transform.a(), &10.0);
+        assert_eq!(transform.b(), &0.0);
+        assert_eq!(transform.xoff(), &400_000.0);
+        assert_eq!(transform.d(), &0.0);
+        assert_eq!(transform.e(), -&10.0);
+        assert_eq!(transform.yoff(), &500_000.0);
+    }
 }