SkMatrix44::preserves2dAxisAlignment()

src/utils/SkMatrix44.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMatrix44.h"
 
 static inline bool eq4(const SkMScalar* SK_RESTRICT a,
@@ skipping 839 matching lines @@
 void SkMatrix44::map2(const double src2[], int count, double dst4[]) const {
     static const Map2Procd gProc[] = {
         map2_id, map2_td, map2_sd, map2_sd, map2_ad, map2_ad, map2_ad, map2_ad
     };
 
     TypeMask mask = this->getType();
     Map2Procd proc = (mask & kPerspective_Mask) ? map2_pd : gProc[mask];
     proc(fMat, src2, count, dst4);
 }
 
+bool SkMatrix44::preserves2dAxisAlignment (SkMScalar epsilon) const {
+
+    // Can't check (mask & kPerspective_Mask) because Z isn't relevant here.
+    if (0 != perspX() || 0 != perspY()) return false;
+
+    // A matrix with two non-zeroish values in any of the upper right
+    // rows or columns will skew.  If only one value in each row or
+    // column is non-zeroish, we get a scale plus perhaps a 90-degree
+    // rotation.
+    int col0 = 0;
+    int col1 = 0;
+    int row0 = 0;
+    int row1 = 0;
+
+    // Must test against epsilon, not 0, because we can get values
+    // around 6e-17 in the matrix that "should" be 0.
+
+    if (SkMScalarAbs(fMat[0][0]) > epsilon) {
+        col0++;
+        row0++;
+    }
+    if (SkMScalarAbs(fMat[0][1]) > epsilon) {
+        col1++;
+        row0++;
+    }
+    if (SkMScalarAbs(fMat[1][0]) > epsilon) {
+        col0++;
+        row1++;
+    }
+    if (SkMScalarAbs(fMat[1][1]) > epsilon) {
+        col1++;
+        row1++;
+    }
+    if (col0 > 1 || col1 > 1 || row0 > 1 || row1 > 1) {
+        return false;

[reed1, 2014/09/26 18:34:28]

evil, but you could say for speed:

if ((col0 | col1 | row0 | row1) > 1) {
    return false;
}

+    }
+
+    return true;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkMatrix44::dump() const {
     static const char* format =
         "[%g %g %g %g][%g %g %g %g][%g %g %g %g][%g %g %g %g]\n";
 #if 0
     SkDebugf(format,
              fMat[0][0], fMat[1][0], fMat[2][0], fMat[3][0],
              fMat[0][1], fMat[1][1], fMat[2][1], fMat[3][1],
              fMat[0][2], fMat[1][2], fMat[2][2], fMat[3][2],
@@ skipping 53 matching lines @@
     dst[SkMatrix::kMSkewY]  = SkMScalarToScalar(fMat[0][1]);
     dst[SkMatrix::kMScaleY] = SkMScalarToScalar(fMat[1][1]);
     dst[SkMatrix::kMTransY] = SkMScalarToScalar(fMat[3][1]);
 
     dst[SkMatrix::kMPersp0] = SkMScalarToScalar(fMat[0][3]);
     dst[SkMatrix::kMPersp1] = SkMScalarToScalar(fMat[1][3]);
     dst[SkMatrix::kMPersp2] = SkMScalarToScalar(fMat[3][3]);
 
     return dst;
 }