Implement NSAffineTransformStruct.invert() and tests

It also adds missing arithmetic operators to `CGFloat` which are needed for the matrix inversion.

Author: Dominique d'Argent

Foundation/NSAffineTransform.swift

@@ -96,7 +96,14 @@ public class NSAffineTransform : NSObject, NSCopying, NSSecureCoding {
     }
 
     // Inverting
-    public func invert() { NSUnimplemented() }
+    public func invert() {
+        if let inverse = transformStruct.inverse {
+            transformStruct = inverse
+        }
+        else {
+            preconditionFailure("NSAffineTransform: Transform has no inverse")
+        }
+    }
 
     // Transforming with transform
     public func appendTransform(transform: NSAffineTransform) {
@@ -241,6 +248,45 @@ private extension NSAffineTransformStruct {
 
         return NSSize(width: w, height: h)
     }
+    
+    
+    /**
+     Returns the inverse affine transformation matrix or `nil` if it has no inverse.
+     The receiver's affine transformation matrix can be divided into matrix sub-block as
+       [ M  t ]
+       [ 0  1 ]
+     where `M` represents the linear map and `t` the translation vector.
+     
+     The inversion can then be calculated as
+       [ inv(M)  -inv(M) * t ]
+       [   0           1     ]
+     if `M` is invertible.
+     */
+    var inverse: NSAffineTransformStruct? {
+        get {
+            // Calculate determinant of M: det(M)
+            let det = (m11 * m22) - (m12 * m21)
+            if det == CGFloat() {
+                return nil
+            }
+
+            let detReciprocal = CGFloat(1.0) / det
+            
+            // Calculate the inverse of M: inv(M)
+            let (invM11, invM12) = (detReciprocal *  m22, detReciprocal * -m12)
+            let (invM21, invM22) = (detReciprocal * -m21, detReciprocal *  m11)
+            
+            // Calculate -inv(M)*t
+            let invTX = ((-invM11 * tX) + (-invM12 * tY))
+            let invTY = ((-invM21 * tX) + (-invM22 * tY))
+            
+            return NSAffineTransformStruct(
+                m11: invM11, m12: invM12,
+                m21: invM21, m22: invM22,
+                tX: invTX, tY: invTY
+            )
+        }
+    }
 }
 
 

Foundation/NSGeometry.swift

@@ -45,6 +45,18 @@ public func +(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
     return CGFloat(lhs.native + rhs.native)
 }
 
+public func -(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
+    return CGFloat(lhs.native - rhs.native)
+}
+
+public func /(lhs: CGFloat, rhs: CGFloat) -> CGFloat {
+    return CGFloat(lhs.native / rhs.native)
+}
+
+prefix public func -(x: CGFloat) -> CGFloat {
+    return CGFloat(-x.native)
+}
+
 @_transparent extension Double {
     public init(_ value: CGFloat) {
         self = Double(value.native)

TestFoundation/TestNSAffineTransform.swift

@@ -33,7 +33,8 @@ class TestNSAffineTransform : XCTestCase {
             ("test_Translation", test_Translation),
             ("test_Scale", test_Scale),
             ("test_Rotation_Degrees", test_Rotation_Degrees),
-            ("test_Rotation_Radians", test_Rotation_Radians)
+            ("test_Rotation_Radians", test_Rotation_Radians),
+            ("test_Inversion", test_Inversion)
         ]
     }
 
@@ -143,6 +144,38 @@ class TestNSAffineTransform : XCTestCase {
         reflectAboutOrigin.rotateByRadians(CGFloat(M_PI))
         checkPointTransformation(reflectAboutOrigin, point: point, expectedPoint: NSPoint(x: CGFloat(-10.0), y: CGFloat(-10.0)))
     }
+    
+    func test_Inversion() {
+        let point = NSPoint(x: CGFloat(10.0), y: CGFloat(10.0))
+        
+        let translate = NSAffineTransform()
+        translate.translateXBy(CGFloat(-30.0), yBy: CGFloat(40.0))
+        
+        let rotate = NSAffineTransform()
+        translate.rotateByDegrees(CGFloat(30.0))
+        
+        let scale = NSAffineTransform()
+        scale.scaleBy(CGFloat(2.0))
+        
+        let identityTransform = NSAffineTransform()
+        
+        // append transformations
+        identityTransform.appendTransform(translate)
+        identityTransform.appendTransform(rotate)
+        identityTransform.appendTransform(scale)
+        
+        // invert transformations
+        scale.invert()
+        rotate.invert()
+        translate.invert()
+        
+        // append inverse transformations in reverse order
+        identityTransform.appendTransform(scale)
+        identityTransform.appendTransform(rotate)
+        identityTransform.appendTransform(translate)
+        
+        checkPointTransformation(identityTransform, point: point, expectedPoint: point)
+    }
 }