int SkIntersections::insert(double one, double two, const SkDPoint& pt) {
if (fIsCoincident[0] == 3 && between(fT[0][0], one, fT[0][1])) {
// For now, don't allow a mix of coincident and non-coincident intersections
return -1;
}
SkASSERT(fUsed <= 1 || fT[0][0] <= fT[0][1]);
int index;
for (index = 0; index < fUsed; ++index) {
double oldOne = fT[0][index];
double oldTwo = fT[1][index];
if (one == oldOne && two == oldTwo) {
return -1;
}
if (more_roughly_equal(oldOne, one) && more_roughly_equal(oldTwo, two)) {
if ((precisely_zero(one) && !precisely_zero(oldOne))
|| (precisely_equal(one, 1) && !precisely_equal(oldOne, 1))
|| (precisely_zero(two) && !precisely_zero(oldTwo))
|| (precisely_equal(two, 1) && !precisely_equal(oldTwo, 1))) {
SkASSERT(one >= 0 && one <= 1);
SkASSERT(two >= 0 && two <= 1);
fT[0][index] = one;
fT[1][index] = two;
fPt[index] = pt;
}
return -1;
}
#if ONE_OFF_DEBUG
if (pt.roughlyEqual(fPt[index])) {
SkDebugf("%s t=%1.9g pts roughly equal\n", __FUNCTION__, one);
}
#endif
if (fT[0][index] > one) {
break;
}
}
if (fUsed >= fMax) {
SkASSERT(0); // FIXME : this error, if it is to be handled at runtime in release, must
// be propagated all the way back down to the caller, and return failure.
fUsed = 0;
return 0;
}
int remaining = fUsed - index;
if (remaining > 0) {
memmove(&fPt[index + 1], &fPt[index], sizeof(fPt[0]) * remaining);
memmove(&fT[0][index + 1], &fT[0][index], sizeof(fT[0][0]) * remaining);
memmove(&fT[1][index + 1], &fT[1][index], sizeof(fT[1][0]) * remaining);
int clearMask = ~((1 << index) - 1);
fIsCoincident[0] += fIsCoincident[0] & clearMask;
fIsCoincident[1] += fIsCoincident[1] & clearMask;
}
fPt[index] = pt;
SkASSERT(one >= 0 && one <= 1);
SkASSERT(two >= 0 && two <= 1);
fT[0][index] = one;
fT[1][index] = two;
++fUsed;
return index;
}
static bool only_end_pts_in_common(const SkDQuad& q1, const SkDQuad& q2) {
// the idea here is to see at minimum do a quick reject by rotating all points
// to either side of the line formed by connecting the endpoints
// if the opposite curves points are on the line or on the other side, the
// curves at most intersect at the endpoints
for (int oddMan = 0; oddMan < 3; ++oddMan) {
const SkDPoint* endPt[2];
for (int opp = 1; opp < 3; ++opp) {
int end = oddMan ^ opp; // choose a value not equal to oddMan
if (3 == end) { // and correct so that largest value is 1 or 2
end = opp;
}
endPt[opp - 1] = &q1[end];
}
double origX = endPt[0]->fX;
double origY = endPt[0]->fY;
double adj = endPt[1]->fX - origX;
double opp = endPt[1]->fY - origY;
double sign = (q1[oddMan].fY - origY) * adj - (q1[oddMan].fX - origX) * opp;
if (approximately_zero(sign)) {
goto tryNextHalfPlane;
}
for (int n = 0; n < 3; ++n) {
double test = (q2[n].fY - origY) * adj - (q2[n].fX - origX) * opp;
if (test * sign > 0 && !precisely_zero(test)) {
goto tryNextHalfPlane;
}
}
return true;
tryNextHalfPlane:
;
}
return false;
}
/* if returning true, check contains true if quad's hull collapsed, making the cubic linear
if returning false, check contains true if the the quad pair have only the end point in common
*/
bool SkDQuad::hullIntersects(const SkDQuad& q2, bool* isLinear) const {
bool linear = true;
for (int oddMan = 0; oddMan < kPointCount; ++oddMan) {
const SkDPoint* endPt[2];
this->otherPts(oddMan, endPt);
double origX = endPt[0]->fX;
double origY = endPt[0]->fY;
double adj = endPt[1]->fX - origX;
double opp = endPt[1]->fY - origY;
double sign = (fPts[oddMan].fY - origY) * adj - (fPts[oddMan].fX - origX) * opp;
if (approximately_zero(sign)) {
continue;
}
linear = false;
bool foundOutlier = false;
for (int n = 0; n < kPointCount; ++n) {
double test = (q2[n].fY - origY) * adj - (q2[n].fX - origX) * opp;
if (test * sign > 0 && !precisely_zero(test)) {
foundOutlier = true;
break;
}
}
if (!foundOutlier) {
return false;
}
}
*isLinear = linear;
return true;
}
int SkOpContour::alignT(bool swap, int tIndex, SkIntersections* ts) const {
double tVal = (*ts)[swap][tIndex];
if (tVal != 0 && precisely_zero(tVal)) {
ts->set(swap, tIndex, 0);
return 0;
}
if (tVal != 1 && precisely_equal(tVal, 1)) {
ts->set(swap, tIndex, 1);
return 1;
}
return -1;
}
/* if returning true, check contains true if cubic's hull collapsed, making the cubic linear
if returning false, check contains true if the the cubic pair have only the end point in common
*/
bool SkDCubic::hullIntersects(const SkDPoint* pts, int ptCount, bool* isLinear) const {
bool linear = true;
char hullOrder[4];
int hullCount = convexHull(hullOrder);
int end1 = hullOrder[0];
int hullIndex = 0;
const SkDPoint* endPt[2];
endPt[0] = &fPts[end1];
do {
hullIndex = (hullIndex + 1) % hullCount;
int end2 = hullOrder[hullIndex];
endPt[1] = &fPts[end2];
double origX = endPt[0]->fX;
double origY = endPt[0]->fY;
double adj = endPt[1]->fX - origX;
double opp = endPt[1]->fY - origY;
int oddManMask = other_two(end1, end2);
int oddMan = end1 ^ oddManMask;
double sign = (fPts[oddMan].fY - origY) * adj - (fPts[oddMan].fX - origX) * opp;
int oddMan2 = end2 ^ oddManMask;
double sign2 = (fPts[oddMan2].fY - origY) * adj - (fPts[oddMan2].fX - origX) * opp;
if (sign * sign2 < 0) {
continue;
}
if (approximately_zero(sign)) {
sign = sign2;
if (approximately_zero(sign)) {
continue;
}
}
linear = false;
bool foundOutlier = false;
for (int n = 0; n < ptCount; ++n) {
double test = (pts[n].fY - origY) * adj - (pts[n].fX - origX) * opp;
if (test * sign > 0 && !precisely_zero(test)) {
foundOutlier = true;
break;
}
}
if (!foundOutlier) {
return false;
}
endPt[0] = endPt[1];
end1 = end2;
} while (hullIndex);
*isLinear = linear;
return true;
}
static bool only_end_pts_in_common(const SkDCubic& c1, const SkDCubic& c2) {
// the idea here is to see at minimum do a quick reject by rotating all points
// to either side of the line formed by connecting the endpoints
// if the opposite curves points are on the line or on the other side, the
// curves at most intersect at the endpoints
for (int oddMan = 0; oddMan < 4; ++oddMan) {
const SkDPoint* endPt[3];
for (int opp = 1; opp < 4; ++opp) {
int end = oddMan ^ opp; // choose a value not equal to oddMan
endPt[opp - 1] = &c1[end];
}
for (int triTest = 0; triTest < 3; ++triTest) {
double origX = endPt[triTest]->fX;
double origY = endPt[triTest]->fY;
int oppTest = triTest + 1;
if (3 == oppTest) {
oppTest = 0;
}
double adj = endPt[oppTest]->fX - origX;
double opp = endPt[oppTest]->fY - origY;
if (adj == 0 && opp == 0) { // if the other point equals the test point, ignore it
continue;
}
double sign = (c1[oddMan].fY - origY) * adj - (c1[oddMan].fX - origX) * opp;
if (approximately_zero(sign)) {
goto tryNextHalfPlane;
}
for (int n = 0; n < 4; ++n) {
double test = (c2[n].fY - origY) * adj - (c2[n].fX - origX) * opp;
if (test * sign > 0 && !precisely_zero(test)) {
goto tryNextHalfPlane;
}
}
}
return true;
tryNextHalfPlane:
;
}
return false;
}
