Flutter Engine
The Flutter Engine
PathOpsQuadIntersectionTest.cpp
Go to the documentation of this file.
1/*
2 * Copyright 2012 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#include "include/core/SkTypes.h"
8#include "include/private/base/SkDebug.h"
9#include "src/base/SkFloatBits.h"
10#include "src/pathops/SkIntersections.h"
11#include "src/pathops/SkPathOpsDebug.h"
12#include "src/pathops/SkPathOpsPoint.h"
13#include "src/pathops/SkPathOpsQuad.h"
14#include "src/pathops/SkPathOpsTypes.h"
15#include "src/pathops/SkReduceOrder.h"
16#include "tests/PathOpsQuadIntersectionTestData.h"
17#include "tests/PathOpsTestCommon.h"
18#include "tests/Test.h"
19
20#include <array>
21#include <cstddef>
22
23static void standardTestCases(skiatest::Reporter* reporter) {
24 bool showSkipped = false;
25 for (size_t index = 0; index < quadraticTests_count; ++index) {
26 const QuadPts& q1 = quadraticTests[index][0];
27 SkDQuad quad1;
28 quad1.debugSet(q1.fPts);
29 SkASSERT(ValidQuad(quad1));
30 const QuadPts& q2 = quadraticTests[index][1];
31 SkDQuad quad2;
32 quad2.debugSet(q2.fPts);
33 SkASSERT(ValidQuad(quad2));
34 SkReduceOrder reduce1, reduce2;
35 int order1 = reduce1.reduce(quad1);
36 int order2 = reduce2.reduce(quad2);
37 if (order1 < 3) {
38 if (showSkipped) {
39 SkDebugf("[%d] quad1 order=%d\n", static_cast<int>(index), order1);
40 }
41 }
42 if (order2 < 3) {
43 if (showSkipped) {
44 SkDebugf("[%d] quad2 order=%d\n", static_cast<int>(index), order2);
45 }
46 }
47 if (order1 == 3 && order2 == 3) {
48 SkIntersections intersections;
49 intersections.intersect(quad1, quad2);
50 if (intersections.used() > 0) {
51 for (int pt = 0; pt < intersections.used(); ++pt) {
52 double tt1 = intersections[0][pt];
53 SkDPoint xy1 = quad1.ptAtT(tt1);
54 double tt2 = intersections[1][pt];
55 SkDPoint xy2 = quad2.ptAtT(tt2);
56 if (!xy1.approximatelyEqual(xy2)) {
57 SkDebugf("%s [%d,%d] x!= t1=%g (%g,%g) t2=%g (%g,%g)\n",
58 __FUNCTION__, static_cast<int>(index), pt, tt1, xy1.fX, xy1.fY,
59 tt2, xy2.fX, xy2.fY);
60 REPORTER_ASSERT(reporter, 0);
61 }
62 }
63 }
64 }
65 }
66}
67
68static const QuadPts testSet[] = {
69{{{123.637985f, 102.405312f}, {125.172699f, 104.575714f}, {123.387383f, 106.91227f}}},
70{{{123.388428f, 106.910896f}, {123.365623f, 106.94088f}, {123.320007f, 107.000946f}}},
71
72{{{-0.001019871095195412636, -0.008523519150912761688}, {-0.005396408028900623322, -0.005396373569965362549}, {-0.02855382487177848816, -0.02855364233255386353}}},
73{{{-0.004567248281091451645, -0.01482933573424816132}, {-0.01142475008964538574, -0.01140109263360500336}, {-0.02852955088019371033, -0.02847047336399555206}}},
74
75{{{1, 1}, {0, 2}, {3, 3}}},
76{{{3, 0}, {0, 1}, {1, 2}}},
77
78{{{0.33333333333333326, 0.81481481481481488}, {0.63395173631977997, 0.68744136726313931}, {1.205684411948591, 0.81344322326274499}}},
79{{{0.33333333333333326, 0.81481481481481488}, {0.63396444791444551, 0.68743368362444768}, {1.205732763658403, 0.81345617746834109}}},
80
81{{{4981.9990234375, 1590}, {4981.9990234375, 1617.7523193359375}, {4962.375, 1637.3760986328125}}},
82{{{4962.3759765625, 1637.3760986328125}, {4982, 1617.7523193359375}, {4982, 1590}}},
83
84{{{48.7416f, 7.74160004f}, {96.4831848f, -40}, {164, -40}}},
85{{{56.9671326f, 0}, {52.7835083f, 3.69968891f}, {48.7416f, 7.74160004f}}},
86
87{{{138, 80}, {147.15692138671875, 80}, {155.12803649902344, 82.86279296875}}},
88{{{155.12803649902344, 82.86279296875}, {153.14971923828125, 82.152290344238281}, {151.09841918945312, 81.618133544921875}}},
89
90{{{88, 130}, {88, 131.54483032226562}, {88.081489562988281, 133.0560302734375}}},
91{{{88.081489562988281, 133.0560302734375}, {88, 131.54483032226562}, {88, 130}}},
92
93{{{0.59987992,2.14448452}, {0.775417507,1.95606446}, {1.00564098,1.79310346}}},
94{{{1.00564098,1.79310346}, {1.25936198,1.615623}, {1.35901463,1.46834028}}},
95
96{{{3,0}, {0,1}, {3,2}}},
97{{{2,0}, {1,1}, {2,2}}},
98
99{{{38.656852722167969, 38.656852722167969}, {38.651023864746094, 38.662681579589844}, {38.644744873046875, 38.668937683105469}}},
100{{{38.656852722167969, 38.656852722167969}, {36.313709259033203, 41}, {33, 41}}},
101
102{{{4914.9990234375, 1523}, {4942.75146484375, 1523}, {4962.375, 1542.6239013671875}}},
103{{{4962.3759765625, 1542.6239013671875}, {4942.75244140625, 1523}, {4915, 1523}}},
104
105{{{4867.623046875, 1637.3760986328125}, {4847.9990234375, 1617.7523193359375}, {4847.9990234375, 1590}}},
106{{{4848, 1590}, {4848, 1617.7523193359375}, {4867.6240234375, 1637.3760986328125}}},
107
108{{{102.64466094970703, 165.3553466796875}, {110.79246520996094, 173.50314331054687}, {120.81797790527344, 177.11778259277344}}},
109{{{113.232177734375, 173.57899475097656}, {116.88026428222656, 175.69805908203125}, {120.81797790527344, 177.11778259277344}}},
110
111{{{-37.3484879,10.0192947}, {-36.4966316,13.2140198}, {-38.1506348,16.0788383}}},
112{{{-38.1462746,16.08918}, {-36.4904327,13.2193804}, {-37.3484879,10.0192947}}},
113
114{{{-37.3513985,10.0082998}, {-36.4938011,13.2090998}, {-38.1506004,16.0788002}}},
115{{{-37.3508987,10.0102997}, {-36.4930992,13.2110004}, {-38.1497993,16.0809002}}},
116
117{{{-37.3508987,10.0102997}, {-37.3510017,10.0098}, {-37.3512001,10.0093002}}},
118{{{-49.0778008,19.0097008}, {-38.2086983,6.80954981}, {-37.3508987,10.0102997}}},
119
120{{{SkBits2Float(0xc22423b2), SkBits2Float(0x40afae2c)},
121 {SkBits2Float(0xc2189b24), SkBits2Float(0x40e3f058)},
122 {SkBits2Float(0xc21511d9), SkBits2Float(0x41251125)}}},
123{{{SkBits2Float(0xc2153d2f), SkBits2Float(0x412299db)},
124 {SkBits2Float(0xc2153265), SkBits2Float(0x41233845)},
125 {SkBits2Float(0xc21527fc), SkBits2Float(0x4123d684)}}},
126
127{{{-37.3097496, 10.1625624}, {-37.2992134, 10.2012377}, {-37.2890472, 10.239872}}},
128{{{-41.0348587, 5.49001122}, {-38.1515045, 7.12308884}, {-37.2674294, 10.3166857}}},
129
130{{{-52.8062439,14.1493912}, {-53.6638947,10.948595}, {-52.0070419,8.07883835}}},
131{{{-52.8054848,14.1522331}, {-53.6633072,10.9514809}, {-52.0066071,8.08163643}}},
132
133{{{441.853149, 308.209106}, {434.672272, 315.389984}, {424.516998, 315.389984}}},
134{{{385.207275, 334.241272}, {406.481598, 312.96698}, {436.567993, 312.96698}}},
135
136{{{-708.00779269310044, -154.36998607290101}, {-707.90560262312511, -154.36998607290101}, {-707.8333433370193, -154.44224536635932}}},
137{{{-708.00779269310044, -154.61669472244046}, {-701.04513225634582, -128.85970734043804}, {505.58447265625, -504.9130859375}}},
138
139{{{164, -40}, {231.51681518554687, -40}, {279.25839233398438, 7.7416000366210938}}},
140{{{279.25839233398438, 7.7416000366210938}, {275.2164306640625, 3.6996400356292725}, {271.03286743164062, -5.3290705182007514e-015}}},
141
142{{{2.9999997378517067, 1.9737872594345709}, {2.9999997432230918, 1.9739647181863822}, {1.2414155459263587e-163, 5.2957833941332142e-315}}},
143{{{2.9999047485265304, 1.9739164225694723}, {3.0000947268526112, 1.9738379076623633}, {0.61149411077591886, 0.0028382324376270418}}},
144
145 {{{2.9999996843656502, 1.9721416019045801}, {2.9999997725237835, 1.9749798343422071},
146 {5.3039068214821359e-315, 8.9546185262775165e-307}}},
147 {{{2.9984791443874976, 1.974505741312242}, {2.9999992702127476, 1.9738772171479178},
148 {3.0015187977319759, 1.9732495027303418}}},
149
150 {{{0.647069409,2.97691634}, {0.946860918,3.17625612}, {1.46875407,2.65105457}}},
151 {{{0,1}, {0.723699095,2.82756208}, {1.08907197,2.97497449}}},
152
153 {{{131.37418,11414.9825}, {130.28798,11415.9328}, {130.042755,11417.4131}}},
154 {{{130.585787,11418.4142}, {130.021447,11417.8498}, {130,11417}}},
155
156 {{{130.73167037963867, 11418.546386718750}, {131.26360225677490, 11418.985778808592},
157 {132, 11419 }}},
158 {{{132, 11419}, {131.15012693405151, 11418.978546142578},
159 {130.58578681945801, 11418.414184570313}}},
160
161 {{{132, 11419},
162 {130.73167037963867, 11418.546386718750}, {131.26360225677490, 11418.985778808592}}},
163 {{{131.15012693405151, 11418.978546142578},
164 {130.58578681945801, 11418.414184570313}, {132, 11419}}},
165
166 {{{3.0774019473063863, 3.35198509346713}, {3.0757503498668397, 3.327320623945933},
167 {3.0744102085015879, 3.3025879417907196}}},
168 {{{3.053913680774329, 3.3310471586283938}, {3.0758730889691694, 3.3273466070370152},
169 {3.0975671980059394, 3.3235031316554351}}},
170
171 {{{3.39068129, 4.44939202}, {3.03659239, 3.81843234}, {3.06844529, 3.02100922}}},
172 {{{2.10714698, 3.44196686}, {3.12180288, 3.38575704}, {3.75968569, 3.1281838}}},
173
174 {{{2.74792918, 4.77711896}, {2.82236867, 4.23882547}, {2.82848144, 3.63729341}}},
175 {{{2.62772567, 3.64823958}, {3.46652495, 3.64258364}, {4.1425079, 3.48623815}}},
176
177 {{{1.34375, 2.03125}, {2.2734375, 2.6640625}, {3.25, 3.25}}},
178 {{{3.96875, 4.65625}, {3.3359375, 3.7265625}, {2.75, 2.75}}},
179
180 {{{0, 1}, {0.324417544, 2.27953848}, {0.664376547, 2.58940267}}},
181 {{{1, 2}, {0.62109375, 2.70703125}, {0.640625, 2.546875}}},
182
183 {{{1, 2}, {0.984375, 2.3359375}, {1.0625, 2.15625}}},
184 {{{0, 1}, {0.983539095, 2.30041152}, {1.47325103, 2.61316872}}},
185
186 {{{4.09011926, 2.20971038}, {4.74608133, 1.9335932}, {5.02469918, 2.00694987}}},
187 {{{2.79472921, 1.73568666}, {3.36246373, 1.21251209}, {5, 2}}},
188
189 {{{1.80814127, 2.41537795}, {2.23475077, 2.05922313}, {3.16529668, 1.98358763}}},
190 {{{2.16505631, 2.55782454}, {2.40541285, 2.02193091}, {2.99836023, 1.68247638}}},
191
192 {{{3, 1.875}, {3.375, 1.54296875}, {3.375, 1.421875}}},
193 {{{3.375, 1.421875}, {3.3749999999999996, 1.3007812499999998}, {3, 2}}},
194
195 {{{3.34, 8.98}, {2.83363281, 9.4265625}, {2.83796875, 9.363125}}},
196 {{{2.83796875, 9.363125}, {2.84230469, 9.2996875}, {3.17875, 9.1725}}},
197
198 {{{2.7279999999999998, 3.024}, {2.5600000000000005, 2.5600000000000005},
199 {2.1520000000000001, 1.8560000000000001}}},
200 {{{0.66666666666666652, 1.1481481481481481}, {1.3333333333333326, 1.3333333333333335},
201 {2.6666666666666665, 2.1851851851851851}}},
202
203 {{{2.728, 3.024}, {2.56, 2.56}, {2.152, 1.856}}},
204 {{{0.666666667, 1.14814815}, {1.33333333, 1.33333333}, {2.66666667, 2.18518519}}},
205
206 {{{0.875, 1.5}, {1.03125, 1.11022302e-16}, {1, 0}}},
207 {{{0.875, 0.859375}, {1.6875, 0.73046875}, {2.5, 0.625}}},
208
209 {{{1.64451042, 0.0942001592}, {1.53635465, 0.00152863961}, {1, 0}}},
210 {{{1.27672209, 0.15}, {1.32143477, 9.25185854e-17}, {1, 0}}},
211
212 {{{0, 0}, {0.51851851851851849, 1.0185185185185186}, {1.2592592592592591, 1.9259259259259258}}},
213 {{{1.2592592592592593, 1.9259259259259265}, {0.51851851851851893, 1.0185185185185195}, {0, 0}}},
214
215 {{{1.93281168, 2.58856757}, {2.38543691, 2.7096125}, {2.51967352, 2.34531784}}},
216 {{{2.51967352, 2.34531784}, {2.65263731, 2.00639194}, {3.1212119, 1.98608967}}},
217 {{{2.09544533, 2.51981963}, {2.33331524, 2.25252128}, {2.92003302, 2.39442311}}},
218
219 {{{0.924337655, 1.94072717}, {1.25185043, 1.52836494}, {1.71793901, 1.06149951}}},
220 {{{0.940798831, 1.67439357}, {1.25988251, 1.39778567}, {1.71791672, 1.06650313}}},
221
222 {{{0.924337655, 1.94072717}, {1.39158994, 1.32418496}, {2.14967426, 0.687365435}}},
223 {{{0.940798831, 1.67439357}, {1.48941875, 1.16280321}, {2.47884711, 0.60465921}}},
224
225 {{{1.7465749139282332, 1.9930452039527999}, {1.8320006564080331, 1.859481345189089},
226 {1.8731035127758437, 1.6344055934266613}}},
227 {{{1.8731035127758437, 1.6344055934266613}, {1.89928170345231, 1.5006405518943067},
228 {1.9223833226085514, 1.3495796165215643}}},
229 {{{1.74657491, 1.9930452}, {1.87407679, 1.76762853}, {1.92238332, 1.34957962}}},
230 {{{0.60797907, 1.68776977}, {1.0447864, 1.50810914}, {1.87464474, 1.63655092}}},
231 {{{1.87464474, 1.63655092}, {2.70450308, 1.76499271}, {4, 3}}},
232
233 {{{1.2071879545809394, 0.82163474041730045}, {1.1534203513372994, 0.52790870069930229},
234 {1.0880000000000001, 0.29599999999999982}}}, //t=0.63155333662549329,0.80000000000000004
235 {{{0.33333333333333326, 0.81481481481481488}, {0.63395173631977997, 0.68744136726313931},
236 {1.205684411948591, 0.81344322326274499}}},
237 {{{0.33333333333333326, 0.81481481481481488}, {0.63396444791444551, 0.68743368362444768},
238 {1.205732763658403, 0.81345617746834109}}}, //t=0.33333333333333331, 0.63396444791444551
239 {{{1.205684411948591, 0.81344322326274499}, {1.2057085875611198, 0.81344969999329253},
240 {1.205732763658403, 0.81345617746834109}}},
241
242 {{{1.20718795, 0.82163474}, {1.15342035, 0.527908701}, {1.088, 0.296}}},
243 {{{1.20568441, 0.813443223}, {1.20570859, 0.8134497}, {1.20573276, 0.813456177}}},
244
245 {{{41.5072916, 87.1234036}, {28.2747836, 80.9545395}, {23.5780771, 69.3344126}}},
246 {{{72.9633878, 95.6593007}, {42.7738746, 88.4730382}, {31.1932785, 80.2458029}}},
247
248 {{{31.1663962, 54.7302484}, {31.1662882, 54.7301074}, {31.1663969, 54.7302485}}},
249 {{{26.0404936, 45.4260361}, {27.7887523, 33.1863051}, {40.8833242, 26.0301855}}},
250
251 {{{29.9404074, 49.1672596}, {44.3131071, 45.3915253}, {58.1067559, 59.5061814}}},
252 {{{72.6510251, 64.2972928}, {53.6989659, 60.1862397}, {35.2053722, 44.8391126}}},
253
254 {{{52.14807018377202, 65.012420045148644}, {44.778669050208237, 66.315562705604378},
255 {51.619118408823567, 63.787827046262684}}},
256 {{{30.004993234763383, 93.921296668202288}, {53.384822003076991, 60.732180341802753},
257 {58.652998934338584, 43.111073088306185}}},
258
259 {{{80.897794748143198, 49.236332042718459}, {81.082078218891212, 64.066749904488631},
260 {69.972305057149981, 72.968595519850993}}},
261 {{{72.503745601281395, 32.952320736577882}, {88.030880716061645, 38.137194847810164},
262 {73.193774825517906, 67.773492479591397}}},
263
264 {{{67.426548091427676, 37.993772624988935}, {51.129513170665035, 57.542281234563646},
265 {44.594748190899189, 65.644267382683879}}},
266 {{{61.336508189019057, 82.693132843213675}, {54.825078921449354, 71.663932799212432},
267 {47.727444217558926, 61.4049645128392}}},
268
269 {{{67.4265481, 37.9937726}, {51.1295132, 57.5422812}, {44.5947482, 65.6442674}}},
270 {{{61.3365082, 82.6931328}, {54.8250789, 71.6639328}, {47.7274442, 61.4049645}}},
271
272 {{{53.774852327053594, 53.318060789841951}, {45.787877803416805, 51.393492026284981},
273 {46.703936967162392, 53.06860709822206}}},
274 {{{46.703936967162392, 53.06860709822206}, {47.619996130907957, 54.74372217015916},
275 {53.020051653535361, 48.633140968832024}}},
276
277 {{{50.934805397717923, 51.52391952648901}, {56.803308902971423, 44.246234610627596},
278 {69.776888596721406, 40.166645096692555}}},
279 {{{50.230212796400401, 38.386469101526998}, {49.855620812184917, 38.818990392153609},
280 {56.356567496227363, 47.229909093319407}}},
281
282 {{{36.148792695174222, 70.336952793070424}, {36.141613037691357, 70.711654739870085},
283 {36.154708826402597, 71.088492662905836}}},
284 {{{35.216235592661825, 70.580199617313212}, {36.244476835123969, 71.010897787304074},
285 {37.230244263238326, 71.423156953613102}}},
286
287 // this pair is nearly coincident, and causes the quartic code to produce bad
288 // data. Mathematica doesn't think they touch. Graphically, I can't tell.
289 // it may not be so bad to pretend that they don't touch, if I can detect that
290 {{{369.848602, 145.680267}, {382.360413, 121.298294}, {406.207703, 121.298294}}},
291 {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
292
293 {{{33.567436351153468, 62.336347586395924}, {35.200980274619084, 65.038561460144479},
294 {36.479571811084995, 67.632178905412445}}},
295 {{{41.349524945572696, 67.886658677862641}, {39.125562529359087, 67.429772735149214},
296 {35.600314083992416, 66.705372160552685}}},
297
298 {{{67.25299631583178, 21.109080184767524}, {43.617595267398613, 33.658034168577529},
299 {33.38371819435676, 44.214192553988745}}},
300 {{{40.476838859398541, 39.543209911285999}, {36.701186108431131, 34.8817994016458},
301 {30.102144288878023, 26.739063172945315}}},
302
303 {{{25.367434474345036, 50.4712103169743}, {17.865013304933097, 37.356741010559439},
304 {16.818988838905465, 37.682915484123129}}},
305 {{{16.818988838905465, 37.682915484123129}, {15.772964372877833, 38.009089957686811},
306 {20.624104547604965, 41.825131596683121}}},
307
308 {{{26.440225044088567, 79.695009812848298}, {26.085525979582247, 83.717928354134784},
309 {27.075079976297072, 84.820633667838905}}},
310 {{{27.075079976297072, 84.820633667838905}, {28.276546859574015, 85.988574184029034},
311 {25.649263209500006, 87.166762066617025}}},
312
313 {{{34.879150914024962, 83.862726601601125}, {35.095810134304429, 83.693473210169543},
314 {35.359284111931586, 83.488069234177502}}},
315 {{{54.503204203015471, 76.094098492518242}, {51.366889541918894, 71.609856061299155},
316 {46.53086955445437, 69.949863036494207}}},
317
318 {{{0, 0}, {1, 0}, {0, 3}}},
319 {{{1, 0}, {0, 1}, {1, 1}}},
320 {{{369.961151, 137.980698}, {383.970093, 121.298294}, {406.213287, 121.298294}}},
321 {{{353.2948, 194.351074}, {353.2948, 173.767563}, {364.167572, 160.819855}}},
322 {{{360.416077, 166.795715}, {370.126831, 147.872162}, {388.635406, 147.872162}}},
323 {{{406.236359, 121.254936}, {409.445679, 121.254936}, {412.975952, 121.789818}}},
324 {{{406.235992, 121.254936}, {425.705902, 121.254936}, {439.71994, 137.087616}}},
325
326 {{{369.8543701171875, 145.66734313964844}, {382.36788940429688, 121.28203582763672},
327 {406.21844482421875, 121.28203582763672}}},
328 {{{369.96469116210938, 137.96672058105469}, {383.97555541992188, 121.28203582763672},
329 {406.2218017578125, 121.28203582763672}}},
330
331 {{{369.962311, 137.976044}, {383.971893, 121.29287}, {406.216125, 121.29287}}},
332
333 {{{400.121704, 149.468719}, {391.949493, 161.037186}, {391.949493, 181.202423}}},
334 {{{391.946747, 181.839218}, {391.946747, 155.62442}, {406.115479, 138.855438}}},
335 {{{360.048828125, 229.2578125}, {360.048828125, 224.4140625}, {362.607421875, 221.3671875}}},
336 {{{362.607421875, 221.3671875}, {365.166015625, 218.3203125}, {369.228515625, 218.3203125}}},
337 {{{8, 8}, {10, 10}, {8, -10}}},
338 {{{8, 8}, {12, 12}, {14, 4}}},
339 {{{8, 8}, {9, 9}, {10, 8}}}
340};
341
342const size_t testSetCount = std::size(testSet);
343
344static void oneOffTest1(skiatest::Reporter* reporter, size_t outer, size_t inner) {
345 const QuadPts& q1 = testSet[outer];
346 SkDQuad quad1;
347 quad1.debugSet(q1.fPts);
348 SkASSERT(ValidQuad(quad1));
349 const QuadPts& q2 = testSet[inner];
350 SkDQuad quad2;
351 quad2.debugSet(q2.fPts);
352 SkASSERT(ValidQuad(quad2));
353 SkIntersections intersections;
354 intersections.intersect(quad1, quad2);
355 for (int pt = 0; pt < intersections.used(); ++pt) {
356 double tt1 = intersections[0][pt];
357 SkDPoint xy1 = quad1.ptAtT(tt1);
358 double tt2 = intersections[1][pt];
359 SkDPoint xy2 = quad2.ptAtT(tt2);
360 if (!xy1.approximatelyEqual(xy2)) {
361 SkDebugf("%s [%d,%d] x!= t1=%g (%g,%g) t2=%g (%g,%g)\n",
362 __FUNCTION__, static_cast<int>(outer), static_cast<int>(inner),
363 tt1, xy1.fX, xy1.fY, tt2, xy2.fX, xy2.fY);
364 REPORTER_ASSERT(reporter, 0);
365 }
366#if ONE_OFF_DEBUG
367 SkDebugf("%s [%d][%d] t1=%1.9g (%1.9g, %1.9g) t2=%1.9g\n", __FUNCTION__,
368 outer, inner, tt1, xy1.fX, xy1.fY, tt2);
369#endif
370 }
371}
372
373static void oneOffTests(skiatest::Reporter* reporter) {
374 for (size_t outer = 0; outer < testSetCount - 1; ++outer) {
375 for (size_t inner = outer + 1; inner < testSetCount; ++inner) {
376 oneOffTest1(reporter, outer, inner);
377 }
378 }
379}
380
381static const QuadPts coincidentTestSet[] = {
382 {{{4914.9990234375, 1523}, {4942.75146484375, 1523}, {4962.375, 1542.6239013671875}}},
383 {{{4962.3759765625, 1542.6239013671875}, {4942.75244140625, 1523}, {4915, 1523}}},
384#if 0
385 {{{97.9337615966796875,100}, {88,112.94264984130859375}, {88,130}}},
386 {{{88,130}, {88,124.80951690673828125}, {88.91983795166015625,120}}},
387#endif
388 {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
389 {{{369.850525, 145.675964}, {382.362915, 121.29287}, {406.211273, 121.29287}}},
390 {{{8, 8}, {10, 10}, {8, -10}}},
391 {{{8, -10}, {10, 10}, {8, 8}}},
392};
393
394static const int coincidentTestSetCount = (int) std::size(coincidentTestSet);
395
396static void coincidentTestOne(skiatest::Reporter* reporter, int test1, int test2) {
397 const QuadPts& q1 = coincidentTestSet[test1];
398 SkDQuad quad1;
399 quad1.debugSet(q1.fPts);
400 SkASSERT(ValidQuad(quad1));
401 const QuadPts& q2 = coincidentTestSet[test2];
402 SkDQuad quad2;
403 quad2.debugSet(q2.fPts);
404 SkASSERT(ValidQuad(quad2));
405 SkIntersections intersections2;
406 intersections2.intersect(quad1, quad2);
407 REPORTER_ASSERT(reporter, intersections2.debugCoincidentUsed() >= 2);
408 REPORTER_ASSERT(reporter, intersections2.used() >= 2);
409 for (int pt = 0; pt < intersections2.debugCoincidentUsed(); pt += 2) {
410 double tt1 = intersections2[0][pt];
411 double tt2 = intersections2[1][pt];
412 SkDPoint pt1 = quad1.ptAtT(tt1);
413 SkDPoint pt2 = quad2.ptAtT(tt2);
414 REPORTER_ASSERT(reporter, pt1.approximatelyEqual(pt2));
415 }
416}
417
418static void coincidentTest(skiatest::Reporter* reporter) {
419 for (int testIndex = 0; testIndex < coincidentTestSetCount - 1; testIndex += 2) {
420 coincidentTestOne(reporter, testIndex, testIndex + 1);
421 }
422}
423
424static void intersectionFinder(int test1, int test2) {
425 const QuadPts& q1 = testSet[test1];
426 const QuadPts& q2 = testSet[test2];
427 SkDQuad quad1, quad2;
428 quad1.debugSet(q1.fPts);
429 quad2.debugSet(q2.fPts);
430 double t1Seed = 0.5;
431 double t2Seed = 0.8;
432 double t1Step = 0.1;
433 double t2Step = 0.1;
434 SkDPoint t1[3], t2[3];
435 bool toggle = true;
436 do {
437 t1[0] = quad1.ptAtT(t1Seed - t1Step);
438 t1[1] = quad1.ptAtT(t1Seed);
439 t1[2] = quad1.ptAtT(t1Seed + t1Step);
440 t2[0] = quad2.ptAtT(t2Seed - t2Step);
441 t2[1] = quad2.ptAtT(t2Seed);
442 t2[2] = quad2.ptAtT(t2Seed + t2Step);
443 double dist[3][3];
444 dist[1][1] = t1[1].distance(t2[1]);
445 int best_i = 1, best_j = 1;
446 for (int i = 0; i < 3; ++i) {
447 for (int j = 0; j < 3; ++j) {
448 if (i == 1 && j == 1) {
449 continue;
450 }
451 dist[i][j] = t1[i].distance(t2[j]);
452 if (dist[best_i][best_j] > dist[i][j]) {
453 best_i = i;
454 best_j = j;
455 }
456 }
457 }
458 if (best_i == 0) {
459 t1Seed -= t1Step;
460 } else if (best_i == 2) {
461 t1Seed += t1Step;
462 }
463 if (best_j == 0) {
464 t2Seed -= t2Step;
465 } else if (best_j == 2) {
466 t2Seed += t2Step;
467 }
468 if (best_i == 1 && best_j == 1) {
469 if ((toggle ^= true)) {
470 t1Step /= 2;
471 } else {
472 t2Step /= 2;
473 }
474 }
475 } while (!t1[1].approximatelyEqual(t2[1]));
476 t1Step = t2Step = 0.1;
477 double t10 = t1Seed - t1Step * 2;
478 double t12 = t1Seed + t1Step * 2;
479 double t20 = t2Seed - t2Step * 2;
480 double t22 = t2Seed + t2Step * 2;
481 SkDPoint test;
482 while (!approximately_zero(t1Step)) {
483 test = quad1.ptAtT(t10);
484 t10 += t1[1].approximatelyEqual(test) ? -t1Step : t1Step;
485 t1Step /= 2;
486 }
487 t1Step = 0.1;
488 while (!approximately_zero(t1Step)) {
489 test = quad1.ptAtT(t12);
490 t12 -= t1[1].approximatelyEqual(test) ? -t1Step : t1Step;
491 t1Step /= 2;
492 }
493 while (!approximately_zero(t2Step)) {
494 test = quad2.ptAtT(t20);
495 t20 += t2[1].approximatelyEqual(test) ? -t2Step : t2Step;
496 t2Step /= 2;
497 }
498 t2Step = 0.1;
499 while (!approximately_zero(t2Step)) {
500 test = quad2.ptAtT(t22);
501 t22 -= t2[1].approximatelyEqual(test) ? -t2Step : t2Step;
502 t2Step /= 2;
503 }
504#if ONE_OFF_DEBUG
505 SkDebugf("%s t1=(%1.9g<%1.9g<%1.9g) t2=(%1.9g<%1.9g<%1.9g)\n", __FUNCTION__,
506 t10, t1Seed, t12, t20, t2Seed, t22);
507 SkDPoint p10 = quad1.ptAtT(t10);
508 SkDPoint p1Seed = quad1.ptAtT(t1Seed);
509 SkDPoint p12 = quad1.ptAtT(t12);
510 SkDebugf("%s p1=(%1.9g,%1.9g)<(%1.9g,%1.9g)<(%1.9g,%1.9g)\n", __FUNCTION__,
511 p10.fX, p10.fY, p1Seed.fX, p1Seed.fY, p12.fX, p12.fY);
512 SkDPoint p20 = quad2.ptAtT(t20);
513 SkDPoint p2Seed = quad2.ptAtT(t2Seed);
514 SkDPoint p22 = quad2.ptAtT(t22);
515 SkDebugf("%s p2=(%1.9g,%1.9g)<(%1.9g,%1.9g)<(%1.9g,%1.9g)\n", __FUNCTION__,
516 p20.fX, p20.fY, p2Seed.fX, p2Seed.fY, p22.fX, p22.fY);
517#endif
518}
519
520static void QuadraticIntersection_IntersectionFinder() {
521 intersectionFinder(0, 1);
522}
523
524DEF_TEST(PathOpsQuadIntersectionOneOff, reporter) {
525 oneOffTest1(reporter, 0, 1);
526}
527
528DEF_TEST(PathOpsQuadIntersectionCoincidenceOneOff, reporter) {
529 coincidentTestOne(reporter, 0, 1);
530}
531
532DEF_TEST(PathOpsQuadIntersection, reporter) {
533 oneOffTests(reporter);
534 coincidentTest(reporter);
535 standardTestCases(reporter);
536 if ((false)) QuadraticIntersection_IntersectionFinder();
537}
538
539DEF_TEST(PathOpsQuadBinaryProfile, reporter) {
540 if (!SkPathOpsDebug::gVeryVerbose) {
541 return;
542 }
543 SkIntersections intersections;
544 for (int x = 0; x < 100; ++x) {
545 int outer = 0;
546 int inner = outer + 1;
547 do {
548 const QuadPts& q1 = testSet[outer];
549 SkDQuad quad1;
550 quad1.debugSet(q1.fPts);
551 const QuadPts& q2 = testSet[inner];
552 SkDQuad quad2;
553 quad2.debugSet(q2.fPts);
554 (void) intersections.intersect(quad1, quad2);
555 REPORTER_ASSERT(reporter, intersections.used() >= 0); // make sure code isn't tossed
556 inner += 2;
557 outer += 2;
558 } while (outer < (int) testSetCount);
559 }
560 for (int x = 0; x < 100; ++x) {
561 for (size_t test = 0; test < quadraticTests_count; ++test) {
562 const QuadPts& q1 = quadraticTests[test][0];
563 const QuadPts& q2 = quadraticTests[test][1];
564 SkDQuad quad1, quad2;
565 quad1.debugSet(q1.fPts);
566 quad2.debugSet(q2.fPts);
567 (void) intersections.intersect(quad1, quad2);
568 REPORTER_ASSERT(reporter, intersections.used() >= 0); // make sure code isn't tossed
569 }
570 }
571}
test
#define test(name)
reporter
reporter
Definition: FontMgrTest.cpp:39
quadraticTests_count
const size_t quadraticTests_count
Definition: PathOpsQuadIntersectionTestData.cpp:107
quadraticTests
const QuadPts quadraticTests[][2]
Definition: PathOpsQuadIntersectionTestData.cpp:88
intersectionFinder
static void intersectionFinder(int test1, int test2)
Definition: PathOpsQuadIntersectionTest.cpp:424
standardTestCases
static void standardTestCases(skiatest::Reporter *reporter)
Definition: PathOpsQuadIntersectionTest.cpp:23
coincidentTestSet
static const QuadPts coincidentTestSet[]
Definition: PathOpsQuadIntersectionTest.cpp:381
oneOffTest1
static void oneOffTest1(skiatest::Reporter *reporter, size_t outer, size_t inner)
Definition: PathOpsQuadIntersectionTest.cpp:344
DEF_TEST
DEF_TEST(PathOpsQuadIntersectionOneOff, reporter)
Definition: PathOpsQuadIntersectionTest.cpp:524
QuadraticIntersection_IntersectionFinder
static void QuadraticIntersection_IntersectionFinder()
Definition: PathOpsQuadIntersectionTest.cpp:520
oneOffTests
static void oneOffTests(skiatest::Reporter *reporter)
Definition: PathOpsQuadIntersectionTest.cpp:373
coincidentTest
static void coincidentTest(skiatest::Reporter *reporter)
Definition: PathOpsQuadIntersectionTest.cpp:418
testSet
static const QuadPts testSet[]
Definition: PathOpsQuadIntersectionTest.cpp:68
coincidentTestSetCount
static const int coincidentTestSetCount
Definition: PathOpsQuadIntersectionTest.cpp:394
coincidentTestOne
static void coincidentTestOne(skiatest::Reporter *reporter, int test1, int test2)
Definition: PathOpsQuadIntersectionTest.cpp:396
testSetCount
const size_t testSetCount
Definition: PathOpsQuadIntersectionTest.cpp:342
ValidQuad
bool ValidQuad(const SkDQuad &quad)
Definition: PathOpsTestCommon.cpp:323
SkASSERT
#define SkASSERT(cond)
Definition: SkAssert.h:116
approximately_zero
static bool approximately_zero(double x)
Definition: SkCubics.cpp:153
SkDebugf
void SK_SPI SkDebugf(const char format[],...) SK_PRINTF_LIKE(1
SkBits2Float
static float SkBits2Float(uint32_t bits)
Definition: SkFloatBits.h:48
REPORTER_ASSERT
#define REPORTER_ASSERT(r, cond,...)
Definition: Test.h:286
test1
static void test1(skiatest::Reporter *reporter, SkWriter32 *writer)
Definition: Writer32Test.cpp:84
SkIntersections::intersect
int intersect(const SkDLine &, const SkDLine &)
Definition: SkDLineIntersection.cpp:87
SkIntersections::debugCoincidentUsed
int debugCoincidentUsed() const
Definition: SkPathOpsDebug.cpp:2656
SkIntersections::used
int used() const
Definition: SkIntersections.h:228
SkPathOpsDebug::gVeryVerbose
static bool gVeryVerbose
Definition: SkPathOpsDebug.h:312
i
int i
Definition: fl_socket_accessible.cc:18
x
double x
Definition: mouse-input-test.cc:82
flutter::size
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition: switches.h:259
QuadPts::fPts
SkDPoint fPts[kPointCount]
Definition: PathOpsTestCommon.h:24
SkDPoint::approximatelyEqual
bool approximatelyEqual(const SkDPoint &a) const
Definition: SkPathOpsPoint.h:177
SkDPoint::distance
double distance(const SkDPoint &a) const
Definition: SkPathOpsPoint.h:224
SkDQuad::debugSet
void debugSet(const SkDPoint *pts)
Definition: SkPathOpsDebug.cpp:707
SkDQuad::ptAtT
SkDPoint ptAtT(double t) const
Definition: SkPathOpsQuad.cpp:224
SkReduceOrder::reduce
int reduce(const SkDCubic &cubic, Quadratics)
Definition: SkReduceOrder.cpp:195
Generated on Sun Jun 23 2024 21:56:44 for Flutter Engine by doxygen 1.9.4