Fix matrix similarity test on arm64

tests/MatrixTest.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 "SkMath.h"
 #include "SkMatrix.h"
 #include "SkMatrixUtils.h"
@@ skipping 227 matching lines @@
             }
             if (min > d) {
                 min = d;
             }
         }
         REPORTER_ASSERT(reporter, SkScalarDiv(max, maxScale) >= gCloseScaleTol);
         REPORTER_ASSERT(reporter, SkScalarDiv(minScale, min) >= gCloseScaleTol);
     }
 }
 
-static void test_matrix_is_similarity(skiatest::Reporter* reporter) {
+static void test_matrix_preserve_shape(skiatest::Reporter* reporter) {
     SkMatrix mat;
 
     // identity
     mat.setIdentity();
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // translation only
     mat.reset();
     mat.setTranslate(SkIntToScalar(100), SkIntToScalar(100));
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // scale with same size
     mat.reset();
     mat.setScale(SkIntToScalar(15), SkIntToScalar(15));
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // scale with one negative
     mat.reset();
     mat.setScale(SkIntToScalar(-15), SkIntToScalar(15));
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // scale with different size
     mat.reset();
     mat.setScale(SkIntToScalar(15), SkIntToScalar(20));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // scale with same size at a pivot point
     mat.reset();
     mat.setScale(SkIntToScalar(15), SkIntToScalar(15),
                  SkIntToScalar(2), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // scale with different size at a pivot point
     mat.reset();
     mat.setScale(SkIntToScalar(15), SkIntToScalar(20),
                  SkIntToScalar(2), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // skew with same size
     mat.reset();
     mat.setSkew(SkIntToScalar(15), SkIntToScalar(15));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
     // skew with different size
     mat.reset();
     mat.setSkew(SkIntToScalar(15), SkIntToScalar(20));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
     // skew with same size at a pivot point
     mat.reset();
     mat.setSkew(SkIntToScalar(15), SkIntToScalar(15),
                 SkIntToScalar(2), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
     // skew with different size at a pivot point
     mat.reset();
     mat.setSkew(SkIntToScalar(15), SkIntToScalar(20),
                 SkIntToScalar(2), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
     // perspective x
     mat.reset();
     mat.setPerspX(SkScalarToPersp(SK_Scalar1 / 2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
     // perspective y
     mat.reset();
     mat.setPerspY(SkScalarToPersp(SK_Scalar1 / 2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
     // rotate
     for (int angle = 0; angle < 360; ++angle) {
         mat.reset();
         mat.setRotate(SkIntToScalar(angle));
-#ifndef SK_CPU_ARM64
         REPORTER_ASSERT(reporter, mat.isSimilarity());
-#else
-        // 64-bit ARM devices built with -O2 and -ffp-contract=fast have a loss
-        // of precision and require that we have a higher tolerance
-        REPORTER_ASSERT(reporter, mat.isSimilarity(SK_ScalarNearlyZero + 0.00010113f));
-#endif
+        REPORTER_ASSERT(reporter, mat.preservesRightAngles());
     }
 
     // see if there are any accumulated precision issues
     mat.reset();
     for (int i = 1; i < 360; i++) {
         mat.postRotate(SkIntToScalar(1));
     }
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // rotate + translate
     mat.reset();
     mat.setRotate(SkIntToScalar(30));
     mat.postTranslate(SkIntToScalar(10), SkIntToScalar(20));
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // rotate + uniform scale
     mat.reset();
     mat.setRotate(SkIntToScalar(30));
     mat.postScale(SkIntToScalar(2), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // rotate + non-uniform scale
     mat.reset();
     mat.setRotate(SkIntToScalar(30));
     mat.postScale(SkIntToScalar(3), SkIntToScalar(2));
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
+
+    // non-uniform scale + rotate
+    mat.reset();
+    mat.setScale(SkIntToScalar(3), SkIntToScalar(2));
+    mat.postRotate(SkIntToScalar(30));
+    REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 
     // all zero
     mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, 0);
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
     // all zero except perspective
+    mat.reset();
     mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, SK_Scalar1);
     REPORTER_ASSERT(reporter, !mat.isSimilarity());
+    REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 
-    // scales zero, only skews
+    // scales zero, only skews (rotation)
+    mat.setAll(0, SK_Scalar1, 0,
+               -SK_Scalar1, 0, 0,
+               0, 0, SkMatrix::I()[8]);
+    REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
+
+    // scales zero, only skews (reflection)
     mat.setAll(0, SK_Scalar1, 0,
                SK_Scalar1, 0, 0,
                0, 0, SkMatrix::I()[8]);
     REPORTER_ASSERT(reporter, mat.isSimilarity());
+    REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 }
 
 // For test_matrix_decomposition, below.
 static bool scalar_nearly_equal_relative(SkScalar a, SkScalar b,
                                          SkScalar tolerance = SK_ScalarNearlyZero) {
     // from Bruce Dawson
     // absolute check
     SkScalar diff = SkScalarAbs(a - b);
     if (diff < tolerance) {
         return true;
@@ skipping 428 matching lines @@
     mat.set(SkMatrix::kMSkewX, -zero);
     REPORTER_ASSERT(reporter, are_equal(reporter, mat, mat2));
 
     mat2.reset();
     mat.reset();
     mat.set(SkMatrix::kMSkewX, SK_ScalarNaN);
     mat2.set(SkMatrix::kMSkewX, SK_ScalarNaN);
     REPORTER_ASSERT(reporter, !are_equal(reporter, mat, mat2));
 
     test_matrix_min_max_scale(reporter);
-    test_matrix_is_similarity(reporter);
+    test_matrix_preserve_shape(reporter);
     test_matrix_recttorect(reporter);
     test_matrix_decomposition(reporter);
     test_matrix_homogeneous(reporter);
 }
 
 DEF_TEST(Matrix_Concat, r) {
     SkMatrix a;
     a.setTranslate(10, 20);
 
     SkMatrix b;
     b.setScale(3, 5);
 
     SkMatrix expected;
     expected.setConcat(a,b);
 
     REPORTER_ASSERT(r, expected == SkMatrix::Concat(a, b));
 }