bool intersect(double minT1, double maxT1, double minT2, double maxT2) { Cubic sub1, sub2; // FIXME: carry last subdivide and reduceOrder result with cubic sub_divide(cubic1, minT1, maxT1, sub1); sub_divide(cubic2, minT2, maxT2, sub2); Intersections i; intersect2(sub1, sub2, i); if (i.used() == 0) { return false; } double x1, y1, x2, y2; t1 = minT1 + i.fT[0][0] * (maxT1 - minT1); t2 = minT2 + i.fT[1][0] * (maxT2 - minT2); xy_at_t(cubic1, t1, x1, y1); xy_at_t(cubic2, t2, x2, y2); if (AlmostEqualUlps(x1, x2) && AlmostEqualUlps(y1, y2)) { return true; } double half1 = (minT1 + maxT1) / 2; double half2 = (minT2 + maxT2) / 2; ++depth; bool result; if (depth & 1) { result = intersect(minT1, half1, minT2, maxT2) || intersect(half1, maxT1, minT2, maxT2) || intersect(minT1, maxT1, minT2, half2) || intersect(minT1, maxT1, half2, maxT2); } else { result = intersect(minT1, maxT1, minT2, half2) || intersect(minT1, maxT1, half2, maxT2) || intersect(minT1, half1, minT2, maxT2) || intersect(half1, maxT1, minT2, maxT2); } --depth; return result; }
static int quadPart(const Cubic& cubic, double tStart, double tEnd, Quadratic& simple) { Cubic part; sub_divide(cubic, tStart, tEnd, part); Quadratic quad; demote_cubic_to_quad(part, quad); // FIXME: should reduceOrder be looser in this use case if quartic is going to blow up on an // extremely shallow quadratic? int order = reduceOrder(quad, simple, kReduceOrder_TreatAsFill); #if DEBUG_QUAD_PART SkDebugf("%s cubic=(%1.17g,%1.17g %1.17g,%1.17g %1.17g,%1.17g %1.17g,%1.17g) t=(%1.17g,%1.17g)\n", __FUNCTION__, cubic[0].x, cubic[0].y, cubic[1].x, cubic[1].y, cubic[2].x, cubic[2].y, cubic[3].x, cubic[3].y, tStart, tEnd); SkDebugf("%s part=(%1.17g,%1.17g %1.17g,%1.17g %1.17g,%1.17g %1.17g,%1.17g)" " quad=(%1.17g,%1.17g %1.17g,%1.17g %1.17g,%1.17g)\n", __FUNCTION__, part[0].x, part[0].y, part[1].x, part[1].y, part[2].x, part[2].y, part[3].x, part[3].y, quad[0].x, quad[0].y, quad[1].x, quad[1].y, quad[2].x, quad[2].y); SkDebugf("%s simple=(%1.17g,%1.17g", __FUNCTION__, simple[0].x, simple[0].y); if (order > 1) { SkDebugf(" %1.17g,%1.17g", simple[1].x, simple[1].y); } if (order > 2) { SkDebugf(" %1.17g,%1.17g", simple[2].x, simple[2].y); } SkDebugf(")\n"); SkASSERT(order < 4 && order > 0); #endif return order; }
void CubicCoincidence_Test() { // split large quadratic // upscale quadratics to cubics // compare original, parts, to see if the are coincident for (size_t index = firstCubicCoincidenceTest; index < quadratics_count; ++index) { const Quadratic& test = quadratics[index]; QuadraticPair split; chop_at(test, split, 0.5); Quadratic midThird; sub_divide(test, 1.0/3, 2.0/3, midThird); Cubic whole, first, second, mid; quad_to_cubic(test, whole); quad_to_cubic(split.first(), first); quad_to_cubic(split.second(), second); quad_to_cubic(midThird, mid); if (!implicit_matches(whole, first)) { printf("%s-1 %d\n", __FUNCTION__, (int)index); } if (!implicit_matches(whole, second)) { printf("%s-2 %d\n", __FUNCTION__, (int)index); } if (!implicit_matches(mid, first)) { printf("%s-3 %d\n", __FUNCTION__, (int)index); } if (!implicit_matches(mid, second)) { printf("%s-4 %d\n", __FUNCTION__, (int)index); } if (!implicit_matches(first, second)) { printf("%s-5 %d\n", __FUNCTION__, (int)index); } } }
bool intersect(const Cubic& cubic, Intersections& i) { SkTDArray<double> ts; double precision = calcPrecision(cubic); cubic_to_quadratics(cubic, precision, ts); int tsCount = ts.count(); if (tsCount == 1) { return false; } double t1Start = 0; Cubic part; for (int idx = 0; idx < tsCount; ++idx) { double t1 = ts[idx]; Quadratic q1; sub_divide(cubic, t1Start, t1, part); demote_cubic_to_quad(part, q1); double t2Start = t1; for (int i2 = idx + 1; i2 <= tsCount; ++i2) { const double t2 = i2 < tsCount ? ts[i2] : 1; Quadratic q2; sub_divide(cubic, t2Start, t2, part); demote_cubic_to_quad(part, q2); Intersections locals; intersect2(q1, q2, locals); for (int tIdx = 0; tIdx < locals.used(); ++tIdx) { // discard intersections at cusp? (maximum curvature) double t1sect = locals.fT[0][tIdx]; double t2sect = locals.fT[1][tIdx]; if (idx + 1 == i2 && t1sect == 1 && t2sect == 0) { continue; } double to1 = t1Start + (t1 - t1Start) * t1sect; double to2 = t2Start + (t2 - t2Start) * t2sect; i.insert(to1, to2); } t2Start = t2; } t1Start = t1; } return i.intersected(); }
_Point top(const Quadratic& quad, double startT, double endT) { Quadratic sub; sub_divide(quad, startT, endT, sub); _Point topPt = sub[0]; if (topPt.y > sub[2].y || (topPt.y == sub[2].y && topPt.x > sub[2].x)) { topPt = sub[2]; } if (!between(sub[0].y, sub[1].y, sub[2].y)) { double extremeT; if (findExtrema(sub[0].y, sub[1].y, sub[2].y, &extremeT)) { extremeT = startT + (endT - startT) * extremeT; _Point test; xy_at_t(quad, extremeT, test.x, test.y); if (topPt.y > test.y || (topPt.y == test.y && topPt.x > test.x)) { topPt = test; } } } return topPt; }
_Point top(const Cubic& cubic, double startT, double endT) { Cubic sub; sub_divide(cubic, startT, endT, sub); _Point topPt = sub[0]; if (topPt.y > sub[3].y || (topPt.y == sub[3].y && topPt.x > sub[3].x)) { topPt = sub[3]; } double extremeTs[2]; if (!monotonic_in_y(sub)) { int roots = findExtrema(sub[0].y, sub[1].y, sub[2].y, sub[3].y, extremeTs); for (int index = 0; index < roots; ++index) { _Point mid; double t = startT + (endT - startT) * extremeTs[index]; xy_at_t(cubic, t, mid.x, mid.y); if (topPt.y > mid.y || (topPt.y == mid.y && topPt.x > mid.x)) { topPt = mid; } } } return topPt; }
int intersect(const Cubic& cubic, const Quadratic& quad, Intersections& i) { SkTDArray<double> ts; double precision = calcPrecision(cubic); cubic_to_quadratics(cubic, precision, ts); double tStart = 0; Cubic part; int tsCount = ts.count(); for (int idx = 0; idx <= tsCount; ++idx) { double t = idx < tsCount ? ts[idx] : 1; Quadratic q1; sub_divide(cubic, tStart, t, part); demote_cubic_to_quad(part, q1); Intersections locals; intersect2(q1, quad, locals); for (int tIdx = 0; tIdx < locals.used(); ++tIdx) { double globalT = tStart + (t - tStart) * locals.fT[0][tIdx]; i.insertOne(globalT, 0); globalT = locals.fT[1][tIdx]; i.insertOne(globalT, 1); } tStart = t; } return i.used(); }
bool intersect(double minT1, double maxT1, double minT2, double maxT2) { bool t1IsLine = maxT1 - minT1 <= quad1Divisions; bool t2IsLine = maxT2 - minT2 <= quad2Divisions; if (t1IsLine | t2IsLine) { return intersectAsLine(minT1, maxT1, minT2, maxT2, t1IsLine, t2IsLine); } Quadratic smaller, larger; // FIXME: carry last subdivide and reduceOrder result with quad sub_divide(quad1, minT1, maxT1, intersections.swapped() ? larger : smaller); sub_divide(quad2, minT2, maxT2, intersections.swapped() ? smaller : larger); double minT, maxT; if (!bezier_clip(smaller, larger, minT, maxT)) { if (approximately_equal(minT, maxT)) { double smallT, largeT; _Point q2pt, q1pt; if (intersections.swapped()) { largeT = interp(minT2, maxT2, minT); xy_at_t(quad2, largeT, q2pt.x, q2pt.y); xy_at_t(quad1, minT1, q1pt.x, q1pt.y); if (AlmostEqualUlps(q2pt.x, q1pt.x) && AlmostEqualUlps(q2pt.y, q1pt.y)) { smallT = minT1; } else { xy_at_t(quad1, maxT1, q1pt.x, q1pt.y); // FIXME: debug code assert(AlmostEqualUlps(q2pt.x, q1pt.x) && AlmostEqualUlps(q2pt.y, q1pt.y)); smallT = maxT1; } } else { smallT = interp(minT1, maxT1, minT); xy_at_t(quad1, smallT, q1pt.x, q1pt.y); xy_at_t(quad2, minT2, q2pt.x, q2pt.y); if (AlmostEqualUlps(q2pt.x, q1pt.x) && AlmostEqualUlps(q2pt.y, q1pt.y)) { largeT = minT2; } else { xy_at_t(quad2, maxT2, q2pt.x, q2pt.y); // FIXME: debug code assert(AlmostEqualUlps(q2pt.x, q1pt.x) && AlmostEqualUlps(q2pt.y, q1pt.y)); largeT = maxT2; } } intersections.add(smallT, largeT); return true; } return false; } int split; if (intersections.swapped()) { double newMinT1 = interp(minT1, maxT1, minT); double newMaxT1 = interp(minT1, maxT1, maxT); split = (newMaxT1 - newMinT1 > (maxT1 - minT1) * tClipLimit) << 1; #define VERBOSE 0 #if VERBOSE printf("%s d=%d s=%d new1=(%g,%g) old1=(%g,%g) split=%d\n", __FUNCTION__, depth, splits, newMinT1, newMaxT1, minT1, maxT1, split); #endif minT1 = newMinT1; maxT1 = newMaxT1; } else { double newMinT2 = interp(minT2, maxT2, minT); double newMaxT2 = interp(minT2, maxT2, maxT); split = newMaxT2 - newMinT2 > (maxT2 - minT2) * tClipLimit; #if VERBOSE printf("%s d=%d s=%d new2=(%g,%g) old2=(%g,%g) split=%d\n", __FUNCTION__, depth, splits, newMinT2, newMaxT2, minT2, maxT2, split); #endif minT2 = newMinT2; maxT2 = newMaxT2; } return chop(minT1, maxT1, minT2, maxT2, split); }
double calcPrecision(const Cubic& cubic, double t, double scale) { Cubic part; sub_divide(cubic, SkTMax(0., t - scale), SkTMin(1., t + scale), part); return calcPrecision(part); }
bool intersect(double minT1, double maxT1, double minT2, double maxT2) { Quadratic smaller, larger; // FIXME: carry last subdivide and reduceOrder result with quad sub_divide(quad1, minT1, maxT1, intersections.swapped() ? larger : smaller); sub_divide(quad2, minT2, maxT2, intersections.swapped() ? smaller : larger); Quadratic smallResult; if (reduceOrder(smaller, smallResult) <= 2) { Quadratic largeResult; if (reduceOrder(larger, largeResult) <= 2) { double smallT[2], largeT[2]; const _Line& smallLine = (const _Line&) smallResult; const _Line& largeLine = (const _Line&) largeResult; // FIXME: this doesn't detect or deal with coincident lines if (!::intersect(smallLine, largeLine, smallT, largeT)) { return false; } if (intersections.swapped()) { smallT[0] = interp(minT2, maxT2, smallT[0]); largeT[0] = interp(minT1, maxT1, largeT[0]); } else { smallT[0] = interp(minT1, maxT1, smallT[0]); largeT[0] = interp(minT2, maxT2, largeT[0]); } intersections.add(smallT[0], largeT[0]); return true; } } double minT, maxT; if (!bezier_clip(smaller, larger, minT, maxT)) { if (minT == maxT) { if (intersections.swapped()) { minT1 = (minT1 + maxT1) / 2; minT2 = interp(minT2, maxT2, minT); } else { minT1 = interp(minT1, maxT1, minT); minT2 = (minT2 + maxT2) / 2; } intersections.add(minT1, minT2); return true; } return false; } int split; if (intersections.swapped()) { double newMinT1 = interp(minT1, maxT1, minT); double newMaxT1 = interp(minT1, maxT1, maxT); split = (newMaxT1 - newMinT1 > (maxT1 - minT1) * tClipLimit) << 1; #define VERBOSE 0 #if VERBOSE printf("%s d=%d s=%d new1=(%g,%g) old1=(%g,%g) split=%d\n", __FUNCTION__, depth, splits, newMinT1, newMaxT1, minT1, maxT1, split); #endif minT1 = newMinT1; maxT1 = newMaxT1; } else { double newMinT2 = interp(minT2, maxT2, minT); double newMaxT2 = interp(minT2, maxT2, maxT); split = newMaxT2 - newMinT2 > (maxT2 - minT2) * tClipLimit; #define VERBOSE 0 #if VERBOSE printf("%s d=%d s=%d new2=(%g,%g) old2=(%g,%g) split=%d\n", __FUNCTION__, depth, splits, newMinT2, newMaxT2, minT2, maxT2, split); #endif minT2 = newMinT2; maxT2 = newMaxT2; } return chop(minT1, maxT1, minT2, maxT2, split); }
// this flavor centers potential intersections recursively. In contrast, '2' may inadvertently // chase intersections near quadratic ends, requiring odd hacks to find them. static bool intersect3(const Cubic& cubic1, double t1s, double t1e, const Cubic& cubic2, double t2s, double t2e, double precisionScale, Intersections& i) { i.upDepth(); bool result = false; Cubic c1, c2; sub_divide(cubic1, t1s, t1e, c1); sub_divide(cubic2, t2s, t2e, c2); SkTDArray<double> ts1; // OPTIMIZE: if c1 == c2, call once (happens when detecting self-intersection) cubic_to_quadratics(c1, calcPrecision(c1) * precisionScale, ts1); SkTDArray<double> ts2; cubic_to_quadratics(c2, calcPrecision(c2) * precisionScale, ts2); double t1Start = t1s; int ts1Count = ts1.count(); for (int i1 = 0; i1 <= ts1Count; ++i1) { const double tEnd1 = i1 < ts1Count ? ts1[i1] : 1; const double t1 = t1s + (t1e - t1s) * tEnd1; Quadratic s1; int o1 = quadPart(cubic1, t1Start, t1, s1); double t2Start = t2s; int ts2Count = ts2.count(); for (int i2 = 0; i2 <= ts2Count; ++i2) { const double tEnd2 = i2 < ts2Count ? ts2[i2] : 1; const double t2 = t2s + (t2e - t2s) * tEnd2; if (cubic1 == cubic2 && t1Start >= t2Start) { t2Start = t2; continue; } Quadratic s2; int o2 = quadPart(cubic2, t2Start, t2, s2); #if ONE_OFF_DEBUG char tab[] = " "; if (tLimits1[0][0] >= t1Start && tLimits1[0][1] <= t1 && tLimits1[1][0] >= t2Start && tLimits1[1][1] <= t2) { Cubic cSub1, cSub2; sub_divide(cubic1, t1Start, t1, cSub1); sub_divide(cubic2, t2Start, t2, cSub2); SkDebugf("%.*s %s t1=(%1.9g,%1.9g) t2=(%1.9g,%1.9g)", i.depth()*2, tab, __FUNCTION__, t1Start, t1, t2Start, t2); Intersections xlocals; intersectWithOrder(s1, o1, s2, o2, xlocals); SkDebugf(" xlocals.fUsed=%d\n", xlocals.used()); } #endif Intersections locals; intersectWithOrder(s1, o1, s2, o2, locals); double coStart[2] = { -1 }; _Point coPoint; int tCount = locals.used(); for (int tIdx = 0; tIdx < tCount; ++tIdx) { double to1 = t1Start + (t1 - t1Start) * locals.fT[0][tIdx]; double to2 = t2Start + (t2 - t2Start) * locals.fT[1][tIdx]; // if the computed t is not sufficiently precise, iterate _Point p1 = xy_at_t(cubic1, to1); _Point p2 = xy_at_t(cubic2, to2); if (p1.approximatelyEqual(p2)) { if (locals.fIsCoincident[0] & 1 << tIdx) { if (coStart[0] < 0) { coStart[0] = to1; coStart[1] = to2; coPoint = p1; } else { i.insertCoincidentPair(coStart[0], to1, coStart[1], to2, coPoint, p1); coStart[0] = -1; } result = true; } else if (cubic1 != cubic2 || !approximately_equal(to1, to2)) { if (i.swapped()) { // FIXME: insert should respect swap i.insert(to2, to1, p1); } else { i.insert(to1, to2, p1); } result = true; } } else { double offset = precisionScale / 16; // FIME: const is arbitrary -- test & refine #if 1 double c1Bottom = tIdx == 0 ? 0 : (t1Start + (t1 - t1Start) * locals.fT[0][tIdx - 1] + to1) / 2; double c1Min = SkTMax(c1Bottom, to1 - offset); double c1Top = tIdx == tCount - 1 ? 1 : (t1Start + (t1 - t1Start) * locals.fT[0][tIdx + 1] + to1) / 2; double c1Max = SkTMin(c1Top, to1 + offset); double c2Min = SkTMax(0., to2 - offset); double c2Max = SkTMin(1., to2 + offset); #if ONE_OFF_DEBUG SkDebugf("%.*s %s 1 contains1=%d/%d contains2=%d/%d\n", i.depth()*2, tab, __FUNCTION__, c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max, to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset, c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max, to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset); SkDebugf("%.*s %s 1 c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9g c2Top=%1.9g" " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1.9g\n", i.depth()*2, tab, __FUNCTION__, c1Bottom, c1Top, 0., 1., to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset); SkDebugf("%.*s %s 1 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1.9g c2Min=%1.9g" " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__, to1, to2, c1Min, c1Max, c2Min, c2Max); #endif intersect3(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); #if ONE_OFF_DEBUG SkDebugf("%.*s %s 1 i.used=%d t=%1.9g\n", i.depth()*2, tab, __FUNCTION__, i.used(), i.used() > 0 ? i.fT[0][i.used() - 1] : -1); #endif if (tCount > 1) { c1Min = SkTMax(0., to1 - offset); c1Max = SkTMin(1., to1 + offset); double c2Bottom = tIdx == 0 ? to2 : (t2Start + (t2 - t2Start) * locals.fT[1][tIdx - 1] + to2) / 2; double c2Top = tIdx == tCount - 1 ? to2 : (t2Start + (t2 - t2Start) * locals.fT[1][tIdx + 1] + to2) / 2; if (c2Bottom > c2Top) { SkTSwap(c2Bottom, c2Top); } if (c2Bottom == to2) { c2Bottom = 0; } if (c2Top == to2) { c2Top = 1; } c2Min = SkTMax(c2Bottom, to2 - offset); c2Max = SkTMin(c2Top, to2 + offset); #if ONE_OFF_DEBUG SkDebugf("%.*s %s 2 contains1=%d/%d contains2=%d/%d\n", i.depth()*2, tab, __FUNCTION__, c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max, to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset, c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max, to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset); SkDebugf("%.*s %s 2 c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9g c2Top=%1.9g" " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1.9g\n", i.depth()*2, tab, __FUNCTION__, 0., 1., c2Bottom, c2Top, to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset); SkDebugf("%.*s %s 2 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1.9g c2Min=%1.9g" " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__, to1, to2, c1Min, c1Max, c2Min, c2Max); #endif intersect3(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); #if ONE_OFF_DEBUG SkDebugf("%.*s %s 2 i.used=%d t=%1.9g\n", i.depth()*2, tab, __FUNCTION__, i.used(), i.used() > 0 ? i.fT[0][i.used() - 1] : -1); #endif c1Min = SkTMax(c1Bottom, to1 - offset); c1Max = SkTMin(c1Top, to1 + offset); #if ONE_OFF_DEBUG SkDebugf("%.*s %s 3 contains1=%d/%d contains2=%d/%d\n", i.depth()*2, tab, __FUNCTION__, c1Min <= tLimits1[0][1] && tLimits1[0][0] <= c1Max && c2Min <= tLimits1[1][1] && tLimits1[1][0] <= c2Max, to1 - offset <= tLimits1[0][1] && tLimits1[0][0] <= to1 + offset && to2 - offset <= tLimits1[1][1] && tLimits1[1][0] <= to2 + offset, c1Min <= tLimits2[0][1] && tLimits2[0][0] <= c1Max && c2Min <= tLimits2[1][1] && tLimits2[1][0] <= c2Max, to1 - offset <= tLimits2[0][1] && tLimits2[0][0] <= to1 + offset && to2 - offset <= tLimits2[1][1] && tLimits2[1][0] <= to2 + offset); SkDebugf("%.*s %s 3 c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9g c2Top=%1.9g" " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1.9g\n", i.depth()*2, tab, __FUNCTION__, 0., 1., c2Bottom, c2Top, to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset); SkDebugf("%.*s %s 3 to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1.9g c2Min=%1.9g" " c2Max=%1.9g\n", i.depth()*2, tab, __FUNCTION__, to1, to2, c1Min, c1Max, c2Min, c2Max); #endif intersect3(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); #if ONE_OFF_DEBUG SkDebugf("%.*s %s 3 i.used=%d t=%1.9g\n", i.depth()*2, tab, __FUNCTION__, i.used(), i.used() > 0 ? i.fT[0][i.used() - 1] : -1); #endif } #else double c1Bottom = tIdx == 0 ? 0 : (t1Start + (t1 - t1Start) * locals.fT[0][tIdx - 1] + to1) / 2; double c1Min = SkTMax(c1Bottom, to1 - offset); double c1Top = tIdx == tCount - 1 ? 1 : (t1Start + (t1 - t1Start) * locals.fT[0][tIdx + 1] + to1) / 2; double c1Max = SkTMin(c1Top, to1 + offset); double c2Bottom = tIdx == 0 ? to2 : (t2Start + (t2 - t2Start) * locals.fT[1][tIdx - 1] + to2) / 2; double c2Top = tIdx == tCount - 1 ? to2 : (t2Start + (t2 - t2Start) * locals.fT[1][tIdx + 1] + to2) / 2; if (c2Bottom > c2Top) { SkTSwap(c2Bottom, c2Top); } if (c2Bottom == to2) { c2Bottom = 0; } if (c2Top == to2) { c2Top = 1; } double c2Min = SkTMax(c2Bottom, to2 - offset); double c2Max = SkTMin(c2Top, to2 + offset); #if ONE_OFF_DEBUG SkDebugf("%s contains1=%d/%d contains2=%d/%d\n", __FUNCTION__, c1Min <= 0.210357794 && 0.210357794 <= c1Max && c2Min <= 0.223476406 && 0.223476406 <= c2Max, to1 - offset <= 0.210357794 && 0.210357794 <= to1 + offset && to2 - offset <= 0.223476406 && 0.223476406 <= to2 + offset, c1Min <= 0.211324707 && 0.211324707 <= c1Max && c2Min <= 0.211327209 && 0.211327209 <= c2Max, to1 - offset <= 0.211324707 && 0.211324707 <= to1 + offset && to2 - offset <= 0.211327209 && 0.211327209 <= to2 + offset); SkDebugf("%s c1Bottom=%1.9g c1Top=%1.9g c2Bottom=%1.9g c2Top=%1.9g" " 1-o=%1.9g 1+o=%1.9g 2-o=%1.9g 2+o=%1.9g offset=%1.9g\n", __FUNCTION__, c1Bottom, c1Top, c2Bottom, c2Top, to1 - offset, to1 + offset, to2 - offset, to2 + offset, offset); SkDebugf("%s to1=%1.9g to2=%1.9g c1Min=%1.9g c1Max=%1.9g c2Min=%1.9g" " c2Max=%1.9g\n", __FUNCTION__, to1, to2, c1Min, c1Max, c2Min, c2Max); #endif #endif intersect3(cubic1, c1Min, c1Max, cubic2, c2Min, c2Max, offset, i); // TODO: if no intersection is found, either quadratics intersected where // cubics did not, or the intersection was missed. In the former case, expect // the quadratics to be nearly parallel at the point of intersection, and check // for that. } } SkASSERT(coStart[0] == -1); t2Start = t2; } t1Start = t1; } i.downDepth(); return result; }
// this flavor approximates the cubics with quads to find the intersecting ts // OPTIMIZE: if this strategy proves successful, the quad approximations, or the ts used // to create the approximations, could be stored in the cubic segment // FIXME: this strategy needs to intersect the convex hull on either end with the opposite to // account for inset quadratics that cause the endpoint intersection to avoid detection // the segments can be very short -- the length of the maximum quadratic error (precision) // FIXME: this needs to recurse on itself, taking a range of T values and computing the new // t range ala is linear inner. The range can be figured by taking the dx/dy and determining // the fraction that matches the precision. That fraction is the change in t for the smaller cubic. static bool intersect2(const Cubic& cubic1, double t1s, double t1e, const Cubic& cubic2, double t2s, double t2e, double precisionScale, Intersections& i) { Cubic c1, c2; sub_divide(cubic1, t1s, t1e, c1); sub_divide(cubic2, t2s, t2e, c2); SkTDArray<double> ts1; cubic_to_quadratics(c1, calcPrecision(c1) * precisionScale, ts1); SkTDArray<double> ts2; cubic_to_quadratics(c2, calcPrecision(c2) * precisionScale, ts2); double t1Start = t1s; int ts1Count = ts1.count(); for (int i1 = 0; i1 <= ts1Count; ++i1) { const double tEnd1 = i1 < ts1Count ? ts1[i1] : 1; const double t1 = t1s + (t1e - t1s) * tEnd1; Cubic part1; sub_divide(cubic1, t1Start, t1, part1); Quadratic q1; demote_cubic_to_quad(part1, q1); // start here; // should reduceOrder be looser in this use case if quartic is going to blow up on an // extremely shallow quadratic? Quadratic s1; int o1 = reduceOrder(q1, s1); double t2Start = t2s; int ts2Count = ts2.count(); for (int i2 = 0; i2 <= ts2Count; ++i2) { const double tEnd2 = i2 < ts2Count ? ts2[i2] : 1; const double t2 = t2s + (t2e - t2s) * tEnd2; Cubic part2; sub_divide(cubic2, t2Start, t2, part2); Quadratic q2; demote_cubic_to_quad(part2, q2); Quadratic s2; double o2 = reduceOrder(q2, s2); Intersections locals; if (o1 == 3 && o2 == 3) { intersect2(q1, q2, locals); } else if (o1 <= 2 && o2 <= 2) { locals.fUsed = intersect((const _Line&) s1, (const _Line&) s2, locals.fT[0], locals.fT[1]); } else if (o1 == 3 && o2 <= 2) { intersect(q1, (const _Line&) s2, locals); } else { SkASSERT(o1 <= 2 && o2 == 3); intersect(q2, (const _Line&) s1, locals); for (int s = 0; s < locals.fUsed; ++s) { SkTSwap(locals.fT[0][s], locals.fT[1][s]); } } for (int tIdx = 0; tIdx < locals.used(); ++tIdx) { double to1 = t1Start + (t1 - t1Start) * locals.fT[0][tIdx]; double to2 = t2Start + (t2 - t2Start) * locals.fT[1][tIdx]; // if the computed t is not sufficiently precise, iterate _Point p1, p2; xy_at_t(cubic1, to1, p1.x, p1.y); xy_at_t(cubic2, to2, p2.x, p2.y); if (p1.approximatelyEqual(p2)) { i.insert(i.swapped() ? to2 : to1, i.swapped() ? to1 : to2); } else { double dt1, dt2; computeDelta(cubic1, to1, (t1e - t1s), cubic2, to2, (t2e - t2s), dt1, dt2); double scale = precisionScale; if (dt1 > 0.125 || dt2 > 0.125) { scale /= 2; SkDebugf("%s scale=%1.9g\n", __FUNCTION__, scale); } #if SK_DEBUG ++debugDepth; assert(debugDepth < 10); #endif i.swap(); intersect2(cubic2, SkTMax(to2 - dt2, 0.), SkTMin(to2 + dt2, 1.), cubic1, SkTMax(to1 - dt1, 0.), SkTMin(to1 + dt1, 1.), scale, i); i.swap(); #if SK_DEBUG --debugDepth; #endif } } t2Start = t2; } t1Start = t1; } return i.intersected(); }