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