// note: caller expects multiple results to be sorted smaller first
// note: http://en.wikipedia.org/wiki/Loss_of_significance has an interesting
// analysis of the quadratic equation, suggesting why the following looks at
// the sign of B -- and further suggesting that the greatest loss of precision
// is in b squared less two a c
int quadraticRootsValidT(double A, double B, double C, double t[2]) {
#if 0
B *= 2;
double square = B * B - 4 * A * C;
if (approximately_negative(square)) {
if (!approximately_positive(square)) {
return 0;
}
square = 0;
}
double squareRt = sqrt(square);
double Q = (B + (B < 0 ? -squareRt : squareRt)) / -2;
int foundRoots = 0;
double ratio = Q / A;
if (approximately_zero_or_more(ratio) && approximately_one_or_less(ratio)) {
if (approximately_less_than_zero(ratio)) {
ratio = 0;
} else if (approximately_greater_than_one(ratio)) {
ratio = 1;
}
t[0] = ratio;
++foundRoots;
}
ratio = C / Q;
if (approximately_zero_or_more(ratio) && approximately_one_or_less(ratio)) {
if (approximately_less_than_zero(ratio)) {
ratio = 0;
} else if (approximately_greater_than_one(ratio)) {
ratio = 1;
}
if (foundRoots == 0 || !approximately_negative(ratio - t[0])) {
t[foundRoots++] = ratio;
} else if (!approximately_negative(t[0] - ratio)) {
t[foundRoots++] = t[0];
t[0] = ratio;
}
}
#else
double s[2];
int realRoots = quadraticRootsReal(A, B, C, s);
int foundRoots = add_valid_ts(s, realRoots, t);
#endif
return foundRoots;
}
bool lineIntersects(double lineT, const int x, int& roots) {
if (!approximately_zero_or_more(lineT) || !approximately_one_or_less(lineT)) {
if (x < --roots) {
intersections.fT[0][x] = intersections.fT[0][roots];
}
return false;
}
if (approximately_less_than_zero(lineT)) {
lineT = 0;
} else if (approximately_greater_than_one(lineT)) {
lineT = 1;
}
intersections.fT[1][x] = lineT;
return true;
}
static void addValidRoots(const double roots[4], const int count, const int side, Intersections& i) {
int index;
for (index = 0; index < count; ++index) {
if (!approximately_zero_or_more(roots[index]) || !approximately_one_or_less(roots[index])) {
continue;
}
double t = 1 - roots[index];
if (approximately_less_than_zero(t)) {
t = 0;
} else if (approximately_greater_than_one(t)) {
t = 1;
}
i.insertOne(t, side);
}
}
static int addValidRoots(const double roots[4], const int count, double valid[4]) {
int result = 0;
int index;
for (index = 0; index < count; ++index) {
if (!approximately_zero_or_more(roots[index]) || !approximately_one_or_less(roots[index])) {
continue;
}
double t = 1 - roots[index];
if (approximately_less_than_zero(t)) {
t = 0;
} else if (approximately_greater_than_one(t)) {
t = 1;
}
valid[result++] = t;
}
return result;
}
/*
Numeric Solutions (5.6) suggests to solve the quadratic by computing
Q = -1/2(B + sgn(B)Sqrt(B^2 - 4 A C))
and using the roots
t1 = Q / A
t2 = C / Q
*/
int add_valid_ts(double s[], int realRoots, double* t) {
int foundRoots = 0;
for (int index = 0; index < realRoots; ++index) {
double tValue = s[index];
if (approximately_zero_or_more(tValue) && approximately_one_or_less(tValue)) {
if (approximately_less_than_zero(tValue)) {
tValue = 0;
} else if (approximately_greater_than_one(tValue)) {
tValue = 1;
}
for (int idx2 = 0; idx2 < foundRoots; ++idx2) {
if (approximately_equal(t[idx2], tValue)) {
goto nextRoot;
}
}
t[foundRoots++] = tValue;
}
nextRoot:
;
}
return foundRoots;
}
static void hackToFixPartialCoincidence(const Quadratic& q1, const Quadratic& q2, Intersections& i) {
// look to see if non-coincident data basically has unsortable tangents
// look to see if a point between non-coincident data is on the curve
int cIndex;
for (int uIndex = 0; uIndex < i.fUsed; ) {
double bestDist1 = 1;
double bestDist2 = 1;
int closest1 = -1;
int closest2 = -1;
for (cIndex = 0; cIndex < i.fCoincidentUsed; ++cIndex) {
double dist = fabs(i.fT[0][uIndex] - i.fCoincidentT[0][cIndex]);
if (bestDist1 > dist) {
bestDist1 = dist;
closest1 = cIndex;
}
dist = fabs(i.fT[1][uIndex] - i.fCoincidentT[1][cIndex]);
if (bestDist2 > dist) {
bestDist2 = dist;
closest2 = cIndex;
}
}
_Line ends;
_Point mid;
double t1 = i.fT[0][uIndex];
xy_at_t(q1, t1, ends[0].x, ends[0].y);
xy_at_t(q1, i.fCoincidentT[0][closest1], ends[1].x, ends[1].y);
double midT = (t1 + i.fCoincidentT[0][closest1]) / 2;
xy_at_t(q1, midT, mid.x, mid.y);
LineParameters params;
params.lineEndPoints(ends);
double midDist = params.pointDistance(mid);
// Note that we prefer to always measure t error, which does not scale,
// instead of point error, which is scale dependent. FIXME
if (!approximately_zero(midDist)) {
++uIndex;
continue;
}
double t2 = i.fT[1][uIndex];
xy_at_t(q2, t2, ends[0].x, ends[0].y);
xy_at_t(q2, i.fCoincidentT[1][closest2], ends[1].x, ends[1].y);
midT = (t2 + i.fCoincidentT[1][closest2]) / 2;
xy_at_t(q2, midT, mid.x, mid.y);
params.lineEndPoints(ends);
midDist = params.pointDistance(mid);
if (!approximately_zero(midDist)) {
++uIndex;
continue;
}
// if both midpoints are close to the line, lengthen coincident span
int cEnd = closest1 ^ 1; // assume coincidence always travels in pairs
if (!between(i.fCoincidentT[0][cEnd], t1, i.fCoincidentT[0][closest1])) {
i.fCoincidentT[0][closest1] = t1;
}
cEnd = closest2 ^ 1;
if (!between(i.fCoincidentT[0][cEnd], t2, i.fCoincidentT[0][closest2])) {
i.fCoincidentT[0][closest2] = t2;
}
int remaining = --i.fUsed - uIndex;
if (remaining > 0) {
memmove(&i.fT[0][uIndex], &i.fT[0][uIndex + 1], sizeof(i.fT[0][0]) * remaining);
memmove(&i.fT[1][uIndex], &i.fT[1][uIndex + 1], sizeof(i.fT[1][0]) * remaining);
}
}
// if coincident data is subjectively a tiny span, replace it with a single point
for (cIndex = 0; cIndex < i.fCoincidentUsed; ) {
double start1 = i.fCoincidentT[0][cIndex];
double end1 = i.fCoincidentT[0][cIndex + 1];
_Line ends1;
xy_at_t(q1, start1, ends1[0].x, ends1[0].y);
xy_at_t(q1, end1, ends1[1].x, ends1[1].y);
if (!AlmostEqualUlps(ends1[0].x, ends1[1].x) || AlmostEqualUlps(ends1[0].y, ends1[1].y)) {
cIndex += 2;
continue;
}
double start2 = i.fCoincidentT[1][cIndex];
double end2 = i.fCoincidentT[1][cIndex + 1];
_Line ends2;
xy_at_t(q2, start2, ends2[0].x, ends2[0].y);
xy_at_t(q2, end2, ends2[1].x, ends2[1].y);
// again, approximately should be used with T values, not points FIXME
if (!AlmostEqualUlps(ends2[0].x, ends2[1].x) || AlmostEqualUlps(ends2[0].y, ends2[1].y)) {
cIndex += 2;
continue;
}
if (approximately_less_than_zero(start1) || approximately_less_than_zero(end1)) {
start1 = 0;
} else if (approximately_greater_than_one(start1) || approximately_greater_than_one(end1)) {
start1 = 1;
} else {
start1 = (start1 + end1) / 2;
}
if (approximately_less_than_zero(start2) || approximately_less_than_zero(end2)) {
start2 = 0;
} else if (approximately_greater_than_one(start2) || approximately_greater_than_one(end2)) {
start2 = 1;
} else {
start2 = (start2 + end2) / 2;
}
i.insert(start1, start2);
i.fCoincidentUsed -= 2;
int remaining = i.fCoincidentUsed - cIndex;
if (remaining > 0) {
memmove(&i.fCoincidentT[0][cIndex], &i.fCoincidentT[0][cIndex + 2], sizeof(i.fCoincidentT[0][0]) * remaining);
memmove(&i.fCoincidentT[1][cIndex], &i.fCoincidentT[1][cIndex + 2], sizeof(i.fCoincidentT[1][0]) * remaining);
}
}
}
// flavor that returns T values only, deferring computing the quads until they are needed
// FIXME: when called from recursive intersect 2, this could take the original cubic
// and do a more precise job when calling chop at and sub divide by computing the fractional ts.
// it would still take the prechopped cubic for reduce order and find cubic inflections
void SkDCubic::toQuadraticTs(double precision, SkTDArray<double>* ts) const {
SkReduceOrder reducer;
int order = reducer.reduce(*this, SkReduceOrder::kAllow_Quadratics, SkReduceOrder::kFill_Style);
if (order < 3) {
return;
}
double inflectT[5];
int inflections = findInflections(inflectT);
SkASSERT(inflections <= 2);
if (!endsAreExtremaInXOrY()) {
inflections += findMaxCurvature(&inflectT[inflections]);
SkASSERT(inflections <= 5);
}
QSort<double>(inflectT, &inflectT[inflections - 1]);
// OPTIMIZATION: is this filtering common enough that it needs to be pulled out into its
// own subroutine?
while (inflections && approximately_less_than_zero(inflectT[0])) {
memmove(inflectT, &inflectT[1], sizeof(inflectT[0]) * --inflections);
}
int start = 0;
do {
int next = start + 1;
if (next >= inflections) {
break;
}
if (!approximately_equal(inflectT[start], inflectT[next])) {
++start;
continue;
}
memmove(&inflectT[start], &inflectT[next], sizeof(inflectT[0]) * (--inflections - start));
} while (true);
while (inflections && approximately_greater_than_one(inflectT[inflections - 1])) {
--inflections;
}
SkDCubicPair pair;
if (inflections == 1) {
pair = chopAt(inflectT[0]);
int orderP1 = reducer.reduce(pair.first(), SkReduceOrder::kNo_Quadratics,
SkReduceOrder::kFill_Style);
if (orderP1 < 2) {
--inflections;
} else {
int orderP2 = reducer.reduce(pair.second(), SkReduceOrder::kNo_Quadratics,
SkReduceOrder::kFill_Style);
if (orderP2 < 2) {
--inflections;
}
}
}
if (inflections == 0 && add_simple_ts(*this, precision, ts)) {
return;
}
if (inflections == 1) {
pair = chopAt(inflectT[0]);
addTs(pair.first(), precision, 0, inflectT[0], ts);
addTs(pair.second(), precision, inflectT[0], 1, ts);
return;
}
if (inflections > 1) {
SkDCubic part = subDivide(0, inflectT[0]);
addTs(part, precision, 0, inflectT[0], ts);
int last = inflections - 1;
for (int idx = 0; idx < last; ++idx) {
part = subDivide(inflectT[idx], inflectT[idx + 1]);
addTs(part, precision, inflectT[idx], inflectT[idx + 1], ts);
}
part = subDivide(inflectT[last], 1);
addTs(part, precision, inflectT[last], 1, ts);
return;
}
addTs(*this, precision, 0, 1, ts);
}
// intersect the end of the cubic with the other. Try lines from the end to control and opposite
// end to determine range of t on opposite cubic.
static bool intersectEnd(const Cubic& cubic1, bool start, const Cubic& cubic2, const _Rect& bounds2,
Intersections& i) {
// bool selfIntersect = cubic1 == cubic2;
_Line line;
int t1Index = start ? 0 : 3;
line[0] = cubic1[t1Index];
// don't bother if the two cubics are connnected
#if 0
if (!selfIntersect && (line[0].approximatelyEqual(cubic2[0])
|| line[0].approximatelyEqual(cubic2[3]))) {
return false;
}
#endif
bool result = false;
SkTDArray<double> tVals; // OPTIMIZE: replace with hard-sized array
for (int index = 0; index < 4; ++index) {
if (index == t1Index) {
continue;
}
_Vector dxy1 = cubic1[index] - line[0];
dxy1 /= gPrecisionUnit;
line[1] = line[0] + dxy1;
_Rect lineBounds;
lineBounds.setBounds(line);
if (!bounds2.intersects(lineBounds)) {
continue;
}
Intersections local;
if (!intersect(cubic2, line, local)) {
continue;
}
for (int idx2 = 0; idx2 < local.used(); ++idx2) {
double foundT = local.fT[0][idx2];
if (approximately_less_than_zero(foundT)
|| approximately_greater_than_one(foundT)) {
continue;
}
if (local.fPt[idx2].approximatelyEqual(line[0])) {
if (i.swapped()) { // FIXME: insert should respect swap
i.insert(foundT, start ? 0 : 1, line[0]);
} else {
i.insert(start ? 0 : 1, foundT, line[0]);
}
result = true;
} else {
*tVals.append() = local.fT[0][idx2];
}
}
}
if (tVals.count() == 0) {
return result;
}
QSort<double>(tVals.begin(), tVals.end() - 1);
double tMin1 = start ? 0 : 1 - LINE_FRACTION;
double tMax1 = start ? LINE_FRACTION : 1;
int tIdx = 0;
do {
int tLast = tIdx;
while (tLast + 1 < tVals.count() && roughly_equal(tVals[tLast + 1], tVals[tIdx])) {
++tLast;
}
double tMin2 = SkTMax(tVals[tIdx] - LINE_FRACTION, 0.0);
double tMax2 = SkTMin(tVals[tLast] + LINE_FRACTION, 1.0);
int lastUsed = i.used();
result |= intersect3(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, i);
if (lastUsed == i.used()) {
tMin2 = SkTMax(tVals[tIdx] - (1.0 / gPrecisionUnit), 0.0);
tMax2 = SkTMin(tVals[tLast] + (1.0 / gPrecisionUnit), 1.0);
result |= intersect3(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, i);
}
tIdx = tLast + 1;
} while (tIdx < tVals.count());
return result;
}
void SkIntersections::cubicNearEnd(const SkDCubic& cubic1, bool start, const SkDCubic& cubic2,
const SkDRect& bounds2) {
SkDLine line;
int t1Index = start ? 0 : 3;
double testT = (double) !start;
// don't bother if the two cubics are connnected
static const int kPointsInCubic = 4; // FIXME: move to DCubic, replace '4' with this
static const int kMaxLineCubicIntersections = 3;
SkSTArray<(kMaxLineCubicIntersections - 1) * kMaxLineCubicIntersections, double, true> tVals;
line[0] = cubic1[t1Index];
// this variant looks for intersections with the end point and lines parallel to other points
for (int index = 0; index < kPointsInCubic; ++index) {
if (index == t1Index) {
continue;
}
SkDVector dxy1 = cubic1[index] - line[0];
dxy1 /= SkDCubic::gPrecisionUnit;
line[1] = line[0] + dxy1;
SkDRect lineBounds;
lineBounds.setBounds(line);
if (!bounds2.intersects(&lineBounds)) {
continue;
}
SkIntersections local;
if (!local.intersect(cubic2, line)) {
continue;
}
for (int idx2 = 0; idx2 < local.used(); ++idx2) {
double foundT = local[0][idx2];
if (approximately_less_than_zero(foundT)
|| approximately_greater_than_one(foundT)) {
continue;
}
if (local.pt(idx2).approximatelyEqual(line[0])) {
if (swapped()) { // FIXME: insert should respect swap
insert(foundT, testT, line[0]);
} else {
insert(testT, foundT, line[0]);
}
} else {
tVals.push_back(foundT);
}
}
}
if (tVals.count() == 0) {
return;
}
SkTQSort<double>(tVals.begin(), tVals.end() - 1);
double tMin1 = start ? 0 : 1 - LINE_FRACTION;
double tMax1 = start ? LINE_FRACTION : 1;
int tIdx = 0;
do {
int tLast = tIdx;
while (tLast + 1 < tVals.count() && roughly_equal(tVals[tLast + 1], tVals[tIdx])) {
++tLast;
}
double tMin2 = SkTMax(tVals[tIdx] - LINE_FRACTION, 0.0);
double tMax2 = SkTMin(tVals[tLast] + LINE_FRACTION, 1.0);
int lastUsed = used();
if (start ? tMax1 < tMin2 : tMax2 < tMin1) {
::intersect(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, *this);
}
if (lastUsed == used()) {
tMin2 = SkTMax(tVals[tIdx] - (1.0 / SkDCubic::gPrecisionUnit), 0.0);
tMax2 = SkTMin(tVals[tLast] + (1.0 / SkDCubic::gPrecisionUnit), 1.0);
if (start ? tMax1 < tMin2 : tMax2 < tMin1) {
::intersect(cubic1, tMin1, tMax1, cubic2, tMin2, tMax2, 1, *this);
}
}
tIdx = tLast + 1;
} while (tIdx < tVals.count());
return;
}
