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 "src/pathops/SkAddIntersections.h" 8#include "src/pathops/SkOpCoincidence.h" 9#include "src/pathops/SkPathOpsBounds.h" 10 11#include <utility> 12 13#if DEBUG_ADD_INTERSECTING_TS 14 15static void debugShowLineIntersection(int pts, const SkIntersectionHelper& wt, 16 const SkIntersectionHelper& wn, const SkIntersections& i) { 17 SkASSERT(i.used() == pts); 18 if (!pts) { 19 SkDebugf("%s no intersect " LINE_DEBUG_STR " " LINE_DEBUG_STR "\n", 20 __FUNCTION__, LINE_DEBUG_DATA(wt.pts()), LINE_DEBUG_DATA(wn.pts())); 21 return; 22 } 23 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " LINE_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 24 i[0][0], LINE_DEBUG_DATA(wt.pts()), PT_DEBUG_DATA(i, 0)); 25 if (pts == 2) { 26 SkDebugf(" " T_DEBUG_STR(wtTs, 1) " " PT_DEBUG_STR, i[0][1], PT_DEBUG_DATA(i, 1)); 27 } 28 SkDebugf(" wnTs[0]=%g " LINE_DEBUG_STR, i[1][0], LINE_DEBUG_DATA(wn.pts())); 29 if (pts == 2) { 30 SkDebugf(" " T_DEBUG_STR(wnTs, 1), i[1][1]); 31 } 32 SkDebugf("\n"); 33} 34 35static void debugShowQuadLineIntersection(int pts, const SkIntersectionHelper& wt, 36 const SkIntersectionHelper& wn, 37 const SkIntersections& i) { 38 SkASSERT(i.used() == pts); 39 if (!pts) { 40 SkDebugf("%s no intersect " QUAD_DEBUG_STR " " LINE_DEBUG_STR "\n", 41 __FUNCTION__, QUAD_DEBUG_DATA(wt.pts()), LINE_DEBUG_DATA(wn.pts())); 42 return; 43 } 44 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " QUAD_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 45 i[0][0], QUAD_DEBUG_DATA(wt.pts()), PT_DEBUG_DATA(i, 0)); 46 for (int n = 1; n < pts; ++n) { 47 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 48 } 49 SkDebugf(" wnTs[0]=%g " LINE_DEBUG_STR, i[1][0], LINE_DEBUG_DATA(wn.pts())); 50 for (int n = 1; n < pts; ++n) { 51 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 52 } 53 SkDebugf("\n"); 54} 55 56static void debugShowQuadIntersection(int pts, const SkIntersectionHelper& wt, 57 const SkIntersectionHelper& wn, const SkIntersections& i) { 58 SkASSERT(i.used() == pts); 59 if (!pts) { 60 SkDebugf("%s no intersect " QUAD_DEBUG_STR " " QUAD_DEBUG_STR "\n", 61 __FUNCTION__, QUAD_DEBUG_DATA(wt.pts()), QUAD_DEBUG_DATA(wn.pts())); 62 return; 63 } 64 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " QUAD_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 65 i[0][0], QUAD_DEBUG_DATA(wt.pts()), PT_DEBUG_DATA(i, 0)); 66 for (int n = 1; n < pts; ++n) { 67 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 68 } 69 SkDebugf(" wnTs[0]=%g " QUAD_DEBUG_STR, i[1][0], QUAD_DEBUG_DATA(wn.pts())); 70 for (int n = 1; n < pts; ++n) { 71 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 72 } 73 SkDebugf("\n"); 74} 75 76static void debugShowConicLineIntersection(int pts, const SkIntersectionHelper& wt, 77 const SkIntersectionHelper& wn, const SkIntersections& i) { 78 SkASSERT(i.used() == pts); 79 if (!pts) { 80 SkDebugf("%s no intersect " CONIC_DEBUG_STR " " LINE_DEBUG_STR "\n", 81 __FUNCTION__, CONIC_DEBUG_DATA(wt.pts(), wt.weight()), LINE_DEBUG_DATA(wn.pts())); 82 return; 83 } 84 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " CONIC_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 85 i[0][0], CONIC_DEBUG_DATA(wt.pts(), wt.weight()), PT_DEBUG_DATA(i, 0)); 86 for (int n = 1; n < pts; ++n) { 87 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 88 } 89 SkDebugf(" wnTs[0]=%g " LINE_DEBUG_STR, i[1][0], LINE_DEBUG_DATA(wn.pts())); 90 for (int n = 1; n < pts; ++n) { 91 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 92 } 93 SkDebugf("\n"); 94} 95 96static void debugShowConicQuadIntersection(int pts, const SkIntersectionHelper& wt, 97 const SkIntersectionHelper& wn, const SkIntersections& i) { 98 SkASSERT(i.used() == pts); 99 if (!pts) { 100 SkDebugf("%s no intersect " CONIC_DEBUG_STR " " QUAD_DEBUG_STR "\n", 101 __FUNCTION__, CONIC_DEBUG_DATA(wt.pts(), wt.weight()), QUAD_DEBUG_DATA(wn.pts())); 102 return; 103 } 104 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " CONIC_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 105 i[0][0], CONIC_DEBUG_DATA(wt.pts(), wt.weight()), PT_DEBUG_DATA(i, 0)); 106 for (int n = 1; n < pts; ++n) { 107 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 108 } 109 SkDebugf(" wnTs[0]=%g " QUAD_DEBUG_STR, i[1][0], QUAD_DEBUG_DATA(wn.pts())); 110 for (int n = 1; n < pts; ++n) { 111 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 112 } 113 SkDebugf("\n"); 114} 115 116static void debugShowConicIntersection(int pts, const SkIntersectionHelper& wt, 117 const SkIntersectionHelper& wn, const SkIntersections& i) { 118 SkASSERT(i.used() == pts); 119 if (!pts) { 120 SkDebugf("%s no intersect " CONIC_DEBUG_STR " " CONIC_DEBUG_STR "\n", 121 __FUNCTION__, CONIC_DEBUG_DATA(wt.pts(), wt.weight()), 122 CONIC_DEBUG_DATA(wn.pts(), wn.weight())); 123 return; 124 } 125 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " CONIC_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 126 i[0][0], CONIC_DEBUG_DATA(wt.pts(), wt.weight()), PT_DEBUG_DATA(i, 0)); 127 for (int n = 1; n < pts; ++n) { 128 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 129 } 130 SkDebugf(" wnTs[0]=%g " CONIC_DEBUG_STR, i[1][0], CONIC_DEBUG_DATA(wn.pts(), wn.weight())); 131 for (int n = 1; n < pts; ++n) { 132 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 133 } 134 SkDebugf("\n"); 135} 136 137static void debugShowCubicLineIntersection(int pts, const SkIntersectionHelper& wt, 138 const SkIntersectionHelper& wn, const SkIntersections& i) { 139 SkASSERT(i.used() == pts); 140 if (!pts) { 141 SkDebugf("%s no intersect " CUBIC_DEBUG_STR " " LINE_DEBUG_STR "\n", 142 __FUNCTION__, CUBIC_DEBUG_DATA(wt.pts()), LINE_DEBUG_DATA(wn.pts())); 143 return; 144 } 145 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " CUBIC_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 146 i[0][0], CUBIC_DEBUG_DATA(wt.pts()), PT_DEBUG_DATA(i, 0)); 147 for (int n = 1; n < pts; ++n) { 148 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 149 } 150 SkDebugf(" wnTs[0]=%g " LINE_DEBUG_STR, i[1][0], LINE_DEBUG_DATA(wn.pts())); 151 for (int n = 1; n < pts; ++n) { 152 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 153 } 154 SkDebugf("\n"); 155} 156 157static void debugShowCubicQuadIntersection(int pts, const SkIntersectionHelper& wt, 158 const SkIntersectionHelper& wn, const SkIntersections& i) { 159 SkASSERT(i.used() == pts); 160 if (!pts) { 161 SkDebugf("%s no intersect " CUBIC_DEBUG_STR " " QUAD_DEBUG_STR "\n", 162 __FUNCTION__, CUBIC_DEBUG_DATA(wt.pts()), QUAD_DEBUG_DATA(wn.pts())); 163 return; 164 } 165 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " CUBIC_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 166 i[0][0], CUBIC_DEBUG_DATA(wt.pts()), PT_DEBUG_DATA(i, 0)); 167 for (int n = 1; n < pts; ++n) { 168 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 169 } 170 SkDebugf(" wnTs[0]=%g " QUAD_DEBUG_STR, i[1][0], QUAD_DEBUG_DATA(wn.pts())); 171 for (int n = 1; n < pts; ++n) { 172 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 173 } 174 SkDebugf("\n"); 175} 176 177static void debugShowCubicConicIntersection(int pts, const SkIntersectionHelper& wt, 178 const SkIntersectionHelper& wn, const SkIntersections& i) { 179 SkASSERT(i.used() == pts); 180 if (!pts) { 181 SkDebugf("%s no intersect " CUBIC_DEBUG_STR " " CONIC_DEBUG_STR "\n", 182 __FUNCTION__, CUBIC_DEBUG_DATA(wt.pts()), CONIC_DEBUG_DATA(wn.pts(), wn.weight())); 183 return; 184 } 185 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " CUBIC_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 186 i[0][0], CUBIC_DEBUG_DATA(wt.pts()), PT_DEBUG_DATA(i, 0)); 187 for (int n = 1; n < pts; ++n) { 188 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 189 } 190 SkDebugf(" wnTs[0]=%g " CONIC_DEBUG_STR, i[1][0], CONIC_DEBUG_DATA(wn.pts(), wn.weight())); 191 for (int n = 1; n < pts; ++n) { 192 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 193 } 194 SkDebugf("\n"); 195} 196 197static void debugShowCubicIntersection(int pts, const SkIntersectionHelper& wt, 198 const SkIntersectionHelper& wn, const SkIntersections& i) { 199 SkASSERT(i.used() == pts); 200 if (!pts) { 201 SkDebugf("%s no intersect " CUBIC_DEBUG_STR " " CUBIC_DEBUG_STR "\n", 202 __FUNCTION__, CUBIC_DEBUG_DATA(wt.pts()), CUBIC_DEBUG_DATA(wn.pts())); 203 return; 204 } 205 SkDebugf("%s " T_DEBUG_STR(wtTs, 0) " " CUBIC_DEBUG_STR " " PT_DEBUG_STR, __FUNCTION__, 206 i[0][0], CUBIC_DEBUG_DATA(wt.pts()), PT_DEBUG_DATA(i, 0)); 207 for (int n = 1; n < pts; ++n) { 208 SkDebugf(" " TX_DEBUG_STR(wtTs) " " PT_DEBUG_STR, n, i[0][n], PT_DEBUG_DATA(i, n)); 209 } 210 SkDebugf(" wnTs[0]=%g " CUBIC_DEBUG_STR, i[1][0], CUBIC_DEBUG_DATA(wn.pts())); 211 for (int n = 1; n < pts; ++n) { 212 SkDebugf(" " TX_DEBUG_STR(wnTs), n, i[1][n]); 213 } 214 SkDebugf("\n"); 215} 216 217#else 218static void debugShowLineIntersection(int , const SkIntersectionHelper& , 219 const SkIntersectionHelper& , const SkIntersections& ) { 220} 221 222static void debugShowQuadLineIntersection(int , const SkIntersectionHelper& , 223 const SkIntersectionHelper& , const SkIntersections& ) { 224} 225 226static void debugShowQuadIntersection(int , const SkIntersectionHelper& , 227 const SkIntersectionHelper& , const SkIntersections& ) { 228} 229 230static void debugShowConicLineIntersection(int , const SkIntersectionHelper& , 231 const SkIntersectionHelper& , const SkIntersections& ) { 232} 233 234static void debugShowConicQuadIntersection(int , const SkIntersectionHelper& , 235 const SkIntersectionHelper& , const SkIntersections& ) { 236} 237 238static void debugShowConicIntersection(int , const SkIntersectionHelper& , 239 const SkIntersectionHelper& , const SkIntersections& ) { 240} 241 242static void debugShowCubicLineIntersection(int , const SkIntersectionHelper& , 243 const SkIntersectionHelper& , const SkIntersections& ) { 244} 245 246static void debugShowCubicQuadIntersection(int , const SkIntersectionHelper& , 247 const SkIntersectionHelper& , const SkIntersections& ) { 248} 249 250static void debugShowCubicConicIntersection(int , const SkIntersectionHelper& , 251 const SkIntersectionHelper& , const SkIntersections& ) { 252} 253 254static void debugShowCubicIntersection(int , const SkIntersectionHelper& , 255 const SkIntersectionHelper& , const SkIntersections& ) { 256} 257#endif 258 259bool AddIntersectTs(SkOpContour* test, SkOpContour* next, SkOpCoincidence* coincidence) { 260 if (test != next) { 261 if (AlmostLessUlps(test->bounds().fBottom, next->bounds().fTop)) { 262 return false; 263 } 264 // OPTIMIZATION: outset contour bounds a smidgen instead? 265 if (!SkPathOpsBounds::Intersects(test->bounds(), next->bounds())) { 266 return true; 267 } 268 } 269 SkIntersectionHelper wt; 270 wt.init(test); 271 do { 272 SkIntersectionHelper wn; 273 wn.init(next); 274 test->debugValidate(); 275 next->debugValidate(); 276 if (test == next && !wn.startAfter(wt)) { 277 continue; 278 } 279 do { 280 if (!SkPathOpsBounds::Intersects(wt.bounds(), wn.bounds())) { 281 continue; 282 } 283 int pts = 0; 284 SkIntersections ts { SkDEBUGCODE(test->globalState()) }; 285 bool swap = false; 286 SkDQuad quad1, quad2; 287 SkDConic conic1, conic2; 288 SkDCubic cubic1, cubic2; 289 switch (wt.segmentType()) { 290 case SkIntersectionHelper::kHorizontalLine_Segment: 291 swap = true; 292 switch (wn.segmentType()) { 293 case SkIntersectionHelper::kHorizontalLine_Segment: 294 case SkIntersectionHelper::kVerticalLine_Segment: 295 case SkIntersectionHelper::kLine_Segment: 296 pts = ts.lineHorizontal(wn.pts(), wt.left(), 297 wt.right(), wt.y(), wt.xFlipped()); 298 debugShowLineIntersection(pts, wn, wt, ts); 299 break; 300 case SkIntersectionHelper::kQuad_Segment: 301 pts = ts.quadHorizontal(wn.pts(), wt.left(), 302 wt.right(), wt.y(), wt.xFlipped()); 303 debugShowQuadLineIntersection(pts, wn, wt, ts); 304 break; 305 case SkIntersectionHelper::kConic_Segment: 306 pts = ts.conicHorizontal(wn.pts(), wn.weight(), wt.left(), 307 wt.right(), wt.y(), wt.xFlipped()); 308 debugShowConicLineIntersection(pts, wn, wt, ts); 309 break; 310 case SkIntersectionHelper::kCubic_Segment: 311 pts = ts.cubicHorizontal(wn.pts(), wt.left(), 312 wt.right(), wt.y(), wt.xFlipped()); 313 debugShowCubicLineIntersection(pts, wn, wt, ts); 314 break; 315 default: 316 SkASSERT(0); 317 } 318 break; 319 case SkIntersectionHelper::kVerticalLine_Segment: 320 swap = true; 321 switch (wn.segmentType()) { 322 case SkIntersectionHelper::kHorizontalLine_Segment: 323 case SkIntersectionHelper::kVerticalLine_Segment: 324 case SkIntersectionHelper::kLine_Segment: { 325 pts = ts.lineVertical(wn.pts(), wt.top(), 326 wt.bottom(), wt.x(), wt.yFlipped()); 327 debugShowLineIntersection(pts, wn, wt, ts); 328 break; 329 } 330 case SkIntersectionHelper::kQuad_Segment: { 331 pts = ts.quadVertical(wn.pts(), wt.top(), 332 wt.bottom(), wt.x(), wt.yFlipped()); 333 debugShowQuadLineIntersection(pts, wn, wt, ts); 334 break; 335 } 336 case SkIntersectionHelper::kConic_Segment: { 337 pts = ts.conicVertical(wn.pts(), wn.weight(), wt.top(), 338 wt.bottom(), wt.x(), wt.yFlipped()); 339 debugShowConicLineIntersection(pts, wn, wt, ts); 340 break; 341 } 342 case SkIntersectionHelper::kCubic_Segment: { 343 pts = ts.cubicVertical(wn.pts(), wt.top(), 344 wt.bottom(), wt.x(), wt.yFlipped()); 345 debugShowCubicLineIntersection(pts, wn, wt, ts); 346 break; 347 } 348 default: 349 SkASSERT(0); 350 } 351 break; 352 case SkIntersectionHelper::kLine_Segment: 353 switch (wn.segmentType()) { 354 case SkIntersectionHelper::kHorizontalLine_Segment: 355 pts = ts.lineHorizontal(wt.pts(), wn.left(), 356 wn.right(), wn.y(), wn.xFlipped()); 357 debugShowLineIntersection(pts, wt, wn, ts); 358 break; 359 case SkIntersectionHelper::kVerticalLine_Segment: 360 pts = ts.lineVertical(wt.pts(), wn.top(), 361 wn.bottom(), wn.x(), wn.yFlipped()); 362 debugShowLineIntersection(pts, wt, wn, ts); 363 break; 364 case SkIntersectionHelper::kLine_Segment: 365 pts = ts.lineLine(wt.pts(), wn.pts()); 366 debugShowLineIntersection(pts, wt, wn, ts); 367 break; 368 case SkIntersectionHelper::kQuad_Segment: 369 swap = true; 370 pts = ts.quadLine(wn.pts(), wt.pts()); 371 debugShowQuadLineIntersection(pts, wn, wt, ts); 372 break; 373 case SkIntersectionHelper::kConic_Segment: 374 swap = true; 375 pts = ts.conicLine(wn.pts(), wn.weight(), wt.pts()); 376 debugShowConicLineIntersection(pts, wn, wt, ts); 377 break; 378 case SkIntersectionHelper::kCubic_Segment: 379 swap = true; 380 pts = ts.cubicLine(wn.pts(), wt.pts()); 381 debugShowCubicLineIntersection(pts, wn, wt, ts); 382 break; 383 default: 384 SkASSERT(0); 385 } 386 break; 387 case SkIntersectionHelper::kQuad_Segment: 388 switch (wn.segmentType()) { 389 case SkIntersectionHelper::kHorizontalLine_Segment: 390 pts = ts.quadHorizontal(wt.pts(), wn.left(), 391 wn.right(), wn.y(), wn.xFlipped()); 392 debugShowQuadLineIntersection(pts, wt, wn, ts); 393 break; 394 case SkIntersectionHelper::kVerticalLine_Segment: 395 pts = ts.quadVertical(wt.pts(), wn.top(), 396 wn.bottom(), wn.x(), wn.yFlipped()); 397 debugShowQuadLineIntersection(pts, wt, wn, ts); 398 break; 399 case SkIntersectionHelper::kLine_Segment: 400 pts = ts.quadLine(wt.pts(), wn.pts()); 401 debugShowQuadLineIntersection(pts, wt, wn, ts); 402 break; 403 case SkIntersectionHelper::kQuad_Segment: { 404 pts = ts.intersect(quad1.set(wt.pts()), quad2.set(wn.pts())); 405 debugShowQuadIntersection(pts, wt, wn, ts); 406 break; 407 } 408 case SkIntersectionHelper::kConic_Segment: { 409 swap = true; 410 pts = ts.intersect(conic2.set(wn.pts(), wn.weight()), 411 quad1.set(wt.pts())); 412 debugShowConicQuadIntersection(pts, wn, wt, ts); 413 break; 414 } 415 case SkIntersectionHelper::kCubic_Segment: { 416 swap = true; 417 pts = ts.intersect(cubic2.set(wn.pts()), quad1.set(wt.pts())); 418 debugShowCubicQuadIntersection(pts, wn, wt, ts); 419 break; 420 } 421 default: 422 SkASSERT(0); 423 } 424 break; 425 case SkIntersectionHelper::kConic_Segment: 426 switch (wn.segmentType()) { 427 case SkIntersectionHelper::kHorizontalLine_Segment: 428 pts = ts.conicHorizontal(wt.pts(), wt.weight(), wn.left(), 429 wn.right(), wn.y(), wn.xFlipped()); 430 debugShowConicLineIntersection(pts, wt, wn, ts); 431 break; 432 case SkIntersectionHelper::kVerticalLine_Segment: 433 pts = ts.conicVertical(wt.pts(), wt.weight(), wn.top(), 434 wn.bottom(), wn.x(), wn.yFlipped()); 435 debugShowConicLineIntersection(pts, wt, wn, ts); 436 break; 437 case SkIntersectionHelper::kLine_Segment: 438 pts = ts.conicLine(wt.pts(), wt.weight(), wn.pts()); 439 debugShowConicLineIntersection(pts, wt, wn, ts); 440 break; 441 case SkIntersectionHelper::kQuad_Segment: { 442 pts = ts.intersect(conic1.set(wt.pts(), wt.weight()), 443 quad2.set(wn.pts())); 444 debugShowConicQuadIntersection(pts, wt, wn, ts); 445 break; 446 } 447 case SkIntersectionHelper::kConic_Segment: { 448 pts = ts.intersect(conic1.set(wt.pts(), wt.weight()), 449 conic2.set(wn.pts(), wn.weight())); 450 debugShowConicIntersection(pts, wt, wn, ts); 451 break; 452 } 453 case SkIntersectionHelper::kCubic_Segment: { 454 swap = true; 455 pts = ts.intersect(cubic2.set(wn.pts() 456 SkDEBUGPARAMS(ts.globalState())), 457 conic1.set(wt.pts(), wt.weight() 458 SkDEBUGPARAMS(ts.globalState()))); 459 debugShowCubicConicIntersection(pts, wn, wt, ts); 460 break; 461 } 462 } 463 break; 464 case SkIntersectionHelper::kCubic_Segment: 465 switch (wn.segmentType()) { 466 case SkIntersectionHelper::kHorizontalLine_Segment: 467 pts = ts.cubicHorizontal(wt.pts(), wn.left(), 468 wn.right(), wn.y(), wn.xFlipped()); 469 debugShowCubicLineIntersection(pts, wt, wn, ts); 470 break; 471 case SkIntersectionHelper::kVerticalLine_Segment: 472 pts = ts.cubicVertical(wt.pts(), wn.top(), 473 wn.bottom(), wn.x(), wn.yFlipped()); 474 debugShowCubicLineIntersection(pts, wt, wn, ts); 475 break; 476 case SkIntersectionHelper::kLine_Segment: 477 pts = ts.cubicLine(wt.pts(), wn.pts()); 478 debugShowCubicLineIntersection(pts, wt, wn, ts); 479 break; 480 case SkIntersectionHelper::kQuad_Segment: { 481 pts = ts.intersect(cubic1.set(wt.pts()), quad2.set(wn.pts())); 482 debugShowCubicQuadIntersection(pts, wt, wn, ts); 483 break; 484 } 485 case SkIntersectionHelper::kConic_Segment: { 486 pts = ts.intersect(cubic1.set(wt.pts() 487 SkDEBUGPARAMS(ts.globalState())), 488 conic2.set(wn.pts(), wn.weight() 489 SkDEBUGPARAMS(ts.globalState()))); 490 debugShowCubicConicIntersection(pts, wt, wn, ts); 491 break; 492 } 493 case SkIntersectionHelper::kCubic_Segment: { 494 pts = ts.intersect(cubic1.set(wt.pts()), cubic2.set(wn.pts())); 495 debugShowCubicIntersection(pts, wt, wn, ts); 496 break; 497 } 498 default: 499 SkASSERT(0); 500 } 501 break; 502 default: 503 SkASSERT(0); 504 } 505#if DEBUG_T_SECT_LOOP_COUNT 506 test->globalState()->debugAddLoopCount(&ts, wt, wn); 507#endif 508 int coinIndex = -1; 509 SkOpPtT* coinPtT[2]; 510 for (int pt = 0; pt < pts; ++pt) { 511 SkASSERT(ts[0][pt] >= 0 && ts[0][pt] <= 1); 512 SkASSERT(ts[1][pt] >= 0 && ts[1][pt] <= 1); 513 wt.segment()->debugValidate(); 514 // if t value is used to compute pt in addT, error may creep in and 515 // rect intersections may result in non-rects. if pt value from intersection 516 // is passed in, current tests break. As a workaround, pass in pt 517 // value from intersection only if pt.x and pt.y is integral 518 SkPoint iPt = ts.pt(pt).asSkPoint(); 519 bool iPtIsIntegral = iPt.fX == floor(iPt.fX) && iPt.fY == floor(iPt.fY); 520 SkOpPtT* testTAt = iPtIsIntegral ? wt.segment()->addT(ts[swap][pt], iPt) 521 : wt.segment()->addT(ts[swap][pt]); 522 wn.segment()->debugValidate(); 523 SkOpPtT* nextTAt = iPtIsIntegral ? wn.segment()->addT(ts[!swap][pt], iPt) 524 : wn.segment()->addT(ts[!swap][pt]); 525 if (!testTAt->contains(nextTAt)) { 526 SkOpPtT* oppPrev = testTAt->oppPrev(nextTAt); // Returns nullptr if pair 527 if (oppPrev) { // already share a pt-t loop. 528 testTAt->span()->mergeMatches(nextTAt->span()); 529 testTAt->addOpp(nextTAt, oppPrev); 530 } 531 if (testTAt->fPt != nextTAt->fPt) { 532 testTAt->span()->unaligned(); 533 nextTAt->span()->unaligned(); 534 } 535 wt.segment()->debugValidate(); 536 wn.segment()->debugValidate(); 537 } 538 if (!ts.isCoincident(pt)) { 539 continue; 540 } 541 if (coinIndex < 0) { 542 coinPtT[0] = testTAt; 543 coinPtT[1] = nextTAt; 544 coinIndex = pt; 545 continue; 546 } 547 if (coinPtT[0]->span() == testTAt->span()) { 548 coinIndex = -1; 549 continue; 550 } 551 if (coinPtT[1]->span() == nextTAt->span()) { 552 coinIndex = -1; // coincidence span collapsed 553 continue; 554 } 555 if (swap) { 556 using std::swap; 557 swap(coinPtT[0], coinPtT[1]); 558 swap(testTAt, nextTAt); 559 } 560 SkASSERT(coincidence->globalState()->debugSkipAssert() 561 || coinPtT[0]->span()->t() < testTAt->span()->t()); 562 if (coinPtT[0]->span()->deleted()) { 563 coinIndex = -1; 564 continue; 565 } 566 if (testTAt->span()->deleted()) { 567 coinIndex = -1; 568 continue; 569 } 570 coincidence->add(coinPtT[0], testTAt, coinPtT[1], nextTAt); 571 wt.segment()->debugValidate(); 572 wn.segment()->debugValidate(); 573 coinIndex = -1; 574 } 575 SkOPOBJASSERT(coincidence, coinIndex < 0); // expect coincidence to be paired 576 } while (wn.advance()); 577 } while (wt.advance()); 578 return true; 579} 580