Add basic SVD support to SkMatrix. Allows you to pull out the x- and y-scale factors, sandwiched by…

src/core/SkMatrix.cpp

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix.h"
 #include "Sk64.h"
 #include "SkFloatBits.h"
@@ skipping 222 matching lines @@
     // it has scales and skews, but it could also be rotation, check it out.
     SkVector vec[2];
     vec[0].set(mx, sx);
     vec[1].set(sy, my);
 
     return SkScalarNearlyZero(vec[0].dot(vec[1]), SkScalarSquare(tol)) &&
            SkScalarNearlyEqual(vec[0].lengthSqd(), vec[1].lengthSqd(),
                                SkScalarSquare(tol));
 }
 
+bool SkMatrix::decomposeUpper2x2(SkScalar* rotation0, 
+                        SkScalar* xScale, SkScalar* yScale, 
+                        SkScalar* rotation1) const {
+
+    // borrowed from Jim Blinn's article "Consider the Lowly 2x2 Matrix"
+    // Note: he uses row vectors, so we have to do some swapping of terms
+    SkScalar A = fMat[kMScaleX];
+    SkScalar B = fMat[kMSkewX];
+    SkScalar C = fMat[kMSkewY];
+    SkScalar D = fMat[kMScaleY];                            
+
+    SkScalar E = SK_ScalarHalf*(A + D);
+    SkScalar F = SK_ScalarHalf*(A - D);
+    SkScalar G = SK_ScalarHalf*(C + B);
+    SkScalar H = SK_ScalarHalf*(C - B);
+
+    SkScalar sqrt0 = SkScalarSqrt(E*E + H*H);
+    SkScalar sqrt1 = SkScalarSqrt(F*F + G*G);
+
+    // can't have zero yScale, must be degenerate
+    if (SkScalarNearlyEqual(sqrt0, sqrt1)) {
+        return false;
+    }
+    if (NULL != xScale) {
+        *xScale = sqrt0 + sqrt1;
+    }
+    if (NULL != yScale) {
+        *yScale = sqrt0 - sqrt1;
+    }
+
+    // uniformly scaled rotation
+    if (SkScalarNearlyZero(F) && SkScalarNearlyZero(G)) {
+        SkASSERT(!SkScalarNearlyZero(E));
+        if (NULL != rotation0) {
+            *rotation0 = SkScalarATan2(H, E);
+        }
+        if (NULL != rotation1) {
+            *rotation1 = 0;
+        }
+    // uniformly scaled reflection 
+    } else if (SkScalarNearlyZero(E) && SkScalarNearlyZero(H)) {
+        SkASSERT(!SkScalarNearlyZero(F));
+        if (NULL != rotation0) {
+            *rotation0 = -SkScalarATan2(G, F);
+        }
+        if (NULL != rotation1) {
+            *rotation1 = 0;
+        }
+    } else {
+        SkASSERT(!SkScalarNearlyZero(E));
+        SkASSERT(!SkScalarNearlyZero(F));
+
+        SkScalar arctan0 = SkScalarATan2(H, E);  
+        SkScalar arctan1 = SkScalarATan2(G, F);
+        if (NULL != rotation0) {
+            *rotation0 = SK_ScalarHalf*(arctan0 - arctan1);
+        }
+        if (NULL != rotation1) {
+            *rotation1 = SK_ScalarHalf*(arctan0 + arctan1);
+        }
+    }
+
+    return true;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix::setTranslate(SkScalar dx, SkScalar dy) {
     if (SkScalarToCompareType(dx) || SkScalarToCompareType(dy)) {
         fMat[kMTransX] = dx;
         fMat[kMTransY] = dy;
 
         fMat[kMScaleX] = fMat[kMScaleY] = SK_Scalar1;
         fMat[kMSkewX]  = fMat[kMSkewY] =
         fMat[kMPersp0] = fMat[kMPersp1] = 0;
@@ skipping 1706 matching lines @@
         dst.fLeft *= scale;
         dst.fTop *= scale;
         dst.fRight *= scale;
         dst.fBottom *= scale;
     }
 
     SkIRect idst;
     dst.round(&idst);
     return isrc == idst;
 }