/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkIntersections.h"
#include "SkOpAngle.h"
#include "SkOpSegment.h"
#include "SkPathOpsCurve.h"
#include "SkTSort.h"
#if DEBUG_ANGLE
#include "SkString.h"
static const char funcName[] = "SkOpSegment::operator<";
static const int bugChar = strlen(funcName) + 1;
#endif
/* Angles are sorted counterclockwise. The smallest angle has a positive x and the smallest
positive y. The largest angle has a positive x and a zero y. */
#if DEBUG_ANGLE
static bool CompareResult(SkString* bugOut, const char* append, bool compare) {
bugOut->appendf("%s", append);
bugOut->writable_str()[bugChar] = "><"[compare];
SkDebugf("%s\n", bugOut->c_str());
return compare;
}
#define COMPARE_RESULT(append, compare) CompareResult(&bugOut, append, compare)
#else
#define COMPARE_RESULT(append, compare) compare
#endif
bool SkOpAngle::calcSlop(double x, double y, double rx, double ry, bool* result) const{
double absX = fabs(x);
double absY = fabs(y);
double length = absX < absY ? absX / 2 + absY : absX + absY / 2;
int exponent;
(void) frexp(length, &exponent);
double epsilon = ldexp(FLT_EPSILON, exponent);
SkPath::Verb verb = fSegment->verb();
SkASSERT(verb == SkPath::kQuad_Verb || verb == SkPath::kCubic_Verb);
// FIXME: the quad and cubic factors are made up ; determine actual values
double slop = verb == SkPath::kQuad_Verb ? 4 * epsilon : 512 * epsilon;
double xSlop = slop;
double ySlop = x * y < 0 ? -xSlop : xSlop; // OPTIMIZATION: use copysign / _copysign ?
double x1 = x - xSlop;
double y1 = y + ySlop;
double x_ry1 = x1 * ry;
double rx_y1 = rx * y1;
*result = x_ry1 < rx_y1;
double x2 = x + xSlop;
double y2 = y - ySlop;
double x_ry2 = x2 * ry;
double rx_y2 = rx * y2;
bool less2 = x_ry2 < rx_y2;
return *result == less2;
}
/*
for quads and cubics, set up a parameterized line (e.g. LineParameters )
for points [0] to [1]. See if point [2] is on that line, or on one side
or the other. If it both quads' end points are on the same side, choose
the shorter tangent. If the tangents are equal, choose the better second
tangent angle
FIXME: maybe I could set up LineParameters lazily
*/
bool SkOpAngle::operator<(const SkOpAngle& rh) const { // this/lh: left-hand; rh: right-hand
double y = dy();
double ry = rh.dy();
#if DEBUG_ANGLE
SkString bugOut;
bugOut.printf("%s _ id=%d segId=%d tStart=%1.9g tEnd=%1.9g"
" | id=%d segId=%d tStart=%1.9g tEnd=%1.9g ", funcName,
fID, fSegment->debugID(), fSegment->t(fStart), fSegment->t(fEnd),
rh.fID, rh.fSegment->debugID(), rh.fSegment->t(rh.fStart), rh.fSegment->t(rh.fEnd));
#endif
double y_ry = y * ry;
if (y_ry < 0) { // if y's are opposite signs, we can do a quick return
return COMPARE_RESULT("1 y * ry < 0", y < 0);
}
// at this point, both y's must be the same sign, or one (or both) is zero
double x = dx();
double rx = rh.dx();
if (x * rx < 0) { // if x's are opposite signs, use y to determine first or second half
if (y < 0 && ry < 0) { // if y's are negative, lh x is smaller if positive
return COMPARE_RESULT("2 x_rx < 0 && y < 0 ...", x > 0);
}
if (y >= 0 && ry >= 0) { // if y's are zero or positive, lh x is smaller if negative
return COMPARE_RESULT("3 x_rx < 0 && y >= 0 ...", x < 0);
}
SkASSERT((y == 0) ^ (ry == 0)); // if one y is zero and one is negative, neg y is smaller
return COMPARE_RESULT("4 x_rx < 0 && y == 0 ...", y < 0);
}
// at this point, both x's must be the same sign, or one (or both) is zero
if (y_ry == 0) { // if either y is zero
if (y + ry < 0) { // if the other y is less than zero, it must be smaller
return COMPARE_RESULT("5 y_ry == 0 && y + ry < 0", y < 0);
}
if (y + ry > 0) { // if a y is greater than zero and an x is positive, non zero is smaller
return COMPARE_RESULT("6 y_ry == 0 && y + ry > 0", (x + rx > 0) ^ (y == 0));
}
// at this point, both y's are zero, so lines are coincident or one is degenerate
SkASSERT(x * rx != 0); // and a degenerate line should haven't gotten this far
}
// see if either curve can be lengthened before trying the tangent
if (fSegment->other(fEnd) != rh.fSegment // tangents not absolutely identical
&& rh.fSegment->other(rh.fEnd) != fSegment
&& y != -DBL_EPSILON
&& ry != -DBL_EPSILON) { // and not intersecting
SkOpAngle longer = *this;
SkOpAngle rhLonger = rh;
if ((longer.lengthen(rh) | rhLonger.lengthen(*this)) // lengthen both
&& (fUnorderable || !longer.fUnorderable)
&& (rh.fUnorderable || !rhLonger.fUnorderable)) {
#if DEBUG_ANGLE
bugOut.prepend(" ");
#endif
return COMPARE_RESULT("10 longer.lengthen(rh) ...", longer < rhLonger);
}
}
SkPath::Verb verb = fSegment->verb();
SkPath::Verb rVerb = rh.fSegment->verb();
if (y_ry != 0) { // if they aren't coincident, look for a stable cross product
// at this point, y's are the same sign, neither is zero
// and x's are the same sign, or one (or both) is zero
double x_ry = x * ry;
double rx_y = rx * y;
if (!fComputed && !rh.fComputed) {
if (!SkDLine::NearRay(x, y, rx, ry) && x_ry != rx_y) {
return COMPARE_RESULT("7 !fComputed && !rh.fComputed", x_ry < rx_y);
}
if (fSide2 == 0 && rh.fSide2 == 0) {
return COMPARE_RESULT("7a !fComputed && !rh.fComputed", x_ry < rx_y);
}
} else {
// if the vector was a result of subdividing a curve, see if it is stable
bool sloppy1 = x_ry < rx_y;
bool sloppy2 = !sloppy1;
if ((!fComputed || calcSlop(x, y, rx, ry, &sloppy1))
&& (!rh.fComputed || rh.calcSlop(rx, ry, x, y, &sloppy2))
&& sloppy1 != sloppy2) {
return COMPARE_RESULT("8 CalcSlop(x, y ...", sloppy1);
}
}
}
if (fSide2 * rh.fSide2 == 0) { // one is zero
#if DEBUG_ANGLE
if (fSide2 == rh.fSide2 && y_ry) { // both is zero; coincidence was undetected
SkDebugf("%s coincidence!\n", __FUNCTION__);
}
#endif
return COMPARE_RESULT("9a fSide2 * rh.fSide2 == 0 ...", fSide2 < rh.fSide2);
}
// at this point, the initial tangent line is nearly coincident
// see if edges curl away from each other
if (fSide * rh.fSide < 0 && (!approximately_zero(fSide) || !approximately_zero(rh.fSide))) {
return COMPARE_RESULT("9b fSide * rh.fSide < 0 ...", fSide < rh.fSide);
}
if (fUnsortable || rh.fUnsortable) {
// even with no solution, return a stable sort
return COMPARE_RESULT("11 fUnsortable || rh.fUnsortable", this < &rh);
}
if ((verb == SkPath::kLine_Verb && approximately_zero(y) && approximately_zero(x))
|| (rVerb == SkPath::kLine_Verb
&& approximately_zero(ry) && approximately_zero(rx))) {
// See general unsortable comment below. This case can happen when
// one line has a non-zero change in t but no change in x and y.
fUnsortable = true;
return COMPARE_RESULT("12 verb == SkPath::kLine_Verb ...", this < &rh);
}
if (fSegment->isTiny(this) || rh.fSegment->isTiny(&rh)) {
fUnsortable = true;
return COMPARE_RESULT("13 verb == fSegment->isTiny(this) ...", this < &rh);
}
SkASSERT(verb >= SkPath::kQuad_Verb);
SkASSERT(rVerb >= SkPath::kQuad_Verb);
// FIXME: until I can think of something better, project a ray from the
// end of the shorter tangent to midway between the end points
// through both curves and use the resulting angle to sort
// FIXME: some of this setup can be moved to set() if it works, or cached if it's expensive
double len = fTangentPart.normalSquared();
double rlen = rh.fTangentPart.normalSquared();
SkDLine ray;
SkIntersections i, ri;
int roots, rroots;
bool flip = false;
bool useThis;
bool leftLessThanRight = fSide > 0;
do {
useThis = (len < rlen) ^ flip;
const SkDCubic& part = useThis ? fCurvePart : rh.fCurvePart;
SkPath::Verb partVerb = useThis ? verb : rVerb;
ray[0] = partVerb == SkPath::kCubic_Verb && part[0].approximatelyEqual(part[1]) ?
part[2] : part[1];
ray[1] = SkDPoint::Mid(part[0], part[SkPathOpsVerbToPoints(partVerb)]);
SkASSERT(ray[0] != ray[1]);
roots = (i.*CurveRay[SkPathOpsVerbToPoints(verb)])(fSegment->pts(), ray);
rroots = (ri.*CurveRay[SkPathOpsVerbToPoints(rVerb)])(rh.fSegment->pts(), ray);
} while ((roots == 0 || rroots == 0) && (flip ^= true));
if (roots == 0 || rroots == 0) {
// FIXME: we don't have a solution in this case. The interim solution
// is to mark the edges as unsortable, exclude them from this and
// future computations, and allow the returned path to be fragmented
fUnsortable = true;
return COMPARE_RESULT("roots == 0 || rroots == 0", this < &rh);
}
SkASSERT(fSide != 0 && rh.fSide != 0);
if (fSide * rh.fSide < 0) {
fUnsortable = true;
return COMPARE_RESULT("14 fSide * rh.fSide < 0", this < &rh);
}
SkDPoint lLoc;
double best = SK_ScalarInfinity;
#if DEBUG_SORT
SkDebugf("lh=%d rh=%d use-lh=%d ray={{%1.9g,%1.9g}, {%1.9g,%1.9g}} %c\n",
fSegment->debugID(), rh.fSegment->debugID(), useThis, ray[0].fX, ray[0].fY,
ray[1].fX, ray[1].fY, "-+"[fSide > 0]);
#endif
for (int index = 0; index < roots; ++index) {
SkDPoint loc = i.pt(index);
SkDVector dxy = loc - ray[0];
double dist = dxy.lengthSquared();
#if DEBUG_SORT
SkDebugf("best=%1.9g dist=%1.9g loc={%1.9g,%1.9g} dxy={%1.9g,%1.9g}\n",
best, dist, loc.fX, loc.fY, dxy.fX, dxy.fY);
#endif
if (best > dist) {
lLoc = loc;
best = dist;
}
}
flip = false;
SkDPoint rLoc;
for (int index = 0; index < rroots; ++index) {
rLoc = ri.pt(index);
SkDVector dxy = rLoc - ray[0];
double dist = dxy.lengthSquared();
#if DEBUG_SORT
SkDebugf("best=%1.9g dist=%1.9g %c=(fSide < 0) rLoc={%1.9g,%1.9g} dxy={%1.9g,%1.9g}\n",
best, dist, "><"[fSide < 0], rLoc.fX, rLoc.fY, dxy.fX, dxy.fY);
#endif
if (best > dist) {
flip = true;
break;
}
}
if (flip) {
leftLessThanRight = !leftLessThanRight;
}
return COMPARE_RESULT("15 leftLessThanRight", leftLessThanRight);
}
bool SkOpAngle::isHorizontal() const {
return dy() == 0 && fSegment->verb() == SkPath::kLine_Verb;
}
// lengthen cannot cross opposite angle
bool SkOpAngle::lengthen(const SkOpAngle& opp) {
if (fSegment->other(fEnd) == opp.fSegment) {
return false;
}
// FIXME: make this a while loop instead and make it as large as possible?
int newEnd = fEnd;
if (fStart < fEnd ? ++newEnd < fSegment->count() : --newEnd >= 0) {
fEnd = newEnd;
setSpans();
return true;
}
return false;
}
void SkOpAngle::set(const SkOpSegment* segment, int start, int end) {
fSegment = segment;
fStart = start;
fEnd = end;
setSpans();
}
void SkOpAngle::setSpans() {
fUnorderable = fSegment->isTiny(this);
fLastMarked = NULL;
fUnsortable = false;
const SkPoint* pts = fSegment->pts();
if (fSegment->verb() != SkPath::kLine_Verb) {
fComputed = fSegment->subDivide(fStart, fEnd, &fCurvePart);
fSegment->subDivide(fStart, fStart < fEnd ? fSegment->count() - 1 : 0, &fCurveHalf);
}
// FIXME: slight errors in subdivision cause sort trouble later on. As an experiment, try
// rounding the curve part to float precision here
// fCurvePart.round(fSegment->verb());
switch (fSegment->verb()) {
case SkPath::kLine_Verb: {
SkASSERT(fStart != fEnd);
fCurvePart[0].set(pts[fStart > fEnd]);
fCurvePart[1].set(pts[fStart < fEnd]);
fComputed = false;
// OPTIMIZATION: for pure line compares, we never need fTangentPart.c
fTangentPart.lineEndPoints(*SkTCast<SkDLine*>(&fCurvePart));
fSide = 0;
fSide2 = 0;
} break;
case SkPath::kQuad_Verb: {
fSide2 = -fTangentHalf.quadPart(*SkTCast<SkDQuad*>(&fCurveHalf));
SkDQuad& quad = *SkTCast<SkDQuad*>(&fCurvePart);
fTangentPart.quadEndPoints(quad);
fSide = -fTangentPart.pointDistance(fCurvePart[2]); // not normalized -- compare sign only
if (fComputed && dx() > 0 && approximately_zero(dy())) {
SkDCubic origCurve; // can't use segment's curve in place since it may be flipped
int last = fSegment->count() - 1;
fSegment->subDivide(fStart < fEnd ? 0 : last, fStart < fEnd ? last : 0, &origCurve);
SkLineParameters origTan;
origTan.quadEndPoints(*SkTCast<SkDQuad*>(&origCurve));
if (origTan.dx() <= 0
|| (dy() != origTan.dy() && dy() * origTan.dy() <= 0)) { // signs match?
fUnorderable = true;
return;
}
}
} break;
case SkPath::kCubic_Verb: {
double startT = fSegment->t(fStart);
fSide2 = -fTangentHalf.cubicPart(fCurveHalf);
fTangentPart.cubicEndPoints(fCurvePart);
double testTs[4];
// OPTIMIZATION: keep inflections precomputed with cubic segment?
int testCount = SkDCubic::FindInflections(pts, testTs);
double endT = fSegment->t(fEnd);
double limitT = endT;
int index;
for (index = 0; index < testCount; ++index) {
if (!between(startT, testTs[index], limitT)) {
testTs[index] = -1;
}
}
testTs[testCount++] = startT;
testTs[testCount++] = endT;
SkTQSort<double>(testTs, &testTs[testCount - 1]);
double bestSide = 0;
int testCases = (testCount << 1) - 1;
index = 0;
while (testTs[index] < 0) {
++index;
}
index <<= 1;
for (; index < testCases; ++index) {
int testIndex = index >> 1;
double testT = testTs[testIndex];
if (index & 1) {
testT = (testT + testTs[testIndex + 1]) / 2;
}
// OPTIMIZE: could avoid call for t == startT, endT
SkDPoint pt = dcubic_xy_at_t(pts, testT);
double testSide = fTangentPart.pointDistance(pt);
if (fabs(bestSide) < fabs(testSide)) {
bestSide = testSide;
}
}
fSide = -bestSide; // compare sign only
SkASSERT(fSide == 0 || fSide2 != 0);
if (fComputed && dx() > 0 && approximately_zero(dy())) {
SkDCubic origCurve; // can't use segment's curve in place since it may be flipped
int last = fSegment->count() - 1;
fSegment->subDivide(fStart < fEnd ? 0 : last, fStart < fEnd ? last : 0, &origCurve);
SkDCubicPair split = origCurve.chopAt(startT);
SkLineParameters splitTan;
splitTan.cubicEndPoints(fStart < fEnd ? split.second() : split.first());
if (splitTan.dx() <= 0) {
fUnorderable = true;
fUnsortable = fSegment->isTiny(this);
return;
}
// if one is < 0 and the other is >= 0
if (dy() * splitTan.dy() < 0) {
fUnorderable = true;
fUnsortable = fSegment->isTiny(this);
return;
}
}
} break;
default:
SkASSERT(0);
}
if ((fUnsortable = approximately_zero(dx()) && approximately_zero(dy()))) {
return;
}
if (fSegment->verb() == SkPath::kLine_Verb) {
return;
}
SkASSERT(fStart != fEnd);
int smaller = SkMin32(fStart, fEnd);
int larger = SkMax32(fStart, fEnd);
while (smaller < larger && fSegment->span(smaller).fTiny) {
++smaller;
}
if (precisely_equal(fSegment->span(smaller).fT, fSegment->span(larger).fT)) {
#if DEBUG_UNSORTABLE
SkPoint iPt = fSegment->xyAtT(fStart);
SkPoint ePt = fSegment->xyAtT(fEnd);
SkDebugf("%s all tiny unsortable [%d] (%1.9g,%1.9g) [%d] (%1.9g,%1.9g)\n", __FUNCTION__,
fStart, iPt.fX, iPt.fY, fEnd, ePt.fX, ePt.fY);
#endif
fUnsortable = true;
return;
}
fUnsortable = fStart < fEnd ? fSegment->span(smaller).fUnsortableStart
: fSegment->span(larger).fUnsortableEnd;
#if DEBUG_UNSORTABLE
if (fUnsortable) {
SkPoint iPt = fSegment->xyAtT(smaller);
SkPoint ePt = fSegment->xyAtT(larger);
SkDebugf("%s unsortable [%d] (%1.9g,%1.9g) [%d] (%1.9g,%1.9g)\n", __FUNCTION__,
smaller, iPt.fX, iPt.fY, fEnd, ePt.fX, ePt.fY);
}
#endif
return;
}
#ifdef SK_DEBUG
void SkOpAngle::dump() const {
const SkOpSpan& spanStart = fSegment->span(fStart);
const SkOpSpan& spanEnd = fSegment->span(fEnd);
const SkOpSpan& spanMin = fStart < fEnd ? spanStart : spanEnd;
SkDebugf("id=%d (%1.9g,%1.9g) start=%d (%1.9g) end=%d (%1.9g) sumWind=",
fSegment->debugID(), fSegment->xAtT(fStart), fSegment->yAtT(fStart),
fStart, spanStart.fT, fEnd, spanEnd.fT);
SkPathOpsDebug::WindingPrintf(spanMin.fWindSum);
SkDebugf(" oppWind=");
SkPathOpsDebug::WindingPrintf(spanMin.fOppSum),
SkDebugf(" done=%d\n", spanMin.fDone);
}
#endif