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 "PathOpsExtendedTest.h" 8 9 #define TEST(name) { name, #name } 10 11 static void cubicOp1d(skiatest::Reporter* reporter) { 12 SkPath path, pathB; 13 path.setFillType(SkPath::kWinding_FillType); 14 path.moveTo(0,1); 15 path.cubicTo(0,2, 1,0, 1,0); 16 path.close(); 17 pathB.setFillType(SkPath::kWinding_FillType); 18 pathB.moveTo(0,1); 19 pathB.cubicTo(0,1, 1,0, 2,0); 20 pathB.close(); 21 testPathOp(reporter, path, pathB, kDifference_PathOp); 22 } 23 24 static void cubicOp2d(skiatest::Reporter* reporter) { 25 SkPath path, pathB; 26 path.setFillType(SkPath::kWinding_FillType); 27 path.moveTo(0,2); 28 path.cubicTo(0,1, 1,0, 1,0); 29 path.close(); 30 pathB.setFillType(SkPath::kWinding_FillType); 31 pathB.moveTo(0,1); 32 pathB.cubicTo(0,1, 2,0, 1,0); 33 pathB.close(); 34 testPathOp(reporter, path, pathB, kDifference_PathOp); 35 } 36 37 static void cubicOp3d(skiatest::Reporter* reporter) { 38 SkPath path, pathB; 39 path.setFillType(SkPath::kWinding_FillType); 40 path.moveTo(0,1); 41 path.cubicTo(2,3, 1,0, 1,0); 42 path.close(); 43 pathB.setFillType(SkPath::kWinding_FillType); 44 pathB.moveTo(0,1); 45 pathB.cubicTo(0,1, 1,0, 3,2); 46 pathB.close(); 47 testPathOp(reporter, path, pathB, kDifference_PathOp); 48 } 49 50 static void cubicOp5d(skiatest::Reporter* reporter) { 51 SkPath path, pathB; 52 path.setFillType(SkPath::kWinding_FillType); 53 path.moveTo(0,1); 54 path.cubicTo(0,2, 1,0, 2,0); 55 path.close(); 56 pathB.setFillType(SkPath::kWinding_FillType); 57 pathB.moveTo(0,1); 58 pathB.cubicTo(0,2, 1,0, 2,0); 59 pathB.close(); 60 testPathOp(reporter, path, pathB, kDifference_PathOp); 61 } 62 63 static void cubicOp6d(skiatest::Reporter* reporter) { 64 SkPath path, pathB; 65 path.setFillType(SkPath::kWinding_FillType); 66 path.moveTo(0,1); 67 path.cubicTo(0,6, 1,0, 3,0); 68 path.close(); 69 pathB.setFillType(SkPath::kWinding_FillType); 70 pathB.moveTo(0,1); 71 pathB.cubicTo(0,3, 1,0, 6,0); 72 pathB.close(); 73 testPathOp(reporter, path, pathB, kDifference_PathOp); 74 } 75 76 static void cubicOp7d(skiatest::Reporter* reporter) { 77 SkPath path, pathB; 78 path.setFillType(SkPath::kWinding_FillType); 79 path.moveTo(0,1); 80 path.cubicTo(3,4, 1,0, 3,0); 81 path.close(); 82 pathB.setFillType(SkPath::kWinding_FillType); 83 pathB.moveTo(0,1); 84 pathB.cubicTo(0,3, 1,0, 4,3); 85 pathB.close(); 86 testPathOp(reporter, path, pathB, kDifference_PathOp); 87 } 88 89 static void cubicOp8d(skiatest::Reporter* reporter) { 90 SkPath path, pathB; 91 path.setFillType(SkPath::kWinding_FillType); 92 path.moveTo(0,1); 93 path.cubicTo(0,5, 1,0, 4,0); 94 path.close(); 95 pathB.setFillType(SkPath::kWinding_FillType); 96 pathB.moveTo(0,1); 97 pathB.cubicTo(0,4, 1,0, 5,0); 98 pathB.close(); 99 testPathOp(reporter, path, pathB, kDifference_PathOp); 100 } 101 102 static void cubicOp9d(skiatest::Reporter* reporter) { 103 SkPath path, pathB; 104 path.setFillType(SkPath::kWinding_FillType); 105 path.moveTo(0,1); 106 path.cubicTo(1,6, 1,0, 2,1); 107 path.close(); 108 pathB.setFillType(SkPath::kWinding_FillType); 109 pathB.moveTo(0,1); 110 pathB.cubicTo(1,2, 1,0, 6,1); 111 pathB.close(); 112 testPathOp(reporter, path, pathB, kDifference_PathOp); 113 } 114 115 static void quadOp9d(skiatest::Reporter* reporter) { 116 SkPath path, pathB; 117 path.setFillType(SkPath::kWinding_FillType); 118 path.moveTo(0,1); 119 path.quadTo(1,6, 1.5f,1); 120 path.quadTo(1.5f,0.5f, 2,1); 121 path.close(); 122 pathB.setFillType(SkPath::kWinding_FillType); 123 pathB.moveTo(0,1); 124 pathB.quadTo(1,2, 1.4f,1); 125 pathB.quadTo(3,0.4f, 6,1); 126 pathB.close(); 127 testPathOp(reporter, path, pathB, kDifference_PathOp); 128 } 129 130 static void lineOp9d(skiatest::Reporter* reporter) { 131 SkPath path, pathB; 132 path.setFillType(SkPath::kWinding_FillType); 133 path.moveTo(0,1); 134 path.lineTo(1,6); 135 path.lineTo(1.5f,1); 136 path.lineTo(1.8f,0.8f); 137 path.lineTo(2,1); 138 path.close(); 139 pathB.setFillType(SkPath::kWinding_FillType); 140 pathB.moveTo(0,1); 141 pathB.lineTo(1,2); 142 pathB.lineTo(1.4f,1); 143 pathB.lineTo(3,0.4f); 144 pathB.lineTo(6,1); 145 pathB.close(); 146 testPathOp(reporter, path, pathB, kDifference_PathOp); 147 } 148 149 static void cubicOp1i(skiatest::Reporter* reporter) { 150 SkPath path, pathB; 151 path.setFillType(SkPath::kWinding_FillType); 152 path.moveTo(0,1); 153 path.cubicTo(1,2, 1,0, 2,1); 154 path.close(); 155 pathB.setFillType(SkPath::kWinding_FillType); 156 pathB.moveTo(0,1); 157 pathB.cubicTo(1,2, 1,0, 2,1); 158 pathB.close(); 159 testPathOp(reporter, path, pathB, kIntersect_PathOp); 160 } 161 162 static void cubicOp10d(skiatest::Reporter* reporter) { 163 SkPath path, pathB; 164 path.setFillType(SkPath::kWinding_FillType); 165 path.moveTo(0,1); 166 path.cubicTo(1,3, 1,0, 4,1); 167 path.close(); 168 pathB.setFillType(SkPath::kWinding_FillType); 169 pathB.moveTo(0,1); 170 pathB.cubicTo(1,4, 1,0, 3,1); 171 pathB.close(); 172 testPathOp(reporter, path, pathB, kDifference_PathOp); 173 } 174 175 static void cubicOp11d(skiatest::Reporter* reporter) { 176 SkPath path, pathB; 177 path.setFillType(SkPath::kWinding_FillType); 178 path.moveTo(0,1); 179 path.cubicTo(3,4, 1,0, 5,1); 180 path.close(); 181 pathB.setFillType(SkPath::kWinding_FillType); 182 pathB.moveTo(0,1); 183 pathB.cubicTo(1,5, 1,0, 4,3); 184 pathB.close(); 185 testPathOp(reporter, path, pathB, kDifference_PathOp); 186 } 187 188 static void cubicOp12d(skiatest::Reporter* reporter) { 189 SkPath path, pathB; 190 path.setFillType(SkPath::kWinding_FillType); 191 path.moveTo(0,1); 192 path.cubicTo(1,6, 1,0, 1,0); 193 path.close(); 194 pathB.setFillType(SkPath::kWinding_FillType); 195 pathB.moveTo(0,1); 196 pathB.cubicTo(0,1, 1,0, 6,1); 197 pathB.close(); 198 testPathOp(reporter, path, pathB, kDifference_PathOp); 199 } 200 201 static void cubicOp13d(skiatest::Reporter* reporter) { 202 SkPath path, pathB; 203 path.setFillType(SkPath::kWinding_FillType); 204 path.moveTo(0,1); 205 path.cubicTo(4,5, 1,0, 5,3); 206 path.close(); 207 pathB.setFillType(SkPath::kWinding_FillType); 208 pathB.moveTo(0,1); 209 pathB.cubicTo(3,5, 1,0, 5,4); 210 pathB.close(); 211 testPathOp(reporter, path, pathB, kDifference_PathOp); 212 } 213 214 static void cubicOp14d(skiatest::Reporter* reporter) { 215 SkPath path, pathB; 216 path.setFillType(SkPath::kWinding_FillType); 217 path.moveTo(0,1); 218 path.cubicTo(0,2, 2,0, 2,1); 219 path.close(); 220 pathB.setFillType(SkPath::kWinding_FillType); 221 pathB.moveTo(0,2); 222 pathB.cubicTo(1,2, 1,0, 2,0); 223 pathB.close(); 224 testPathOp(reporter, path, pathB, kDifference_PathOp); 225 } 226 227 static void cubicOp15d(skiatest::Reporter* reporter) { 228 SkPath path, pathB; 229 path.setFillType(SkPath::kWinding_FillType); 230 path.moveTo(0,1); 231 path.cubicTo(3,6, 2,0, 2,1); 232 path.close(); 233 pathB.setFillType(SkPath::kWinding_FillType); 234 pathB.moveTo(0,2); 235 pathB.cubicTo(1,2, 1,0, 6,3); 236 pathB.close(); 237 testPathOp(reporter, path, pathB, kDifference_PathOp); 238 } 239 240 static void cubicOp16d(skiatest::Reporter* reporter) { 241 SkPath path, pathB; 242 path.setFillType(SkPath::kWinding_FillType); 243 path.moveTo(0,2); 244 path.cubicTo(0,1, 3,0, 1,0); 245 path.close(); 246 pathB.setFillType(SkPath::kWinding_FillType); 247 pathB.moveTo(0,3); 248 pathB.cubicTo(0,1, 2,0, 1,0); 249 pathB.close(); 250 testPathOp(reporter, path, pathB, kDifference_PathOp); 251 } 252 253 static void cubicOp17d(skiatest::Reporter* reporter) { 254 SkPath path, pathB; 255 path.setFillType(SkPath::kWinding_FillType); 256 path.moveTo(0,2); 257 path.cubicTo(0,2, 4,0, 2,1); 258 path.close(); 259 pathB.setFillType(SkPath::kWinding_FillType); 260 pathB.moveTo(0,4); 261 pathB.cubicTo(1,2, 2,0, 2,0); 262 pathB.close(); 263 testPathOp(reporter, path, pathB, kDifference_PathOp); 264 } 265 266 static void cubicOp18d(skiatest::Reporter* reporter) { 267 SkPath path, pathB; 268 path.setFillType(SkPath::kWinding_FillType); 269 path.moveTo(0,1); 270 path.cubicTo(3,5, 2,0, 2,1); 271 path.close(); 272 pathB.setFillType(SkPath::kWinding_FillType); 273 pathB.moveTo(0,2); 274 pathB.cubicTo(1,2, 1,0, 5,3); 275 pathB.close(); 276 testPathOp(reporter, path, pathB, kDifference_PathOp); 277 } 278 279 static void cubicOp19i(skiatest::Reporter* reporter) { 280 SkPath path, pathB; 281 path.setFillType(SkPath::kWinding_FillType); 282 path.moveTo(0,2); 283 path.cubicTo(0,1, 2,1, 6,2); 284 path.close(); 285 pathB.setFillType(SkPath::kWinding_FillType); 286 pathB.moveTo(1,2); 287 pathB.cubicTo(2,6, 2,0, 1,0); 288 pathB.close(); 289 testPathOp(reporter, path, pathB, kIntersect_PathOp); 290 } 291 292 static void cubicOp20d(skiatest::Reporter* reporter) { 293 SkPath path, pathB; 294 path.setFillType(SkPath::kWinding_FillType); 295 path.moveTo(0,1); 296 path.cubicTo(0,1, 6,0, 2,1); 297 path.close(); 298 pathB.setFillType(SkPath::kWinding_FillType); 299 pathB.moveTo(0,6); 300 pathB.cubicTo(1,2, 1,0, 1,0); 301 pathB.close(); 302 testPathOp(reporter, path, pathB, kDifference_PathOp); 303 } 304 305 static void cubicOp21d(skiatest::Reporter* reporter) { 306 SkPath path, pathB; 307 path.setFillType(SkPath::kWinding_FillType); 308 path.moveTo(0,1); 309 path.cubicTo(0,1, 2,1, 6,5); 310 path.close(); 311 pathB.setFillType(SkPath::kWinding_FillType); 312 pathB.moveTo(1,2); 313 pathB.cubicTo(5,6, 1,0, 1,0); 314 pathB.close(); 315 testPathOp(reporter, path, pathB, kDifference_PathOp); 316 } 317 318 static void cubicOp22d(skiatest::Reporter* reporter) { 319 SkPath path, pathB; 320 path.setFillType(SkPath::kWinding_FillType); 321 path.moveTo(0,1); 322 path.cubicTo(2,3, 3,0, 2,1); 323 path.close(); 324 pathB.setFillType(SkPath::kWinding_FillType); 325 pathB.moveTo(0,3); 326 pathB.cubicTo(1,2, 1,0, 3,2); 327 pathB.close(); 328 testPathOp(reporter, path, pathB, kDifference_PathOp); 329 } 330 331 static void cubicOp23d(skiatest::Reporter* reporter) { 332 SkPath path, pathB; 333 path.setFillType(SkPath::kWinding_FillType); 334 path.moveTo(0,1); 335 path.cubicTo(1,2, 4,0, 2,1); 336 path.close(); 337 pathB.setFillType(SkPath::kWinding_FillType); 338 pathB.moveTo(0,4); 339 pathB.cubicTo(1,2, 1,0, 2,1); 340 pathB.close(); 341 testPathOp(reporter, path, pathB, kDifference_PathOp); 342 } 343 344 static void cubicOp24d(skiatest::Reporter* reporter) { 345 SkPath path, pathB; 346 path.setFillType(SkPath::kWinding_FillType); 347 path.moveTo(0,1); 348 path.cubicTo(1,2, 2,0, 3,2); 349 path.close(); 350 pathB.setFillType(SkPath::kWinding_FillType); 351 pathB.moveTo(0,2); 352 pathB.cubicTo(2,3, 1,0, 2,1); 353 pathB.close(); 354 testPathOp(reporter, path, pathB, kDifference_PathOp); 355 } 356 357 static void testIntersect1(skiatest::Reporter* reporter) { 358 SkPath one, two; 359 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 360 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 361 testPathOp(reporter, one, two, kIntersect_PathOp); 362 } 363 364 static void testUnion1(skiatest::Reporter* reporter) { 365 SkPath one, two; 366 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 367 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 368 testPathOp(reporter, one, two, kUnion_PathOp); 369 } 370 371 static void testDiff1(skiatest::Reporter* reporter) { 372 SkPath one, two; 373 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 374 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 375 testPathOp(reporter, one, two, kDifference_PathOp); 376 } 377 378 static void testXor1(skiatest::Reporter* reporter) { 379 SkPath one, two; 380 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 381 two.addRect(3, 3, 9, 9, SkPath::kCW_Direction); 382 testPathOp(reporter, one, two, kXOR_PathOp); 383 } 384 385 static void testIntersect2(skiatest::Reporter* reporter) { 386 SkPath one, two; 387 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 388 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 389 testPathOp(reporter, one, two, kIntersect_PathOp); 390 } 391 392 static void testUnion2(skiatest::Reporter* reporter) { 393 SkPath one, two; 394 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 395 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 396 testPathOp(reporter, one, two, kUnion_PathOp); 397 } 398 399 static void testDiff2(skiatest::Reporter* reporter) { 400 SkPath one, two; 401 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 402 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 403 testPathOp(reporter, one, two, kDifference_PathOp); 404 } 405 406 static void testXor2(skiatest::Reporter* reporter) { 407 SkPath one, two; 408 one.addRect(0, 0, 6, 6, SkPath::kCW_Direction); 409 two.addRect(0, 3, 9, 9, SkPath::kCW_Direction); 410 testPathOp(reporter, one, two, kXOR_PathOp); 411 } 412 413 static void testOp1d(skiatest::Reporter* reporter) { 414 SkPath path, pathB; 415 path.setFillType(SkPath::kWinding_FillType); 416 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 417 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 418 pathB.setFillType(SkPath::kWinding_FillType); 419 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 420 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 421 testPathOp(reporter, path, pathB, kDifference_PathOp); 422 } 423 424 static void testOp2d(skiatest::Reporter* reporter) { 425 SkPath path, pathB; 426 path.setFillType(SkPath::kWinding_FillType); 427 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 428 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 429 pathB.setFillType(SkPath::kEvenOdd_FillType); 430 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 431 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 432 testPathOp(reporter, path, pathB, kDifference_PathOp); 433 } 434 435 static void testOp3d(skiatest::Reporter* reporter) { 436 SkPath path, pathB; 437 path.setFillType(SkPath::kWinding_FillType); 438 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 439 path.addRect(1, 1, 2, 2, SkPath::kCW_Direction); 440 pathB.setFillType(SkPath::kWinding_FillType); 441 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 442 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 443 testPathOp(reporter, path, pathB, kDifference_PathOp); 444 } 445 446 static void testOp1u(skiatest::Reporter* reporter) { 447 SkPath path, pathB; 448 path.setFillType(SkPath::kWinding_FillType); 449 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 450 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 451 pathB.setFillType(SkPath::kWinding_FillType); 452 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 453 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 454 testPathOp(reporter, path, pathB, kUnion_PathOp); 455 } 456 457 static void testOp4d(skiatest::Reporter* reporter) { 458 SkPath path, pathB; 459 path.setFillType(SkPath::kWinding_FillType); 460 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 461 path.addRect(2, 2, 4, 4, SkPath::kCW_Direction); 462 pathB.setFillType(SkPath::kWinding_FillType); 463 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 464 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 465 testPathOp(reporter, path, pathB, kDifference_PathOp); 466 } 467 468 static void testOp5d(skiatest::Reporter* reporter) { 469 SkPath path, pathB; 470 path.setFillType(SkPath::kEvenOdd_FillType); 471 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 472 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 473 pathB.setFillType(SkPath::kEvenOdd_FillType); 474 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 475 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 476 testPathOp(reporter, path, pathB, kDifference_PathOp); 477 } 478 479 static void testOp6d(skiatest::Reporter* reporter) { 480 SkPath path, pathB; 481 path.setFillType(SkPath::kEvenOdd_FillType); 482 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 483 path.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 484 pathB.setFillType(SkPath::kWinding_FillType); 485 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 486 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 487 testPathOp(reporter, path, pathB, kDifference_PathOp); 488 } 489 490 static void testOp7d(skiatest::Reporter* reporter) { 491 SkPath path, pathB; 492 path.setFillType(SkPath::kEvenOdd_FillType); 493 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 494 path.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 495 pathB.setFillType(SkPath::kEvenOdd_FillType); 496 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 497 pathB.addRect(0, 0, 1, 1, SkPath::kCW_Direction); 498 testPathOp(reporter, path, pathB, kDifference_PathOp); 499 } 500 501 static void testOp2u(skiatest::Reporter* reporter) { 502 SkPath path, pathB; 503 path.setFillType(SkPath::kEvenOdd_FillType); 504 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 505 path.addRect(0, 0, 2, 2, SkPath::kCW_Direction); 506 pathB.setFillType(SkPath::kWinding_FillType); 507 pathB.addRect(0, 0, 3, 3, SkPath::kCW_Direction); 508 pathB.addRect(1, 1, 2, 2, SkPath::kCW_Direction); 509 testPathOp(reporter, path, pathB, kUnion_PathOp); 510 } 511 512 static void testOp8d(skiatest::Reporter* reporter) { 513 SkPath path, pathB; 514 path.addRect(0, 0, 640, 480); 515 pathB.moveTo(577330, 1971.72f); 516 pathB.cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f); 517 pathB.close(); 518 testPathOp(reporter, path, pathB, kDifference_PathOp); 519 } 520 static void cubicOp25i(skiatest::Reporter* reporter) { 521 SkPath path, pathB; 522 path.setFillType(SkPath::kWinding_FillType); 523 path.moveTo(0,1); 524 path.cubicTo(2,4, 5,0, 3,2); 525 path.close(); 526 pathB.setFillType(SkPath::kWinding_FillType); 527 pathB.moveTo(0,5); 528 pathB.cubicTo(2,3, 1,0, 4,2); 529 pathB.close(); 530 testPathOp(reporter, path, pathB, kIntersect_PathOp); 531 } 532 533 static void cubicOp26d(skiatest::Reporter* reporter) { 534 SkPath path, pathB; 535 path.setFillType(SkPath::kWinding_FillType); 536 path.moveTo(0,1); 537 path.cubicTo(3,4, 4,0, 3,2); 538 path.close(); 539 pathB.setFillType(SkPath::kWinding_FillType); 540 pathB.moveTo(0,4); 541 pathB.cubicTo(2,3, 1,0, 4,3); 542 pathB.close(); 543 testPathOp(reporter, path, pathB, kDifference_PathOp); 544 } 545 546 static void cubicOp27d(skiatest::Reporter* reporter) { 547 SkPath path, pathB; 548 path.setFillType(SkPath::kWinding_FillType); 549 path.moveTo(0,1); 550 path.cubicTo(3,6, 1,0, 5,2); 551 path.close(); 552 pathB.setFillType(SkPath::kWinding_FillType); 553 pathB.moveTo(0,1); 554 pathB.cubicTo(2,5, 1,0, 6,3); 555 pathB.close(); 556 testPathOp(reporter, path, pathB, kDifference_PathOp); 557 } 558 559 static void cubicOp28u(skiatest::Reporter* reporter) { 560 SkPath path, pathB; 561 path.setFillType(SkPath::kWinding_FillType); 562 path.moveTo(0,1); 563 path.cubicTo(1,4, 6,0, 3,2); 564 path.close(); 565 pathB.setFillType(SkPath::kWinding_FillType); 566 pathB.moveTo(0,6); 567 pathB.cubicTo(2,3, 1,0, 4,1); 568 pathB.close(); 569 testPathOp(reporter, path, pathB, kUnion_PathOp); 570 } 571 572 static void cubicOp29d(skiatest::Reporter* reporter) { 573 SkPath path, pathB; 574 path.setFillType(SkPath::kWinding_FillType); 575 path.moveTo(0,1); 576 path.cubicTo(2,5, 6,0, 4,2); 577 path.close(); 578 pathB.setFillType(SkPath::kWinding_FillType); 579 pathB.moveTo(0,6); 580 pathB.cubicTo(2,4, 1,0, 5,2); 581 pathB.close(); 582 testPathOp(reporter, path, pathB, kDifference_PathOp); 583 } 584 585 static void cubicOp30d(skiatest::Reporter* reporter) { 586 SkPath path, pathB; 587 path.setFillType(SkPath::kWinding_FillType); 588 path.moveTo(0,1); 589 path.cubicTo(2,5, 6,0, 5,3); 590 path.close(); 591 pathB.setFillType(SkPath::kWinding_FillType); 592 pathB.moveTo(0,6); 593 pathB.cubicTo(3,5, 1,0, 5,2); 594 pathB.close(); 595 testPathOp(reporter, path, pathB, kDifference_PathOp); 596 } 597 598 static void cubicOp31d(skiatest::Reporter* reporter) { 599 SkPath path, pathB; 600 path.setFillType(SkPath::kWinding_FillType); 601 path.moveTo(0,2); 602 path.cubicTo(0,3, 2,1, 4,0); 603 path.close(); 604 pathB.setFillType(SkPath::kWinding_FillType); 605 pathB.moveTo(1,2); 606 pathB.cubicTo(0,4, 2,0, 3,0); 607 pathB.close(); 608 testPathOp(reporter, path, pathB, kDifference_PathOp); 609 } 610 611 static void cubicOp31u(skiatest::Reporter* reporter) { 612 SkPath path, pathB; 613 path.setFillType(SkPath::kWinding_FillType); 614 path.moveTo(0,2); 615 path.cubicTo(0,3, 2,1, 4,0); 616 path.close(); 617 pathB.setFillType(SkPath::kWinding_FillType); 618 pathB.moveTo(1,2); 619 pathB.cubicTo(0,4, 2,0, 3,0); 620 pathB.close(); 621 testPathOp(reporter, path, pathB, kUnion_PathOp); 622 } 623 624 static void cubicOp31x(skiatest::Reporter* reporter) { 625 SkPath path, pathB; 626 path.setFillType(SkPath::kWinding_FillType); 627 path.moveTo(0,2); 628 path.cubicTo(0,3, 2,1, 4,0); 629 path.close(); 630 pathB.setFillType(SkPath::kWinding_FillType); 631 pathB.moveTo(1,2); 632 pathB.cubicTo(0,4, 2,0, 3,0); 633 pathB.close(); 634 testPathOp(reporter, path, pathB, kXOR_PathOp); 635 } 636 637 static void cubicOp32d(skiatest::Reporter* reporter) { 638 SkPath path, pathB; 639 path.setFillType(SkPath::kWinding_FillType); 640 path.moveTo(0,1); 641 path.cubicTo(1,2, 6,0, 3,1); 642 path.close(); 643 pathB.setFillType(SkPath::kWinding_FillType); 644 pathB.moveTo(0,6); 645 pathB.cubicTo(1,3, 1,0, 2,1); 646 pathB.close(); 647 testPathOp(reporter, path, pathB, kDifference_PathOp); 648 } 649 650 static void cubicOp33i(skiatest::Reporter* reporter) { 651 SkPath path, pathB; 652 path.setFillType(SkPath::kWinding_FillType); 653 path.moveTo(0,1); 654 path.cubicTo(1,2, 6,0, 3,1); 655 path.close(); 656 pathB.setFillType(SkPath::kWinding_FillType); 657 pathB.moveTo(0,6); 658 pathB.cubicTo(1,3, 1,0, 2,1); 659 pathB.close(); 660 testPathOp(reporter, path, pathB, kIntersect_PathOp); 661 } 662 663 static void cubicOp34d(skiatest::Reporter* reporter) { 664 SkPath path, pathB; 665 path.setFillType(SkPath::kWinding_FillType); 666 path.moveTo(0,1); 667 path.cubicTo(3,5, 2,1, 3,1); 668 path.close(); 669 pathB.setFillType(SkPath::kWinding_FillType); 670 pathB.moveTo(1,2); 671 pathB.cubicTo(1,3, 1,0, 5,3); 672 pathB.close(); 673 testPathOp(reporter, path, pathB, kDifference_PathOp); 674 } 675 676 static void cubicOp35d(skiatest::Reporter* reporter) { 677 SkPath path, pathB; 678 path.setFillType(SkPath::kWinding_FillType); 679 path.moveTo(0,1); 680 path.cubicTo(1,5, 2,1, 4,0); 681 path.close(); 682 pathB.setFillType(SkPath::kWinding_FillType); 683 pathB.moveTo(1,2); 684 pathB.cubicTo(0,4, 1,0, 5,1); 685 pathB.close(); 686 testPathOp(reporter, path, pathB, kDifference_PathOp); 687 } 688 689 static void cubicOp36u(skiatest::Reporter* reporter) { 690 SkPath path, pathB; 691 path.setFillType(SkPath::kWinding_FillType); 692 path.moveTo(0,1); 693 path.cubicTo(1,6, 2,0, 5,1); 694 path.close(); 695 pathB.setFillType(SkPath::kWinding_FillType); 696 pathB.moveTo(0,2); 697 pathB.cubicTo(1,5, 1,0, 6,1); 698 pathB.close(); 699 testPathOp(reporter, path, pathB, kUnion_PathOp); 700 } 701 702 static void cubicOp37d(skiatest::Reporter* reporter) { 703 SkPath path, pathB; 704 path.setFillType(SkPath::kWinding_FillType); 705 path.moveTo(0,1); 706 path.cubicTo(2,6, 6,1, 4,3); 707 path.close(); 708 pathB.setFillType(SkPath::kWinding_FillType); 709 pathB.moveTo(1,6); 710 pathB.cubicTo(3,4, 1,0, 6,2); 711 pathB.close(); 712 testPathOp(reporter, path, pathB, kDifference_PathOp); 713 } 714 715 #if 1 716 // this fails to detect a cubic/cubic intersection 717 // the slight overlap is missed when the cubics are approximated by quadratics 718 // and the subsequent line/cubic intersection also (correctly) misses the intersection 719 // if the line/cubic was a matching line/approx.quadratic then the missing intersection 720 // could have been detected 721 static void cubicOp38d(skiatest::Reporter* reporter) { 722 SkPath path, pathB; 723 path.setFillType(SkPath::kWinding_FillType); 724 path.moveTo(0,1); 725 path.cubicTo(0,6, 3,2, 4,1); 726 path.close(); 727 pathB.setFillType(SkPath::kWinding_FillType); 728 pathB.moveTo(2,3); 729 pathB.cubicTo(1,4, 1,0, 6,0); 730 pathB.close(); 731 testPathOp(reporter, path, pathB, kDifference_PathOp); 732 } 733 #endif 734 735 static void cubicOp39d(skiatest::Reporter* reporter) { 736 SkPath path, pathB; 737 path.setFillType(SkPath::kWinding_FillType); 738 path.moveTo(0,1); 739 path.cubicTo(2,3, 5,1, 4,3); 740 path.close(); 741 pathB.setFillType(SkPath::kWinding_FillType); 742 pathB.moveTo(1,5); 743 pathB.cubicTo(3,4, 1,0, 3,2); 744 pathB.close(); 745 testPathOp(reporter, path, pathB, kDifference_PathOp); 746 } 747 748 static void cubicOp40d(skiatest::Reporter* reporter) { 749 SkPath path, pathB; 750 path.setFillType(SkPath::kWinding_FillType); 751 path.moveTo(0,1); 752 path.cubicTo(1,5, 3,2, 4,2); 753 path.close(); 754 pathB.setFillType(SkPath::kWinding_FillType); 755 pathB.moveTo(2,3); 756 pathB.cubicTo(2,4, 1,0, 5,1); 757 pathB.close(); 758 testPathOp(reporter, path, pathB, kDifference_PathOp); 759 } 760 761 static void cubicOp41i(skiatest::Reporter* reporter) { 762 SkPath path, pathB; 763 path.setFillType(SkPath::kWinding_FillType); 764 path.moveTo(0,1); 765 path.cubicTo(2,6, 4,3, 6,4); 766 path.close(); 767 pathB.setFillType(SkPath::kWinding_FillType); 768 pathB.moveTo(3,4); 769 pathB.cubicTo(4,6, 1,0, 6,2); 770 pathB.close(); 771 testPathOp(reporter, path, pathB, kIntersect_PathOp); 772 } 773 774 static void cubicOp42d(skiatest::Reporter* reporter) { 775 SkPath path, pathB; 776 path.setFillType(SkPath::kWinding_FillType); 777 path.moveTo(0,1); 778 path.cubicTo(1,2, 6,5, 5,4); 779 path.close(); 780 pathB.setFillType(SkPath::kWinding_FillType); 781 pathB.moveTo(5,6); 782 pathB.cubicTo(4,5, 1,0, 2,1); 783 pathB.close(); 784 testPathOp(reporter, path, pathB, kDifference_PathOp); 785 } 786 787 static void cubicOp43d(skiatest::Reporter* reporter) { 788 SkPath path, pathB; 789 path.setFillType(SkPath::kWinding_FillType); 790 path.moveTo(0,2); 791 path.cubicTo(1,2, 4,0, 3,1); 792 path.close(); 793 pathB.setFillType(SkPath::kWinding_FillType); 794 pathB.moveTo(0,4); 795 pathB.cubicTo(1,3, 2,0, 2,1); 796 pathB.close(); 797 testPathOp(reporter, path, pathB, kDifference_PathOp); 798 } 799 800 static void cubicOp44d(skiatest::Reporter* reporter) { 801 SkPath path, pathB; 802 path.setFillType(SkPath::kWinding_FillType); 803 path.moveTo(0,2); 804 path.cubicTo(3,6, 4,0, 3,2); 805 path.close(); 806 pathB.setFillType(SkPath::kWinding_FillType); 807 pathB.moveTo(0,4); 808 pathB.cubicTo(2,3, 2,0, 6,3); 809 pathB.close(); 810 testPathOp(reporter, path, pathB, kDifference_PathOp); 811 } 812 813 static void cubicOp45d(skiatest::Reporter* reporter) { 814 SkPath path, pathB; 815 path.setFillType(SkPath::kWinding_FillType); 816 path.moveTo(0,2); 817 path.cubicTo(2,4, 4,0, 3,2); 818 path.close(); 819 pathB.setFillType(SkPath::kWinding_FillType); 820 pathB.moveTo(0,4); 821 pathB.cubicTo(2,3, 2,0, 4,2); 822 pathB.close(); 823 testPathOp(reporter, path, pathB, kDifference_PathOp); 824 } 825 826 static void cubicOp46d(skiatest::Reporter* reporter) { 827 SkPath path, pathB; 828 path.setFillType(SkPath::kWinding_FillType); 829 path.moveTo(0,2); 830 path.cubicTo(3,5, 5,0, 4,2); 831 path.close(); 832 pathB.setFillType(SkPath::kWinding_FillType); 833 pathB.moveTo(0,5); 834 pathB.cubicTo(2,4, 2,0, 5,3); 835 pathB.close(); 836 testPathOp(reporter, path, pathB, kDifference_PathOp); 837 } 838 839 static void cubicOp47d(skiatest::Reporter* reporter) { 840 SkPath path, pathB; 841 path.setFillType(SkPath::kWinding_FillType); 842 path.moveTo(0,1); 843 path.cubicTo(1,6, 6,2, 5,4); 844 path.close(); 845 pathB.setFillType(SkPath::kWinding_FillType); 846 pathB.moveTo(2,6); 847 pathB.cubicTo(4,5, 1,0, 6,1); 848 pathB.close(); 849 testPathOp(reporter, path, pathB, kDifference_PathOp); 850 } 851 852 static void cubicOp48d(skiatest::Reporter* reporter) { 853 SkPath path, pathB; 854 path.setFillType(SkPath::kWinding_FillType); 855 path.moveTo(0,2); 856 path.cubicTo(2,3, 5,1, 3,2); 857 path.close(); 858 pathB.setFillType(SkPath::kWinding_FillType); 859 pathB.moveTo(1,5); 860 pathB.cubicTo(2,3, 2,0, 3,2); 861 pathB.close(); 862 testPathOp(reporter, path, pathB, kDifference_PathOp); 863 } 864 865 static void cubicOp49d(skiatest::Reporter* reporter) { 866 SkPath path, pathB; 867 path.setFillType(SkPath::kWinding_FillType); 868 path.moveTo(0,2); 869 path.cubicTo(1,5, 3,2, 4,1); 870 path.close(); 871 pathB.setFillType(SkPath::kWinding_FillType); 872 pathB.moveTo(2,3); 873 pathB.cubicTo(1,4, 2,0, 5,1); 874 pathB.close(); 875 testPathOp(reporter, path, pathB, kDifference_PathOp); 876 } 877 878 static void cubicOp50d(skiatest::Reporter* reporter) { 879 SkPath path, pathB; 880 path.setFillType(SkPath::kWinding_FillType); 881 path.moveTo(0,3); 882 path.cubicTo(1,6, 5,0, 5,1); 883 path.close(); 884 pathB.setFillType(SkPath::kWinding_FillType); 885 pathB.moveTo(0,5); 886 pathB.cubicTo(1,5, 3,0, 6,1); 887 pathB.close(); 888 testPathOp(reporter, path, pathB, kDifference_PathOp); 889 } 890 891 static void cubicOp51d(skiatest::Reporter* reporter) { 892 SkPath path, pathB; 893 path.setFillType(SkPath::kWinding_FillType); 894 path.moveTo(0,3); 895 path.cubicTo(1,2, 4,1, 6,0); 896 path.close(); 897 pathB.setFillType(SkPath::kWinding_FillType); 898 pathB.moveTo(1,4); 899 pathB.cubicTo(0,6, 3,0, 2,1); 900 pathB.close(); 901 testPathOp(reporter, path, pathB, kDifference_PathOp); 902 } 903 904 static void cubicOp52d(skiatest::Reporter* reporter) { 905 SkPath path, pathB; 906 path.setFillType(SkPath::kWinding_FillType); 907 path.moveTo(0,2); 908 path.cubicTo(1,2, 5,4, 4,3); 909 path.close(); 910 pathB.setFillType(SkPath::kWinding_FillType); 911 pathB.moveTo(4,5); 912 pathB.cubicTo(3,4, 2,0, 2,1); 913 pathB.close(); 914 testPathOp(reporter, path, pathB, kDifference_PathOp); 915 } 916 917 static void cubicOp53d(skiatest::Reporter* reporter) { 918 SkPath path, pathB; 919 path.setFillType(SkPath::kWinding_FillType); 920 path.moveTo(0,3); 921 path.cubicTo(1,2, 5,3, 2,1); 922 path.close(); 923 pathB.setFillType(SkPath::kWinding_FillType); 924 pathB.moveTo(3,5); 925 pathB.cubicTo(1,2, 3,0, 2,1); 926 pathB.close(); 927 testPathOp(reporter, path, pathB, kDifference_PathOp); 928 } 929 930 static void cubicOp54d(skiatest::Reporter* reporter) { 931 SkPath path, pathB; 932 path.setFillType(SkPath::kWinding_FillType); 933 path.moveTo(0,4); 934 path.cubicTo(1,3, 5,4, 4,2); 935 path.close(); 936 pathB.setFillType(SkPath::kWinding_FillType); 937 pathB.moveTo(4,5); 938 pathB.cubicTo(2,4, 4,0, 3,1); 939 pathB.close(); 940 testPathOp(reporter, path, pathB, kDifference_PathOp); 941 } 942 943 static void cubicOp55d(skiatest::Reporter* reporter) { 944 SkPath path, pathB; 945 path.setFillType(SkPath::kWinding_FillType); 946 path.moveTo(0,5); 947 path.cubicTo(1,3, 3,2, 5,0); 948 path.close(); 949 pathB.setFillType(SkPath::kWinding_FillType); 950 pathB.moveTo(2,3); 951 pathB.cubicTo(0,5, 5,0, 3,1); 952 pathB.close(); 953 testPathOp(reporter, path, pathB, kDifference_PathOp); 954 } 955 956 static void cubicOp56d(skiatest::Reporter* reporter) { 957 SkPath path, pathB; 958 path.setFillType(SkPath::kWinding_FillType); 959 path.moveTo(0,1); 960 path.cubicTo(2,6, 5,0, 2,1); 961 path.close(); 962 pathB.setFillType(SkPath::kWinding_FillType); 963 pathB.moveTo(0,5); 964 pathB.cubicTo(1,2, 1,0, 6,2); 965 pathB.close(); 966 testPathOp(reporter, path, pathB, kDifference_PathOp); 967 } 968 969 static void cubicOp57d(skiatest::Reporter* reporter) { 970 SkPath path, pathB; 971 path.setFillType(SkPath::kWinding_FillType); 972 path.moveTo(0,5); 973 path.cubicTo(0,5, 5,4, 6,4); 974 path.close(); 975 pathB.setFillType(SkPath::kWinding_FillType); 976 pathB.moveTo(4,5); 977 pathB.cubicTo(4,6, 5,0, 5,0); 978 pathB.close(); 979 testPathOp(reporter, path, pathB, kDifference_PathOp); 980 } 981 982 static void cubicOp58d(skiatest::Reporter* reporter) { 983 SkPath path, pathB; 984 path.setFillType(SkPath::kWinding_FillType); 985 path.moveTo(0,5); 986 path.cubicTo(3,4, 6,5, 5,3); 987 path.close(); 988 pathB.setFillType(SkPath::kWinding_FillType); 989 pathB.moveTo(5,6); 990 pathB.cubicTo(3,5, 5,0, 4,3); 991 pathB.close(); 992 testPathOp(reporter, path, pathB, kDifference_PathOp); 993 } 994 995 static void cubicOp59d(skiatest::Reporter* reporter) { 996 SkPath path, pathB; 997 path.setFillType(SkPath::kWinding_FillType); 998 path.moveTo(0,1); 999 path.cubicTo(5,6, 4,0, 4,1); 1000 path.close(); 1001 pathB.setFillType(SkPath::kWinding_FillType); 1002 pathB.moveTo(0,4); 1003 pathB.cubicTo(1,4, 1,0, 6,5); 1004 pathB.close(); 1005 testPathOp(reporter, path, pathB, kDifference_PathOp); 1006 } 1007 1008 static void cubicOp60d(skiatest::Reporter* reporter) { 1009 SkPath path, pathB; 1010 path.setFillType(SkPath::kWinding_FillType); 1011 path.moveTo(0,2); 1012 path.cubicTo(4,6, 6,0, 5,2); 1013 path.close(); 1014 pathB.setFillType(SkPath::kWinding_FillType); 1015 pathB.moveTo(0,6); 1016 pathB.cubicTo(2,5, 2,0, 6,4); 1017 pathB.close(); 1018 testPathOp(reporter, path, pathB, kDifference_PathOp); 1019 } 1020 1021 static void cubicOp61d(skiatest::Reporter* reporter) { 1022 SkPath path, pathB; 1023 path.setFillType(SkPath::kWinding_FillType); 1024 path.moveTo(1,2); 1025 path.cubicTo(0,5, 3,2, 6,1); 1026 path.close(); 1027 pathB.setFillType(SkPath::kWinding_FillType); 1028 pathB.moveTo(2,3); 1029 pathB.cubicTo(1,6, 2,1, 5,0); 1030 pathB.close(); 1031 testPathOp(reporter, path, pathB, kDifference_PathOp); 1032 } 1033 1034 static void cubicOp62d(skiatest::Reporter* reporter) { 1035 SkPath path, pathB; 1036 path.setFillType(SkPath::kWinding_FillType); 1037 path.moveTo(1,3); 1038 path.cubicTo(5,6, 5,3, 5,4); 1039 path.close(); 1040 pathB.setFillType(SkPath::kWinding_FillType); 1041 pathB.moveTo(3,5); 1042 pathB.cubicTo(4,5, 3,1, 6,5); 1043 pathB.close(); 1044 testPathOp(reporter, path, pathB, kDifference_PathOp); 1045 } 1046 1047 static void cubicOp63d(skiatest::Reporter* reporter) { 1048 SkPath path, pathB; 1049 path.setFillType(SkPath::kWinding_FillType); 1050 path.moveTo(2,3); 1051 path.cubicTo(0,4, 3,2, 5,3); 1052 path.close(); 1053 pathB.setFillType(SkPath::kWinding_FillType); 1054 pathB.moveTo(2,3); 1055 pathB.cubicTo(3,5, 3,2, 4,0); 1056 pathB.close(); 1057 testPathOp(reporter, path, pathB, kDifference_PathOp); 1058 } 1059 1060 static void cubicOp64d(skiatest::Reporter* reporter) { 1061 SkPath path, pathB; 1062 path.moveTo(0,1); 1063 path.cubicTo(0,1, 1,0, 3,0); 1064 path.lineTo(0,1); 1065 path.close(); 1066 pathB.moveTo(0,1); 1067 pathB.cubicTo(0,3, 1,0, 1,0); 1068 pathB.lineTo(0,1); 1069 pathB.close(); 1070 testPathOp(reporter, path, pathB, kDifference_PathOp); 1071 } 1072 1073 static void cubicOp65d(skiatest::Reporter* reporter) { 1074 SkPath path, pathB; 1075 path.moveTo(0,1); 1076 path.cubicTo(1,5, 1,0, 1,0); 1077 path.lineTo(0,1); 1078 path.close(); 1079 pathB.moveTo(0,1); 1080 pathB.cubicTo(0,1, 1,0, 5,1); 1081 pathB.lineTo(0,1); 1082 pathB.close(); 1083 testPathOp(reporter, path, pathB, kDifference_PathOp); 1084 } 1085 1086 static void rectOp1d(skiatest::Reporter* reporter) { 1087 SkPath path, pathB; 1088 path.moveTo(0,1); 1089 path.cubicTo(0,1, 1,0, 3,0); 1090 path.lineTo(0,1); 1091 path.close(); 1092 pathB.moveTo(0,1); 1093 pathB.cubicTo(0,3, 1,0, 1,0); 1094 pathB.lineTo(0,1); 1095 pathB.close(); 1096 testPathOp(reporter, path, pathB, kDifference_PathOp); 1097 } 1098 1099 static void cubicOp66u(skiatest::Reporter* reporter) { 1100 SkPath path, pathB; 1101 path.setFillType(SkPath::kWinding_FillType); 1102 path.moveTo(0,1); 1103 path.cubicTo(2,6, 4,2, 5,3); 1104 path.close(); 1105 pathB.setFillType(SkPath::kWinding_FillType); 1106 pathB.moveTo(2,4); 1107 pathB.cubicTo(3,5, 1,0, 6,2); 1108 pathB.close(); 1109 testPathOp(reporter, path, pathB, kUnion_PathOp); 1110 } 1111 1112 static void cubicOp67u(skiatest::Reporter* reporter) { 1113 SkPath path, pathB; 1114 path.moveTo(3,5); 1115 path.cubicTo(1,6, 5,0, 3,1); 1116 path.lineTo(3,5); 1117 path.close(); 1118 pathB.moveTo(0,5); 1119 pathB.cubicTo(1,3, 5,3, 6,1); 1120 pathB.lineTo(0,5); 1121 pathB.close(); 1122 testPathOp(reporter, path, pathB, kUnion_PathOp); 1123 } 1124 1125 static void cubicOp68u(skiatest::Reporter* reporter) { 1126 SkPath path, pathB; 1127 path.moveTo(0,5); 1128 path.cubicTo(4,5, 4,1, 5,0); 1129 path.close(); 1130 pathB.moveTo(1,4); 1131 pathB.cubicTo(0,5, 5,0, 5,4); 1132 pathB.close(); 1133 testPathOp(reporter, path, pathB, kUnion_PathOp); 1134 } 1135 1136 static void cubicOp69d(skiatest::Reporter* reporter) { 1137 SkPath path, pathB; 1138 path.moveTo(1,3); 1139 path.cubicTo(0,1, 3,1, 2,0); 1140 path.close(); 1141 pathB.moveTo(1,3); 1142 pathB.cubicTo(0,2, 3,1, 1,0); 1143 pathB.close(); 1144 testPathOp(reporter, path, pathB, kDifference_PathOp); 1145 } 1146 1147 SkPathOp ops[] = { 1148 kUnion_PathOp, 1149 kXOR_PathOp, 1150 kReverseDifference_PathOp, 1151 kXOR_PathOp, 1152 kReverseDifference_PathOp, 1153 }; 1154 1155 static void rRect1(skiatest::Reporter* reporter) { 1156 SkScalar xA = SkFloatToScalar(0.65f); 1157 SkScalar xB = SkFloatToScalar(10.65f); 1158 SkScalar xC = SkFloatToScalar(20.65f); 1159 SkScalar xD = SkFloatToScalar(30.65f); 1160 SkScalar xE = SkFloatToScalar(40.65f); 1161 SkScalar xF = SkFloatToScalar(50.65f); 1162 1163 SkScalar yA = SkFloatToScalar(0.65f); 1164 SkScalar yB = SkFloatToScalar(10.65f); 1165 SkScalar yC = SkFloatToScalar(20.65f); 1166 SkScalar yD = SkFloatToScalar(30.65f); 1167 SkScalar yE = SkFloatToScalar(40.65f); 1168 SkScalar yF = SkFloatToScalar(50.65f); 1169 SkPath paths[5]; 1170 SkRect rects[5]; 1171 rects[0].set(xB, yB, xE, yE); 1172 paths[0].addRoundRect(rects[0], SkIntToScalar(5), SkIntToScalar(5)); // red 1173 rects[1].set(xA, yA, xD, yD); 1174 paths[1].addRoundRect(rects[1], SkIntToScalar(5), SkIntToScalar(5)); // green 1175 rects[2].set(xC, yA, xF, yD); 1176 paths[2].addRoundRect(rects[2], SkIntToScalar(5), SkIntToScalar(5)); // blue 1177 rects[3].set(xA, yC, xD, yF); 1178 paths[3].addRoundRect(rects[3], SkIntToScalar(5), SkIntToScalar(5)); // yellow 1179 rects[4].set(xC, yC, xF, yF); 1180 paths[4].addRoundRect(rects[4], SkIntToScalar(5), SkIntToScalar(5)); // cyan 1181 SkPath path; 1182 path.setFillType(SkPath::kInverseEvenOdd_FillType); 1183 for (int index = 0; index < 5; ++index) { 1184 testPathOp(reporter, path, paths[index], ops[index]); 1185 Op(path, paths[index], ops[index], &path); 1186 } 1187 } 1188 1189 static void skp1(skiatest::Reporter* reporter) { 1190 SkPath path; 1191 path.setFillType(SkPath::kEvenOdd_FillType); 1192 path.moveTo(189,7); 1193 path.cubicTo(189,5.34314585f, 190.34314f,4, 192,4); 1194 path.lineTo(243,4); 1195 path.cubicTo(244.65686f,4, 246,5.34314585f, 246,7); 1196 path.lineTo(246,21); 1197 path.cubicTo(246,22.6568546f, 244.65686f,24, 243,24); 1198 path.lineTo(192,24); 1199 path.cubicTo(190.34314f,24, 189,22.6568546f, 189,21); 1200 path.lineTo(189,7); 1201 path.close(); 1202 path.moveTo(191,8); 1203 path.cubicTo(191,6.89543009f, 191.895432f,6, 193,6); 1204 path.lineTo(242,6); 1205 path.cubicTo(243.104568f,6, 244,6.89543009f, 244,8); 1206 path.lineTo(244,20); 1207 path.cubicTo(244,21.1045704f, 243.104568f,22, 242,22); 1208 path.lineTo(193,22); 1209 path.cubicTo(191.895432f,22, 191,21.1045704f, 191,20); 1210 path.lineTo(191,8); 1211 path.close(); 1212 SkPath pathB; 1213 pathB.setFillType(SkPath::kWinding_FillType); 1214 pathB.moveTo(189,4); 1215 pathB.lineTo(199,14); 1216 pathB.lineTo(236,14); 1217 pathB.lineTo(246,4); 1218 pathB.lineTo(189,4); 1219 pathB.close(); 1220 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1221 } 1222 1223 static void skp2(skiatest::Reporter* reporter) { 1224 SkPath path; 1225 path.setFillType(SkPath::kEvenOdd_FillType); 1226 path.moveTo(253.000000f, 11757.0000f); 1227 path.lineTo(253.000000f, 222.000000f); 1228 path.lineTo(823.000000f, 222.000000f); 1229 path.lineTo(823.000000f, 11757.0000f); 1230 path.lineTo(253.000000f, 11757.0000f); 1231 path.close(); 1232 SkPath pathB; 1233 pathB.setFillType(SkPath::kWinding_FillType); 1234 pathB.moveTo(258.000000f, 1028.00000f); 1235 pathB.lineTo(258.000000f, 1027.00000f); 1236 pathB.lineTo(823.000000f, 1027.00000f); 1237 pathB.lineTo(823.000000f, 1028.00000f); 1238 pathB.lineTo(258.000000f, 1028.00000f); 1239 pathB.close(); 1240 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1241 } 1242 1243 static void skp3(skiatest::Reporter* reporter) { 1244 SkPath path; 1245 path.setFillType(SkPath::kEvenOdd_FillType); 1246 path.moveTo(717.000000f, 507.000000f); 1247 path.lineTo(717.000000f, 425.000000f); 1248 path.lineTo(973.000000f, 425.000000f); 1249 path.lineTo(973.000000f, 507.000000f); 1250 path.quadTo(973.000000f, 508.242645f, 972.121582f, 509.121613f); 1251 path.quadTo(971.242615f, 510.000000f, 970.000000f, 510.000000f); 1252 path.lineTo(720.000000f, 510.000000f); 1253 path.quadTo(718.757385f, 510.000000f, 717.878418f, 509.121613f); 1254 path.quadTo(717.000000f, 508.242645f, 717.000000f, 507.000000f); 1255 path.close(); 1256 path.moveTo(719.000000f, 426.000000f); 1257 path.lineTo(971.000000f, 426.000000f); 1258 path.lineTo(971.000000f, 506.000000f); 1259 path.cubicTo(971.000000f, 507.104584f, 970.104553f, 508.000000f, 969.000000f, 508.000000f); 1260 path.lineTo(721.000000f, 508.000000f); 1261 path.cubicTo(719.895447f, 508.000000f, 719.000000f, 507.104584f, 719.000000f, 506.000000f); 1262 path.lineTo(719.000000f, 426.000000f); 1263 path.close(); 1264 SkPath pathB; 1265 pathB.setFillType(SkPath::kWinding_FillType); 1266 pathB.moveTo(717.000000f, 510.000000f); 1267 pathB.lineTo(760.000000f, 467.000000f); 1268 pathB.lineTo(930.000000f, 467.000000f); 1269 pathB.lineTo(973.000000f, 510.000000f); 1270 pathB.lineTo(717.000000f, 510.000000f); 1271 pathB.close(); 1272 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1273 } 1274 1275 static void skp4(skiatest::Reporter* reporter) { 1276 SkPath path; 1277 path.setFillType(SkPath::kEvenOdd_FillType); 1278 path.moveTo(230.756805f, 591.756775f); 1279 path.quadTo(232.514725f, 590.000000f, 235.000000f, 590.000000f); 1280 path.lineTo(300.000000f, 590.000000f); 1281 path.quadTo(302.485291f, 590.000000f, 304.243195f, 591.756775f); 1282 path.quadTo(306.000000f, 593.514709f, 306.000000f, 596.000000f); 1283 path.lineTo(306.000000f, 617.000000f); 1284 path.lineTo(229.000000f, 617.000000f); 1285 path.lineTo(229.000000f, 596.000000f); 1286 path.quadTo(229.000000f, 593.514709f, 230.756805f, 591.756775f); 1287 path.close(); 1288 path.moveTo(231.000000f, 597.000000f); 1289 path.cubicTo(231.000000f, 594.238586f, 233.238571f, 592.000000f, 236.000000f, 592.000000f); 1290 path.lineTo(299.000000f, 592.000000f); 1291 path.cubicTo(301.761414f, 592.000000f, 304.000000f, 594.238586f, 304.000000f, 597.000000f); 1292 path.lineTo(304.000000f, 616.000000f); 1293 path.lineTo(231.000000f, 616.000000f); 1294 path.lineTo(231.000000f, 597.000000f); 1295 path.close(); 1296 SkPath pathB; 1297 pathB.setFillType(SkPath::kWinding_FillType); 1298 pathB.moveTo(306.000000f, 590.000000f); 1299 pathB.lineTo(292.000000f, 604.000000f); 1300 pathB.lineTo(305.000000f, 617.000000f); 1301 pathB.lineTo(306.000000f, 617.000000f); 1302 pathB.lineTo(306.000000f, 590.000000f); 1303 pathB.close(); 1304 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1305 } 1306 1307 static void skp5(skiatest::Reporter* reporter) { 1308 SkPath path; 1309 path.setFillType(SkPath::kEvenOdd_FillType); 1310 path.moveTo(18.0000000f, 226.000000f); 1311 path.quadTo(14.6862917f, 226.000000f, 12.3423996f, 228.342407f); 1312 path.quadTo(10.0000000f, 230.686295f, 10.0000000f, 234.000000f); 1313 path.lineTo(10.0000000f, 253.000000f); 1314 path.lineTo(1247.00000f, 253.000000f); 1315 path.lineTo(1247.00000f, 234.000000f); 1316 path.quadTo(1247.00000f, 230.686295f, 1244.65759f, 228.342407f); 1317 path.quadTo(1242.31372f, 226.000000f, 1239.00000f, 226.000000f); 1318 path.lineTo(18.0000000f, 226.000000f); 1319 path.close(); 1320 SkPath pathB; 1321 pathB.setFillType(SkPath::kInverseWinding_FillType); 1322 pathB.moveTo(18.0000000f, 226.000000f); 1323 pathB.lineTo(1239.00000f, 226.000000f); 1324 pathB.cubicTo(1243.41833f, 226.000000f, 1247.00000f, 229.581726f, 1247.00000f, 234.000000f); 1325 pathB.lineTo(1247.00000f, 252.000000f); 1326 pathB.lineTo(10.0000000f, 252.000000f); 1327 pathB.lineTo(10.0000000f, 234.000000f); 1328 pathB.cubicTo(10.0000000f, 229.581726f, 13.5817204f, 226.000000f, 18.0000000f, 226.000000f); 1329 pathB.close(); 1330 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1331 } 1332 1333 static void cubicOp70d(skiatest::Reporter* reporter) { 1334 SkPath path, pathB; 1335 path.setFillType(SkPath::kWinding_FillType); 1336 path.moveTo(0,1); 1337 path.cubicTo(0,5, 4,0, 5,0); 1338 path.close(); 1339 pathB.setFillType(SkPath::kWinding_FillType); 1340 pathB.moveTo(0,4); 1341 pathB.cubicTo(0,5, 1,0, 5,0); 1342 pathB.close(); 1343 testPathOp(reporter, path, pathB, kDifference_PathOp); 1344 } 1345 1346 static void cubicOp71d(skiatest::Reporter* reporter) { 1347 SkPath path, pathB; 1348 path.setFillType(SkPath::kWinding_FillType); 1349 path.moveTo(0,1); 1350 path.cubicTo(0,5, 4,1, 6,4); 1351 path.close(); 1352 pathB.setFillType(SkPath::kWinding_FillType); 1353 pathB.moveTo(1,4); 1354 pathB.cubicTo(4,6, 1,0, 5,0); 1355 pathB.close(); 1356 testPathOp(reporter, path, pathB, kDifference_PathOp); 1357 } 1358 1359 static void cubicOp72i(skiatest::Reporter* reporter) { 1360 SkPath path, pathB; 1361 path.setFillType(SkPath::kWinding_FillType); 1362 path.moveTo(0,1); 1363 path.cubicTo(0,5, 5,2, 5,4); 1364 path.close(); 1365 pathB.setFillType(SkPath::kWinding_FillType); 1366 pathB.moveTo(2,5); 1367 pathB.cubicTo(4,5, 1,0, 5,0); 1368 pathB.close(); 1369 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1370 } 1371 1372 static void cubicOp73d(skiatest::Reporter* reporter) { 1373 SkPath path, pathB; 1374 path.setFillType(SkPath::kWinding_FillType); 1375 path.moveTo(0,1); 1376 path.cubicTo(3,4, 4,0, 6,4); 1377 path.lineTo(0,1); 1378 path.close(); 1379 pathB.setFillType(SkPath::kWinding_FillType); 1380 pathB.moveTo(0,4); 1381 pathB.cubicTo(4,6, 1,0, 4,3); 1382 pathB.lineTo(0,4); 1383 pathB.close(); 1384 testPathOp(reporter, path, pathB, kDifference_PathOp); 1385 } 1386 1387 static void cubicOp74d(skiatest::Reporter* reporter) { 1388 SkPath path, pathB; 1389 path.setFillType(SkPath::kWinding_FillType); 1390 path.moveTo(0,1); 1391 path.cubicTo(1,5, 5,1, 5,1); 1392 path.lineTo(0,1); 1393 path.close(); 1394 pathB.setFillType(SkPath::kWinding_FillType); 1395 pathB.moveTo(1,5); 1396 pathB.cubicTo(1,5, 1,0, 5,1); 1397 pathB.lineTo(1,5); 1398 pathB.close(); 1399 testPathOp(reporter, path, pathB, kDifference_PathOp); 1400 } 1401 1402 static void cubicOp75d(skiatest::Reporter* reporter) { 1403 SkPath path, pathB; 1404 path.setFillType(SkPath::kWinding_FillType); 1405 path.moveTo(0,1); 1406 path.cubicTo(0,4, 5,1, 6,4); 1407 path.lineTo(0,1); 1408 path.close(); 1409 pathB.setFillType(SkPath::kWinding_FillType); 1410 pathB.moveTo(1,5); 1411 pathB.cubicTo(4,6, 1,0, 4,0); 1412 pathB.lineTo(1,5); 1413 pathB.close(); 1414 testPathOp(reporter, path, pathB, kDifference_PathOp); 1415 } 1416 1417 static void cubicOp76u(skiatest::Reporter* reporter) { 1418 SkPath path, pathB; 1419 path.setFillType(SkPath::kWinding_FillType); 1420 path.moveTo(0,1); 1421 path.cubicTo(0,2, 2,0, 5,3); 1422 path.close(); 1423 pathB.setFillType(SkPath::kWinding_FillType); 1424 pathB.moveTo(0,2); 1425 pathB.cubicTo(3,5, 1,0, 2,0); 1426 pathB.close(); 1427 testPathOp(reporter, path, pathB, kUnion_PathOp); 1428 } 1429 1430 static void cubicOp77i(skiatest::Reporter* reporter) { 1431 SkPath path, pathB; 1432 path.setFillType(SkPath::kEvenOdd_FillType); 1433 path.moveTo(0,1); 1434 path.cubicTo(1,3, 2,0, 3,2); 1435 path.lineTo(0,1); 1436 path.close(); 1437 pathB.setFillType(SkPath::kEvenOdd_FillType); 1438 pathB.moveTo(0,2); 1439 pathB.cubicTo(2,3, 1,0, 3,1); 1440 pathB.lineTo(0,2); 1441 pathB.close(); 1442 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1443 } 1444 1445 static void cubicOp78u(skiatest::Reporter* reporter) { 1446 SkPath path, pathB; 1447 path.setFillType(SkPath::kEvenOdd_FillType); 1448 path.moveTo(1,6); 1449 path.cubicTo(1,6, 5,0, 6,1); 1450 path.lineTo(1,6); 1451 path.close(); 1452 pathB.setFillType(SkPath::kEvenOdd_FillType); 1453 pathB.moveTo(0,5); 1454 pathB.cubicTo(1,6, 6,1, 6,1); 1455 pathB.lineTo(0,5); 1456 pathB.close(); 1457 testPathOp(reporter, path, pathB, kUnion_PathOp); 1458 } 1459 1460 static void cubicOp79u(skiatest::Reporter* reporter) { 1461 SkPath path, pathB; 1462 path.setFillType(SkPath::kWinding_FillType); 1463 path.moveTo(0,1); 1464 path.cubicTo(1,3, 1,0, 6,4); 1465 path.close(); 1466 pathB.setFillType(SkPath::kWinding_FillType); 1467 pathB.moveTo(0,1); 1468 pathB.cubicTo(4,6, 1,0, 3,1); 1469 pathB.close(); 1470 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1471 } 1472 1473 static void cubicOp80i(skiatest::Reporter* reporter) { 1474 SkPath path, pathB; 1475 path.setFillType(SkPath::kWinding_FillType); 1476 path.moveTo(0,1); 1477 path.cubicTo(2,3, 2,1, 4,3); 1478 path.lineTo(0,1); 1479 path.close(); 1480 pathB.setFillType(SkPath::kWinding_FillType); 1481 pathB.moveTo(1,2); 1482 pathB.cubicTo(3,4, 1,0, 3,2); 1483 pathB.lineTo(1,2); 1484 pathB.close(); 1485 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1486 } 1487 1488 static void cubicOp81d(skiatest::Reporter* reporter) { 1489 SkPath path, pathB; 1490 path.setFillType(SkPath::kWinding_FillType); 1491 path.moveTo(0,1); 1492 path.cubicTo(4,6, 4,3, 5,4); 1493 path.close(); 1494 pathB.setFillType(SkPath::kWinding_FillType); 1495 pathB.moveTo(3,4); 1496 pathB.cubicTo(4,5, 1,0, 6,4); 1497 pathB.close(); 1498 testPathOp(reporter, path, pathB, kDifference_PathOp); 1499 } 1500 1501 static void cubicOp82i(skiatest::Reporter* reporter) { 1502 SkPath path, pathB; 1503 path.setFillType(SkPath::kEvenOdd_FillType); 1504 path.moveTo(0,1); 1505 path.cubicTo(2,3, 5,2, 3,0); 1506 path.lineTo(0,1); 1507 path.close(); 1508 pathB.setFillType(SkPath::kWinding_FillType); 1509 pathB.moveTo(2,5); 1510 pathB.cubicTo(0,3, 1,0, 3,2); 1511 pathB.lineTo(2,5); 1512 pathB.close(); 1513 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1514 } 1515 1516 static void cubicOp83i(skiatest::Reporter* reporter) { 1517 SkPath path, pathB; 1518 path.setFillType(SkPath::kWinding_FillType); 1519 path.moveTo(0,1); 1520 path.cubicTo(0,3, 2,1, 4,1); 1521 path.lineTo(0,1); 1522 path.close(); 1523 pathB.setFillType(SkPath::kWinding_FillType); 1524 pathB.moveTo(1,2); 1525 pathB.cubicTo(1,4, 1,0, 3,0); 1526 pathB.lineTo(1,2); 1527 pathB.close(); 1528 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1529 } 1530 1531 static void cubicOp84d(skiatest::Reporter* reporter) { 1532 SkPath path, pathB; 1533 path.setFillType(SkPath::kWinding_FillType); 1534 path.moveTo(0,4); 1535 path.cubicTo(2,3, 6,3, 3,2); 1536 path.close(); 1537 pathB.setFillType(SkPath::kWinding_FillType); 1538 pathB.moveTo(3,6); 1539 pathB.cubicTo(2,3, 4,0, 3,2); 1540 pathB.close(); 1541 testPathOp(reporter, path, pathB, kDifference_PathOp); 1542 } 1543 1544 static void skpClip1(skiatest::Reporter* reporter) { 1545 SkPath path; 1546 path.setFillType(SkPath::kEvenOdd_FillType); 1547 path.moveTo(1126.17114f, 877.171204f); 1548 path.quadTo(1127.34314f, 876.000000f, 1129.00000f, 876.000000f); 1549 path.lineTo(1243.00000f, 876.000000f); 1550 path.quadTo(1244.65686f, 876.000000f, 1245.82886f, 877.171204f); 1551 path.quadTo(1247.00000f, 878.343140f, 1247.00000f, 880.000000f); 1552 path.lineTo(1247.00000f, 907.000000f); 1553 path.lineTo(1246.00000f, 907.000000f); 1554 path.lineTo(1246.00000f, 880.000000f); 1555 path.cubicTo(1246.00000f, 878.343140f, 1244.65686f, 877.000000f, 1243.00000f, 877.000000f); 1556 path.lineTo(1129.00000f, 877.000000f); 1557 path.cubicTo(1127.34314f, 877.000000f, 1126.00000f, 878.343140f, 1126.00000f, 880.000000f); 1558 path.lineTo(1126.00000f, 907.000000f); 1559 path.lineTo(1125.00000f, 907.000000f); 1560 path.lineTo(1125.00000f, 880.000000f); 1561 path.quadTo(1125.00000f, 878.343140f, 1126.17114f, 877.171204f); 1562 path.close(); 1563 SkPath pathB; 1564 pathB.setFillType(SkPath::kWinding_FillType); 1565 pathB.moveTo(1247.00000f, 876.000000f); 1566 pathB.lineTo(1231.00000f, 892.000000f); 1567 pathB.lineTo(1246.00000f, 907.000000f); 1568 pathB.lineTo(1247.00000f, 907.000000f); 1569 pathB.lineTo(1247.00000f, 876.000000f); 1570 pathB.close(); 1571 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1572 } 1573 1574 static void skpClip2(skiatest::Reporter* reporter) { 1575 SkPath path; 1576 path.setFillType(SkPath::kEvenOdd_FillType); 1577 path.moveTo(134.000000f, 11414.0000f); 1578 path.cubicTo(131.990234f, 11414.0000f, 130.326660f, 11415.4824f, 130.042755f, 11417.4131f); 1579 path.cubicTo(130.233124f, 11418.3193f, 131.037079f, 11419.0000f, 132.000000f, 11419.0000f); 1580 path.lineTo(806.000000f, 11419.0000f); 1581 path.cubicTo(806.962891f, 11419.0000f, 807.766907f, 11418.3193f, 807.957275f, 11417.4131f); 1582 path.cubicTo(807.673401f, 11415.4824f, 806.009766f, 11414.0000f, 804.000000f, 11414.0000f); 1583 path.lineTo(134.000000f, 11414.0000f); 1584 path.close(); 1585 SkPath pathB; 1586 pathB.setFillType(SkPath::kInverseWinding_FillType); 1587 pathB.moveTo(132.000000f, 11415.0000f); 1588 pathB.lineTo(806.000000f, 11415.0000f); 1589 pathB.cubicTo(807.104553f, 11415.0000f, 808.000000f, 11415.4473f, 808.000000f, 11416.0000f); 1590 pathB.lineTo(808.000000f, 11417.0000f); 1591 pathB.cubicTo(808.000000f, 11418.1045f, 807.104553f, 11419.0000f, 806.000000f, 11419.0000f); 1592 pathB.lineTo(132.000000f, 11419.0000f); 1593 pathB.cubicTo(130.895432f, 11419.0000f, 130.000000f, 11418.1045f, 130.000000f, 11417.0000f); 1594 pathB.lineTo(130.000000f, 11416.0000f); 1595 pathB.cubicTo(130.000000f, 11415.4473f, 130.895432f, 11415.0000f, 132.000000f, 11415.0000f); 1596 pathB.close(); 1597 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1598 } 1599 1600 static void skp96prezzi1(skiatest::Reporter* reporter) { 1601 SkPath path; 1602 path.setFillType(SkPath::kEvenOdd_FillType); 1603 path.moveTo(157.464005f, 670.463989f); 1604 path.quadTo(158.928925f, 669.000000f, 161.000000f, 669.000000f); 1605 path.lineTo(248.000000f, 669.000000f); 1606 path.quadTo(250.071075f, 669.000000f, 251.535995f, 670.463989f); 1607 path.quadTo(253.000000f, 671.928955f, 253.000000f, 674.000000f); 1608 path.lineTo(253.000000f, 706.000000f); 1609 path.lineTo(251.000000f, 706.000000f); 1610 path.lineTo(251.000000f, 675.000000f); 1611 path.cubicTo(251.000000f, 672.790833f, 249.209137f, 671.000000f, 247.000000f, 671.000000f); 1612 path.lineTo(162.000000f, 671.000000f); 1613 path.cubicTo(159.790863f, 671.000000f, 158.000000f, 672.790833f, 158.000000f, 675.000000f); 1614 path.lineTo(158.000000f, 706.000000f); 1615 path.lineTo(156.000000f, 706.000000f); 1616 path.lineTo(156.000000f, 674.000000f); 1617 path.quadTo(156.000000f, 671.928955f, 157.464005f, 670.463989f); 1618 path.close(); 1619 SkPath pathB; 1620 pathB.setFillType(SkPath::kWinding_FillType); 1621 pathB.moveTo(156.000000f, 669.000000f); 1622 pathB.lineTo(178.500000f, 691.500000f); 1623 pathB.lineTo(230.500000f, 691.500000f); 1624 pathB.lineTo(253.000000f, 669.000000f); 1625 pathB.lineTo(156.000000f, 669.000000f); 1626 pathB.close(); 1627 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1628 } 1629 1630 static void skpancestry_com1(skiatest::Reporter* reporter) { 1631 SkPath path; 1632 path.setFillType(SkPath::kEvenOdd_FillType); 1633 path.moveTo(161.000000f, 925.000000f); 1634 path.cubicTo(159.874390f, 925.000000f, 158.835663f, 925.371948f, 158.000000f, 925.999634f); 1635 path.lineTo(158.000000f, 926.000000f); 1636 path.lineTo(1108.00000f, 926.000000f); 1637 path.lineTo(1108.00000f, 925.999634f); 1638 path.cubicTo(1107.16443f, 925.371948f, 1106.12561f, 925.000000f, 1105.00000f, 925.000000f); 1639 path.lineTo(161.000000f, 925.000000f); 1640 path.close(); 1641 SkPath pathB; 1642 pathB.setFillType(SkPath::kEvenOdd_FillType); 1643 pathB.moveTo(161.000000f, 926.000000f); 1644 pathB.lineTo(1105.00000f, 926.000000f); 1645 pathB.cubicTo(1107.20911f, 926.000000f, 1109.00000f, 927.790833f, 1109.00000f, 930.000000f); 1646 pathB.lineTo(1109.00000f, 956.000000f); 1647 pathB.cubicTo(1109.00000f, 958.209167f, 1107.20911f, 960.000000f, 1105.00000f, 960.000000f); 1648 pathB.lineTo(161.000000f, 960.000000f); 1649 pathB.cubicTo(158.790863f, 960.000000f, 157.000000f, 958.209167f, 157.000000f, 956.000000f); 1650 pathB.lineTo(157.000000f, 930.000000f); 1651 pathB.cubicTo(157.000000f, 927.790833f, 158.790863f, 926.000000f, 161.000000f, 926.000000f); 1652 pathB.close(); 1653 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1654 } 1655 1656 static void skpeldorado_com_ua1(skiatest::Reporter* reporter) { 1657 SkPath path; 1658 path.setFillType(SkPath::kEvenOdd_FillType); 1659 path.moveTo(286.695129f, 291.000000f); 1660 path.lineTo(229.304855f, 561.000000f); 1661 path.lineTo(979.304871f, 561.000000f); 1662 path.lineTo(1036.69507f, 291.000000f); 1663 path.lineTo(286.695129f, 291.000000f); 1664 path.close(); 1665 SkPath pathB; 1666 pathB.setFillType(SkPath::kWinding_FillType); 1667 pathB.moveTo(1006.69513f, 291.000000f); 1668 pathB.cubicTo(1023.26367f, 291.000000f, 1033.84021f, 304.431458f, 1030.31836f, 321.000000f); 1669 pathB.lineTo(985.681519f, 531.000000f); 1670 pathB.cubicTo(982.159790f, 547.568542f, 965.873413f, 561.000000f, 949.304871f, 561.000000f); 1671 pathB.lineTo(259.304871f, 561.000000f); 1672 pathB.cubicTo(242.736313f, 561.000000f, 232.159805f, 547.568542f, 235.681549f, 531.000000f); 1673 pathB.lineTo(280.318420f, 321.000000f); 1674 pathB.cubicTo(283.840179f, 304.431458f, 300.126587f, 291.000000f, 316.695129f, 291.000000f); 1675 pathB.lineTo(1006.69513f, 291.000000f); 1676 pathB.close(); 1677 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1678 } 1679 1680 static void skpbyte_com1(skiatest::Reporter* reporter) { 1681 SkPath path; 1682 path.setFillType(SkPath::kEvenOdd_FillType); 1683 path.moveTo(968.000000f, 14.0000000f); 1684 path.cubicTo(965.238586f, 14.0000000f, 963.000000f, 16.2385769f, 963.000000f, 19.0000000f); 1685 path.lineTo(963.000000f, 32.0000000f); 1686 path.cubicTo(963.000000f, 34.7614250f, 965.238586f, 37.0000000f, 968.000000f, 37.0000000f); 1687 path.lineTo(1034.00000f, 37.0000000f); 1688 path.cubicTo(1036.76147f, 37.0000000f, 1039.00000f, 34.7614250f, 1039.00000f, 32.0000000f); 1689 path.lineTo(1039.00000f, 19.0000000f); 1690 path.cubicTo(1039.00000f, 16.2385769f, 1036.76147f, 14.0000000f, 1034.00000f, 14.0000000f); 1691 path.lineTo(968.000000f, 14.0000000f); 1692 path.close(); 1693 SkPath pathB; 1694 pathB.setFillType(SkPath::kInverseWinding_FillType); 1695 pathB.moveTo(968.000000f, 14.0000000f); 1696 pathB.lineTo(1034.00000f, 14.0000000f); 1697 pathB.cubicTo(1036.76147f, 14.0000000f, 1039.00000f, 16.2385750f, 1039.00000f, 19.0000000f); 1698 pathB.lineTo(1039.00000f, 32.0000000f); 1699 pathB.cubicTo(1039.00000f, 34.2091408f, 1036.76147f, 36.0000000f, 1034.00000f, 36.0000000f); 1700 pathB.lineTo(968.000000f, 36.0000000f); 1701 pathB.cubicTo(965.238586f, 36.0000000f, 963.000000f, 34.2091408f, 963.000000f, 32.0000000f); 1702 pathB.lineTo(963.000000f, 19.0000000f); 1703 pathB.cubicTo(963.000000f, 16.2385750f, 965.238586f, 14.0000000f, 968.000000f, 14.0000000f); 1704 pathB.close(); 1705 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1706 } 1707 1708 static void skphealth_com76(skiatest::Reporter* reporter) { 1709 SkPath path; 1710 path.setFillType(SkPath::kEvenOdd_FillType); 1711 path.moveTo(708.099182f, 7.09919119f); 1712 path.lineTo(708.099182f, 7.09920025f); 1713 path.quadTo(704.000000f, 11.2010098f, 704.000000f, 17.0000000f); 1714 path.lineTo(704.000000f, 33.0000000f); 1715 path.lineTo(705.000000f, 33.0000000f); 1716 path.lineTo(705.000000f, 17.0000000f); 1717 path.cubicTo(705.000000f, 13.4101496f, 706.455078f, 10.1601505f, 708.807617f, 7.80761385f); 1718 path.lineTo(708.099182f, 7.09919119f); 1719 path.close(); 1720 SkPath pathB; 1721 pathB.setFillType(SkPath::kWinding_FillType); 1722 pathB.moveTo(704.000000f, 3.00000000f); 1723 #if 0 1724 pathB.lineTo(719.500000f, 3.00000000f); 1725 pathB.lineTo(705.000000f, 33.0000000f); 1726 pathB.lineTo(704.000000f, 33.0000000f); 1727 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1728 #else 1729 pathB.lineTo(704.000000f, 33.0000000f); 1730 pathB.lineTo(705.000000f, 33.0000000f); 1731 pathB.lineTo(719.500000f, 3.00000000f); 1732 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1733 #endif 1734 } 1735 1736 static void skpahrefs_com88(skiatest::Reporter* reporter) { 1737 SkPath path; 1738 path.setFillType(SkPath::kEvenOdd_FillType); 1739 path.moveTo(1099.82886f, 7.17117119f); 1740 path.lineTo(1099.12134f, 7.87867832f); 1741 path.cubicTo(1099.66418f, 8.42157173f, 1100.00000f, 9.17157173f, 1100.00000f, 10.0000000f); 1742 path.lineTo(1100.00000f, 28.0000000f); 1743 path.cubicTo(1100.00000f, 29.6568546f, 1098.65686f, 31.0000000f, 1097.00000f, 31.0000000f); 1744 path.lineTo(1088.00000f, 31.0000000f); 1745 path.lineTo(1088.00000f, 32.0000000f); 1746 path.lineTo(1097.00000f, 32.0000000f); 1747 path.quadTo(1098.65686f, 32.0000000f, 1099.82886f, 30.8288002f); 1748 path.quadTo(1101.00000f, 29.6568546f, 1101.00000f, 28.0000000f); 1749 path.lineTo(1101.00000f, 10.0000000f); 1750 path.quadTo(1101.00000f, 8.34314537f, 1099.82886f, 7.17119980f); 1751 path.lineTo(1099.82886f, 7.17117119f); 1752 path.close(); 1753 SkPath pathB; 1754 pathB.setFillType(SkPath::kWinding_FillType); 1755 pathB.moveTo(1101.00000f, 6.00000000f); 1756 pathB.lineTo(1088.00000f, 6.00000000f); 1757 pathB.lineTo(1088.00000f, 19.0000000f); 1758 pathB.lineTo(1101.00000f, 32.0000000f); 1759 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1760 } 1761 1762 static void skpahrefs_com29(skiatest::Reporter* reporter) { 1763 SkPath path; 1764 path.setFillType(SkPath::kEvenOdd_FillType); 1765 path.moveTo(1037.17114f, 7.17119980f); 1766 path.quadTo(1038.34314f, 6.00000000f, 1040.00000f, 6.00000000f); 1767 path.lineTo(1074.00000f, 6.00000000f); 1768 path.lineTo(1074.00000f, 32.0000000f); 1769 path.lineTo(1040.00000f, 32.0000000f); 1770 path.quadTo(1038.34314f, 32.0000000f, 1037.17114f, 30.8288002f); 1771 path.quadTo(1036.00000f, 29.6568546f, 1036.00000f, 28.0000000f); 1772 path.lineTo(1036.00000f, 10.0000000f); 1773 path.quadTo(1036.00000f, 8.34314537f, 1037.17114f, 7.17119980f); 1774 path.close(); 1775 path.moveTo(1037.00000f, 10.0000000f); 1776 path.cubicTo(1037.00000f, 8.34314537f, 1038.34314f, 7.00000000f, 1040.00000f, 7.00000000f); 1777 path.lineTo(1073.00000f, 7.00000000f); 1778 path.lineTo(1073.00000f, 31.0000000f); 1779 path.lineTo(1040.00000f, 31.0000000f); 1780 path.cubicTo(1038.34314f, 31.0000000f, 1037.00000f, 29.6568546f, 1037.00000f, 28.0000000f); 1781 path.lineTo(1037.00000f, 10.0000000f); 1782 path.close(); 1783 SkPath pathB; 1784 pathB.setFillType(SkPath::kWinding_FillType); 1785 pathB.moveTo(1036.00000f, 32.0000000f); 1786 pathB.lineTo(1049.00000f, 19.0000000f); 1787 pathB.lineTo(1073.00000f, 31.0000000f); 1788 pathB.lineTo(1074.00000f, 32.0000000f); 1789 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1790 } 1791 1792 static void cubicOp85d(skiatest::Reporter* reporter) { 1793 SkPath path; 1794 path.setFillType(SkPath::kWinding_FillType); 1795 path.moveTo(0,1); 1796 path.cubicTo(1,6, 1,0, 6,2); 1797 path.close(); 1798 SkPath pathB; 1799 pathB.setFillType(SkPath::kWinding_FillType); 1800 pathB.moveTo(0,1); 1801 pathB.cubicTo(2,6, 1,0, 6,1); 1802 pathB.close(); 1803 testPathOp(reporter, path, pathB, kDifference_PathOp); 1804 } 1805 1806 // this fails because the pair of nearly coincident cubics intersect at the ends 1807 // but the line connected to one of the cubics at the same point does not intersect 1808 // the other 1809 static void skpkkiste_to98(skiatest::Reporter* reporter) { 1810 SkPath path; 1811 path.setFillType(SkPath::kEvenOdd_FillType); 1812 path.moveTo(96, 122); 1813 path.cubicTo(94.6192932f, 122, 93.3692932f, 122.559647f, 92.4644699f, 123.46447f); 1814 path.lineTo(94.1715698f, 125.17157f); 1815 path.cubicTo(94.8954315f, 124.447708f, 95.8954315f, 124, 97, 124); 1816 path.lineTo(257, 124); 1817 path.cubicTo(258.104553f, 124, 259.104584f, 124.447708f, 259.82843f, 125.17157f); 1818 path.lineTo(261.535522f, 123.46447f); 1819 path.cubicTo(260.630707f, 122.559647f, 259.380707f, 122, 258, 122); 1820 path.lineTo(96, 122); 1821 path.close(); 1822 SkPath pathB; 1823 pathB.setFillType(SkPath::kWinding_FillType); 1824 pathB.moveTo(258, 122); 1825 pathB.cubicTo(260.761414f, 122, 263, 124.238579f, 263, 127); 1826 pathB.lineTo(263, 284); 1827 pathB.cubicTo(263, 286.761414f, 260.761414f, 289, 258, 289); 1828 pathB.lineTo(96, 289); 1829 pathB.cubicTo(93.2385788f, 289, 91, 286.761414f, 91, 284); 1830 pathB.lineTo(91, 127); 1831 pathB.cubicTo(91, 124.238579f, 93.2385788f, 122, 96, 122); 1832 pathB.lineTo(258, 122); 1833 pathB.close(); 1834 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1835 } 1836 1837 #if 01 1838 static void issue1417(skiatest::Reporter* reporter) { 1839 SkPath path1; 1840 path1.moveTo(122.58908843994140625f, 82.2836456298828125f); 1841 path1.quadTo(129.8215789794921875f, 80, 138, 80); 1842 path1.quadTo(147.15692138671875f, 80, 155.1280364990234375f, 82.86279296875f); 1843 path1.lineTo(161.1764678955078125f, 100); 1844 path1.lineTo(161.1764678955078125f, 100); 1845 path1.lineTo(115.29412078857421875f, 100); 1846 path1.lineTo(115.29412078857421875f, 100); 1847 path1.lineTo(122.58908843994140625f, 82.2836456298828125f); 1848 path1.lineTo(122.58908843994140625f, 82.2836456298828125f); 1849 path1.close(); 1850 path1.moveTo(98.68194580078125f, 140.343841552734375f); 1851 path1.lineTo(115.29412078857421875f, 100); 1852 path1.lineTo(115.29412078857421875f, 100); 1853 path1.lineTo(97.9337615966796875f, 100); 1854 path1.lineTo(97.9337615966796875f, 100); 1855 path1.quadTo(88, 112.94264984130859375f, 88, 130); 1856 path1.quadTo(88, 131.544830322265625f, 88.08148956298828125f, 133.0560302734375f); 1857 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1858 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1859 path1.close(); 1860 path1.moveTo(136.969696044921875f, 166.6666717529296875f); 1861 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1862 path1.lineTo(98.68194580078125f, 140.343841552734375f); 1863 path1.lineTo(93.45894622802734375f, 153.02825927734375f); 1864 path1.lineTo(93.45894622802734375f, 153.02825927734375f); 1865 path1.quadTo(96.94116973876953125f, 159.65185546875f, 102.64466094970703125f, 165.3553466796875f); 1866 path1.quadTo(110.7924652099609375f, 173.503143310546875f, 120.8179779052734375f, 177.1177825927734375f); 1867 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1868 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1869 path1.close(); 1870 path1.moveTo(175.8309783935546875f, 141.5211334228515625f); 1871 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1872 path1.lineTo(136.969696044921875f, 166.6666717529296875f); 1873 path1.lineTo(153.15728759765625f, 177.7956390380859375f); 1874 path1.lineTo(153.15728759765625f, 177.7956390380859375f); 1875 path1.quadTo(164.392425537109375f, 174.318267822265625f, 173.3553466796875f, 165.3553466796875f); 1876 path1.quadTo(177.805816650390625f, 160.9048614501953125f, 180.90380859375f, 155.8941650390625f); 1877 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1878 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1879 path1.close(); 1880 path1.moveTo(175.8309783935546875f, 141.5211334228515625f); 1881 path1.lineTo(187.8782806396484375f, 133.7258148193359375f); 1882 path1.lineTo(187.8782806396484375f, 133.7258148193359375f); 1883 path1.quadTo(188, 131.8880615234375f, 188, 130); 1884 path1.quadTo(188, 112.942657470703125f, 178.0662384033203125f, 100); 1885 path1.lineTo(161.1764678955078125f, 100); 1886 path1.lineTo(161.1764678955078125f, 100); 1887 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1888 path1.lineTo(175.8309783935546875f, 141.5211334228515625f); 1889 path1.close(); 1890 1891 SkPath path2; 1892 path2.moveTo(174.117645263671875f, 100); 1893 path2.lineTo(161.1764678955078125f, 100); 1894 path2.lineTo(161.1764678955078125f, 100); 1895 path2.lineTo(155.1280364990234375f, 82.86279296875f); 1896 path2.lineTo(155.1280364990234375f, 82.86279296875f); 1897 path2.quadTo(153.14971923828125f, 82.15229034423828125f, 151.098419189453125f, 81.618133544921875f); 1898 path2.lineTo(143.5294189453125f, 100); 1899 path2.lineTo(143.5294189453125f, 100); 1900 path2.lineTo(161.1764678955078125f, 100); 1901 path2.lineTo(161.1764678955078125f, 100); 1902 path2.lineTo(168.23529052734375f, 120); 1903 path2.lineTo(168.23529052734375f, 120); 1904 path2.lineTo(181.1764678955078125f, 120); 1905 path2.lineTo(181.1764678955078125f, 120); 1906 path2.lineTo(186.3661956787109375f, 134.7042236328125f); 1907 path2.lineTo(186.3661956787109375f, 134.7042236328125f); 1908 path2.lineTo(187.8782806396484375f, 133.7258148193359375f); 1909 path2.lineTo(187.8782806396484375f, 133.7258148193359375f); 1910 path2.quadTo(188, 131.8880615234375f, 188, 130); 1911 path2.quadTo(188, 124.80947113037109375f, 187.080169677734375f, 120); 1912 path2.lineTo(181.1764678955078125f, 120); 1913 path2.lineTo(181.1764678955078125f, 120); 1914 path2.lineTo(174.117645263671875f, 100); 1915 path2.lineTo(174.117645263671875f, 100); 1916 path2.close(); 1917 path2.moveTo(88.91983795166015625f, 120); 1918 path2.lineTo(107.0588226318359375f, 120); 1919 path2.lineTo(107.0588226318359375f, 120); 1920 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1921 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1922 path2.lineTo(88.08148956298828125f, 133.0560302734375f); 1923 path2.lineTo(88.08148956298828125f, 133.0560302734375f); 1924 path2.quadTo(88, 131.544830322265625f, 88, 130); 1925 path2.quadTo(88, 124.80951690673828125f, 88.91983795166015625f, 120); 1926 path2.close(); 1927 path2.moveTo(96.67621612548828125f, 145.21490478515625f); 1928 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1929 path2.lineTo(98.68194580078125f, 140.343841552734375f); 1930 path2.lineTo(120.68767547607421875f, 155.4727783203125f); 1931 path2.lineTo(120.68767547607421875f, 155.4727783203125f); 1932 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1933 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1934 path2.lineTo(96.67621612548828125f, 145.21490478515625f); 1935 path2.lineTo(96.67621612548828125f, 145.21490478515625f); 1936 path2.close(); 1937 path2.moveTo(113.232177734375f, 173.5789947509765625f); 1938 path2.quadTo(116.8802642822265625f, 175.69805908203125f, 120.8179779052734375f, 177.1177825927734375f); 1939 path2.lineTo(132.2864990234375f, 169.6969757080078125f); 1940 path2.lineTo(132.2864990234375f, 169.6969757080078125f); 1941 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1942 path2.lineTo(118.68194580078125f, 160.343841552734375f); 1943 path2.lineTo(113.232177734375f, 173.5789947509765625f); 1944 path2.lineTo(113.232177734375f, 173.5789947509765625f); 1945 path2.close(); 1946 1947 testPathOp(reporter, path1, path2, kUnion_PathOp); 1948 } 1949 #endif 1950 1951 static void issue1418(skiatest::Reporter* reporter) { 1952 SkPath path1; 1953 path1.moveTo(0, 0); 1954 path1.lineTo(1, 0); 1955 path1.lineTo(1, 0); 1956 path1.lineTo(1, 1); 1957 path1.lineTo(1, 1); 1958 path1.lineTo(0, 1); 1959 path1.lineTo(0, 1); 1960 path1.lineTo(0, 0); 1961 path1.lineTo(0, 0); 1962 path1.close(); 1963 1964 SkPath path2; 1965 path2.moveTo(0.64644664525985717773f, -0.35355341434478759766f); 1966 path2.quadTo(0.79289329051971435547f, -0.50000005960464477539f, 1.0000001192092895508f, -0.50000005960464477539f); 1967 path2.quadTo(1.2071068286895751953f, -0.50000005960464477539f, 1.3535535335540771484f, -0.35355341434478759766f); 1968 path2.quadTo(1.5000001192092895508f, -0.20710679888725280762f, 1.5000001192092895508f, 0); 1969 path2.quadTo(1.5000001192092895508f, 0.20710679888725280762f, 1.3535535335540771484f, 0.35355341434478759766f); 1970 path2.quadTo(1.2071068286895751953f, 0.50000005960464477539f, 1.0000001192092895508f, 0.50000005960464477539f); 1971 path2.quadTo(0.79289329051971435547f, 0.50000005960464477539f, 0.64644664525985717773f, 0.35355341434478759766f); 1972 path2.quadTo(0.50000005960464477539f, 0.20710679888725280762f, 0.50000005960464477539f, 0); 1973 path2.quadTo(0.50000005960464477539f, -0.20710679888725280762f, 0.64644664525985717773f, -0.35355341434478759766f); 1974 testPathOp(reporter, path1, path2, kIntersect_PathOp); 1975 } 1976 1977 static void cubicOp85i(skiatest::Reporter* reporter) { 1978 SkPath path, pathB; 1979 path.setFillType(SkPath::kWinding_FillType); 1980 path.moveTo(3, 4); 1981 path.cubicTo(1, 5, 4, 3, 6, 4); 1982 path.close(); 1983 pathB.setFillType(SkPath::kWinding_FillType); 1984 pathB.moveTo(3, 4); 1985 pathB.cubicTo(4, 6, 4, 3, 5, 1); 1986 pathB.close(); 1987 testPathOp(reporter, path, pathB, kIntersect_PathOp); 1988 } 1989 1990 #if 0 1991 static void skpkkiste_to716(skiatest::Reporter* reporter) { 1992 SkPath path; 1993 path.setFillType(SkPath::kEvenOdd_FillType); 1994 path.moveTo(1173, 284); 1995 path.cubicTo(1173, 285.125824f, 1173.37207f, 286.164734f, 1174, 287.000488f); 1996 path.lineTo(1174, 123.999496f); 1997 path.cubicTo(1173.37207f, 124.835243f, 1173, 125.874168f, 1173, 127); 1998 path.lineTo(1173, 284); 1999 path.close(); 2000 SkPath pathB; 2001 pathB.setFillType(SkPath::kWinding_FillType); 2002 pathB.moveTo(1340, 122); 2003 pathB.cubicTo(1342.76147f, 122, 1345, 124.238579f, 1345, 127); 2004 pathB.lineTo(1345, 284); 2005 pathB.cubicTo(1345, 286.761414f, 1342.76147f, 289, 1340, 289); 2006 pathB.lineTo(1178, 289); 2007 pathB.cubicTo(1175.23853f, 289, 1173, 286.761414f, 1173, 284); 2008 pathB.lineTo(1173, 127); 2009 pathB.cubicTo(1173, 124.238579f, 1175.23853f, 122, 1178, 122); 2010 pathB.lineTo(1340, 122); 2011 pathB.close(); 2012 testPathOp(reporter, path, pathB, kIntersect_PathOp); 2013 } 2014 #endif 2015 2016 static void (*firstTest)(skiatest::Reporter* ) = 0; 2017 2018 static struct TestDesc tests[] = { 2019 // TEST(skpkkiste_to716), 2020 TEST(cubicOp85i), 2021 TEST(issue1417), 2022 TEST(issue1418), 2023 TEST(skpkkiste_to98), 2024 TEST(skpahrefs_com29), 2025 TEST(cubicOp85d), 2026 TEST(skpahrefs_com88), 2027 TEST(skphealth_com76), 2028 TEST(skpancestry_com1), 2029 TEST(skpbyte_com1), 2030 TEST(skpeldorado_com_ua1), 2031 TEST(skp96prezzi1), 2032 TEST(skpClip2), 2033 TEST(skpClip1), 2034 TEST(cubicOp84d), 2035 TEST(cubicOp83i), 2036 TEST(cubicOp82i), 2037 TEST(cubicOp81d), 2038 TEST(cubicOp80i), 2039 TEST(cubicOp79u), 2040 TEST(cubicOp78u), 2041 TEST(cubicOp77i), 2042 TEST(cubicOp76u), 2043 TEST(cubicOp75d), 2044 TEST(cubicOp74d), 2045 TEST(cubicOp73d), 2046 TEST(cubicOp72i), 2047 TEST(cubicOp71d), 2048 TEST(skp5), 2049 TEST(skp4), 2050 TEST(skp3), 2051 TEST(skp2), 2052 TEST(skp1), 2053 TEST(rRect1), 2054 TEST(cubicOp70d), 2055 TEST(cubicOp69d), 2056 TEST(cubicOp68u), 2057 TEST(cubicOp67u), 2058 TEST(cubicOp66u), 2059 TEST(rectOp1d), 2060 TEST(cubicOp65d), 2061 TEST(cubicOp64d), 2062 TEST(cubicOp63d), 2063 TEST(cubicOp62d), 2064 TEST(cubicOp61d), 2065 TEST(cubicOp60d), 2066 TEST(cubicOp59d), 2067 TEST(cubicOp58d), 2068 TEST(cubicOp57d), 2069 TEST(cubicOp56d), 2070 TEST(cubicOp55d), 2071 TEST(cubicOp54d), 2072 TEST(cubicOp53d), 2073 TEST(cubicOp52d), 2074 TEST(cubicOp51d), 2075 TEST(cubicOp50d), 2076 TEST(cubicOp49d), 2077 TEST(cubicOp48d), 2078 TEST(cubicOp47d), 2079 TEST(cubicOp46d), 2080 TEST(cubicOp45d), 2081 TEST(cubicOp44d), 2082 TEST(cubicOp43d), 2083 TEST(cubicOp42d), 2084 TEST(cubicOp41i), 2085 TEST(cubicOp40d), 2086 TEST(cubicOp39d), 2087 TEST(cubicOp38d), 2088 TEST(cubicOp37d), 2089 TEST(cubicOp36u), 2090 TEST(cubicOp35d), 2091 TEST(cubicOp34d), 2092 TEST(cubicOp33i), 2093 TEST(cubicOp32d), 2094 TEST(cubicOp31d), 2095 TEST(cubicOp31x), 2096 TEST(cubicOp31u), 2097 TEST(cubicOp30d), 2098 TEST(cubicOp29d), 2099 TEST(cubicOp28u), 2100 TEST(cubicOp27d), 2101 TEST(cubicOp26d), 2102 TEST(cubicOp25i), 2103 TEST(testOp8d), 2104 TEST(testDiff1), 2105 TEST(testIntersect1), 2106 TEST(testUnion1), 2107 TEST(testXor1), 2108 TEST(testDiff2), 2109 TEST(testIntersect2), 2110 TEST(testUnion2), 2111 TEST(testXor2), 2112 TEST(testOp1d), 2113 TEST(testOp2d), 2114 TEST(testOp3d), 2115 TEST(testOp1u), 2116 TEST(testOp4d), 2117 TEST(testOp5d), 2118 TEST(testOp6d), 2119 TEST(testOp7d), 2120 TEST(testOp2u), 2121 2122 TEST(cubicOp24d), 2123 TEST(cubicOp23d), 2124 TEST(cubicOp22d), 2125 TEST(cubicOp21d), 2126 TEST(cubicOp20d), 2127 TEST(cubicOp19i), 2128 TEST(cubicOp18d), 2129 TEST(cubicOp17d), 2130 TEST(cubicOp16d), 2131 TEST(cubicOp15d), 2132 TEST(cubicOp14d), 2133 TEST(cubicOp13d), 2134 TEST(cubicOp12d), 2135 TEST(cubicOp11d), 2136 TEST(cubicOp10d), 2137 TEST(cubicOp1i), 2138 TEST(cubicOp9d), 2139 TEST(quadOp9d), 2140 TEST(lineOp9d), 2141 TEST(cubicOp8d), 2142 TEST(cubicOp7d), 2143 TEST(cubicOp6d), 2144 TEST(cubicOp5d), 2145 TEST(cubicOp3d), 2146 TEST(cubicOp2d), 2147 TEST(cubicOp1d), 2148 }; 2149 2150 static const size_t testCount = SK_ARRAY_COUNT(tests); 2151 2152 static struct TestDesc subTests[] = { 2153 TEST(cubicOp6d), 2154 TEST(cubicOp8d), 2155 TEST(cubicOp70d), 2156 TEST(cubicOp16d), 2157 TEST(skp5), 2158 }; 2159 2160 static const size_t subTestCount = SK_ARRAY_COUNT(subTests); 2161 2162 static void (*firstSubTest)(skiatest::Reporter* ) = 0; 2163 2164 static bool runSubTestsFirst = false; 2165 static bool runReverse = false; 2166 static void (*stopTest)(skiatest::Reporter* ) = 0; 2167 2168 static void PathOpsOpTest(skiatest::Reporter* reporter) { 2169 #ifdef SK_DEBUG 2170 gDebugMaxWindSum = 4; 2171 gDebugMaxWindValue = 4; 2172 #endif 2173 #if DEBUG_SHOW_TEST_NAME 2174 strncpy(DEBUG_FILENAME_STRING, "", DEBUG_FILENAME_STRING_LENGTH); 2175 #endif 2176 if (runSubTestsFirst) { 2177 RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse); 2178 } 2179 RunTestSet(reporter, tests, testCount, firstTest, stopTest, runReverse); 2180 if (!runSubTestsFirst) { 2181 RunTestSet(reporter, subTests, subTestCount, firstSubTest, stopTest, runReverse); 2182 } 2183 #ifdef SK_DEBUG 2184 gDebugMaxWindSum = SK_MaxS32; 2185 gDebugMaxWindValue = SK_MaxS32; 2186 #endif 2187 } 2188 2189 #include "TestClassDef.h" 2190 DEFINE_TESTCLASS_SHORT(PathOpsOpTest) 2191
