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 "SkGeometry.h"
9 #include "Test.h"
10 #include "SkRandom.h"
11 #include <array>
12
nearly_equal(const SkPoint & a,const SkPoint & b)13 static bool nearly_equal(const SkPoint& a, const SkPoint& b) {
14 return SkScalarNearlyEqual(a.fX, b.fX) && SkScalarNearlyEqual(a.fY, b.fY);
15 }
16
testChopCubic(skiatest::Reporter * reporter)17 static void testChopCubic(skiatest::Reporter* reporter) {
18 /*
19 Inspired by this test, which used to assert that the tValues had dups
20
21 <path stroke="#202020" d="M0,0 C0,0 1,1 2190,5130 C2190,5070 2220,5010 2205,4980" />
22 */
23 const SkPoint src[] = {
24 { SkIntToScalar(2190), SkIntToScalar(5130) },
25 { SkIntToScalar(2190), SkIntToScalar(5070) },
26 { SkIntToScalar(2220), SkIntToScalar(5010) },
27 { SkIntToScalar(2205), SkIntToScalar(4980) },
28 };
29 SkPoint dst[13];
30 SkScalar tValues[3];
31 // make sure we don't assert internally
32 int count = SkChopCubicAtMaxCurvature(src, dst, tValues);
33 if (false) { // avoid bit rot, suppress warning
34 REPORTER_ASSERT(reporter, count);
35 }
36 }
37
check_pairs(skiatest::Reporter * reporter,int index,SkScalar t,const char name[],SkScalar x0,SkScalar y0,SkScalar x1,SkScalar y1)38 static void check_pairs(skiatest::Reporter* reporter, int index, SkScalar t, const char name[],
39 SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1) {
40 bool eq = SkScalarNearlyEqual(x0, x1) && SkScalarNearlyEqual(y0, y1);
41 if (!eq) {
42 SkDebugf("%s [%d %g] p0 [%10.8f %10.8f] p1 [%10.8f %10.8f]\n",
43 name, index, t, x0, y0, x1, y1);
44 REPORTER_ASSERT(reporter, eq);
45 }
46 }
47
test_evalquadat(skiatest::Reporter * reporter)48 static void test_evalquadat(skiatest::Reporter* reporter) {
49 SkRandom rand;
50 for (int i = 0; i < 1000; ++i) {
51 SkPoint pts[3];
52 for (int j = 0; j < 3; ++j) {
53 pts[j].set(rand.nextSScalar1() * 100, rand.nextSScalar1() * 100);
54 }
55 const SkScalar dt = SK_Scalar1 / 128;
56 SkScalar t = dt;
57 for (int j = 1; j < 128; ++j) {
58 SkPoint r0;
59 SkEvalQuadAt(pts, t, &r0);
60 SkPoint r1 = SkEvalQuadAt(pts, t);
61 check_pairs(reporter, i, t, "quad-pos", r0.fX, r0.fY, r1.fX, r1.fY);
62
63 SkVector v0;
64 SkEvalQuadAt(pts, t, nullptr, &v0);
65 SkVector v1 = SkEvalQuadTangentAt(pts, t);
66 check_pairs(reporter, i, t, "quad-tan", v0.fX, v0.fY, v1.fX, v1.fY);
67
68 t += dt;
69 }
70 }
71 }
72
test_conic_eval_pos(skiatest::Reporter * reporter,const SkConic & conic,SkScalar t)73 static void test_conic_eval_pos(skiatest::Reporter* reporter, const SkConic& conic, SkScalar t) {
74 SkPoint p0, p1;
75 conic.evalAt(t, &p0, nullptr);
76 p1 = conic.evalAt(t);
77 check_pairs(reporter, 0, t, "conic-pos", p0.fX, p0.fY, p1.fX, p1.fY);
78 }
79
test_conic_eval_tan(skiatest::Reporter * reporter,const SkConic & conic,SkScalar t)80 static void test_conic_eval_tan(skiatest::Reporter* reporter, const SkConic& conic, SkScalar t) {
81 SkVector v0, v1;
82 conic.evalAt(t, nullptr, &v0);
83 v1 = conic.evalTangentAt(t);
84 check_pairs(reporter, 0, t, "conic-tan", v0.fX, v0.fY, v1.fX, v1.fY);
85 }
86
test_conic(skiatest::Reporter * reporter)87 static void test_conic(skiatest::Reporter* reporter) {
88 SkRandom rand;
89 for (int i = 0; i < 1000; ++i) {
90 SkPoint pts[3];
91 for (int j = 0; j < 3; ++j) {
92 pts[j].set(rand.nextSScalar1() * 100, rand.nextSScalar1() * 100);
93 }
94 for (int k = 0; k < 10; ++k) {
95 SkScalar w = rand.nextUScalar1() * 2;
96 SkConic conic(pts, w);
97
98 const SkScalar dt = SK_Scalar1 / 128;
99 SkScalar t = dt;
100 for (int j = 1; j < 128; ++j) {
101 test_conic_eval_pos(reporter, conic, t);
102 test_conic_eval_tan(reporter, conic, t);
103 t += dt;
104 }
105 }
106 }
107 }
108
test_quad_tangents(skiatest::Reporter * reporter)109 static void test_quad_tangents(skiatest::Reporter* reporter) {
110 SkPoint pts[] = {
111 {10, 20}, {10, 20}, {20, 30},
112 {10, 20}, {15, 25}, {20, 30},
113 {10, 20}, {20, 30}, {20, 30},
114 };
115 int count = (int) SK_ARRAY_COUNT(pts) / 3;
116 for (int index = 0; index < count; ++index) {
117 SkConic conic(&pts[index * 3], 0.707f);
118 SkVector start = SkEvalQuadTangentAt(&pts[index * 3], 0);
119 SkVector mid = SkEvalQuadTangentAt(&pts[index * 3], .5f);
120 SkVector end = SkEvalQuadTangentAt(&pts[index * 3], 1);
121 REPORTER_ASSERT(reporter, start.fX && start.fY);
122 REPORTER_ASSERT(reporter, mid.fX && mid.fY);
123 REPORTER_ASSERT(reporter, end.fX && end.fY);
124 REPORTER_ASSERT(reporter, SkScalarNearlyZero(start.cross(mid)));
125 REPORTER_ASSERT(reporter, SkScalarNearlyZero(mid.cross(end)));
126 }
127 }
128
test_conic_tangents(skiatest::Reporter * reporter)129 static void test_conic_tangents(skiatest::Reporter* reporter) {
130 SkPoint pts[] = {
131 { 10, 20}, {10, 20}, {20, 30},
132 { 10, 20}, {15, 25}, {20, 30},
133 { 10, 20}, {20, 30}, {20, 30}
134 };
135 int count = (int) SK_ARRAY_COUNT(pts) / 3;
136 for (int index = 0; index < count; ++index) {
137 SkConic conic(&pts[index * 3], 0.707f);
138 SkVector start = conic.evalTangentAt(0);
139 SkVector mid = conic.evalTangentAt(.5f);
140 SkVector end = conic.evalTangentAt(1);
141 REPORTER_ASSERT(reporter, start.fX && start.fY);
142 REPORTER_ASSERT(reporter, mid.fX && mid.fY);
143 REPORTER_ASSERT(reporter, end.fX && end.fY);
144 REPORTER_ASSERT(reporter, SkScalarNearlyZero(start.cross(mid)));
145 REPORTER_ASSERT(reporter, SkScalarNearlyZero(mid.cross(end)));
146 }
147 }
148
test_this_conic_to_quad(skiatest::Reporter * r,const SkPoint pts[3],SkScalar w)149 static void test_this_conic_to_quad(skiatest::Reporter* r, const SkPoint pts[3], SkScalar w) {
150 SkAutoConicToQuads quadder;
151 const SkPoint* qpts = quadder.computeQuads(pts, w, 0.25);
152 const int qcount = quadder.countQuads();
153 const int pcount = qcount * 2 + 1;
154
155 REPORTER_ASSERT(r, SkPointsAreFinite(qpts, pcount));
156 }
157
158 /**
159 * We need to ensure that when a conic is approximated by quads, that we always return finite
160 * values in the quads.
161 *
162 * Inspired by crbug_627414
163 */
test_conic_to_quads(skiatest::Reporter * reporter)164 static void test_conic_to_quads(skiatest::Reporter* reporter) {
165 const SkPoint triples[] = {
166 { 0, 0 }, { 1, 0 }, { 1, 1 },
167 { 0, 0 }, { 3.58732e-43f, 2.72084f }, { 3.00392f, 3.00392f },
168 { 0, 0 }, { 100000, 0 }, { 100000, 100000 },
169 { 0, 0 }, { 1e30f, 0 }, { 1e30f, 1e30f },
170 };
171 const int N = sizeof(triples) / sizeof(SkPoint);
172
173 for (int i = 0; i < N; i += 3) {
174 const SkPoint* pts = &triples[i];
175
176 SkRect bounds;
177 bounds.set(pts, 3);
178
179 SkScalar w = 1e30f;
180 do {
181 w *= 2;
182 test_this_conic_to_quad(reporter, pts, w);
183 } while (SkScalarIsFinite(w));
184 test_this_conic_to_quad(reporter, pts, SK_ScalarNaN);
185 }
186 }
187
test_cubic_tangents(skiatest::Reporter * reporter)188 static void test_cubic_tangents(skiatest::Reporter* reporter) {
189 SkPoint pts[] = {
190 { 10, 20}, {10, 20}, {20, 30}, {30, 40},
191 { 10, 20}, {15, 25}, {20, 30}, {30, 40},
192 { 10, 20}, {20, 30}, {30, 40}, {30, 40},
193 };
194 int count = (int) SK_ARRAY_COUNT(pts) / 4;
195 for (int index = 0; index < count; ++index) {
196 SkConic conic(&pts[index * 3], 0.707f);
197 SkVector start, mid, end;
198 SkEvalCubicAt(&pts[index * 4], 0, nullptr, &start, nullptr);
199 SkEvalCubicAt(&pts[index * 4], .5f, nullptr, &mid, nullptr);
200 SkEvalCubicAt(&pts[index * 4], 1, nullptr, &end, nullptr);
201 REPORTER_ASSERT(reporter, start.fX && start.fY);
202 REPORTER_ASSERT(reporter, mid.fX && mid.fY);
203 REPORTER_ASSERT(reporter, end.fX && end.fY);
204 REPORTER_ASSERT(reporter, SkScalarNearlyZero(start.cross(mid)));
205 REPORTER_ASSERT(reporter, SkScalarNearlyZero(mid.cross(end)));
206 }
207 }
208
check_cubic_type(skiatest::Reporter * reporter,const std::array<SkPoint,4> & bezierPoints,SkCubicType expectedType)209 static void check_cubic_type(skiatest::Reporter* reporter,
210 const std::array<SkPoint, 4>& bezierPoints, SkCubicType expectedType) {
211 SkCubicType actualType = SkClassifyCubic(bezierPoints.data());
212 REPORTER_ASSERT(reporter, actualType == expectedType);
213 }
214
test_classify_cubic(skiatest::Reporter * reporter)215 static void test_classify_cubic(skiatest::Reporter* reporter) {
216 check_cubic_type(reporter, {{{149.325f, 107.705f}, {149.325f, 103.783f},
217 {151.638f, 100.127f}, {156.263f, 96.736f}}},
218 SkCubicType::kQuadratic);
219 check_cubic_type(reporter, {{{225.694f, 223.15f}, {209.831f, 224.837f},
220 {195.994f, 230.237f}, {184.181f, 239.35f}}},
221 SkCubicType::kQuadratic);
222 check_cubic_type(reporter, {{{4.873f, 5.581f}, {5.083f, 5.2783f},
223 {5.182f, 4.8593f}, {5.177f, 4.3242f}}},
224 SkCubicType::kSerpentine);
225 }
226
DEF_TEST(Geometry,reporter)227 DEF_TEST(Geometry, reporter) {
228 SkPoint pts[3], dst[5];
229
230 pts[0].set(0, 0);
231 pts[1].set(100, 50);
232 pts[2].set(0, 100);
233
234 int count = SkChopQuadAtMaxCurvature(pts, dst);
235 REPORTER_ASSERT(reporter, count == 1 || count == 2);
236
237 pts[0].set(0, 0);
238 pts[1].set(3, 0);
239 pts[2].set(3, 3);
240 SkConvertQuadToCubic(pts, dst);
241 const SkPoint cubic[] = {
242 { 0, 0, }, { 2, 0, }, { 3, 1, }, { 3, 3 },
243 };
244 for (int i = 0; i < 4; ++i) {
245 REPORTER_ASSERT(reporter, nearly_equal(cubic[i], dst[i]));
246 }
247
248 testChopCubic(reporter);
249 test_evalquadat(reporter);
250 test_conic(reporter);
251 test_cubic_tangents(reporter);
252 test_quad_tangents(reporter);
253 test_conic_tangents(reporter);
254 test_conic_to_quads(reporter);
255 test_classify_cubic(reporter);
256 }
257