Matrix decomposition cleanup: Add is_degenerate_2x2(), and fix some asserts

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 152 matching lines @@
 
     return  ma[0] == mb[0] && ma[1] == mb[1] && ma[2] == mb[2] &&
             ma[3] == mb[3] && ma[4] == mb[4] && ma[5] == mb[5] &&
             ma[6] == mb[6] && ma[7] == mb[7] && ma[8] == mb[8];
 }
 
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
+// helper function to determine if upper-left 2x2 of matrix is degenerate
+static inline bool is_degenerate_2x2(SkScalar scaleX, SkScalar skewX, 
+                                     SkScalar skewY,  SkScalar scaleY) {
+    SkScalar perp_dot = scaleX*scaleY - skewX*skewY;
+    return SkScalarNearlyZero(perp_dot, SK_ScalarNearlyZero*SK_ScalarNearlyZero);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 bool SkMatrix::isSimilarity(SkScalar tol) const {
     // if identity or translate matrix
     TypeMask mask = this->getType();
     if (mask <= kTranslate_Mask) {
         return true;
     }
     if (mask & kPerspective_Mask) {
         return false;
     }
 
     SkScalar mx = fMat[kMScaleX];
     SkScalar my = fMat[kMScaleY];
     // if no skew, can just compare scale factors
     if (!(mask & kAffine_Mask)) {
         return !SkScalarNearlyZero(mx) && SkScalarNearlyEqual(SkScalarAbs(mx), SkScalarAbs(my));
     }
     SkScalar sx = fMat[kMSkewX];
     SkScalar sy = fMat[kMSkewY];
 
-    // TODO: I (rphillips) think there should be an || in here (see preservesRightAngles)
-    // degenerate matrix, non-similarity
-    if (SkScalarNearlyZero(mx) && SkScalarNearlyZero(my)
-        && SkScalarNearlyZero(sx) && SkScalarNearlyZero(sy)) {
+    if (is_degenerate_2x2(mx, sx, sy, my)) {
         return false;
     }
 
     // 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(),
@@ skipping 11 matching lines @@
         return false;
     }
 
     SkASSERT(mask & kAffine_Mask);
 
     SkScalar mx = fMat[kMScaleX];
     SkScalar my = fMat[kMScaleY];
     SkScalar sx = fMat[kMSkewX];
     SkScalar sy = fMat[kMSkewY];
 
-    if ((SkScalarNearlyZero(mx) && SkScalarNearlyZero(sx)) ||
-        (SkScalarNearlyZero(my) && SkScalarNearlyZero(sy))) {
-        // degenerate matrix
+    if (is_degenerate_2x2(mx, sx, sy, my)) {
         return false;
     }
 
     // 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(),
@@ skipping 1732 matching lines @@
                          SkScalar* xScale, SkScalar* yScale,
                          SkScalar* rotation1) {
 
     // 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 = matrix[SkMatrix::kMScaleX];
     SkScalar B = matrix[SkMatrix::kMSkewX];
     SkScalar C = matrix[SkMatrix::kMSkewY];
     SkScalar D = matrix[SkMatrix::kMScaleY];
 
+    if (is_degenerate_2x2(A, B, C, D)) {
+        return false;
+    }
+
     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);
 
     SkScalar xs, ys, r0, r1;
 
-    // can't have zero yScale, must be degenerate
-    if (SkScalarNearlyEqual(sqrt0, sqrt1)) {
-        return false;
-    }
     xs = sqrt0 + sqrt1;
     ys = sqrt0 - sqrt1;
+    // can't have zero yScale, must be degenerate
+    SkASSERT(!SkScalarNearlyZero(ys));
 
     // uniformly scaled rotation
     if (SkScalarNearlyZero(F) && SkScalarNearlyZero(G)) {
-        SkASSERT(!SkScalarNearlyZero(E));
+        SkASSERT(!SkScalarNearlyZero(E) || !SkScalarNearlyZero(H));
         r0 = SkScalarATan2(H, E);
         r1 = 0;
     // uniformly scaled reflection
     } else if (SkScalarNearlyZero(E) && SkScalarNearlyZero(H)) {
-        SkASSERT(!SkScalarNearlyZero(F));
+        SkASSERT(!SkScalarNearlyZero(F) || !SkScalarNearlyZero(G));
         r0 = -SkScalarATan2(G, F);
         r1 = 0;
     } else {
-        SkASSERT(!SkScalarNearlyZero(E));
-        SkASSERT(!SkScalarNearlyZero(F));
+        SkASSERT(!SkScalarNearlyZero(E) || !SkScalarNearlyZero(H));
+        SkASSERT(!SkScalarNearlyZero(F) || !SkScalarNearlyZero(G));
 
         SkScalar arctan0 = SkScalarATan2(H, E);
         SkScalar arctan1 = SkScalarATan2(G, F);
         r0 = SK_ScalarHalf*(arctan0 - arctan1);
         r1 = SK_ScalarHalf*(arctan0 + arctan1);
 
         // simplify the results
         const SkScalar kHalfPI = SK_ScalarHalf*SK_ScalarPI;
         if (SkScalarNearlyEqual(SkScalarAbs(r0), kHalfPI)) {
             SkScalar tmp = xs;
@@ skipping 20 matching lines @@
     }
     if (NULL != rotation0) {
         *rotation0 = r0;
     }
     if (NULL != rotation1) {
         *rotation1 = r1;
     }
 
     return true;
 }