Implement getter methods on AffineTransform to access internal elements

geo/CHANGES.md

@@ -2,6 +2,9 @@
 
 ## Unreleased
 
+* Implement getter methods on `AffineTransform` to access internal elements.
+  * <https://github.com/georust/geo/pull/1159>
+
 ## 0.28.0
 
 * BREAKING: The `HasKernel` trait was removed and it's functionality was merged

geo/src/algorithm/affine_ops.rs

@@ -115,6 +115,22 @@ 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
+/// ```
+/// use geo::AffineTransform;
+///
+/// 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();
+/// assert_eq!(transform, AffineTransform::new(a, b, c, d, e, f))
+/// ```
+
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub struct AffineTransform<T: CoordNum = f64>([[T; 3]; 3]);
 
@@ -300,12 +316,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 +626,14 @@ mod tests {
         poly.affine_transform_mut(&identity);
         assert_eq!(expected, poly);
     }
+    #[test]
+    fn test_affine_transform_getters() {
+        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);
+    }
 }