blob: b44f1135f04adccc6152d5acb26c703f9d71c81c [file] [log] [blame]
epoger@google.comec3ed6a2011-07-28 14:26:00 +00001/*
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 */
tfarina@chromium.orge4fafb12013-12-12 21:11:12 +00007
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "include/core/SkMath.h"
9#include "include/core/SkPoint3.h"
10#include "include/utils/SkRandom.h"
11#include "src/core/SkMatrixPriv.h"
12#include "src/core/SkMatrixUtils.h"
13#include "tests/Test.h"
reed@android.comed673312009-02-27 16:24:51 +000014
15static bool nearly_equal_scalar(SkScalar a, SkScalar b) {
epoger@google.com2047f002011-05-17 17:36:59 +000016 const SkScalar tolerance = SK_Scalar1 / 200000;
reed@android.comed673312009-02-27 16:24:51 +000017 return SkScalarAbs(a - b) <= tolerance;
18}
19
20static bool nearly_equal(const SkMatrix& a, const SkMatrix& b) {
21 for (int i = 0; i < 9; i++) {
22 if (!nearly_equal_scalar(a[i], b[i])) {
Robert Phillipsc100d482018-07-10 10:11:01 -040023 SkDebugf("matrices not equal [%d] %g %g\n", i, (float)a[i], (float)b[i]);
reed@android.comed673312009-02-27 16:24:51 +000024 return false;
25 }
26 }
27 return true;
28}
29
Mike Kleine72e7732018-06-14 14:41:22 -040030static int float_bits(float f) {
31 int result;
32 memcpy(&result, &f, 4);
33 return result;
34}
35
bsalomon@google.com8fe84b52012-03-26 15:24:27 +000036static bool are_equal(skiatest::Reporter* reporter,
37 const SkMatrix& a,
38 const SkMatrix& b) {
39 bool equal = a == b;
Mike Reed2c383152019-12-18 16:47:47 -050040 bool cheapEqual = SkMatrixPriv::CheapEqual(a, b);
bsalomon@google.com8fe84b52012-03-26 15:24:27 +000041 if (equal != cheapEqual) {
bsalomon@google.com39d4f3a2012-03-26 17:25:45 +000042 if (equal) {
bsalomon@google.com8fe84b52012-03-26 15:24:27 +000043 bool foundZeroSignDiff = false;
44 for (int i = 0; i < 9; ++i) {
45 float aVal = a.get(i);
46 float bVal = b.get(i);
Mike Kleine72e7732018-06-14 14:41:22 -040047 int aValI = float_bits(aVal);
48 int bValI = float_bits(bVal);
bsalomon@google.com8fe84b52012-03-26 15:24:27 +000049 if (0 == aVal && 0 == bVal && aValI != bValI) {
50 foundZeroSignDiff = true;
51 } else {
halcanarye76ca8b2016-05-20 10:36:50 -070052 REPORTER_ASSERT(reporter, aVal == bVal && aValI == bValI);
bsalomon@google.com8fe84b52012-03-26 15:24:27 +000053 }
54 }
55 REPORTER_ASSERT(reporter, foundZeroSignDiff);
56 } else {
57 bool foundNaN = false;
58 for (int i = 0; i < 9; ++i) {
59 float aVal = a.get(i);
60 float bVal = b.get(i);
Mike Kleine72e7732018-06-14 14:41:22 -040061 int aValI = float_bits(aVal);
62 int bValI = float_bits(bVal);
bsalomon@google.com8fe84b52012-03-26 15:24:27 +000063 if (sk_float_isnan(aVal) && aValI == bValI) {
64 foundNaN = true;
65 } else {
66 REPORTER_ASSERT(reporter, aVal == bVal && aValI == bValI);
67 }
68 }
69 REPORTER_ASSERT(reporter, foundNaN);
70 }
bsalomon@google.com8fe84b52012-03-26 15:24:27 +000071 }
72 return equal;
73}
74
reed@android.comed673312009-02-27 16:24:51 +000075static bool is_identity(const SkMatrix& m) {
76 SkMatrix identity;
reed@android.com80e39a72009-04-02 16:59:40 +000077 identity.reset();
reed@android.comed673312009-02-27 16:24:51 +000078 return nearly_equal(m, identity);
79}
80
reed451e8222014-12-13 08:46:48 -080081static void assert9(skiatest::Reporter* reporter, const SkMatrix& m,
82 SkScalar a, SkScalar b, SkScalar c,
83 SkScalar d, SkScalar e, SkScalar f,
84 SkScalar g, SkScalar h, SkScalar i) {
85 SkScalar buffer[9];
86 m.get9(buffer);
87 REPORTER_ASSERT(reporter, buffer[0] == a);
88 REPORTER_ASSERT(reporter, buffer[1] == b);
89 REPORTER_ASSERT(reporter, buffer[2] == c);
90 REPORTER_ASSERT(reporter, buffer[3] == d);
91 REPORTER_ASSERT(reporter, buffer[4] == e);
92 REPORTER_ASSERT(reporter, buffer[5] == f);
93 REPORTER_ASSERT(reporter, buffer[6] == g);
94 REPORTER_ASSERT(reporter, buffer[7] == h);
95 REPORTER_ASSERT(reporter, buffer[8] == i);
96}
97
98static void test_set9(skiatest::Reporter* reporter) {
99
100 SkMatrix m;
101 m.reset();
102 assert9(reporter, m, 1, 0, 0, 0, 1, 0, 0, 0, 1);
halcanary9d524f22016-03-29 09:03:52 -0700103
reed451e8222014-12-13 08:46:48 -0800104 m.setScale(2, 3);
105 assert9(reporter, m, 2, 0, 0, 0, 3, 0, 0, 0, 1);
halcanary9d524f22016-03-29 09:03:52 -0700106
reed451e8222014-12-13 08:46:48 -0800107 m.postTranslate(4, 5);
108 assert9(reporter, m, 2, 0, 4, 0, 3, 5, 0, 0, 1);
109
110 SkScalar buffer[9];
111 sk_bzero(buffer, sizeof(buffer));
112 buffer[SkMatrix::kMScaleX] = 1;
113 buffer[SkMatrix::kMScaleY] = 1;
114 buffer[SkMatrix::kMPersp2] = 1;
115 REPORTER_ASSERT(reporter, !m.isIdentity());
116 m.set9(buffer);
117 REPORTER_ASSERT(reporter, m.isIdentity());
118}
119
reed@google.com97cd69c2012-10-12 14:35:48 +0000120static void test_matrix_recttorect(skiatest::Reporter* reporter) {
121 SkRect src, dst;
122 SkMatrix matrix;
skia.committer@gmail.comf57c01b2012-10-13 02:01:56 +0000123
Mike Reed92b33352019-08-24 19:39:13 -0400124 src.setLTRB(0, 0, 10, 10);
reed@google.com97cd69c2012-10-12 14:35:48 +0000125 dst = src;
126 matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
127 REPORTER_ASSERT(reporter, SkMatrix::kIdentity_Mask == matrix.getType());
128 REPORTER_ASSERT(reporter, matrix.rectStaysRect());
skia.committer@gmail.comf57c01b2012-10-13 02:01:56 +0000129
Mike Reed97245822019-07-18 11:37:43 -0400130 dst.offset(1, 1);
reed@google.com97cd69c2012-10-12 14:35:48 +0000131 matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
132 REPORTER_ASSERT(reporter, SkMatrix::kTranslate_Mask == matrix.getType());
133 REPORTER_ASSERT(reporter, matrix.rectStaysRect());
skia.committer@gmail.comf57c01b2012-10-13 02:01:56 +0000134
Mike Reed97245822019-07-18 11:37:43 -0400135 dst.fRight += 1;
reed@google.com97cd69c2012-10-12 14:35:48 +0000136 matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
skia.committer@gmail.come659c2e2012-12-04 02:01:25 +0000137 REPORTER_ASSERT(reporter,
robertphillips@google.com93f03322012-12-03 17:35:19 +0000138 (SkMatrix::kTranslate_Mask | SkMatrix::kScale_Mask) == matrix.getType());
reed@google.com97cd69c2012-10-12 14:35:48 +0000139 REPORTER_ASSERT(reporter, matrix.rectStaysRect());
140
141 dst = src;
142 dst.fRight = src.fRight * 2;
143 matrix.setRectToRect(src, dst, SkMatrix::kFill_ScaleToFit);
144 REPORTER_ASSERT(reporter, SkMatrix::kScale_Mask == matrix.getType());
145 REPORTER_ASSERT(reporter, matrix.rectStaysRect());
146}
147
reed@android.com4b7577b2009-06-29 16:14:41 +0000148static void test_flatten(skiatest::Reporter* reporter, const SkMatrix& m) {
149 // add 100 in case we have a bug, I don't want to kill my stack in the test
Cary Clark6d6d6032017-10-20 12:14:33 -0400150 static const size_t kBufferSize = SkMatrixPriv::kMaxFlattenSize + 100;
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000151 char buffer[kBufferSize];
Cary Clark6d6d6032017-10-20 12:14:33 -0400152 size_t size1 = SkMatrixPriv::WriteToMemory(m, nullptr);
153 size_t size2 = SkMatrixPriv::WriteToMemory(m, buffer);
reed@android.com4b7577b2009-06-29 16:14:41 +0000154 REPORTER_ASSERT(reporter, size1 == size2);
Cary Clark6d6d6032017-10-20 12:14:33 -0400155 REPORTER_ASSERT(reporter, size1 <= SkMatrixPriv::kMaxFlattenSize);
rmistry@google.comd6176b02012-08-23 18:14:13 +0000156
reed@android.com4b7577b2009-06-29 16:14:41 +0000157 SkMatrix m2;
Cary Clark6d6d6032017-10-20 12:14:33 -0400158 size_t size3 = SkMatrixPriv::ReadFromMemory(&m2, buffer, kBufferSize);
djsollen@google.com94e75ee2012-06-08 18:30:46 +0000159 REPORTER_ASSERT(reporter, size1 == size3);
bsalomon@google.com8fe84b52012-03-26 15:24:27 +0000160 REPORTER_ASSERT(reporter, are_equal(reporter, m, m2));
rmistry@google.comd6176b02012-08-23 18:14:13 +0000161
commit-bot@chromium.org4faa8692013-11-05 15:46:56 +0000162 char buffer2[kBufferSize];
Cary Clark6d6d6032017-10-20 12:14:33 -0400163 size3 = SkMatrixPriv::WriteToMemory(m2, buffer2);
djsollen@google.com94e75ee2012-06-08 18:30:46 +0000164 REPORTER_ASSERT(reporter, size1 == size3);
reed@android.com4b7577b2009-06-29 16:14:41 +0000165 REPORTER_ASSERT(reporter, memcmp(buffer, buffer2, size1) == 0);
166}
167
commit-bot@chromium.org18786512014-05-20 14:53:45 +0000168static void test_matrix_min_max_scale(skiatest::Reporter* reporter) {
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000169 SkScalar scales[2];
170 bool success;
171
bsalomon@google.com38396322011-09-09 19:32:04 +0000172 SkMatrix identity;
173 identity.reset();
Mike Reed97245822019-07-18 11:37:43 -0400174 REPORTER_ASSERT(reporter, 1 == identity.getMinScale());
175 REPORTER_ASSERT(reporter, 1 == identity.getMaxScale());
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000176 success = identity.getMinMaxScales(scales);
Mike Reed97245822019-07-18 11:37:43 -0400177 REPORTER_ASSERT(reporter, success && 1 == scales[0] && 1 == scales[1]);
bsalomon@google.com38396322011-09-09 19:32:04 +0000178
179 SkMatrix scale;
Mike Reed97245822019-07-18 11:37:43 -0400180 scale.setScale(2, 4);
181 REPORTER_ASSERT(reporter, 2 == scale.getMinScale());
182 REPORTER_ASSERT(reporter, 4 == scale.getMaxScale());
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000183 success = scale.getMinMaxScales(scales);
Mike Reed97245822019-07-18 11:37:43 -0400184 REPORTER_ASSERT(reporter, success && 2 == scales[0] && 4 == scales[1]);
bsalomon@google.com38396322011-09-09 19:32:04 +0000185
186 SkMatrix rot90Scale;
Mike Reed97245822019-07-18 11:37:43 -0400187 rot90Scale.setRotate(90).postScale(SK_Scalar1 / 4, SK_Scalar1 / 2);
commit-bot@chromium.org18786512014-05-20 14:53:45 +0000188 REPORTER_ASSERT(reporter, SK_Scalar1 / 4 == rot90Scale.getMinScale());
189 REPORTER_ASSERT(reporter, SK_Scalar1 / 2 == rot90Scale.getMaxScale());
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000190 success = rot90Scale.getMinMaxScales(scales);
191 REPORTER_ASSERT(reporter, success && SK_Scalar1 / 4 == scales[0] && SK_Scalar1 / 2 == scales[1]);
bsalomon@google.com38396322011-09-09 19:32:04 +0000192
193 SkMatrix rotate;
Mike Reed97245822019-07-18 11:37:43 -0400194 rotate.setRotate(128);
195 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(1, rotate.getMinScale(), SK_ScalarNearlyZero));
196 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(1, rotate.getMaxScale(), SK_ScalarNearlyZero));
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000197 success = rotate.getMinMaxScales(scales);
198 REPORTER_ASSERT(reporter, success);
Mike Reed97245822019-07-18 11:37:43 -0400199 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(1, scales[0], SK_ScalarNearlyZero));
200 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(1, scales[1], SK_ScalarNearlyZero));
bsalomon@google.com38396322011-09-09 19:32:04 +0000201
202 SkMatrix translate;
Mike Reed97245822019-07-18 11:37:43 -0400203 translate.setTranslate(10, -5);
204 REPORTER_ASSERT(reporter, 1 == translate.getMinScale());
205 REPORTER_ASSERT(reporter, 1 == translate.getMaxScale());
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000206 success = translate.getMinMaxScales(scales);
Mike Reed97245822019-07-18 11:37:43 -0400207 REPORTER_ASSERT(reporter, success && 1 == scales[0] && 1 == scales[1]);
bsalomon@google.com38396322011-09-09 19:32:04 +0000208
209 SkMatrix perspX;
Mike Reed97245822019-07-18 11:37:43 -0400210 perspX.reset().setPerspX(SK_Scalar1 / 1000);
211 REPORTER_ASSERT(reporter, -1 == perspX.getMinScale());
212 REPORTER_ASSERT(reporter, -1 == perspX.getMaxScale());
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000213 success = perspX.getMinMaxScales(scales);
bsalomonef2c7c72015-12-17 15:33:13 -0800214 REPORTER_ASSERT(reporter, !success);
215
216 // skbug.com/4718
217 SkMatrix big;
218 big.setAll(2.39394089e+36f, 8.85347779e+36f, 9.26526204e+36f,
219 3.9159619e+36f, 1.44823453e+37f, 1.51559342e+37f,
220 0.f, 0.f, 1.f);
bsalomonef2c7c72015-12-17 15:33:13 -0800221 success = big.getMinMaxScales(scales);
222 REPORTER_ASSERT(reporter, !success);
bsalomon@google.com38396322011-09-09 19:32:04 +0000223
kolczykcea22ae2016-07-16 11:52:37 -0700224 // skbug.com/4718
225 SkMatrix givingNegativeNearlyZeros;
226 givingNegativeNearlyZeros.setAll(0.00436534f, 0.114138f, 0.37141f,
227 0.00358857f, 0.0936228f, -0.0174198f,
228 0.f, 0.f, 1.f);
229 success = givingNegativeNearlyZeros.getMinMaxScales(scales);
230 REPORTER_ASSERT(reporter, success && 0 == scales[0]);
231
bsalomon@google.com38396322011-09-09 19:32:04 +0000232 SkMatrix perspY;
Mike Reed97245822019-07-18 11:37:43 -0400233 perspY.reset().setPerspY(-SK_Scalar1 / 500);
234 REPORTER_ASSERT(reporter, -1 == perspY.getMinScale());
235 REPORTER_ASSERT(reporter, -1 == perspY.getMaxScale());
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000236 scales[0] = -5;
237 scales[1] = -5;
238 success = perspY.getMinMaxScales(scales);
Mike Reed97245822019-07-18 11:37:43 -0400239 REPORTER_ASSERT(reporter, !success && -5 == scales[0] && -5 == scales[1]);
bsalomon@google.com38396322011-09-09 19:32:04 +0000240
241 SkMatrix baseMats[] = {scale, rot90Scale, rotate,
242 translate, perspX, perspY};
243 SkMatrix mats[2*SK_ARRAY_COUNT(baseMats)];
tomhudson@google.com83a44462011-10-27 15:27:51 +0000244 for (size_t i = 0; i < SK_ARRAY_COUNT(baseMats); ++i) {
bsalomon@google.com38396322011-09-09 19:32:04 +0000245 mats[i] = baseMats[i];
bungemane55131c2016-08-24 12:01:31 -0700246 bool invertible = mats[i].invert(&mats[i + SK_ARRAY_COUNT(baseMats)]);
247 REPORTER_ASSERT(reporter, invertible);
bsalomon@google.com38396322011-09-09 19:32:04 +0000248 }
commit-bot@chromium.orge0e7cfe2013-09-09 20:09:12 +0000249 SkRandom rand;
bsalomon@google.com38396322011-09-09 19:32:04 +0000250 for (int m = 0; m < 1000; ++m) {
251 SkMatrix mat;
252 mat.reset();
253 for (int i = 0; i < 4; ++i) {
254 int x = rand.nextU() % SK_ARRAY_COUNT(mats);
255 mat.postConcat(mats[x]);
256 }
rmistry@google.comd6176b02012-08-23 18:14:13 +0000257
commit-bot@chromium.org18786512014-05-20 14:53:45 +0000258 SkScalar minScale = mat.getMinScale();
259 SkScalar maxScale = mat.getMaxScale();
260 REPORTER_ASSERT(reporter, (minScale < 0) == (maxScale < 0));
261 REPORTER_ASSERT(reporter, (maxScale < 0) == mat.hasPerspective());
bsalomon@google.com38396322011-09-09 19:32:04 +0000262
commit-bot@chromium.org311a3cd2014-05-20 17:02:03 +0000263 SkScalar scales[2];
264 bool success = mat.getMinMaxScales(scales);
265 REPORTER_ASSERT(reporter, success == !mat.hasPerspective());
266 REPORTER_ASSERT(reporter, !success || (scales[0] == minScale && scales[1] == maxScale));
267
bsalomon@google.com38396322011-09-09 19:32:04 +0000268 if (mat.hasPerspective()) {
269 m -= 1; // try another non-persp matrix
270 continue;
271 }
272
commit-bot@chromium.org18786512014-05-20 14:53:45 +0000273 // test a bunch of vectors. All should be scaled by between minScale and maxScale
commit-bot@chromium.orgcea9abb2013-12-09 19:15:37 +0000274 // (modulo some error) and we should find a vector that is scaled by almost each.
commit-bot@chromium.org18786512014-05-20 14:53:45 +0000275 static const SkScalar gVectorScaleTol = (105 * SK_Scalar1) / 100;
276 static const SkScalar gCloseScaleTol = (97 * SK_Scalar1) / 100;
commit-bot@chromium.orgcea9abb2013-12-09 19:15:37 +0000277 SkScalar max = 0, min = SK_ScalarMax;
bsalomon@google.com38396322011-09-09 19:32:04 +0000278 SkVector vectors[1000];
tomhudson@google.com83a44462011-10-27 15:27:51 +0000279 for (size_t i = 0; i < SK_ARRAY_COUNT(vectors); ++i) {
bsalomon@google.com38396322011-09-09 19:32:04 +0000280 vectors[i].fX = rand.nextSScalar1();
281 vectors[i].fY = rand.nextSScalar1();
282 if (!vectors[i].normalize()) {
283 i -= 1;
284 continue;
285 }
286 }
287 mat.mapVectors(vectors, SK_ARRAY_COUNT(vectors));
tomhudson@google.com83a44462011-10-27 15:27:51 +0000288 for (size_t i = 0; i < SK_ARRAY_COUNT(vectors); ++i) {
bsalomon@google.com38396322011-09-09 19:32:04 +0000289 SkScalar d = vectors[i].length();
reed80ea19c2015-05-12 10:37:34 -0700290 REPORTER_ASSERT(reporter, d / maxScale < gVectorScaleTol);
291 REPORTER_ASSERT(reporter, minScale / d < gVectorScaleTol);
bsalomon@google.com38396322011-09-09 19:32:04 +0000292 if (max < d) {
293 max = d;
294 }
commit-bot@chromium.orgcea9abb2013-12-09 19:15:37 +0000295 if (min > d) {
296 min = d;
297 }
bsalomon@google.com38396322011-09-09 19:32:04 +0000298 }
reed80ea19c2015-05-12 10:37:34 -0700299 REPORTER_ASSERT(reporter, max / maxScale >= gCloseScaleTol);
300 REPORTER_ASSERT(reporter, minScale / min >= gCloseScaleTol);
bsalomon@google.com38396322011-09-09 19:32:04 +0000301 }
302}
303
jvanverth17a845f2014-09-02 13:15:40 -0700304static void test_matrix_preserve_shape(skiatest::Reporter* reporter) {
bsalomon@google.com69afee12012-04-25 15:07:40 +0000305 SkMatrix mat;
306
307 // identity
308 mat.setIdentity();
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000309 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700310 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000311
312 // translation only
Mike Reed97245822019-07-18 11:37:43 -0400313 mat.setTranslate(100, 100);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000314 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700315 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000316
317 // scale with same size
Mike Reed97245822019-07-18 11:37:43 -0400318 mat.setScale(15, 15);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000319 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700320 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000321
322 // scale with one negative
Mike Reed97245822019-07-18 11:37:43 -0400323 mat.setScale(-15, 15);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000324 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700325 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000326
327 // scale with different size
Mike Reed97245822019-07-18 11:37:43 -0400328 mat.setScale(15, 20);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000329 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700330 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000331
332 // scale with same size at a pivot point
Mike Reed97245822019-07-18 11:37:43 -0400333 mat.setScale(15, 15, 2, 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000334 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700335 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000336
337 // scale with different size at a pivot point
Mike Reed97245822019-07-18 11:37:43 -0400338 mat.setScale(15, 20, 2, 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000339 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700340 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000341
342 // skew with same size
Mike Reed97245822019-07-18 11:37:43 -0400343 mat.setSkew(15, 15);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000344 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700345 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000346
347 // skew with different size
Mike Reed97245822019-07-18 11:37:43 -0400348 mat.setSkew(15, 20);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000349 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700350 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000351
352 // skew with same size at a pivot point
Mike Reed97245822019-07-18 11:37:43 -0400353 mat.setSkew(15, 15, 2, 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000354 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700355 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000356
357 // skew with different size at a pivot point
Mike Reed97245822019-07-18 11:37:43 -0400358 mat.setSkew(15, 20, 2, 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000359 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700360 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000361
362 // perspective x
Mike Reed97245822019-07-18 11:37:43 -0400363 mat.reset().setPerspX(SK_Scalar1 / 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000364 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700365 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000366
367 // perspective y
Mike Reed97245822019-07-18 11:37:43 -0400368 mat.reset().setPerspY(SK_Scalar1 / 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000369 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700370 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000371
bsalomon@google.com69afee12012-04-25 15:07:40 +0000372 // rotate
373 for (int angle = 0; angle < 360; ++angle) {
bsalomon@google.com69afee12012-04-25 15:07:40 +0000374 mat.setRotate(SkIntToScalar(angle));
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000375 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700376 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000377 }
378
379 // see if there are any accumulated precision issues
380 mat.reset();
381 for (int i = 1; i < 360; i++) {
Mike Reed97245822019-07-18 11:37:43 -0400382 mat.postRotate(1);
bsalomon@google.com69afee12012-04-25 15:07:40 +0000383 }
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000384 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700385 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000386
387 // rotate + translate
Mike Reed97245822019-07-18 11:37:43 -0400388 mat.setRotate(30).postTranslate(10, 20);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000389 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700390 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000391
392 // rotate + uniform scale
Mike Reed97245822019-07-18 11:37:43 -0400393 mat.setRotate(30).postScale(2, 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000394 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700395 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000396
397 // rotate + non-uniform scale
Mike Reed97245822019-07-18 11:37:43 -0400398 mat.setRotate(30).postScale(3, 2);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000399 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700400 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
401
402 // non-uniform scale + rotate
Mike Reed97245822019-07-18 11:37:43 -0400403 mat.setScale(3, 2).postRotate(30);
jvanverth17a845f2014-09-02 13:15:40 -0700404 REPORTER_ASSERT(reporter, !mat.isSimilarity());
405 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000406
407 // all zero
408 mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, 0);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000409 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700410 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000411
412 // all zero except perspective
Mike Reed97245822019-07-18 11:37:43 -0400413 mat.setAll(0, 0, 0, 0, 0, 0, 0, 0, 1);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000414 REPORTER_ASSERT(reporter, !mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700415 REPORTER_ASSERT(reporter, !mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000416
jvanverth17a845f2014-09-02 13:15:40 -0700417 // scales zero, only skews (rotation)
Mike Reed97245822019-07-18 11:37:43 -0400418 mat.setAll(0, 1, 0,
419 -1, 0, 0,
420 0, 0, 1);
jvanverth17a845f2014-09-02 13:15:40 -0700421 REPORTER_ASSERT(reporter, mat.isSimilarity());
422 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
423
424 // scales zero, only skews (reflection)
Mike Reed97245822019-07-18 11:37:43 -0400425 mat.setAll(0, 1, 0,
426 1, 0, 0,
427 0, 0, 1);
jvanverth@google.com46d3d392013-01-22 13:34:01 +0000428 REPORTER_ASSERT(reporter, mat.isSimilarity());
jvanverth17a845f2014-09-02 13:15:40 -0700429 REPORTER_ASSERT(reporter, mat.preservesRightAngles());
bsalomon@google.com69afee12012-04-25 15:07:40 +0000430}
431
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000432// For test_matrix_decomposition, below.
skia.committer@gmail.com5c561cb2013-07-25 07:01:00 +0000433static bool scalar_nearly_equal_relative(SkScalar a, SkScalar b,
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000434 SkScalar tolerance = SK_ScalarNearlyZero) {
435 // from Bruce Dawson
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000436 // absolute check
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000437 SkScalar diff = SkScalarAbs(a - b);
438 if (diff < tolerance) {
439 return true;
440 }
441
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000442 // relative check
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000443 a = SkScalarAbs(a);
444 b = SkScalarAbs(b);
445 SkScalar largest = (b > a) ? b : a;
446
447 if (diff <= largest*tolerance) {
448 return true;
449 }
450
451 return false;
452}
453
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000454static bool check_matrix_recomposition(const SkMatrix& mat,
455 const SkPoint& rotation1,
456 const SkPoint& scale,
457 const SkPoint& rotation2) {
458 SkScalar c1 = rotation1.fX;
459 SkScalar s1 = rotation1.fY;
460 SkScalar scaleX = scale.fX;
461 SkScalar scaleY = scale.fY;
462 SkScalar c2 = rotation2.fX;
463 SkScalar s2 = rotation2.fY;
skia.committer@gmail.com85092f02013-09-04 07:01:39 +0000464
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000465 // We do a relative check here because large scale factors cause problems with an absolute check
466 bool result = scalar_nearly_equal_relative(mat[SkMatrix::kMScaleX],
467 scaleX*c1*c2 - scaleY*s1*s2) &&
468 scalar_nearly_equal_relative(mat[SkMatrix::kMSkewX],
469 -scaleX*s1*c2 - scaleY*c1*s2) &&
470 scalar_nearly_equal_relative(mat[SkMatrix::kMSkewY],
471 scaleX*c1*s2 + scaleY*s1*c2) &&
472 scalar_nearly_equal_relative(mat[SkMatrix::kMScaleY],
473 -scaleX*s1*s2 + scaleY*c1*c2);
474 return result;
475}
476
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000477static void test_matrix_decomposition(skiatest::Reporter* reporter) {
478 SkMatrix mat;
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000479 SkPoint rotation1, scale, rotation2;
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000480
481 const float kRotation0 = 15.5f;
482 const float kRotation1 = -50.f;
483 const float kScale0 = 5000.f;
484 const float kScale1 = 0.001f;
485
486 // identity
487 mat.reset();
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000488 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
489 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000490 // make sure it doesn't crash if we pass in NULLs
halcanary96fcdcc2015-08-27 07:41:13 -0700491 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, nullptr, nullptr, nullptr));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000492
493 // rotation only
494 mat.setRotate(kRotation0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000495 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
496 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000497
498 // uniform scale only
499 mat.setScale(kScale0, kScale0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000500 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
501 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000502
503 // anisotropic scale only
504 mat.setScale(kScale1, kScale0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000505 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
506 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000507
508 // rotation then uniform scale
Mike Reed97245822019-07-18 11:37:43 -0400509 mat.setRotate(kRotation1).postScale(kScale0, kScale0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000510 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
511 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000512
513 // uniform scale then rotation
Mike Reed97245822019-07-18 11:37:43 -0400514 mat.setScale(kScale0, kScale0).postRotate(kRotation1);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000515 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
516 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000517
518 // rotation then uniform scale+reflection
Mike Reed97245822019-07-18 11:37:43 -0400519 mat.setRotate(kRotation0).postScale(kScale1, -kScale1);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000520 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
521 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000522
523 // uniform scale+reflection, then rotate
Mike Reed97245822019-07-18 11:37:43 -0400524 mat.setScale(kScale0, -kScale0).postRotate(kRotation1);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000525 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
526 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000527
528 // rotation then anisotropic scale
Mike Reed97245822019-07-18 11:37:43 -0400529 mat.setRotate(kRotation1).postScale(kScale1, kScale0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000530 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
531 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000532
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000533 // rotation then anisotropic scale
Mike Reed97245822019-07-18 11:37:43 -0400534 mat.setRotate(90).postScale(kScale1, kScale0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000535 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
536 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
skia.committer@gmail.com85092f02013-09-04 07:01:39 +0000537
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000538 // anisotropic scale then rotation
Mike Reed97245822019-07-18 11:37:43 -0400539 mat.setScale(kScale1, kScale0).postRotate(kRotation0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000540 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
541 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
skia.committer@gmail.com85092f02013-09-04 07:01:39 +0000542
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000543 // anisotropic scale then rotation
Mike Reed97245822019-07-18 11:37:43 -0400544 mat.setScale(kScale1, kScale0).postRotate(90);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000545 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
546 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000547
548 // rotation, uniform scale, then different rotation
Mike Reed97245822019-07-18 11:37:43 -0400549 mat.setRotate(kRotation1).postScale(kScale0, kScale0).postRotate(kRotation0);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000550 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
551 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000552
553 // rotation, anisotropic scale, then different rotation
Mike Reed97245822019-07-18 11:37:43 -0400554 mat.setRotate(kRotation0).postScale(kScale1, kScale0).postRotate(kRotation1);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000555 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
556 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
skia.committer@gmail.com85092f02013-09-04 07:01:39 +0000557
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000558 // rotation, anisotropic scale + reflection, then different rotation
Mike Reed97245822019-07-18 11:37:43 -0400559 mat.setRotate(kRotation0).postScale(-kScale1, kScale0).postRotate(kRotation1);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000560 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
561 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000562
563 // try some random matrices
commit-bot@chromium.orge0e7cfe2013-09-09 20:09:12 +0000564 SkRandom rand;
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000565 for (int m = 0; m < 1000; ++m) {
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000566 SkScalar rot0 = rand.nextRangeF(-180, 180);
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000567 SkScalar sx = rand.nextRangeF(-3000.f, 3000.f);
568 SkScalar sy = rand.nextRangeF(-3000.f, 3000.f);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000569 SkScalar rot1 = rand.nextRangeF(-180, 180);
Mike Reed97245822019-07-18 11:37:43 -0400570 mat.setRotate(rot0).postScale(sx, sy).postRotate(rot1);
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000571
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000572 if (SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2)) {
573 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000574 } else {
575 // if the matrix is degenerate, the basis vectors should be near-parallel or near-zero
576 SkScalar perpdot = mat[SkMatrix::kMScaleX]*mat[SkMatrix::kMScaleY] -
577 mat[SkMatrix::kMSkewX]*mat[SkMatrix::kMSkewY];
578 REPORTER_ASSERT(reporter, SkScalarNearlyZero(perpdot));
579 }
580 }
581
582 // translation shouldn't affect this
583 mat.postTranslate(-1000.f, 1000.f);
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000584 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
585 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000586
587 // perspective shouldn't affect this
jvanverth@google.com588f3d32013-07-24 18:44:10 +0000588 mat[SkMatrix::kMPersp0] = 12.f;
589 mat[SkMatrix::kMPersp1] = 4.f;
590 mat[SkMatrix::kMPersp2] = 1872.f;
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000591 REPORTER_ASSERT(reporter, SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
592 REPORTER_ASSERT(reporter, check_matrix_recomposition(mat, rotation1, scale, rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000593
594 // degenerate matrices
595 // mostly zero entries
596 mat.reset();
597 mat[SkMatrix::kMScaleX] = 0.f;
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000598 REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000599 mat.reset();
600 mat[SkMatrix::kMScaleY] = 0.f;
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000601 REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000602 mat.reset();
603 // linearly dependent entries
604 mat[SkMatrix::kMScaleX] = 1.f;
605 mat[SkMatrix::kMSkewX] = 2.f;
606 mat[SkMatrix::kMSkewY] = 4.f;
607 mat[SkMatrix::kMScaleY] = 8.f;
commit-bot@chromium.org5b2e2642013-09-03 19:08:14 +0000608 REPORTER_ASSERT(reporter, !SkDecomposeUpper2x2(mat, &rotation1, &scale, &rotation2));
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000609}
610
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000611// For test_matrix_homogeneous, below.
Cary Clarke4442cb2017-10-18 11:46:18 -0400612static bool point3_array_nearly_equal_relative(const SkPoint3 a[], const SkPoint3 b[], int count) {
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000613 for (int i = 0; i < count; ++i) {
Cary Clarke4442cb2017-10-18 11:46:18 -0400614 if (!scalar_nearly_equal_relative(a[i].fX, b[i].fX)) {
615 return false;
616 }
617 if (!scalar_nearly_equal_relative(a[i].fY, b[i].fY)) {
618 return false;
619 }
620 if (!scalar_nearly_equal_relative(a[i].fZ, b[i].fZ)) {
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000621 return false;
622 }
623 }
624 return true;
625}
626
627// For test_matrix_homogeneous, below.
628// Maps a single triple in src using m and compares results to those in dst
Cary Clarke4442cb2017-10-18 11:46:18 -0400629static bool naive_homogeneous_mapping(const SkMatrix& m, const SkPoint3& src,
630 const SkPoint3& dst) {
631 SkPoint3 res;
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000632 SkScalar ms[9] = {m[0], m[1], m[2],
633 m[3], m[4], m[5],
634 m[6], m[7], m[8]};
Cary Clarke4442cb2017-10-18 11:46:18 -0400635 res.fX = src.fX * ms[0] + src.fY * ms[1] + src.fZ * ms[2];
636 res.fY = src.fX * ms[3] + src.fY * ms[4] + src.fZ * ms[5];
637 res.fZ = src.fX * ms[6] + src.fY * ms[7] + src.fZ * ms[8];
638 return point3_array_nearly_equal_relative(&res, &dst, 1);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000639}
640
641static void test_matrix_homogeneous(skiatest::Reporter* reporter) {
642 SkMatrix mat;
643
644 const float kRotation0 = 15.5f;
645 const float kRotation1 = -50.f;
646 const float kScale0 = 5000.f;
647
Mike Klein6613cc52017-12-19 09:09:33 -0500648#if defined(SK_BUILD_FOR_GOOGLE3)
649 // Stack frame size is limited in SK_BUILD_FOR_GOOGLE3.
benjaminwagner7d974f52015-10-19 13:55:55 -0700650 const int kTripleCount = 100;
651 const int kMatrixCount = 100;
652#else
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000653 const int kTripleCount = 1000;
654 const int kMatrixCount = 1000;
benjaminwagner7d974f52015-10-19 13:55:55 -0700655#endif
commit-bot@chromium.orge0e7cfe2013-09-09 20:09:12 +0000656 SkRandom rand;
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000657
Cary Clarke4442cb2017-10-18 11:46:18 -0400658 SkPoint3 randTriples[kTripleCount];
659 for (int i = 0; i < kTripleCount; ++i) {
660 randTriples[i].fX = rand.nextRangeF(-3000.f, 3000.f);
661 randTriples[i].fY = rand.nextRangeF(-3000.f, 3000.f);
662 randTriples[i].fZ = rand.nextRangeF(-3000.f, 3000.f);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000663 }
664
665 SkMatrix mats[kMatrixCount];
666 for (int i = 0; i < kMatrixCount; ++i) {
667 for (int j = 0; j < 9; ++j) {
668 mats[i].set(j, rand.nextRangeF(-3000.f, 3000.f));
669 }
670 }
671
672 // identity
673 {
674 mat.reset();
Cary Clarke4442cb2017-10-18 11:46:18 -0400675 SkPoint3 dst[kTripleCount];
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000676 mat.mapHomogeneousPoints(dst, randTriples, kTripleCount);
Cary Clarke4442cb2017-10-18 11:46:18 -0400677 REPORTER_ASSERT(reporter, point3_array_nearly_equal_relative(randTriples, dst, kTripleCount));
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000678 }
679
Cary Clarke4442cb2017-10-18 11:46:18 -0400680 const SkPoint3 zeros = {0.f, 0.f, 0.f};
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000681 // zero matrix
682 {
683 mat.setAll(0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 0.f);
Cary Clarke4442cb2017-10-18 11:46:18 -0400684 SkPoint3 dst[kTripleCount];
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000685 mat.mapHomogeneousPoints(dst, randTriples, kTripleCount);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000686 for (int i = 0; i < kTripleCount; ++i) {
Cary Clarke4442cb2017-10-18 11:46:18 -0400687 REPORTER_ASSERT(reporter, point3_array_nearly_equal_relative(&dst[i], &zeros, 1));
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000688 }
689 }
690
691 // zero point
692 {
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000693 for (int i = 0; i < kMatrixCount; ++i) {
Cary Clarke4442cb2017-10-18 11:46:18 -0400694 SkPoint3 dst;
695 mats[i].mapHomogeneousPoints(&dst, &zeros, 1);
696 REPORTER_ASSERT(reporter, point3_array_nearly_equal_relative(&dst, &zeros, 1));
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000697 }
698 }
699
700 // doesn't crash with null dst, src, count == 0
701 {
Mike Reed190b82d2019-12-17 17:25:27 -0500702 mats[0].mapHomogeneousPoints(nullptr, (const SkPoint3*)nullptr, 0);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000703 }
704
705 // uniform scale of point
706 {
707 mat.setScale(kScale0, kScale0);
Cary Clarke4442cb2017-10-18 11:46:18 -0400708 SkPoint3 dst;
709 SkPoint3 src = {randTriples[0].fX, randTriples[0].fY, 1.f};
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000710 SkPoint pnt;
Cary Clarke4442cb2017-10-18 11:46:18 -0400711 pnt.set(src.fX, src.fY);
712 mat.mapHomogeneousPoints(&dst, &src, 1);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000713 mat.mapPoints(&pnt, &pnt, 1);
Cary Clarke4442cb2017-10-18 11:46:18 -0400714 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fX, pnt.fX));
715 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fY, pnt.fY));
Mike Reed97245822019-07-18 11:37:43 -0400716 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fZ, 1));
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000717 }
718
719 // rotation of point
720 {
721 mat.setRotate(kRotation0);
Cary Clarke4442cb2017-10-18 11:46:18 -0400722 SkPoint3 dst;
723 SkPoint3 src = {randTriples[0].fX, randTriples[0].fY, 1.f};
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000724 SkPoint pnt;
Cary Clarke4442cb2017-10-18 11:46:18 -0400725 pnt.set(src.fX, src.fY);
726 mat.mapHomogeneousPoints(&dst, &src, 1);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000727 mat.mapPoints(&pnt, &pnt, 1);
Cary Clarke4442cb2017-10-18 11:46:18 -0400728 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fX, pnt.fX));
729 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fY, pnt.fY));
Mike Reed97245822019-07-18 11:37:43 -0400730 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fZ, 1));
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000731 }
732
733 // rotation, scale, rotation of point
734 {
735 mat.setRotate(kRotation1);
736 mat.postScale(kScale0, kScale0);
737 mat.postRotate(kRotation0);
Cary Clarke4442cb2017-10-18 11:46:18 -0400738 SkPoint3 dst;
739 SkPoint3 src = {randTriples[0].fX, randTriples[0].fY, 1.f};
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000740 SkPoint pnt;
Cary Clarke4442cb2017-10-18 11:46:18 -0400741 pnt.set(src.fX, src.fY);
742 mat.mapHomogeneousPoints(&dst, &src, 1);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000743 mat.mapPoints(&pnt, &pnt, 1);
Cary Clarke4442cb2017-10-18 11:46:18 -0400744 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fX, pnt.fX));
745 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fY, pnt.fY));
Mike Reed97245822019-07-18 11:37:43 -0400746 REPORTER_ASSERT(reporter, SkScalarNearlyEqual(dst.fZ, 1));
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000747 }
748
749 // compare with naive approach
750 {
751 for (int i = 0; i < kMatrixCount; ++i) {
752 for (int j = 0; j < kTripleCount; ++j) {
Cary Clarke4442cb2017-10-18 11:46:18 -0400753 SkPoint3 dst;
754 mats[i].mapHomogeneousPoints(&dst, &randTriples[j], 1);
755 REPORTER_ASSERT(reporter, naive_homogeneous_mapping(mats[i], randTriples[j], dst));
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000756 }
757 }
758 }
759
760}
761
Robert Phillipsc100d482018-07-10 10:11:01 -0400762static bool check_decompScale(const SkMatrix& original) {
reedadf99902015-03-19 16:10:54 -0700763 SkSize scale;
764 SkMatrix remaining;
765
Robert Phillipsc100d482018-07-10 10:11:01 -0400766 if (!original.decomposeScale(&scale, &remaining)) {
reedadf99902015-03-19 16:10:54 -0700767 return false;
768 }
769 if (scale.width() <= 0 || scale.height() <= 0) {
770 return false;
771 }
Robert Phillipsc100d482018-07-10 10:11:01 -0400772
773 // First ensure that the decomposition reconstitutes back to the original
774 {
775 SkMatrix reconstituted = remaining;
776
Michael Ludwigaa861a12019-07-19 10:13:47 -0400777 reconstituted.preScale(scale.width(), scale.height());
Robert Phillipsc100d482018-07-10 10:11:01 -0400778 if (!nearly_equal(original, reconstituted)) {
779 return false;
780 }
781 }
782
783 // Then push some points through both paths and make sure they are the same.
784 static const int kNumPoints = 5;
785 const SkPoint testPts[kNumPoints] = {
786 { 0.0f, 0.0f },
787 { 1.0f, 1.0f },
788 { 1.0f, 0.5f },
789 { -1.0f, -0.5f },
790 { -1.0f, 2.0f }
791 };
792
793 SkPoint v1[kNumPoints];
794 original.mapPoints(v1, testPts, kNumPoints);
795
796 SkPoint v2[kNumPoints];
797 SkMatrix scaleMat = SkMatrix::MakeScale(scale.width(), scale.height());
798
799 // Note, we intend the decomposition to be applied in the order scale and then remainder but,
800 // due to skbug.com/7211, the order is reversed!
Michael Ludwigaa861a12019-07-19 10:13:47 -0400801 scaleMat.mapPoints(v2, testPts, kNumPoints);
802 remaining.mapPoints(v2, kNumPoints);
Robert Phillipsc100d482018-07-10 10:11:01 -0400803
804 for (int i = 0; i < kNumPoints; ++i) {
805 if (!SkPointPriv::EqualsWithinTolerance(v1[i], v2[i], 0.00001f)) {
806 return false;
807 }
808 }
809
810 return true;
reedadf99902015-03-19 16:10:54 -0700811}
812
813static void test_decompScale(skiatest::Reporter* reporter) {
814 SkMatrix m;
815
816 m.reset();
817 REPORTER_ASSERT(reporter, check_decompScale(m));
818 m.setScale(2, 3);
819 REPORTER_ASSERT(reporter, check_decompScale(m));
820 m.setRotate(35, 0, 0);
821 REPORTER_ASSERT(reporter, check_decompScale(m));
822
823 m.setScale(1, 0);
824 REPORTER_ASSERT(reporter, !check_decompScale(m));
Robert Phillipsc100d482018-07-10 10:11:01 -0400825
Mike Reed97245822019-07-18 11:37:43 -0400826 m.setRotate(35, 0, 0).preScale(2, 3);
Robert Phillipsc100d482018-07-10 10:11:01 -0400827 REPORTER_ASSERT(reporter, check_decompScale(m));
828
Mike Reed97245822019-07-18 11:37:43 -0400829 m.setRotate(35, 0, 0).postScale(2, 3);
Robert Phillipsc100d482018-07-10 10:11:01 -0400830 REPORTER_ASSERT(reporter, check_decompScale(m));
reedadf99902015-03-19 16:10:54 -0700831}
832
tfarina@chromium.orge4fafb12013-12-12 21:11:12 +0000833DEF_TEST(Matrix, reporter) {
reed@android.comed673312009-02-27 16:24:51 +0000834 SkMatrix mat, inverse, iden1, iden2;
835
836 mat.reset();
Mike Reed97245822019-07-18 11:37:43 -0400837 mat.setTranslate(1, 1);
reed@google.com5bfa55b2012-04-19 18:59:25 +0000838 REPORTER_ASSERT(reporter, mat.invert(&inverse));
reed@android.comed673312009-02-27 16:24:51 +0000839 iden1.setConcat(mat, inverse);
840 REPORTER_ASSERT(reporter, is_identity(iden1));
841
Mike Reed97245822019-07-18 11:37:43 -0400842 mat.setScale(2, 4);
reed@google.com5bfa55b2012-04-19 18:59:25 +0000843 REPORTER_ASSERT(reporter, mat.invert(&inverse));
reed@android.comed673312009-02-27 16:24:51 +0000844 iden1.setConcat(mat, inverse);
845 REPORTER_ASSERT(reporter, is_identity(iden1));
reed@android.com4b7577b2009-06-29 16:14:41 +0000846 test_flatten(reporter, mat);
reed@android.comed673312009-02-27 16:24:51 +0000847
Mike Reed97245822019-07-18 11:37:43 -0400848 mat.setScale(SK_Scalar1/2, 2);
reed@google.com5bfa55b2012-04-19 18:59:25 +0000849 REPORTER_ASSERT(reporter, mat.invert(&inverse));
reed@android.comed673312009-02-27 16:24:51 +0000850 iden1.setConcat(mat, inverse);
851 REPORTER_ASSERT(reporter, is_identity(iden1));
reed@android.com4b7577b2009-06-29 16:14:41 +0000852 test_flatten(reporter, mat);
reed@android.comed673312009-02-27 16:24:51 +0000853
Mike Reed97245822019-07-18 11:37:43 -0400854 mat.setScale(3, 5, 20, 0).postRotate(25);
halcanary96fcdcc2015-08-27 07:41:13 -0700855 REPORTER_ASSERT(reporter, mat.invert(nullptr));
reed@google.com5bfa55b2012-04-19 18:59:25 +0000856 REPORTER_ASSERT(reporter, mat.invert(&inverse));
reed@android.comed673312009-02-27 16:24:51 +0000857 iden1.setConcat(mat, inverse);
858 REPORTER_ASSERT(reporter, is_identity(iden1));
859 iden2.setConcat(inverse, mat);
860 REPORTER_ASSERT(reporter, is_identity(iden2));
reed@android.com4b7577b2009-06-29 16:14:41 +0000861 test_flatten(reporter, mat);
862 test_flatten(reporter, iden2);
reed@android.com80e39a72009-04-02 16:59:40 +0000863
Mike Reed97245822019-07-18 11:37:43 -0400864 mat.setScale(0, 1);
halcanary96fcdcc2015-08-27 07:41:13 -0700865 REPORTER_ASSERT(reporter, !mat.invert(nullptr));
reed@google.com2fb96cc2013-01-04 17:02:33 +0000866 REPORTER_ASSERT(reporter, !mat.invert(&inverse));
Mike Reed97245822019-07-18 11:37:43 -0400867 mat.setScale(1, 0);
halcanary96fcdcc2015-08-27 07:41:13 -0700868 REPORTER_ASSERT(reporter, !mat.invert(nullptr));
reed@google.com2fb96cc2013-01-04 17:02:33 +0000869 REPORTER_ASSERT(reporter, !mat.invert(&inverse));
870
robertphillips20eee3f2015-06-19 05:14:26 -0700871 // Inverting this matrix results in a non-finite matrix
872 mat.setAll(0.0f, 1.0f, 2.0f,
873 0.0f, 1.0f, -3.40277175e+38f,
874 1.00003040f, 1.0f, 0.0f);
halcanary96fcdcc2015-08-27 07:41:13 -0700875 REPORTER_ASSERT(reporter, !mat.invert(nullptr));
robertphillips20eee3f2015-06-19 05:14:26 -0700876 REPORTER_ASSERT(reporter, !mat.invert(&inverse));
877
reed@android.comed673312009-02-27 16:24:51 +0000878 // rectStaysRect test
879 {
880 static const struct {
881 SkScalar m00, m01, m10, m11;
882 bool mStaysRect;
883 }
884 gRectStaysRectSamples[] = {
Mike Reed97245822019-07-18 11:37:43 -0400885 { 0, 0, 0, 0, false },
886 { 0, 0, 0, 1, false },
887 { 0, 0, 1, 0, false },
888 { 0, 0, 1, 1, false },
889 { 0, 1, 0, 0, false },
890 { 0, 1, 0, 1, false },
891 { 0, 1, 1, 0, true },
892 { 0, 1, 1, 1, false },
893 { 1, 0, 0, 0, false },
894 { 1, 0, 0, 1, true },
895 { 1, 0, 1, 0, false },
896 { 1, 0, 1, 1, false },
897 { 1, 1, 0, 0, false },
898 { 1, 1, 0, 1, false },
899 { 1, 1, 1, 0, false },
900 { 1, 1, 1, 1, false }
reed@android.comed673312009-02-27 16:24:51 +0000901 };
reed@android.com80e39a72009-04-02 16:59:40 +0000902
reed@android.comed673312009-02-27 16:24:51 +0000903 for (size_t i = 0; i < SK_ARRAY_COUNT(gRectStaysRectSamples); i++) {
904 SkMatrix m;
reed@android.com80e39a72009-04-02 16:59:40 +0000905
reed@android.comed673312009-02-27 16:24:51 +0000906 m.reset();
907 m.set(SkMatrix::kMScaleX, gRectStaysRectSamples[i].m00);
908 m.set(SkMatrix::kMSkewX, gRectStaysRectSamples[i].m01);
909 m.set(SkMatrix::kMSkewY, gRectStaysRectSamples[i].m10);
910 m.set(SkMatrix::kMScaleY, gRectStaysRectSamples[i].m11);
911 REPORTER_ASSERT(reporter,
912 m.rectStaysRect() == gRectStaysRectSamples[i].mStaysRect);
913 }
914 }
bungeman@google.com1ddd7c32011-07-13 19:41:55 +0000915
bungeman@google.comba7983e2011-07-13 20:18:16 +0000916 mat.reset();
Mike Reed97245822019-07-18 11:37:43 -0400917 mat.set(SkMatrix::kMScaleX, 1)
918 .set(SkMatrix::kMSkewX, 2)
919 .set(SkMatrix::kMTransX, 3)
920 .set(SkMatrix::kMSkewY, 4)
921 .set(SkMatrix::kMScaleY, 5)
922 .set(SkMatrix::kMTransY, 6);
bungeman@google.com1ddd7c32011-07-13 19:41:55 +0000923 SkScalar affine[6];
924 REPORTER_ASSERT(reporter, mat.asAffine(affine));
925
Mike Reedf0cb7a02017-10-13 13:26:00 +0000926 #define affineEqual(e) affine[SkMatrix::kA##e] == mat.get(SkMatrix::kM##e)
bungeman@google.com1ddd7c32011-07-13 19:41:55 +0000927 REPORTER_ASSERT(reporter, affineEqual(ScaleX));
928 REPORTER_ASSERT(reporter, affineEqual(SkewY));
929 REPORTER_ASSERT(reporter, affineEqual(SkewX));
930 REPORTER_ASSERT(reporter, affineEqual(ScaleY));
931 REPORTER_ASSERT(reporter, affineEqual(TransX));
932 REPORTER_ASSERT(reporter, affineEqual(TransY));
933 #undef affineEqual
934
reed3f43f8a2015-01-20 19:58:36 -0800935 mat.set(SkMatrix::kMPersp1, SK_Scalar1 / 2);
bungeman@google.com1ddd7c32011-07-13 19:41:55 +0000936 REPORTER_ASSERT(reporter, !mat.asAffine(affine));
bsalomon@google.com38396322011-09-09 19:32:04 +0000937
bsalomon@google.com8fe84b52012-03-26 15:24:27 +0000938 SkMatrix mat2;
939 mat2.reset();
940 mat.reset();
941 SkScalar zero = 0;
942 mat.set(SkMatrix::kMSkewX, -zero);
943 REPORTER_ASSERT(reporter, are_equal(reporter, mat, mat2));
944
945 mat2.reset();
946 mat.reset();
947 mat.set(SkMatrix::kMSkewX, SK_ScalarNaN);
948 mat2.set(SkMatrix::kMSkewX, SK_ScalarNaN);
949 REPORTER_ASSERT(reporter, !are_equal(reporter, mat, mat2));
950
commit-bot@chromium.org18786512014-05-20 14:53:45 +0000951 test_matrix_min_max_scale(reporter);
jvanverth17a845f2014-09-02 13:15:40 -0700952 test_matrix_preserve_shape(reporter);
reed@google.com97cd69c2012-10-12 14:35:48 +0000953 test_matrix_recttorect(reporter);
commit-bot@chromium.org08284e42013-07-24 18:08:08 +0000954 test_matrix_decomposition(reporter);
egdaniel@google.com259fbaf2013-08-15 21:12:11 +0000955 test_matrix_homogeneous(reporter);
reed451e8222014-12-13 08:46:48 -0800956 test_set9(reporter);
reedadf99902015-03-19 16:10:54 -0700957
958 test_decompScale(reporter);
reed2dcb6152016-07-05 20:10:42 -0700959
960 mat.setScaleTranslate(2, 3, 1, 4);
Mike Reed97245822019-07-18 11:37:43 -0400961 mat2.setScale(2, 3).postTranslate(1, 4);
reed2dcb6152016-07-05 20:10:42 -0700962 REPORTER_ASSERT(reporter, mat == mat2);
reed@android.comed673312009-02-27 16:24:51 +0000963}
commit-bot@chromium.org99bd7d82014-05-19 15:51:12 +0000964
965DEF_TEST(Matrix_Concat, r) {
966 SkMatrix a;
967 a.setTranslate(10, 20);
968
969 SkMatrix b;
970 b.setScale(3, 5);
971
972 SkMatrix expected;
973 expected.setConcat(a,b);
974
975 REPORTER_ASSERT(r, expected == SkMatrix::Concat(a, b));
976}
reed47df89e2016-06-30 06:38:54 -0700977
978// Test that all variants of maprect are correct.
979DEF_TEST(Matrix_maprects, r) {
980 const SkScalar scale = 1000;
Ben Wagner63fd7602017-10-09 15:45:33 -0400981
reed47df89e2016-06-30 06:38:54 -0700982 SkMatrix mat;
Mike Reed97245822019-07-18 11:37:43 -0400983 mat.setScale(2, 3).postTranslate(1, 4);
reed47df89e2016-06-30 06:38:54 -0700984
985 SkRandom rand;
986 for (int i = 0; i < 10000; ++i) {
987 SkRect src = SkRect::MakeLTRB(rand.nextSScalar1() * scale,
988 rand.nextSScalar1() * scale,
989 rand.nextSScalar1() * scale,
990 rand.nextSScalar1() * scale);
Cary Clarkc06754b2018-05-16 21:28:55 -0400991 SkRect dst[4];
Ben Wagner63fd7602017-10-09 15:45:33 -0400992
reed47df89e2016-06-30 06:38:54 -0700993 mat.mapPoints((SkPoint*)&dst[0].fLeft, (SkPoint*)&src.fLeft, 2);
994 dst[0].sort();
995 mat.mapRect(&dst[1], src);
halcanaryc5769b22016-08-10 07:13:21 -0700996 mat.mapRectScaleTranslate(&dst[2], src);
Cary Clarkc06754b2018-05-16 21:28:55 -0400997 dst[3] = mat.mapRect(src);
reed47df89e2016-06-30 06:38:54 -0700998
999 REPORTER_ASSERT(r, dst[0] == dst[1]);
1000 REPORTER_ASSERT(r, dst[0] == dst[2]);
Cary Clarkc06754b2018-05-16 21:28:55 -04001001 REPORTER_ASSERT(r, dst[0] == dst[3]);
1002 }
1003
1004 // We should report nonfinite-ness after a mapping
1005 {
1006 // We have special-cases in mapRect for different matrix types
1007 SkMatrix m0 = SkMatrix::MakeScale(1e20f, 1e20f);
1008 SkMatrix m1; m1.setRotate(30); m1.postScale(1e20f, 1e20f);
1009
1010 for (const auto& m : { m0, m1 }) {
1011 SkRect rect = { 0, 0, 1e20f, 1e20f };
1012 REPORTER_ASSERT(r, rect.isFinite());
1013 rect = m.mapRect(rect);
1014 REPORTER_ASSERT(r, !rect.isFinite());
1015 }
reed47df89e2016-06-30 06:38:54 -07001016 }
1017}
Mike Kleine0eeda52019-04-15 16:12:31 -05001018
1019DEF_TEST(Matrix_Ctor, r) {
1020 REPORTER_ASSERT(r, SkMatrix{} == SkMatrix::I());
1021}