SkMatrix44::preserves2dAxisAlignment()

include/utils/SkMatrix44.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkMatrix44_DEFINED
 #define SkMatrix44_DEFINED
 
@@ skipping 11 matching lines @@
     }
     static inline float SkMScalarToFloat(double x) {
         return static_cast<float>(x);
     }
     static inline double SkDoubleToMScalar(double x) {
         return x;
     }
     static inline double SkMScalarToDouble(double x) {
         return x;
     }
+    static inline double SkMScalarAbs(double x) {
+        return fabs(x);
+    }
     static const SkMScalar SK_MScalarPI = 3.141592653589793;
 #elif defined SK_MSCALAR_IS_FLOAT
 #ifdef SK_MSCALAR_IS_DOUBLE
     #error "can't define MSCALAR both as DOUBLE and FLOAT"
 #endif
     typedef float SkMScalar;
 
     static inline float SkFloatToMScalar(float x) {
         return x;
     }
     static inline float SkMScalarToFloat(float x) {
         return x;
     }
     static inline float SkDoubleToMScalar(double x) {
         return static_cast<float>(x);
     }
     static inline double SkMScalarToDouble(float x) {
         return static_cast<double>(x);
     }
+    static inline float SkMScalarAbs(float x) {
+        return sk_float_abs(x);
+    }
     static const SkMScalar SK_MScalarPI = 3.14159265f;
 #endif
 
 #define SkMScalarToScalar SkMScalarToFloat
 #define SkScalarToMScalar SkFloatToMScalar
 
 static const SkMScalar SK_MScalar1 = 1;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 309 matching lines @@
      *  map an array of [x, y, 0, 1] through the matrix, returning an array
      *  of [x', y', z', w'].
      *
      *  @param src2     array of [x, y] pairs, with implied z=0 and w=1
      *  @param count    number of [x, y] pairs in src2
      *  @param dst4     array of [x', y', z', w'] quads as the output.
      */
     void map2(const float src2[], int count, float dst4[]) const;
     void map2(const double src2[], int count, double dst4[]) const;
 
+    /** Returns true if transformating an axis-aligned square in 2d by this matrix
+        will produce another 2d axis-aligned square; typically means the matrix
+        is a scale with perhaps a 90-degree rotation. A 3d rotation through 90
+        degrees into a perpendicular plane collapses a square to a line, but
+        is still considered to be axis-aligned.
+
+        By default, tolerates very slight error due to float imprecisions;
+        a 90-degree rotation can still end up with 10^-17 of
+        "non-axis-aligned" result.
+     */
+    bool preserves2dAxisAlignment(SkMScalar epsilon = SK_ScalarNearlyZero) const;
+
     void dump() const;
 
     double determinant() const;
 
 private:
     SkMScalar           fMat[4][4];
     mutable unsigned    fTypeMask;
 
     enum {
         kUnknown_Mask = 0x80,
@@ skipping 27 matching lines @@
     /**
      *  Does not take the time to 'compute' the typemask. Only returns true if
      *  we already know that this matrix is identity.
      */
     inline bool isTriviallyIdentity() const {
         return 0 == fTypeMask;
     }
 };
 
 #endif