src/third_party/skia/tests/MatrixTest.cpp

   1 /*
   2  * Copyright 2011 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "SkMath.h"
   9 #include "SkMatrix.h"
  10 #include "SkMatrixUtils.h"
  11 #include "SkRandom.h"
  12 #include "Test.h"
  13
  14 static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
  15     const SkScalar tolerance = SK_Scalar1 / 200000;
  16     return SkScalarAbs(a - b) <= tolerance;
  17 }
  18
  19 static bool nearly_equal(const SkMatrix& a, const SkMatrix& b) {
  20     for (int i = 0; i < 9; i++) {
  21         if (!nearly_equal_scalar(a[i], b[i])) {
  22             SkDebugf("not equal %g %g\n", (float)a[i], (float)b[i]);
  23             return false;
  24         }
  25     }
  26     return true;
  27 }
  28
  29 static bool are_equal(skiatest::Reporter* reporter,
  30                       const SkMatrix& a,
  31                       const SkMatrix& b) {
  32     bool equal = a == b;
  33     bool cheapEqual = a.cheapEqualTo(b);
  34     if (equal != cheapEqual) {
  35         if (equal) {
  36             bool foundZeroSignDiff = false;
  37             for (int i = 0; i < 9; ++i) {
  38                 float aVal = a.get(i);
  39                 float bVal = b.get(i);
  40                 int aValI = *SkTCast<int*>(&aVal);
  41                 int bValI = *SkTCast<int*>(&bVal);
  42                 if (0 == aVal && 0 == bVal && aValI != bValI) {
  43                     foundZeroSignDiff = true;
  44                 } else {
  45                     REPORTER_ASSERT(reporter, aVal == bVal && aValI == aValI);
  46                 }
  47             }
  48             REPORTER_ASSERT(reporter, foundZeroSignDiff);
  49         } else {
  50             bool foundNaN = false;
  51             for (int i = 0; i < 9; ++i) {
  52                 float aVal = a.get(i);
  53                 float bVal = b.get(i);
  54                 int aValI = *SkTCast<int*>(&aVal);
  55                 int bValI = *SkTCast<int*>(&bVal);
  56                 if (sk_float_isnan(aVal) && aValI == bValI) {
  57                     foundNaN = true;
  58                 } else {
  59                     REPORTER_ASSERT(reporter, aVal == bVal && aValI == bValI);
  60                 }
  61             }
  62             REPORTER_ASSERT(reporter, foundNaN);
  63         }
  64     }
  65     return equal;
  66 }
  67
  68 static bool is_identity(const SkMatrix& m) {
  69     SkMatrix identity;
  70     identity.reset();
  71     return nearly_equal(m, identity);
  72 }
  73
  74 static void test_matrix_recttorect(skiatest::Reporter* reporter) {
  75     SkRect src, dst;
  76     SkMatrix matrix;
  77
  78     src.set(0, 0, SK_Scalar1*10, SK_Scalar1*10);
  79     dst = src;
  80     matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
  81     REPORTER_ASSERT(reporter, SkMatrix::kIdentity_Mask == matrix.getType());
  82     REPORTER_ASSERT(reporter, matrix.rectStaysRect());
  83
  84     dst.offset(SK_Scalar1, SK_Scalar1);
  85     matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
  86     REPORTER_ASSERT(reporter, SkMatrix::kTranslate_Mask == matrix.getType());
  87     REPORTER_ASSERT(reporter, matrix.rectStaysRect());
  88
  89     dst.fRight += SK_Scalar1;
  90     matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
  91     REPORTER_ASSERT(reporter,
  92                     (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask) == matrix.getType());
  93     REPORTER_ASSERT(reporter, matrix.rectStaysRect());
  94
  95     dst = src;
  96     dst.fRight = src.fRight * 2;
  97     matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
  98     REPORTER_ASSERT(reporter, SkMatrix::kScale_Mask == matrix.getType());
  99     REPORTER_ASSERT(reporter, matrix.rectStaysRect());
 100 }
 101
 102 static void test_flatten(skiatest::Reporter* reporter, const SkMatrix& m) {
 103     // add 100 in case we have a bug, I don't want to kill my stack in the test
 104     static const size_t kBufferSize = SkMatrix::kMaxFlattenSize + 100;
 105     char buffer[kBufferSize];
 106     size_t size1 = m.writeToMemory(NULL);
 107     size_t size2 = m.writeToMemory(buffer);
 108     REPORTER_ASSERT(reporter, size1 == size2);
 109     REPORTER_ASSERT(reporter, size1 <= SkMatrix::kMaxFlattenSize);
 110
 111     SkMatrix m2;
 112     size_t size3 = m2.readFromMemory(buffer, kBufferSize);
 113     REPORTER_ASSERT(reporter, size1 == size3);
 114     REPORTER_ASSERT(reporter, are_equal(reporter, m, m2));
 115
 116     char buffer2[kBufferSize];
 117     size3 = m2.writeToMemory(buffer2);
 118     REPORTER_ASSERT(reporter, size1 == size3);
 119     REPORTER_ASSERT(reporter, memcmp(buffer, buffer2, size1) == 0);
 120 }
 121
 122 static void test_matrix_min_max_scale(skiatest::Reporter* reporter) {
 123     SkScalar scales[2];
 124     bool success;
 125
 126     SkMatrix identity;
 127     identity.reset();
 128     REPORTER_ASSERT(reporter, SK_Scalar1 == identity.getMinScale());
 129     REPORTER_ASSERT(reporter, SK_Scalar1 == identity.getMaxScale());
 130     success = identity.getMinMaxScales(scales);
 131     REPORTER_ASSERT(reporter, success && SK_Scalar1 == scales[0] && SK_Scalar1 == scales[1]);
 132
 133     SkMatrix scale;
 134     scale.setScale(SK_Scalar1 * 2, SK_Scalar1 * 4);
 135     REPORTER_ASSERT(reporter, SK_Scalar1 * 2 == scale.getMinScale());
 136     REPORTER_ASSERT(reporter, SK_Scalar1 * 4 == scale.getMaxScale());
 137     success = scale.getMinMaxScales(scales);
 138     REPORTER_ASSERT(reporter, success && SK_Scalar1 * 2 == scales[0] && SK_Scalar1 * 4 == scales[1]);
 139
 140     SkMatrix rot90Scale;
 141     rot90Scale.setRotate(90 * SK_Scalar1);
 142     rot90Scale.postScale(SK_Scalar1 / 4, SK_Scalar1 / 2);
 143     REPORTER_ASSERT(reporter, SK_Scalar1 / 4 == rot90Scale.getMinScale());
 144     REPORTER_ASSERT(reporter, SK_Scalar1 / 2 == rot90Scale.getMaxScale());
 145     success = rot90Scale.getMinMaxScales(scales);
 146     REPORTER_ASSERT(reporter, success && SK_Scalar1 / 4  == scales[0] && SK_Scalar1 / 2 == scales[1]);
 147
 148     SkMatrix rotate;
 149     rotate.setRotate(128 * SK_Scalar1);
 150     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SK_Scalar1, rotate.getMinScale(), SK_ScalarNearlyZero));
 151     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SK_Scalar1, rotate.getMaxScale(), SK_ScalarNearlyZero));
 152     success = rotate.getMinMaxScales(scales);
 153     REPORTER_ASSERT(reporter, success);
 154     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SK_Scalar1, scales[0], SK_ScalarNearlyZero));
 155     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(SK_Scalar1, scales[1], SK_ScalarNearlyZero));
 156
 157     SkMatrix translate;
 158     translate.setTranslate(10 * SK_Scalar1, -5 * SK_Scalar1);
 159     REPORTER_ASSERT(reporter, SK_Scalar1 == translate.getMinScale());
 160     REPORTER_ASSERT(reporter, SK_Scalar1 == translate.getMaxScale());
 161     success = translate.getMinMaxScales(scales);
 162     REPORTER_ASSERT(reporter, success && SK_Scalar1 == scales[0] && SK_Scalar1 == scales[1]);
 163
 164     SkMatrix perspX;
 165     perspX.reset();
 166     perspX.setPerspX(SkScalarToPersp(SK_Scalar1 / 1000));
 167     REPORTER_ASSERT(reporter, -SK_Scalar1 == perspX.getMinScale());
 168     REPORTER_ASSERT(reporter, -SK_Scalar1 == perspX.getMaxScale());
 169     // Verify that getMinMaxScales() doesn't update the scales array on failure.
 170     scales[0] = -5;
 171     scales[1] = -5;
 172     success = perspX.getMinMaxScales(scales);
 173     REPORTER_ASSERT(reporter, !success && -5 * SK_Scalar1 == scales[0] && -5 * SK_Scalar1  == scales[1]);
 174
 175     SkMatrix perspY;
 176     perspY.reset();
 177     perspY.setPerspY(SkScalarToPersp(-SK_Scalar1 / 500));
 178     REPORTER_ASSERT(reporter, -SK_Scalar1 == perspY.getMinScale());
 179     REPORTER_ASSERT(reporter, -SK_Scalar1 == perspY.getMaxScale());
 180     scales[0] = -5;
 181     scales[1] = -5;
 182     success = perspY.getMinMaxScales(scales);
 183     REPORTER_ASSERT(reporter, !success && -5 * SK_Scalar1 == scales[0] && -5 * SK_Scalar1  == scales[1]);
 184
 185     SkMatrix baseMats[] = {scale, rot90Scale, rotate,
 186                            translate, perspX, perspY};
 187     SkMatrix mats[2*SK_ARRAY_COUNT(baseMats)];
 188     for (size_t i = 0; i < SK_ARRAY_COUNT(baseMats); ++i) {
 189         mats[i] = baseMats[i];
 190         bool invertable = mats[i].invert(&mats[i + SK_ARRAY_COUNT(baseMats)]);
 191         REPORTER_ASSERT(reporter, invertable);
 192     }
 193     SkRandom rand;
 194     for (int m = 0; m < 1000; ++m) {
 195         SkMatrix mat;
 196         mat.reset();
 197         for (int i = 0; i < 4; ++i) {
 198             int x = rand.nextU() % SK_ARRAY_COUNT(mats);
 199             mat.postConcat(mats[x]);
 200         }
 201
 202         SkScalar minScale = mat.getMinScale();
 203         SkScalar maxScale = mat.getMaxScale();
 204         REPORTER_ASSERT(reporter, (minScale < 0) == (maxScale < 0));
 205         REPORTER_ASSERT(reporter, (maxScale < 0) == mat.hasPerspective());
 206
 207         SkScalar scales[2];
 208         bool success = mat.getMinMaxScales(scales);
 209         REPORTER_ASSERT(reporter, success == !mat.hasPerspective());
 210         REPORTER_ASSERT(reporter, !success || (scales[0] == minScale && scales[1] == maxScale));
 211
 212         if (mat.hasPerspective()) {
 213             m -= 1; // try another non-persp matrix
 214             continue;
 215         }
 216
 217         // test a bunch of vectors. All should be scaled by between minScale and maxScale
 218         // (modulo some error) and we should find a vector that is scaled by almost each.
 219         static const SkScalar gVectorScaleTol = (105 * SK_Scalar1) / 100;
 220         static const SkScalar gCloseScaleTol = (97 * SK_Scalar1) / 100;
 221         SkScalar max = 0, min = SK_ScalarMax;
 222         SkVector vectors[1000];
 223         for (size_t i = 0; i < SK_ARRAY_COUNT(vectors); ++i) {
 224             vectors[i].fX = rand.nextSScalar1();
 225             vectors[i].fY = rand.nextSScalar1();
 226             if (!vectors[i].normalize()) {
 227                 i -= 1;
 228                 continue;
 229             }
 230         }
 231         mat.mapVectors(vectors, SK_ARRAY_COUNT(vectors));
 232         for (size_t i = 0; i < SK_ARRAY_COUNT(vectors); ++i) {
 233             SkScalar d = vectors[i].length();
 234             REPORTER_ASSERT(reporter, SkScalarDiv(d, maxScale) < gVectorScaleTol);
 235             REPORTER_ASSERT(reporter, SkScalarDiv(minScale, d) < gVectorScaleTol);
 236             if (max < d) {
 237                 max = d;
 238             }
 239             if (min > d) {
 240                 min = d;
 241             }
 242         }
 243         REPORTER_ASSERT(reporter, SkScalarDiv(max, maxScale) >= gCloseScaleTol);
 244         REPORTER_ASSERT(reporter, SkScalarDiv(minScale, min) >= gCloseScaleTol);
 245     }
 246 }
 247
 248 static void test_matrix_preserve_shape(skiatest::Reporter* reporter) {
 249     SkMatrix mat;
 250
 251     // identity
 252     mat.setIdentity();
 253     REPORTER_ASSERT(reporter, mat.isSimilarity());
 254     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 255
 256     // translation only
 257     mat.reset();
 258     mat.setTranslate(SkIntToScalar(100), SkIntToScalar(100));
 259     REPORTER_ASSERT(reporter, mat.isSimilarity());
 260     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 261
 262     // scale with same size
 263     mat.reset();
 264     mat.setScale(SkIntToScalar(15), SkIntToScalar(15));
 265     REPORTER_ASSERT(reporter, mat.isSimilarity());
 266     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 267
 268     // scale with one negative
 269     mat.reset();
 270     mat.setScale(SkIntToScalar(-15), SkIntToScalar(15));
 271     REPORTER_ASSERT(reporter, mat.isSimilarity());
 272     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 273
 274     // scale with different size
 275     mat.reset();
 276     mat.setScale(SkIntToScalar(15), SkIntToScalar(20));
 277     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 278     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 279
 280     // scale with same size at a pivot point
 281     mat.reset();
 282     mat.setScale(SkIntToScalar(15), SkIntToScalar(15),
 283                  SkIntToScalar(2), SkIntToScalar(2));
 284     REPORTER_ASSERT(reporter, mat.isSimilarity());
 285     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 286
 287     // scale with different size at a pivot point
 288     mat.reset();
 289     mat.setScale(SkIntToScalar(15), SkIntToScalar(20),
 290                  SkIntToScalar(2), SkIntToScalar(2));
 291     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 292     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 293
 294     // skew with same size
 295     mat.reset();
 296     mat.setSkew(SkIntToScalar(15), SkIntToScalar(15));
 297     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 298     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 299
 300     // skew with different size
 301     mat.reset();
 302     mat.setSkew(SkIntToScalar(15), SkIntToScalar(20));
 303     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 304     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 305
 306     // skew with same size at a pivot point
 307     mat.reset();
 308     mat.setSkew(SkIntToScalar(15), SkIntToScalar(15),
 309                 SkIntToScalar(2), SkIntToScalar(2));
 310     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 311     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 312
 313     // skew with different size at a pivot point
 314     mat.reset();
 315     mat.setSkew(SkIntToScalar(15), SkIntToScalar(20),
 316                 SkIntToScalar(2), SkIntToScalar(2));
 317     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 318     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 319
 320     // perspective x
 321     mat.reset();
 322     mat.setPerspX(SkScalarToPersp(SK_Scalar1 / 2));
 323     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 324     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 325
 326     // perspective y
 327     mat.reset();
 328     mat.setPerspY(SkScalarToPersp(SK_Scalar1 / 2));
 329     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 330     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 331
 332     // rotate
 333     for (int angle = 0; angle < 360; ++angle) {
 334         mat.reset();
 335         mat.setRotate(SkIntToScalar(angle));
 336         REPORTER_ASSERT(reporter, mat.isSimilarity());
 337         REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 338     }
 339
 340     // see if there are any accumulated precision issues
 341     mat.reset();
 342     for (int i = 1; i < 360; i++) {
 343         mat.postRotate(SkIntToScalar(1));
 344     }
 345     REPORTER_ASSERT(reporter, mat.isSimilarity());
 346     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 347
 348     // rotate + translate
 349     mat.reset();
 350     mat.setRotate(SkIntToScalar(30));
 351     mat.postTranslate(SkIntToScalar(10), SkIntToScalar(20));
 352     REPORTER_ASSERT(reporter, mat.isSimilarity());
 353     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 354
 355     // rotate + uniform scale
 356     mat.reset();
 357     mat.setRotate(SkIntToScalar(30));
 358     mat.postScale(SkIntToScalar(2), SkIntToScalar(2));
 359     REPORTER_ASSERT(reporter, mat.isSimilarity());
 360     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 361
 362     // rotate + non-uniform scale
 363     mat.reset();
 364     mat.setRotate(SkIntToScalar(30));
 365     mat.postScale(SkIntToScalar(3), SkIntToScalar(2));
 366     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 367     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 368
 369     // non-uniform scale + rotate
 370     mat.reset();
 371     mat.setScale(SkIntToScalar(3), SkIntToScalar(2));
 372     mat.postRotate(SkIntToScalar(30));
 373     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 374     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 375
 376     // all zero
 377     mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, 0);
 378     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 379     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 380
 381     // all zero except perspective
 382     mat.reset();
 383     mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, SK_Scalar1);
 384     REPORTER_ASSERT(reporter, !mat.isSimilarity());
 385     REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
 386
 387     // scales zero, only skews (rotation)
 388     mat.setAll(0, SK_Scalar1, 0,
 389                -SK_Scalar1, 0, 0,
 390                0, 0, SkMatrix::I()[8]);
 391     REPORTER_ASSERT(reporter, mat.isSimilarity());
 392     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 393
 394     // scales zero, only skews (reflection)
 395     mat.setAll(0, SK_Scalar1, 0,
 396                SK_Scalar1, 0, 0,
 397                0, 0, SkMatrix::I()[8]);
 398     REPORTER_ASSERT(reporter, mat.isSimilarity());
 399     REPORTER_ASSERT(reporter, mat.preservesRightAngles());
 400 }
 401
 402 // For test_matrix_decomposition, below.
 403 static bool scalar_nearly_equal_relative(SkScalar a, SkScalar b,
 404                                          SkScalar tolerance = SK_ScalarNearlyZero) {
 405     // from Bruce Dawson
 406     // absolute check
 407     SkScalar diff = SkScalarAbs(a - b);
 408     if (diff < tolerance) {
 409         return true;
 410     }
 411
 412     // relative check
 413     a = SkScalarAbs(a);
 414     b = SkScalarAbs(b);
 415     SkScalar largest = (b > a) ? b : a;
 416
 417     if (diff <= largest*tolerance) {
 418         return true;
 419     }
 420
 421     return false;
 422 }
 423
 424 static bool check_matrix_recomposition(const SkMatrix& mat,
 425                                        const SkPoint& rotation1,
 426                                        const SkPoint& scale,
 427                                        const SkPoint& rotation2) {
 428     SkScalar c1 = rotation1.fX;
 429     SkScalar s1 = rotation1.fY;
 430     SkScalar scaleX = scale.fX;
 431     SkScalar scaleY = scale.fY;
 432     SkScalar c2 = rotation2.fX;
 433     SkScalar s2 = rotation2.fY;
 434
 435     // We do a relative check here because large scale factors cause problems with an absolute check
 436     bool result = scalar_nearly_equal_relative(mat[SkMatrix::kMScaleX],
 437                                                scaleX*c1*c2 - scaleY*s1*s2) &&
 438                   scalar_nearly_equal_relative(mat[SkMatrix::kMSkewX],
 439                                                -scaleX*s1*c2 - scaleY*c1*s2) &&
 440                   scalar_nearly_equal_relative(mat[SkMatrix::kMSkewY],
 441                                                scaleX*c1*s2 + scaleY*s1*c2) &&
 442                   scalar_nearly_equal_relative(mat[SkMatrix::kMScaleY],
 443                                                -scaleX*s1*s2 + scaleY*c1*c2);
 444     return result;
 445 }
 446
 447 static void test_matrix_decomposition(skiatest::Reporter* reporter) {
 448     SkMatrix mat;
 449     SkPoint rotation1, scale, rotation2;
 450
 451     const float kRotation0 = 15.5f;
 452     const float kRotation1 = -50.f;
 453     const float kScale0 = 5000.f;
 454     const float kScale1 = 0.001f;
 455
 456     // identity
 457     mat.reset();
 458     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 459     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 460     // make sure it doesn't crash if we pass in NULLs
 461     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, NULL, NULL, NULL));
 462
 463     // rotation only
 464     mat.setRotate(kRotation0);
 465     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 466     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 467
 468     // uniform scale only
 469     mat.setScale(kScale0, kScale0);
 470     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 471     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 472
 473     // anisotropic scale only
 474     mat.setScale(kScale1, kScale0);
 475     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 476     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 477
 478     // rotation then uniform scale
 479     mat.setRotate(kRotation1);
 480     mat.postScale(kScale0, kScale0);
 481     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 482     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 483
 484     // uniform scale then rotation
 485     mat.setScale(kScale0, kScale0);
 486     mat.postRotate(kRotation1);
 487     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 488     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 489
 490     // rotation then uniform scale+reflection
 491     mat.setRotate(kRotation0);
 492     mat.postScale(kScale1, -kScale1);
 493     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 494     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 495
 496     // uniform scale+reflection, then rotate
 497     mat.setScale(kScale0, -kScale0);
 498     mat.postRotate(kRotation1);
 499     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 500     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 501
 502     // rotation then anisotropic scale
 503     mat.setRotate(kRotation1);
 504     mat.postScale(kScale1, kScale0);
 505     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 506     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 507
 508     // rotation then anisotropic scale
 509     mat.setRotate(90);
 510     mat.postScale(kScale1, kScale0);
 511     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 512     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 513
 514     // anisotropic scale then rotation
 515     mat.setScale(kScale1, kScale0);
 516     mat.postRotate(kRotation0);
 517     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 518     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 519
 520     // anisotropic scale then rotation
 521     mat.setScale(kScale1, kScale0);
 522     mat.postRotate(90);
 523     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 524     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 525
 526     // rotation, uniform scale, then different rotation
 527     mat.setRotate(kRotation1);
 528     mat.postScale(kScale0, kScale0);
 529     mat.postRotate(kRotation0);
 530     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 531     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 532
 533     // rotation, anisotropic scale, then different rotation
 534     mat.setRotate(kRotation0);
 535     mat.postScale(kScale1, kScale0);
 536     mat.postRotate(kRotation1);
 537     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 538     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 539
 540     // rotation, anisotropic scale + reflection, then different rotation
 541     mat.setRotate(kRotation0);
 542     mat.postScale(-kScale1, kScale0);
 543     mat.postRotate(kRotation1);
 544     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 545     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 546
 547     // try some random matrices
 548     SkRandom rand;
 549     for (int m = 0; m < 1000; ++m) {
 550         SkScalar rot0 = rand.nextRangeF(-180, 180);
 551         SkScalar sx = rand.nextRangeF(-3000.f, 3000.f);
 552         SkScalar sy = rand.nextRangeF(-3000.f, 3000.f);
 553         SkScalar rot1 = rand.nextRangeF(-180, 180);
 554         mat.setRotate(rot0);
 555         mat.postScale(sx, sy);
 556         mat.postRotate(rot1);
 557
 558         if (SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2)) {
 559             REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 560         } else {
 561             // if the matrix is degenerate, the basis vectors should be near-parallel or near-zero
 562             SkScalar perpdot = mat[SkMatrix::kMScaleX]*mat[SkMatrix::kMScaleY] -
 563                                mat[SkMatrix::kMSkewX]*mat[SkMatrix::kMSkewY];
 564             REPORTER_ASSERT(reporter, SkScalarNearlyZero(perpdot));
 565         }
 566     }
 567
 568     // translation shouldn't affect this
 569     mat.postTranslate(-1000.f, 1000.f);
 570     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 571     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 572
 573     // perspective shouldn't affect this
 574     mat[SkMatrix::kMPersp0] = 12.f;
 575     mat[SkMatrix::kMPersp1] = 4.f;
 576     mat[SkMatrix::kMPersp2] = 1872.f;
 577     REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 578     REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
 579
 580     // degenerate matrices
 581     // mostly zero entries
 582     mat.reset();
 583     mat[SkMatrix::kMScaleX] = 0.f;
 584     REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 585     mat.reset();
 586     mat[SkMatrix::kMScaleY] = 0.f;
 587     REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 588     mat.reset();
 589     // linearly dependent entries
 590     mat[SkMatrix::kMScaleX] = 1.f;
 591     mat[SkMatrix::kMSkewX] = 2.f;
 592     mat[SkMatrix::kMSkewY] = 4.f;
 593     mat[SkMatrix::kMScaleY] = 8.f;
 594     REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
 595 }
 596
 597 // For test_matrix_homogeneous, below.
 598 static bool scalar_array_nearly_equal_relative(const SkScalar a[], const SkScalar b[], int count) {
 599     for (int i = 0; i < count; ++i) {
 600         if (!scalar_nearly_equal_relative(a[i], b[i])) {
 601             return false;
 602         }
 603     }
 604     return true;
 605 }
 606
 607 // For test_matrix_homogeneous, below.
 608 // Maps a single triple in src using m and compares results to those in dst
 609 static bool naive_homogeneous_mapping(const SkMatrix& m, const SkScalar src[3],
 610                                       const SkScalar dst[3]) {
 611     SkScalar res[3];
 612     SkScalar ms[9] = {m[0], m[1], m[2],
 613                       m[3], m[4], m[5],
 614                       m[6], m[7], m[8]};
 615     res[0] = src[0] * ms[0] + src[1] * ms[1] + src[2] * ms[2];
 616     res[1] = src[0] * ms[3] + src[1] * ms[4] + src[2] * ms[5];
 617     res[2] = src[0] * ms[6] + src[1] * ms[7] + src[2] * ms[8];
 618     return scalar_array_nearly_equal_relative(res, dst, 3);
 619 }
 620
 621 static void test_matrix_homogeneous(skiatest::Reporter* reporter) {
 622     SkMatrix mat;
 623
 624     const float kRotation0 = 15.5f;
 625     const float kRotation1 = -50.f;
 626     const float kScale0 = 5000.f;
 627
 628     const int kTripleCount = 1000;
 629     const int kMatrixCount = 1000;
 630     SkRandom rand;
 631
 632     SkScalar randTriples[3*kTripleCount];
 633     for (int i = 0; i < 3*kTripleCount; ++i) {
 634         randTriples[i] = rand.nextRangeF(-3000.f, 3000.f);
 635     }
 636
 637     SkMatrix mats[kMatrixCount];
 638     for (int i = 0; i < kMatrixCount; ++i) {
 639         for (int j = 0; j < 9; ++j) {
 640             mats[i].set(j, rand.nextRangeF(-3000.f, 3000.f));
 641         }
 642     }
 643
 644     // identity
 645     {
 646     mat.reset();
 647     SkScalar dst[3*kTripleCount];
 648     mat.mapHomogeneousPoints(dst, randTriples, kTripleCount);
 649     REPORTER_ASSERT(reporter, scalar_array_nearly_equal_relative(randTriples, dst, kTripleCount*3));
 650     }
 651
 652     // zero matrix
 653     {
 654     mat.setAll(0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
 655     SkScalar dst[3*kTripleCount];
 656     mat.mapHomogeneousPoints(dst, randTriples, kTripleCount);
 657     SkScalar zeros[3] = {0.f, 0.f, 0.f};
 658     for (int i = 0; i < kTripleCount; ++i) {
 659         REPORTER_ASSERT(reporter, scalar_array_nearly_equal_relative(&dst[i*3], zeros, 3));
 660     }
 661     }
 662
 663     // zero point
 664     {
 665     SkScalar zeros[3] = {0.f, 0.f, 0.f};
 666     for (int i = 0; i < kMatrixCount; ++i) {
 667         SkScalar dst[3];
 668         mats[i].mapHomogeneousPoints(dst, zeros, 1);
 669         REPORTER_ASSERT(reporter, scalar_array_nearly_equal_relative(dst, zeros, 3));
 670     }
 671     }
 672
 673     // doesn't crash with null dst, src, count == 0
 674     {
 675     mats[0].mapHomogeneousPoints(NULL, NULL, 0);
 676     }
 677
 678     // uniform scale of point
 679     {
 680     mat.setScale(kScale0, kScale0);
 681     SkScalar dst[3];
 682     SkScalar src[3] = {randTriples[0], randTriples[1], 1.f};
 683     SkPoint pnt;
 684     pnt.set(src[0], src[1]);
 685     mat.mapHomogeneousPoints(dst, src, 1);
 686     mat.mapPoints(&pnt, &pnt, 1);
 687     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[0], pnt.fX));
 688     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[1], pnt.fY));
 689     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[2], SK_Scalar1));
 690     }
 691
 692     // rotation of point
 693     {
 694     mat.setRotate(kRotation0);
 695     SkScalar dst[3];
 696     SkScalar src[3] = {randTriples[0], randTriples[1], 1.f};
 697     SkPoint pnt;
 698     pnt.set(src[0], src[1]);
 699     mat.mapHomogeneousPoints(dst, src, 1);
 700     mat.mapPoints(&pnt, &pnt, 1);
 701     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[0], pnt.fX));
 702     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[1], pnt.fY));
 703     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[2], SK_Scalar1));
 704     }
 705
 706     // rotation, scale, rotation of point
 707     {
 708     mat.setRotate(kRotation1);
 709     mat.postScale(kScale0, kScale0);
 710     mat.postRotate(kRotation0);
 711     SkScalar dst[3];
 712     SkScalar src[3] = {randTriples[0], randTriples[1], 1.f};
 713     SkPoint pnt;
 714     pnt.set(src[0], src[1]);
 715     mat.mapHomogeneousPoints(dst, src, 1);
 716     mat.mapPoints(&pnt, &pnt, 1);
 717     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[0], pnt.fX));
 718     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[1], pnt.fY));
 719     REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst[2], SK_Scalar1));
 720     }
 721
 722     // compare with naive approach
 723     {
 724     for (int i = 0; i < kMatrixCount; ++i) {
 725         for (int j = 0; j < kTripleCount; ++j) {
 726             SkScalar dst[3];
 727             mats[i].mapHomogeneousPoints(dst, &randTriples[j*3], 1);
 728             REPORTER_ASSERT(reporter, naive_homogeneous_mapping(mats[i], &randTriples[j*3], dst));
 729         }
 730     }
 731     }
 732
 733 }
 734
 735 DEF_TEST(Matrix, reporter) {
 736     SkMatrix    mat, inverse, iden1, iden2;
 737
 738     mat.reset();
 739     mat.setTranslate(SK_Scalar1, SK_Scalar1);
 740     REPORTER_ASSERT(reporter, mat.invert(&inverse));
 741     iden1.setConcat(mat, inverse);
 742     REPORTER_ASSERT(reporter, is_identity(iden1));
 743
 744     mat.setScale(SkIntToScalar(2), SkIntToScalar(4));
 745     REPORTER_ASSERT(reporter, mat.invert(&inverse));
 746     iden1.setConcat(mat, inverse);
 747     REPORTER_ASSERT(reporter, is_identity(iden1));
 748     test_flatten(reporter, mat);
 749
 750     mat.setScale(SK_Scalar1/2, SkIntToScalar(2));
 751     REPORTER_ASSERT(reporter, mat.invert(&inverse));
 752     iden1.setConcat(mat, inverse);
 753     REPORTER_ASSERT(reporter, is_identity(iden1));
 754     test_flatten(reporter, mat);
 755
 756     mat.setScale(SkIntToScalar(3), SkIntToScalar(5), SkIntToScalar(20), 0);
 757     mat.postRotate(SkIntToScalar(25));
 758     REPORTER_ASSERT(reporter, mat.invert(NULL));
 759     REPORTER_ASSERT(reporter, mat.invert(&inverse));
 760     iden1.setConcat(mat, inverse);
 761     REPORTER_ASSERT(reporter, is_identity(iden1));
 762     iden2.setConcat(inverse, mat);
 763     REPORTER_ASSERT(reporter, is_identity(iden2));
 764     test_flatten(reporter, mat);
 765     test_flatten(reporter, iden2);
 766
 767     mat.setScale(0, SK_Scalar1);
 768     REPORTER_ASSERT(reporter, !mat.invert(NULL));
 769     REPORTER_ASSERT(reporter, !mat.invert(&inverse));
 770     mat.setScale(SK_Scalar1, 0);
 771     REPORTER_ASSERT(reporter, !mat.invert(NULL));
 772     REPORTER_ASSERT(reporter, !mat.invert(&inverse));
 773
 774     // rectStaysRect test
 775     {
 776         static const struct {
 777             SkScalar    m00, m01, m10, m11;
 778             bool        mStaysRect;
 779         }
 780         gRectStaysRectSamples[] = {
 781             {          0,          0,          0,           0, false },
 782             {          0,          0,          0,  SK_Scalar1, false },
 783             {          0,          0, SK_Scalar1,           0, false },
 784             {          0,          0, SK_Scalar1,  SK_Scalar1, false },
 785             {          0, SK_Scalar1,          0,           0, false },
 786             {          0, SK_Scalar1,          0,  SK_Scalar1, false },
 787             {          0, SK_Scalar1, SK_Scalar1,           0, true },
 788             {          0, SK_Scalar1, SK_Scalar1,  SK_Scalar1, false },
 789             { SK_Scalar1,          0,          0,           0, false },
 790             { SK_Scalar1,          0,          0,  SK_Scalar1, true },
 791             { SK_Scalar1,          0, SK_Scalar1,           0, false },
 792             { SK_Scalar1,          0, SK_Scalar1,  SK_Scalar1, false },
 793             { SK_Scalar1, SK_Scalar1,          0,           0, false },
 794             { SK_Scalar1, SK_Scalar1,          0,  SK_Scalar1, false },
 795             { SK_Scalar1, SK_Scalar1, SK_Scalar1,           0, false },
 796             { SK_Scalar1, SK_Scalar1, SK_Scalar1,  SK_Scalar1, false }
 797         };
 798
 799         for (size_t i = 0; i < SK_ARRAY_COUNT(gRectStaysRectSamples); i++) {
 800             SkMatrix    m;
 801
 802             m.reset();
 803             m.set(SkMatrix::kMScaleX, gRectStaysRectSamples[i].m00);
 804             m.set(SkMatrix::kMSkewX,  gRectStaysRectSamples[i].m01);
 805             m.set(SkMatrix::kMSkewY,  gRectStaysRectSamples[i].m10);
 806             m.set(SkMatrix::kMScaleY, gRectStaysRectSamples[i].m11);
 807             REPORTER_ASSERT(reporter,
 808                     m.rectStaysRect() == gRectStaysRectSamples[i].mStaysRect);
 809         }
 810     }
 811
 812     mat.reset();
 813     mat.set(SkMatrix::kMScaleX, SkIntToScalar(1));
 814     mat.set(SkMatrix::kMSkewX,  SkIntToScalar(2));
 815     mat.set(SkMatrix::kMTransX, SkIntToScalar(3));
 816     mat.set(SkMatrix::kMSkewY,  SkIntToScalar(4));
 817     mat.set(SkMatrix::kMScaleY, SkIntToScalar(5));
 818     mat.set(SkMatrix::kMTransY, SkIntToScalar(6));
 819     SkScalar affine[6];
 820     REPORTER_ASSERT(reporter, mat.asAffine(affine));
 821
 822     #define affineEqual(e) affine[SkMatrix::kA##e] == mat.get(SkMatrix::kM##e)
 823     REPORTER_ASSERT(reporter, affineEqual(ScaleX));
 824     REPORTER_ASSERT(reporter, affineEqual(SkewY));
 825     REPORTER_ASSERT(reporter, affineEqual(SkewX));
 826     REPORTER_ASSERT(reporter, affineEqual(ScaleY));
 827     REPORTER_ASSERT(reporter, affineEqual(TransX));
 828     REPORTER_ASSERT(reporter, affineEqual(TransY));
 829     #undef affineEqual
 830
 831     mat.set(SkMatrix::kMPersp1, SkScalarToPersp(SK_Scalar1 / 2));
 832     REPORTER_ASSERT(reporter, !mat.asAffine(affine));
 833
 834     SkMatrix mat2;
 835     mat2.reset();
 836     mat.reset();
 837     SkScalar zero = 0;
 838     mat.set(SkMatrix::kMSkewX, -zero);
 839     REPORTER_ASSERT(reporter, are_equal(reporter, mat, mat2));
 840
 841     mat2.reset();
 842     mat.reset();
 843     mat.set(SkMatrix::kMSkewX, SK_ScalarNaN);
 844     mat2.set(SkMatrix::kMSkewX, SK_ScalarNaN);
 845     REPORTER_ASSERT(reporter, !are_equal(reporter, mat, mat2));
 846
 847     test_matrix_min_max_scale(reporter);
 848     test_matrix_preserve_shape(reporter);
 849     test_matrix_recttorect(reporter);
 850     test_matrix_decomposition(reporter);
 851     test_matrix_homogeneous(reporter);
 852 }
 853
 854 DEF_TEST(Matrix_Concat, r) {
 855     SkMatrix a;
 856     a.setTranslate(10, 20);
 857
 858     SkMatrix b;
 859     b.setScale(3, 5);
 860
 861     SkMatrix expected;
 862     expected.setConcat(a,b);
 863
 864     REPORTER_ASSERT(r, expected == SkMatrix::Concat(a, b));
 865 }