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 8 #include "SkIntersections.h" 9 #include "SkPathOpsCubic.h" 10 #include "SkPathOpsLine.h" 11 #include "SkPathOpsPoint.h" 12 #include "SkPathOpsQuad.h" 13 #include "SkPathOpsRect.h" 14 #include "SkReduceOrder.h" 15 #include "SkTSort.h" 16 17 #if ONE_OFF_DEBUG 18 static const double tLimits1[2][2] = {{0.388600450, 0.388600452}, {0.245852802, 0.245852804}}; 19 static const double tLimits2[2][2] = {{-0.865211397, -0.865215212}, {-0.865207696, -0.865208078}}; 20 #endif 21 22 #define DEBUG_QUAD_PART ONE_OFF_DEBUG && 1 23 #define DEBUG_QUAD_PART_SHOW_SIMPLE DEBUG_QUAD_PART && 0 24 #define SWAP_TOP_DEBUG 0 25 26 static const int kCubicToQuadSubdivisionDepth = 8; // slots reserved for cubic to quads subdivision 27 28 static int quadPart(const SkDCubic& cubic, double tStart, double tEnd, SkReduceOrder* reducer) { 29 SkDCubic part = cubic.subDivide(tStart, tEnd); 30 SkDQuad quad = part.toQuad(); 31 // FIXME: should reduceOrder be looser in this use case if quartic is going to blow up on an 32 // extremely shallow quadratic? 33 int order = reducer->reduce(quad, SkReduceOrder::kFill_Style); 34 #if DEBUG_QUAD_PART 35 SkDebugf("%s cubic=(%1.9g,%1.9g %1.9g,%1.9g %1.9g,%1.9g %1.9g,%1.9g)" 36 " t=(%1.9g,%1.9g)\n", __FUNCTION__, cubic[0].fX, cubic[0].fY, 37 cubic[1].fX, cubic[1].fY, cubic[2].fX, cubic[2].fY, 38 cubic[3].fX, cubic[3].fY, tStart, tEnd); 39 SkDebugf(" {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n" 40 " {{%1.9g,%1.9g}, {%1.9g,%1.9g}, {%1.9g,%1.9g}},\n", 41 part[0].fX, part[0].fY, part[1].fX, part[1].fY, part[2].fX, part[2].fY, 42 part[3].fX, part[3].fY, quad[0].fX, quad[0].fY, 43 quad[1].fX, quad[1].fY, quad[2].fX, quad[2].fY); 44 #if DEBUG_QUAD_PART_SHOW_SIMPLE 45 SkDebugf("%s simple=(%1.9g,%1.9g", __FUNCTION__, reducer->fQuad[0].fX, reducer->fQuad[0].fY); 46 if (order > 1) { 47 SkDebugf(" %1.9g,%1.9g", reducer->fQuad[1].fX, reducer->fQuad[1].fY); 48 } 49 if (order > 2) { 50 SkDebugf(" %1.9g,%1.9g", reducer->fQuad[2].fX, reducer->fQuad[2].fY); 51 } 52 SkDebugf(")\n"); 53 SkASSERT(order < 4 && order > 0); 54 #endif 55 #endif 56 return order; 57 } 58 59 static void intersectWithOrder(const SkDQuad& simple1, int order1, const SkDQuad& simple2, 60 int order2, SkIntersections& i) { 61 if (order1 == 3 && order2 == 3) { 62 i.intersect(simple1, simple2); 63 } else if (order1 <= 2 && order2 <= 2) { 64 i.intersect((const SkDLine&) simple1, (const SkDLine&) simple2); 65 } else if (order1 == 3 && order2 <= 2) { 66 i.intersect(simple1, (const SkDLine&) simple2); 67 } else { 68 SkASSERT(order1 <= 2 && order2 == 3); 69 i.intersect(simple2, (const SkDLine&) simple1); 70 i.swapPts(); 71 } 72 } 73 74 // this flavor centers potential intersections recursively. In contrast, '2' may inadvertently 75 // chase intersections near quadratic ends, requiring odd hacks to find them. 76 static void intersect(const SkDCubic& cubic1, double t1s, double t1e, const SkDCubic& cubic2, 77 double t2s, double t2e, double precisionScale, SkIntersections& i) { 78 i.upDepth(); 79 SkDCubic c1 = cubic1.subDivide(t1s, t1e); 80 SkDCubic c2 = cubic2.subDivide(t2s, t2e); 81 SkSTArray<kCubicToQuadSubdivisionDepth, double, true> ts1; 82 // OPTIMIZE: if c1 == c2, call once (happens when detecting self-intersection) 83 c1.toQuadraticTs(c1.calcPrecision() * precisionScale, &ts1); 84 SkSTArray<kCubicToQuadSubdivisionDepth, double, true> ts2; 85 c2.toQuadraticTs(c2.calcPrecision() * precisionScale, &ts2); 86 double t1Start = t1s; 87 int ts1Count = ts1.count(); 88 for (int i1 = 0; i1 <= ts1Count; ++i1) { 89 const double tEnd1 = i1 < ts1Count ? ts1[i1] : 1; 90 const double t1 = t1s + (t1e - t1s) * tEnd1; 91 SkReduceOrder s1; 92 int o1 = quadPart(cubic1, t1Start, t1, &s1); 93 double t2Start = t2s; 94 int ts2Count = ts2.count(); 95 for (int i2 = 0; i2 <= ts2Count; ++i2) { 96 const double tEnd2 = i2 < ts2Count ? ts2[i2] : 1; 97 const double t2 = t2s + (t2e - t2s) * tEnd2; 98 if (&cubic1 == &cubic2 && t1Start >= t2Start) { 99 t2Start = t2; 100 continue; 101 } 102 SkReduceOrder s2; 103 int o2 = quadPart(cubic2, t2Start, t2, &s2); 104 #if ONE_OFF_DEBUG 105 char tab[] = " "; 106 if (tLimits1[0][0] >= t1Start && tLimits1[0][1] <= t1 107 && tLimits1[1][0] >= t2Start && tLimits1[1][1] <= t2) { 108 SkDebugf("%.*s %s t1=(%1.9g,%1.9g) t2=(%1.9g,%1.9g)", i.depth()*2, tab, 109 __FUNCTION__, t1Start, t1, t2Start, t2); 110 SkIntersections xlocals; 111 intersectWithOrder(s1.fQuad, o1, s2.fQuad, o2, xlocals); 112 SkDebugf(" xlocals.fUsed=%d\n", xlocals.used()); 113 } 114 #endif 115 SkIntersections locals; 116 intersectWithOrder(s1.fQuad, o1, s2.fQuad, o2, locals); 117 int tCount = locals.used(); 118 for (int tIdx = 0; tIdx < tCount; ++tIdx) { 119 double to1 = t1Start + (t1 - t1Start) * locals[0][tIdx]; 120 double to2 = t2Start + (t2 - t2Start) * locals[1][tIdx]; 121 // if the computed t is not sufficiently precise, iterate 122 SkDPoint p1 = cubic1.ptAtT(to1); 123 SkDPoint p2 = cubic2.ptAtT(to2); 124 if (p1.approximatelyEqual(p2)) { 125 SkASSERT(!locals.isCoincident(tIdx)); 126 if (&cubic1 != &cubic2 || !approximately_equal(to1, to2)) { 127 if (i.swapped()) { // FIXME: insert should respect swap 128 i.insert(to2, to1, p1); 129 } else { 130 i.insert(to1, to2, p1); 131 } 132 } 133 } else { 134 double offset = precisionScale / 16; // FIME: const is arbitrary: test, refine 135 double c1Bottom = tIdx == 0 ? 0 : 136 (t1Start + (t1 - t1Start) * locals[0][tIdx - 1] + to1) / 2; 137 double c1Min = SkTMax(c1Bottom, to1 - offset); 138 double c1Top = tIdx == tCount - 1 ? 1 : 139 (t1Start + (t1 - t1Start) * locals[0][tIdx + 1] + to1) / 2; 140 double c1Max = SkTMin(c1Top, to1 + offset); 141 double c2Min = SkTMax(0., to2 - offset); 142 double c2Max = SkTMin(1., to2 + offset); 143 #if ONE_OFF_DEBUG 144 SkDebugf("%.*s %s 1 contains1=%d/%d contains2=%d/%d\n", i.depth()*2, tab, 145 __FUNCTION__, 146 c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max 147 && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max, 148 to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset 149 && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset, 150 c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max 151 && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max, 152 to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset 153 && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset); 154 SkDebugf("%.*s %s 1 c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9g c2Top=%1.9g" 155 " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1.9g\n", 156 i.depth()*2, tab, __FUNCTION__, c1Bottom, c1Top, 0., 1., 157 to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset); 158 SkDebugf("%.*s %s 1 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1.9g c2Min=%1.9g" 159 " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__, to1, to2, c1Min, 160 c1Max, c2Min, c2Max); 161 #endif 162 intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); 163 #if ONE_OFF_DEBUG 164 SkDebugf("%.*s %s 1 i.used=%d t=%1.9g\n", i.depth()*2, tab, __FUNCTION__, 165 i.used(), i.used() > 0 ? i[0][i.used() - 1] : -1); 166 #endif 167 if (tCount > 1) { 168 c1Min = SkTMax(0., to1 - offset); 169 c1Max = SkTMin(1., to1 + offset); 170 double c2Bottom = tIdx == 0 ? to2 : 171 (t2Start + (t2 - t2Start) * locals[1][tIdx - 1] + to2) / 2; 172 double c2Top = tIdx == tCount - 1 ? to2 : 173 (t2Start + (t2 - t2Start) * locals[1][tIdx + 1] + to2) / 2; 174 if (c2Bottom > c2Top) { 175 SkTSwap(c2Bottom, c2Top); 176 } 177 if (c2Bottom == to2) { 178 c2Bottom = 0; 179 } 180 if (c2Top == to2) { 181 c2Top = 1; 182 } 183 c2Min = SkTMax(c2Bottom, to2 - offset); 184 c2Max = SkTMin(c2Top, to2 + offset); 185 #if ONE_OFF_DEBUG 186 SkDebugf("%.*s %s 2 contains1=%d/%d contains2=%d/%d\n", i.depth()*2, tab, 187 __FUNCTION__, 188 c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max 189 && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max, 190 to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset 191 && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset, 192 c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max 193 && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max, 194 to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset 195 && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset); 196 SkDebugf("%.*s %s 2 c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9g c2Top=%1.9g" 197 " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1.9g\n", 198 i.depth()*2, tab, __FUNCTION__, 0., 1., c2Bottom, c2Top, 199 to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset); 200 SkDebugf("%.*s %s 2 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1.9g c2Min=%1.9g" 201 " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__, to1, to2, c1Min, 202 c1Max, c2Min, c2Max); 203 #endif 204 intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); 205 #if ONE_OFF_DEBUG 206 SkDebugf("%.*s %s 2 i.used=%d t=%1.9g\n", i.depth()*2, tab, __FUNCTION__, 207 i.used(), i.used() > 0 ? i[0][i.used() - 1] : -1); 208 #endif 209 c1Min = SkTMax(c1Bottom, to1 - offset); 210 c1Max = SkTMin(c1Top, to1 + offset); 211 #if ONE_OFF_DEBUG 212 SkDebugf("%.*s %s 3 contains1=%d/%d contains2=%d/%d\n", i.depth()*2, tab, 213 __FUNCTION__, 214 c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max 215 && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max, 216 to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset 217 && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset, 218 c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max 219 && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max, 220 to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset 221 && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset); 222 SkDebugf("%.*s %s 3 c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9g c2Top=%1.9g" 223 " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1.9g\n", 224 i.depth()*2, tab, __FUNCTION__, 0., 1., c2Bottom, c2Top, 225 to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset); 226 SkDebugf("%.*s %s 3 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1.9g c2Min=%1.9g" 227 " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__, to1, to2, c1Min, 228 c1Max, c2Min, c2Max); 229 #endif 230 intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); 231 #if ONE_OFF_DEBUG 232 SkDebugf("%.*s %s 3 i.used=%d t=%1.9g\n", i.depth()*2, tab, __FUNCTION__, 233 i.used(), i.used() > 0 ? i[0][i.used() - 1] : -1); 234 #endif 235 } 236 // intersect(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); 237 // FIXME: if no intersection is found, either quadratics intersected where 238 // cubics did not, or the intersection was missed. In the former case, expect 239 // the quadratics to be nearly parallel at the point of intersection, and check 240 // for that. 241 } 242 } 243 t2Start = t2; 244 } 245 t1Start = t1; 246 } 247 i.downDepth(); 248 } 249 250 #define LINE_FRACTION 0.1 251 252 // intersect the end of the cubic with the other. Try lines from the end to control and opposite 253 // end to determine range of t on opposite cubic. 254 static void intersectEnd(const SkDCubic& cubic1, bool start, const SkDCubic& cubic2, 255 const SkDRect& bounds2, bool selfIntersect, SkIntersections& i) { 256 SkDLine line; 257 int t1Index = start ? 0 : 3; 258 bool swap = i.swapped(); 259 double testT = (double) !start; 260 // quad/quad at this point checks to see if exact matches have already been found 261 // cubic/cubic can't reject so easily since cubics can intersect same point more than once 262 if (!selfIntersect) { 263 SkDLine tmpLine; 264 tmpLine[0] = tmpLine[1] = cubic2[t1Index]; 265 tmpLine[1].fX += cubic2[2 - start].fY - cubic2[t1Index].fY; 266 tmpLine[1].fY -= cubic2[2 - start].fX - cubic2[t1Index].fX; 267 SkIntersections impTs; 268 impTs.intersectRay(cubic1, tmpLine); 269 for (int index = 0; index < impTs.used(); ++index) { 270 SkDPoint realPt = impTs.pt(index); 271 if (!tmpLine[0].approximatelyEqualHalf(realPt)) { 272 continue; 273 } 274 if (swap) { 275 i.insert(testT, impTs[0][index], tmpLine[0]); 276 } else { 277 i.insert(impTs[0][index], testT, tmpLine[0]); 278 } 279 return; 280 } 281 } 282 // don't bother if the two cubics are connnected 283 static const int kPointsInCubic = 4; // FIXME: move to DCubic, replace '4' with this 284 static const int kMaxLineCubicIntersections = 3; 285 SkSTArray<(kMaxLineCubicIntersections - 1) * kMaxLineCubicIntersections, double, true> tVals; 286 line[0] = cubic1[t1Index]; 287 // this variant looks for intersections with the end point and lines parallel to other points 288 for (int index = 0; index < kPointsInCubic; ++index) { 289 if (index == t1Index) { 290 continue; 291 } 292 SkDVector dxy1 = cubic1[index] - line[0]; 293 dxy1 /= SkDCubic::gPrecisionUnit; 294 line[1] = line[0] + dxy1; 295 SkDRect lineBounds; 296 lineBounds.setBounds(line); 297 if (!bounds2.intersects(&lineBounds)) { 298 continue; 299 } 300 SkIntersections local; 301 if (!local.intersect(cubic2, line)) { 302 continue; 303 } 304 for (int idx2 = 0; idx2 < local.used(); ++idx2) { 305 double foundT = local[0][idx2]; 306 if (approximately_less_than_zero(foundT) 307 || approximately_greater_than_one(foundT)) { 308 continue; 309 } 310 if (local.pt(idx2).approximatelyEqual(line[0])) { 311 if (i.swapped()) { // FIXME: insert should respect swap 312 i.insert(foundT, testT, line[0]); 313 } else { 314 i.insert(testT, foundT, line[0]); 315 } 316 } else { 317 tVals.push_back(foundT); 318 } 319 } 320 } 321 if (tVals.count() == 0) { 322 return; 323 } 324 SkTQSort<double>(tVals.begin(), tVals.end() - 1); 325 double tMin1 = start ? 0 : 1 - LINE_FRACTION; 326 double tMax1 = start ? LINE_FRACTION : 1; 327 int tIdx = 0; 328 do { 329 int tLast = tIdx; 330 while (tLast + 1 < tVals.count() && roughly_equal(tVals[tLast + 1], tVals[tIdx])) { 331 ++tLast; 332 } 333 double tMin2 = SkTMax(tVals[tIdx] - LINE_FRACTION, 0.0); 334 double tMax2 = SkTMin(tVals[tLast] + LINE_FRACTION, 1.0); 335 int lastUsed = i.used(); 336 intersect(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, i); 337 if (lastUsed == i.used()) { 338 tMin2 = SkTMax(tVals[tIdx] - (1.0 / SkDCubic::gPrecisionUnit), 0.0); 339 tMax2 = SkTMin(tVals[tLast] + (1.0 / SkDCubic::gPrecisionUnit), 1.0); 340 intersect(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, i); 341 } 342 tIdx = tLast + 1; 343 } while (tIdx < tVals.count()); 344 return; 345 } 346 347 const double CLOSE_ENOUGH = 0.001; 348 349 static bool closeStart(const SkDCubic& cubic, int cubicIndex, SkIntersections& i, SkDPoint& pt) { 350 if (i[cubicIndex][0] != 0 || i[cubicIndex][1] > CLOSE_ENOUGH) { 351 return false; 352 } 353 pt = cubic.ptAtT((i[cubicIndex][0] + i[cubicIndex][1]) / 2); 354 return true; 355 } 356 357 static bool closeEnd(const SkDCubic& cubic, int cubicIndex, SkIntersections& i, SkDPoint& pt) { 358 int last = i.used() - 1; 359 if (i[cubicIndex][last] != 1 || i[cubicIndex][last - 1] < 1 - CLOSE_ENOUGH) { 360 return false; 361 } 362 pt = cubic.ptAtT((i[cubicIndex][last] + i[cubicIndex][last - 1]) / 2); 363 return true; 364 } 365 366 static bool only_end_pts_in_common(const SkDCubic& c1, const SkDCubic& c2) { 367 // the idea here is to see at minimum do a quick reject by rotating all points 368 // to either side of the line formed by connecting the endpoints 369 // if the opposite curves points are on the line or on the other side, the 370 // curves at most intersect at the endpoints 371 for (int oddMan = 0; oddMan < 4; ++oddMan) { 372 const SkDPoint* endPt[3]; 373 for (int opp = 1; opp < 4; ++opp) { 374 int end = oddMan ^ opp; // choose a value not equal to oddMan 375 endPt[opp - 1] = &c1[end]; 376 } 377 for (int triTest = 0; triTest < 3; ++triTest) { 378 double origX = endPt[triTest]->fX; 379 double origY = endPt[triTest]->fY; 380 int oppTest = triTest + 1; 381 if (3 == oppTest) { 382 oppTest = 0; 383 } 384 double adj = endPt[oppTest]->fX - origX; 385 double opp = endPt[oppTest]->fY - origY; 386 double sign = (c1[oddMan].fY - origY) * adj - (c1[oddMan].fX - origX) * opp; 387 if (approximately_zero(sign)) { 388 goto tryNextHalfPlane; 389 } 390 for (int n = 0; n < 4; ++n) { 391 double test = (c2[n].fY - origY) * adj - (c2[n].fX - origX) * opp; 392 if (test * sign > 0 && !precisely_zero(test)) { 393 goto tryNextHalfPlane; 394 } 395 } 396 } 397 return true; 398 tryNextHalfPlane: 399 ; 400 } 401 return false; 402 } 403 404 int SkIntersections::intersect(const SkDCubic& c1, const SkDCubic& c2) { 405 bool selfIntersect = &c1 == &c2; 406 if (selfIntersect) { 407 if (c1[0].approximatelyEqualHalf(c1[3])) { 408 insert(0, 1, c1[0]); 409 } 410 } else { 411 for (int i1 = 0; i1 < 4; i1 += 3) { 412 for (int i2 = 0; i2 < 4; i2 += 3) { 413 if (c1[i1].approximatelyEqualHalf(c2[i2])) { 414 insert(i1 >> 1, i2 >> 1, c1[i1]); 415 } 416 } 417 } 418 } 419 SkASSERT(fUsed < 4); 420 if (!selfIntersect) { 421 if (only_end_pts_in_common(c1, c2)) { 422 return fUsed; 423 } 424 if (only_end_pts_in_common(c2, c1)) { 425 return fUsed; 426 } 427 } 428 // quad/quad does linear test here -- cubic does not 429 // cubics which are really lines should have been detected in reduce step earlier 430 SkDRect c1Bounds, c2Bounds; 431 // FIXME: pass in cached bounds from caller 432 c1Bounds.setBounds(c1); // OPTIMIZE use setRawBounds ? 433 c2Bounds.setBounds(c2); 434 intersectEnd(c1, false, c2, c2Bounds, selfIntersect, *this); 435 intersectEnd(c1, true, c2, c2Bounds, selfIntersect, *this); 436 if (selfIntersect) { 437 if (fUsed) { 438 return fUsed; 439 } 440 } else { 441 swap(); 442 intersectEnd(c2, false, c1, c1Bounds, false, *this); 443 intersectEnd(c2, true, c1, c1Bounds, false, *this); 444 swap(); 445 } 446 // if two ends intersect, check middle for coincidence 447 if (fUsed >= 2) { 448 SkASSERT(!selfIntersect); 449 int last = fUsed - 1; 450 double tRange1 = fT[0][last] - fT[0][0]; 451 double tRange2 = fT[1][last] - fT[1][0]; 452 for (int index = 1; index < 5; ++index) { 453 double testT1 = fT[0][0] + tRange1 * index / 5; 454 double testT2 = fT[1][0] + tRange2 * index / 5; 455 SkDPoint testPt1 = c1.ptAtT(testT1); 456 SkDPoint testPt2 = c2.ptAtT(testT2); 457 if (!testPt1.approximatelyEqual(testPt2)) { 458 goto skipCoincidence; 459 } 460 } 461 if (fUsed > 2) { 462 fPt[1] = fPt[last]; 463 fT[0][1] = fT[0][last]; 464 fT[1][1] = fT[1][last]; 465 fUsed = 2; 466 } 467 fIsCoincident[0] = fIsCoincident[1] = 0x03; 468 return fUsed; 469 } 470 skipCoincidence: 471 ::intersect(c1, 0, 1, c2, 0, 1, 1, *this); 472 // If an end point and a second point very close to the end is returned, the second 473 // point may have been detected because the approximate quads 474 // intersected at the end and close to it. Verify that the second point is valid. 475 if (fUsed <= 1) { 476 return fUsed; 477 } 478 SkDPoint pt[2]; 479 if (closeStart(c1, 0, *this, pt[0]) && closeStart(c2, 1, *this, pt[1]) 480 && pt[0].approximatelyEqual(pt[1])) { 481 removeOne(1); 482 } 483 if (closeEnd(c1, 0, *this, pt[0]) && closeEnd(c2, 1, *this, pt[1]) 484 && pt[0].approximatelyEqual(pt[1])) { 485 removeOne(used() - 2); 486 } 487 // vet the pairs of t values to see if the mid value is also on the curve. If so, mark 488 // the span as coincident 489 if (fUsed >= 2 && !coincidentUsed()) { 490 int last = fUsed - 1; 491 int match = 0; 492 for (int index = 0; index < last; ++index) { 493 double mid1 = (fT[0][index] + fT[0][index + 1]) / 2; 494 double mid2 = (fT[1][index] + fT[1][index + 1]) / 2; 495 pt[0] = c1.ptAtT(mid1); 496 pt[1] = c2.ptAtT(mid2); 497 if (pt[0].approximatelyEqual(pt[1])) { 498 match |= 1 << index; 499 } 500 } 501 if (match) { 502 if (((match + 1) & match) != 0) { 503 SkDebugf("%s coincident hole\n", __FUNCTION__); 504 } 505 // for now, assume that everything from start to finish is coincident 506 if (fUsed > 2) { 507 fPt[1] = fPt[last]; 508 fT[0][1] = fT[0][last]; 509 fT[1][1] = fT[1][last]; 510 fIsCoincident[0] = 0x03; 511 fIsCoincident[1] = 0x03; 512 fUsed = 2; 513 } 514 } 515 } 516 return fUsed; 517 } 518 519 // Up promote the quad to a cubic. 520 // OPTIMIZATION If this is a common use case, optimize by duplicating 521 // the intersect 3 loop to avoid the promotion / demotion code 522 int SkIntersections::intersect(const SkDCubic& cubic, const SkDQuad& quad) { 523 SkDCubic up = quad.toCubic(); 524 (void) intersect(cubic, up); 525 return used(); 526 } 527 528 /* http://www.ag.jku.at/compass/compasssample.pdf 529 ( Self-Intersection Problems and Approximate Implicitization by Jan B. Thomassen 530 Centre of Mathematics for Applications, University of Oslo http://www.cma.uio.no janbth (at) math.uio.no 531 SINTEF Applied Mathematics http://www.sintef.no ) 532 describes a method to find the self intersection of a cubic by taking the gradient of the implicit 533 form dotted with the normal, and solving for the roots. My math foo is too poor to implement this.*/ 534 535 int SkIntersections::intersect(const SkDCubic& c) { 536 // check to see if x or y end points are the extrema. Are other quick rejects possible? 537 if (c.endsAreExtremaInXOrY()) { 538 return false; 539 } 540 (void) intersect(c, c); 541 if (used() > 0) { 542 SkASSERT(used() == 1); 543 if (fT[0][0] > fT[1][0]) { 544 swapPts(); 545 } 546 } 547 return used(); 548 } 549
