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; }
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(); }
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(); }
// 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(); }