OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright 2015 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 "SkMatrix.h" |
| 9 #include "SkPath.h" |
| 10 #include "SkPathRef.h" |
| 11 #include "SkPathOps.h" |
| 12 #include "SkRRect.h" |
| 13 #include "Test.h" |
| 14 |
| 15 static SkRRect path_contains_rrect(skiatest::Reporter* reporter, const SkPath& p
ath) { |
| 16 SkRRect out; |
| 17 REPORTER_ASSERT(reporter, path.isRRect(&out)); |
| 18 SkPath path2, xorBoth; |
| 19 path2.addRRect(out); |
| 20 if (path == path2) { |
| 21 return out; |
| 22 } |
| 23 Op(path, path2, SkPathOp::kXOR_SkPathOp, &xorBoth); |
| 24 REPORTER_ASSERT(reporter, xorBoth.isEmpty()); |
| 25 return out; |
| 26 } |
| 27 |
| 28 static SkRRect inner_path_contains_rrect(skiatest::Reporter* reporter, const SkR
Rect& in) { |
| 29 switch (in.getType()) { |
| 30 case SkRRect::kEmpty_Type: |
| 31 case SkRRect::kRect_Type: |
| 32 case SkRRect::kOval_Type: |
| 33 return in; |
| 34 default: |
| 35 break; |
| 36 } |
| 37 SkPath path; |
| 38 path.addRRect(in); |
| 39 return path_contains_rrect(reporter, path); |
| 40 } |
| 41 |
| 42 static void path_contains_rrect_check(skiatest::Reporter* reporter, const SkRRec
t& in) { |
| 43 SkRRect out = inner_path_contains_rrect(reporter, in); |
| 44 if (in != out) { |
| 45 SkDebugf(""); |
| 46 } |
| 47 REPORTER_ASSERT(reporter, in == out); |
| 48 } |
| 49 |
| 50 static void path_contains_rrect_nocheck(skiatest::Reporter* reporter, const SkRR
ect& in) { |
| 51 SkRRect out = inner_path_contains_rrect(reporter, in); |
| 52 if (in == out) { |
| 53 SkDebugf(""); |
| 54 } |
| 55 } |
| 56 |
| 57 static void path_contains_rrect_check(skiatest::Reporter* reporter, const SkRect
& r, |
| 58 SkVector v[4]) { |
| 59 SkRRect rrect; |
| 60 rrect.setRectRadii(r, v); |
| 61 path_contains_rrect_check(reporter, rrect); |
| 62 } |
| 63 |
| 64 class ForceIsRRect_Private { |
| 65 public: |
| 66 ForceIsRRect_Private(SkPath* path) { |
| 67 path->fPathRef->setIsRRect(true); |
| 68 } |
| 69 }; |
| 70 |
| 71 static void force_path_contains_rrect(skiatest::Reporter* reporter, SkPath& path
) { |
| 72 ForceIsRRect_Private force_rrect(&path); |
| 73 path_contains_rrect(reporter, path); |
| 74 } |
| 75 |
| 76 static void test_undetected_paths(skiatest::Reporter* reporter) { |
| 77 SkPath path; |
| 78 path.moveTo(0, 62.5f); |
| 79 path.lineTo(0, 3.5f); |
| 80 path.conicTo(0, 0, 3.5f, 0, 0.70710677f); |
| 81 path.lineTo(196.5f, 0); |
| 82 path.conicTo(200, 0, 200, 3.5f, 0.70710677f); |
| 83 path.lineTo(200, 62.5f); |
| 84 path.conicTo(200, 66, 196.5f, 66, 0.70710677f); |
| 85 path.lineTo(3.5f, 66); |
| 86 path.conicTo(0, 66, 0, 62.5, 0.70710677f); |
| 87 path.close(); |
| 88 force_path_contains_rrect(reporter, path); |
| 89 |
| 90 path.reset(); |
| 91 path.moveTo(0, 81.5f); |
| 92 path.lineTo(0, 3.5f); |
| 93 path.conicTo(0, 0, 3.5f, 0, 0.70710677f); |
| 94 path.lineTo(149.5, 0); |
| 95 path.conicTo(153, 0, 153, 3.5f, 0.70710677f); |
| 96 path.lineTo(153, 81.5f); |
| 97 path.conicTo(153, 85, 149.5f, 85, 0.70710677f); |
| 98 path.lineTo(3.5f, 85); |
| 99 path.conicTo(0, 85, 0, 81.5f, 0.70710677f); |
| 100 path.close(); |
| 101 force_path_contains_rrect(reporter, path); |
| 102 |
| 103 path.reset(); |
| 104 path.moveTo(14, 1189); |
| 105 path.lineTo(14, 21); |
| 106 path.conicTo(14, 14, 21, 14, 0.70710677f); |
| 107 path.lineTo(1363, 14); |
| 108 path.conicTo(1370, 14, 1370, 21, 0.70710677f); |
| 109 path.lineTo(1370, 1189); |
| 110 path.conicTo(1370, 1196, 1363, 1196, 0.70710677f); |
| 111 path.lineTo(21, 1196); |
| 112 path.conicTo(14, 1196, 14, 1189, 0.70710677f); |
| 113 path.close(); |
| 114 force_path_contains_rrect(reporter, path); |
| 115 |
| 116 path.reset(); |
| 117 path.moveTo(14, 1743); |
| 118 path.lineTo(14, 21); |
| 119 path.conicTo(14, 14, 21, 14, 0.70710677f); |
| 120 path.lineTo(1363, 14); |
| 121 path.conicTo(1370, 14, 1370, 21, 0.70710677f); |
| 122 path.lineTo(1370, 1743); |
| 123 path.conicTo(1370, 1750, 1363, 1750, 0.70710677f); |
| 124 path.lineTo(21, 1750); |
| 125 path.conicTo(14, 1750, 14, 1743, 0.70710677f); |
| 126 path.close(); |
| 127 force_path_contains_rrect(reporter, path); |
| 128 } |
| 129 |
| 130 static const SkScalar kWidth = 100.0f; |
| 131 static const SkScalar kHeight = 100.0f; |
| 132 |
| 133 static void test_tricky_radii(skiatest::Reporter* reporter) { |
| 134 { |
| 135 // crbug.com/458522 |
| 136 SkRRect rr; |
| 137 const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; |
| 138 const SkScalar rad = 12814; |
| 139 const SkVector vec[] = { { rad, rad }, { 0, rad }, { rad, rad }, { 0, ra
d } }; |
| 140 rr.setRectRadii(bounds, vec); |
| 141 path_contains_rrect_check(reporter, rr); |
| 142 } |
| 143 |
| 144 { |
| 145 // crbug.com//463920 |
| 146 SkRect r = SkRect::MakeLTRB(0, 0, 1009, 33554432.0); |
| 147 SkVector radii[4] = { |
| 148 { 13.0f, 8.0f }, { 170.0f, 2.0 }, { 256.0f, 33554432.0 }, { 110.0f,
5.0f } |
| 149 }; |
| 150 SkRRect rr; |
| 151 rr.setRectRadii(r, radii); |
| 152 path_contains_rrect_nocheck(reporter, rr); |
| 153 } |
| 154 } |
| 155 |
| 156 static void test_empty_crbug_458524(skiatest::Reporter* reporter) { |
| 157 SkRRect rr; |
| 158 const SkRect bounds = { 3709, 3709, 3709 + 7402, 3709 + 29825 }; |
| 159 const SkScalar rad = 40; |
| 160 rr.setRectXY(bounds, rad, rad); |
| 161 path_contains_rrect_check(reporter, rr); |
| 162 |
| 163 SkRRect other; |
| 164 SkMatrix matrix; |
| 165 matrix.setScale(0, 1); |
| 166 rr.transform(matrix, &other); |
| 167 path_contains_rrect_check(reporter, rr); |
| 168 } |
| 169 |
| 170 static void test_inset(skiatest::Reporter* reporter) { |
| 171 SkRRect rr, rr2; |
| 172 SkRect r = { 0, 0, 100, 100 }; |
| 173 |
| 174 rr.setRect(r); |
| 175 rr.inset(-20, -20, &rr2); |
| 176 path_contains_rrect_check(reporter, rr); |
| 177 |
| 178 rr.inset(20, 20, &rr2); |
| 179 path_contains_rrect_check(reporter, rr); |
| 180 |
| 181 rr.inset(r.width()/2, r.height()/2, &rr2); |
| 182 path_contains_rrect_check(reporter, rr); |
| 183 |
| 184 rr.setRectXY(r, 20, 20); |
| 185 rr.inset(19, 19, &rr2); |
| 186 path_contains_rrect_check(reporter, rr); |
| 187 rr.inset(20, 20, &rr2); |
| 188 path_contains_rrect_check(reporter, rr); |
| 189 } |
| 190 |
| 191 |
| 192 static void test_9patch_rrect(skiatest::Reporter* reporter, |
| 193 const SkRect& rect, |
| 194 SkScalar l, SkScalar t, SkScalar r, SkScalar b, |
| 195 bool checkRadii) { |
| 196 SkRRect rr; |
| 197 rr.setNinePatch(rect, l, t, r, b); |
| 198 if (checkRadii) { |
| 199 path_contains_rrect_check(reporter, rr); |
| 200 } else { |
| 201 path_contains_rrect_nocheck(reporter, rr); |
| 202 } |
| 203 |
| 204 SkRRect rr2; // construct the same RR using the most general set function |
| 205 SkVector radii[4] = { { l, t }, { r, t }, { r, b }, { l, b } }; |
| 206 rr2.setRectRadii(rect, radii); |
| 207 if (checkRadii) { |
| 208 path_contains_rrect_check(reporter, rr); |
| 209 } else { |
| 210 path_contains_rrect_nocheck(reporter, rr); |
| 211 } |
| 212 } |
| 213 |
| 214 // Test out the basic API entry points |
| 215 static void test_round_rect_basic(skiatest::Reporter* reporter) { |
| 216 |
| 217 //---- |
| 218 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); |
| 219 |
| 220 SkRRect rr1; |
| 221 rr1.setRect(rect); |
| 222 path_contains_rrect_check(reporter, rr1); |
| 223 |
| 224 SkRRect rr1_2; // construct the same RR using the most general set function |
| 225 SkVector rr1_2_radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; |
| 226 rr1_2.setRectRadii(rect, rr1_2_radii); |
| 227 path_contains_rrect_check(reporter, rr1_2); |
| 228 SkRRect rr1_3; // construct the same RR using the nine patch set function |
| 229 rr1_3.setNinePatch(rect, 0, 0, 0, 0); |
| 230 path_contains_rrect_check(reporter, rr1_2); |
| 231 |
| 232 //---- |
| 233 SkPoint halfPoint = { SkScalarHalf(kWidth), SkScalarHalf(kHeight) }; |
| 234 SkRRect rr2; |
| 235 rr2.setOval(rect); |
| 236 path_contains_rrect_check(reporter, rr2); |
| 237 |
| 238 SkRRect rr2_2; // construct the same RR using the most general set function |
| 239 SkVector rr2_2_radii[4] = { { halfPoint.fX, halfPoint.fY }, { halfPoint.fX,
halfPoint.fY }, |
| 240 { halfPoint.fX, halfPoint.fY }, { halfPoint.fX,
halfPoint.fY } }; |
| 241 rr2_2.setRectRadii(rect, rr2_2_radii); |
| 242 path_contains_rrect_check(reporter, rr2_2); |
| 243 SkRRect rr2_3; // construct the same RR using the nine patch set function |
| 244 rr2_3.setNinePatch(rect, halfPoint.fX, halfPoint.fY, halfPoint.fX, halfPoint
.fY); |
| 245 path_contains_rrect_check(reporter, rr2_3); |
| 246 |
| 247 //---- |
| 248 SkPoint p = { 5, 5 }; |
| 249 SkRRect rr3; |
| 250 rr3.setRectXY(rect, p.fX, p.fY); |
| 251 path_contains_rrect_check(reporter, rr3); |
| 252 |
| 253 SkRRect rr3_2; // construct the same RR using the most general set function |
| 254 SkVector rr3_2_radii[4] = { { 5, 5 }, { 5, 5 }, { 5, 5 }, { 5, 5 } }; |
| 255 rr3_2.setRectRadii(rect, rr3_2_radii); |
| 256 path_contains_rrect_check(reporter, rr3_2); |
| 257 SkRRect rr3_3; // construct the same RR using the nine patch set function |
| 258 rr3_3.setNinePatch(rect, 5, 5, 5, 5); |
| 259 path_contains_rrect_check(reporter, rr3_3); |
| 260 |
| 261 //---- |
| 262 test_9patch_rrect(reporter, rect, 10, 9, 8, 7, true); |
| 263 |
| 264 { |
| 265 // Test out the rrect from skia:3466 |
| 266 SkRect rect2 = SkRect::MakeLTRB(0.358211994f, 0.755430222f, 0.872866154f
, 0.806214333f); |
| 267 |
| 268 test_9patch_rrect(reporter, |
| 269 rect2, |
| 270 0.926942348f, 0.642850280f, 0.529063463f, 0.587844372f
, |
| 271 false); |
| 272 } |
| 273 |
| 274 //---- |
| 275 SkPoint radii2[4] = { { 0, 0 }, { 0, 0 }, { 50, 50 }, { 20, 50 } }; |
| 276 |
| 277 SkRRect rr5; |
| 278 rr5.setRectRadii(rect, radii2); |
| 279 path_contains_rrect_check(reporter, rr5); |
| 280 } |
| 281 |
| 282 // Test out the cases when the RR degenerates to a rect |
| 283 static void test_round_rect_rects(skiatest::Reporter* reporter) { |
| 284 |
| 285 //---- |
| 286 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); |
| 287 SkRRect rr1; |
| 288 rr1.setRectXY(rect, 0, 0); |
| 289 |
| 290 path_contains_rrect_check(reporter, rr1); |
| 291 |
| 292 //---- |
| 293 SkPoint radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } }; |
| 294 |
| 295 SkRRect rr2; |
| 296 rr2.setRectRadii(rect, radii); |
| 297 |
| 298 path_contains_rrect_check(reporter, rr2); |
| 299 |
| 300 //---- |
| 301 SkPoint radii2[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; |
| 302 |
| 303 SkRRect rr3; |
| 304 rr3.setRectRadii(rect, radii2); |
| 305 path_contains_rrect_check(reporter, rr3); |
| 306 } |
| 307 |
| 308 // Test out the cases when the RR degenerates to an oval |
| 309 static void test_round_rect_ovals(skiatest::Reporter* reporter) { |
| 310 //---- |
| 311 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); |
| 312 SkRRect rr1; |
| 313 rr1.setRectXY(rect, SkScalarHalf(kWidth), SkScalarHalf(kHeight)); |
| 314 |
| 315 path_contains_rrect_check(reporter, rr1); |
| 316 } |
| 317 |
| 318 // Test out the non-degenerate RR cases |
| 319 static void test_round_rect_general(skiatest::Reporter* reporter) { |
| 320 //---- |
| 321 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); |
| 322 SkRRect rr1; |
| 323 rr1.setRectXY(rect, 20, 20); |
| 324 |
| 325 path_contains_rrect_check(reporter, rr1); |
| 326 |
| 327 //---- |
| 328 SkPoint radii[4] = { { 0, 0 }, { 20, 20 }, { 50, 50 }, { 20, 50 } }; |
| 329 |
| 330 SkRRect rr2; |
| 331 rr2.setRectRadii(rect, radii); |
| 332 |
| 333 path_contains_rrect_check(reporter, rr2); |
| 334 } |
| 335 |
| 336 static void test_round_rect_iffy_parameters(skiatest::Reporter* reporter) { |
| 337 SkRect rect = SkRect::MakeLTRB(0, 0, kWidth, kHeight); |
| 338 SkPoint radii[4] = { { 50, 100 }, { 100, 50 }, { 50, 100 }, { 100, 50 } }; |
| 339 SkRRect rr1; |
| 340 rr1.setRectRadii(rect, radii); |
| 341 path_contains_rrect_nocheck(reporter, rr1); |
| 342 } |
| 343 |
| 344 static void set_radii(SkVector radii[4], int index, float rad) { |
| 345 sk_bzero(radii, sizeof(SkVector) * 4); |
| 346 radii[index].set(rad, rad); |
| 347 } |
| 348 |
| 349 static void test_skbug_3239(skiatest::Reporter* reporter) { |
| 350 const float min = SkBits2Float(0xcb7f16c8); /* -16717512.000000 */ |
| 351 const float max = SkBits2Float(0x4b7f1c1d); /* 16718877.000000 */ |
| 352 const float big = SkBits2Float(0x4b7f1bd7); /* 16718807.000000 */ |
| 353 |
| 354 const float rad = 33436320; |
| 355 |
| 356 const SkRect rectx = SkRect::MakeLTRB(min, min, max, big); |
| 357 const SkRect recty = SkRect::MakeLTRB(min, min, big, max); |
| 358 |
| 359 SkVector radii[4]; |
| 360 for (int i = 0; i < 4; ++i) { |
| 361 set_radii(radii, i, rad); |
| 362 path_contains_rrect_check(reporter, rectx, radii); |
| 363 path_contains_rrect_check(reporter, recty, radii); |
| 364 } |
| 365 } |
| 366 |
| 367 static void test_mix(skiatest::Reporter* reporter) { |
| 368 // Test out mixed degenerate and non-degenerate geometry with Conics |
| 369 const SkVector radii[4] = { { 0, 0 }, { 0, 0 }, { 0, 0 }, { 100, 100 } }; |
| 370 SkRect r = SkRect::MakeWH(100, 100); |
| 371 SkRRect rr; |
| 372 rr.setRectRadii(r, radii); |
| 373 path_contains_rrect_check(reporter, rr); |
| 374 } |
| 375 |
| 376 DEF_TEST(RoundRectInPath, reporter) { |
| 377 test_tricky_radii(reporter); |
| 378 test_empty_crbug_458524(reporter); |
| 379 test_inset(reporter); |
| 380 test_round_rect_basic(reporter); |
| 381 test_round_rect_rects(reporter); |
| 382 test_round_rect_ovals(reporter); |
| 383 test_round_rect_general(reporter); |
| 384 test_undetected_paths(reporter); |
| 385 test_round_rect_iffy_parameters(reporter); |
| 386 test_skbug_3239(reporter); |
| 387 test_mix(reporter); |
| 388 } |
OLD | NEW |