turn off debugging printfs

src/pathops/SkDQuadIntersection.cpp

 // Another approach is to start with the implicit form of one curve and solve
 // (seek implicit coefficients in QuadraticParameter.cpp
 // by substituting in the parametric form of the other.
 // The downside of this approach is that early rejects are difficult to come by.
 // http://planetmath.org/encyclopedia/GaloisTheoreticDerivationOfTheQuarticFormula.html#step
 
 
 #include "SkDQuadImplicit.h"
 #include "SkIntersections.h"
 #include "SkPathOpsLine.h"
@@ skipping 69 matching lines @@
 }
 
 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;
-            if (end == 3) {
+            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)) {
@@ skipping 11 matching lines @@
     }
     return false;
 }
 
 // returns false if there's more than one intercept or the intercept doesn't match the point
 // returns true if the intercept was successfully added or if the
 // original quads need to be subdivided
 static bool add_intercept(const SkDQuad& q1, const SkDQuad& q2, double tMin, double tMax,
                           SkIntersections* i, bool* subDivide) {
     double tMid = (tMin + tMax) / 2;
-    SkDPoint mid = q2.xyAtT(tMid);
+    SkDPoint mid = q2.ptAtT(tMid);
     SkDLine line;
     line[0] = line[1] = mid;
     SkDVector dxdy = q2.dxdyAtT(tMid);
     line[0] -= dxdy;
     line[1] += dxdy;
     SkIntersections rootTs;
     rootTs.allowNear(false);
     int roots = rootTs.intersect(q1, line);
     if (roots == 0) {
         if (subDivide) {
             *subDivide = true;
         }
         return true;
     }
     if (roots == 2) {
         return false;
     }
-    SkDPoint pt2 = q1.xyAtT(rootTs[0][0]);
+    SkDPoint pt2 = q1.ptAtT(rootTs[0][0]);
     if (!pt2.approximatelyEqualHalf(mid)) {
         return false;
     }
     i->insertSwap(rootTs[0][0], tMid, pt2);
     return true;
 }
 
 static bool is_linear_inner(const SkDQuad& q1, double t1s, double t1e, const SkDQuad& q2,
                             double t2s, double t2e, SkIntersections* i, bool* subDivide) {
     SkDQuad hull = q1.subDivide(t1s, t1e);
     SkDLine line = {{hull[2], hull[0]}};
     const SkDLine* testLines[] = { &line, (const SkDLine*) &hull[0], (const SkDLine*) &hull[1] };
     const size_t kTestCount = SK_ARRAY_COUNT(testLines);
     SkSTArray<kTestCount * 2, double, true> tsFound;
     for (size_t index = 0; index < kTestCount; ++index) {
         SkIntersections rootTs;
         rootTs.allowNear(false);
         int roots = rootTs.intersect(q2, *testLines[index]);
         for (int idx2 = 0; idx2 < roots; ++idx2) {
             double t = rootTs[0][idx2];
 #ifdef SK_DEBUG
-            SkDPoint qPt = q2.xyAtT(t);
-            SkDPoint lPt = testLines[index]->xyAtT(rootTs[1][idx2]);
+            SkDPoint qPt = q2.ptAtT(t);
+            SkDPoint lPt = testLines[index]->ptAtT(rootTs[1][idx2]);
             SkASSERT(qPt.approximatelyEqual(lPt));
 #endif
             if (approximately_negative(t - t2s) || approximately_positive(t - t2e)) {
                 continue;
             }
             tsFound.push_back(rootTs[0][idx2]);
         }
     }
     int tCount = tsFound.count();
     if (tCount <= 0) {
         return true;
     }
     double tMin, tMax;
     if (tCount == 1) {
         tMin = tMax = tsFound[0];
     } else {
         SkASSERT(tCount > 1);
         SkTQSort<double>(tsFound.begin(), tsFound.end() - 1);
         tMin = tsFound[0];
         tMax = tsFound[tsFound.count() - 1];
     }
-    SkDPoint end = q2.xyAtT(t2s);
+    SkDPoint end = q2.ptAtT(t2s);
     bool startInTriangle = hull.pointInHull(end);
     if (startInTriangle) {
         tMin = t2s;
     }
-    end = q2.xyAtT(t2e);
+    end = q2.ptAtT(t2e);
     bool endInTriangle = hull.pointInHull(end);
     if (endInTriangle) {
         tMax = t2e;
     }
     int split = 0;
     SkDVector dxy1, dxy2;
     if (tMin != tMax || tCount > 2) {
         dxy2 = q2.dxdyAtT(tMin);
         for (int index = 1; index < tCount; ++index) {
             dxy1 = dxy2;
@@ skipping 81 matching lines @@
 // each time through the loop, this computes values it had from the last loop
 // if i == j == 1, the center values are still good
 // otherwise, for i != 1 or j != 1, four of the values are still good
 // and if i == 1 ^ j == 1, an additional value is good
 static bool binary_search(const SkDQuad& quad1, const SkDQuad& quad2, double* t1Seed,
                           double* t2Seed, SkDPoint* pt) {
     double tStep = ROUGH_EPSILON;
     SkDPoint t1[3], t2[3];
     int calcMask = ~0;
     do {
-        if (calcMask & (1 << 1)) t1[1] = quad1.xyAtT(*t1Seed);
-        if (calcMask & (1 << 4)) t2[1] = quad2.xyAtT(*t2Seed);
+        if (calcMask & (1 << 1)) t1[1] = quad1.ptAtT(*t1Seed);
+        if (calcMask & (1 << 4)) t2[1] = quad2.ptAtT(*t2Seed);
         if (t1[1].approximatelyEqual(t2[1])) {
             *pt = t1[1];
     #if ONE_OFF_DEBUG
             SkDebugf("%s t1=%1.9g t2=%1.9g (%1.9g,%1.9g) == (%1.9g,%1.9g)\n", __FUNCTION__,
                     t1Seed, t2Seed, t1[1].fX, t1[1].fY, t1[2].fX, t1[2].fY);
     #endif
             return true;
         }
-        if (calcMask & (1 << 0)) t1[0] = quad1.xyAtT(*t1Seed - tStep);
-        if (calcMask & (1 << 2)) t1[2] = quad1.xyAtT(*t1Seed + tStep);
-        if (calcMask & (1 << 3)) t2[0] = quad2.xyAtT(*t2Seed - tStep);
-        if (calcMask & (1 << 5)) t2[2] = quad2.xyAtT(*t2Seed + tStep);
+        if (calcMask & (1 << 0)) t1[0] = quad1.ptAtT(*t1Seed - tStep);
+        if (calcMask & (1 << 2)) t1[2] = quad1.ptAtT(*t1Seed + tStep);
+        if (calcMask & (1 << 3)) t2[0] = quad2.ptAtT(*t2Seed - tStep);
+        if (calcMask & (1 << 5)) t2[2] = quad2.ptAtT(*t2Seed + tStep);
         double dist[3][3];
         // OPTIMIZE: using calcMask value permits skipping some distance calcuations
         //   if prior loop's results are moved to correct slot for reuse
         dist[1][1] = t1[1].distanceSquared(t2[1]);
         int best_i = 1, best_j = 1;
         for (int i = 0; i < 3; ++i) {
             for (int j = 0; j < 3; ++j) {
                 if (i == 1 && j == 1) {
                     continue;
                 }
@@ skipping 37 matching lines @@
             calcMask |= 1 << 5;
         }
     } while (true);
 #if ONE_OFF_DEBUG
     SkDebugf("%s t1=%1.9g t2=%1.9g (%1.9g,%1.9g) != (%1.9g,%1.9g) %s\n", __FUNCTION__,
         t1Seed, t2Seed, t1[1].fX, t1[1].fY, t1[2].fX, t1[2].fY);
 #endif
     return false;
 }
 
+static void lookNearEnd(const SkDQuad& q1, const SkDQuad& q2, int testT,
+        const SkIntersections& orig, bool swap, SkIntersections* i) {
+    if (orig.used() == 1 && orig[!swap][0] == testT) {
+        return;
+    }
+    if (orig.used() == 2 && orig[!swap][1] == testT) {
+        return;
+    }
+    SkDLine tmpLine;
+    int testTIndex = testT << 1;
+    tmpLine[0] = tmpLine[1] = q2[testTIndex];
+    tmpLine[1].fX += q2[1].fY - q2[testTIndex].fY;
+    tmpLine[1].fY -= q2[1].fX - q2[testTIndex].fX;
+    SkIntersections impTs;
+    impTs.intersectRay(q1, tmpLine);
+    for (int index = 0; index < impTs.used(); ++index) {
+        SkDPoint realPt = impTs.pt(index);
+        if (!tmpLine[0].approximatelyEqualHalf(realPt)) {
+            continue;
+        }
+        if (swap) {
+            i->insert(testT, impTs[0][index], tmpLine[0]);
+        } else {
+            i->insert(impTs[0][index], testT, tmpLine[0]);
+        }
+    }
+}
+
 int SkIntersections::intersect(const SkDQuad& q1, const SkDQuad& q2) {
     // if the quads share an end point, check to see if they overlap
 
     for (int i1 = 0; i1 < 3; i1 += 2) {
         for (int i2 = 0; i2 < 3; i2 += 2) {
             if (q1[i1].approximatelyEqualHalf(q2[i2])) {
                 insert(i1 >> 1, i2 >> 1, q1[i1]);
             }
         }
     }
     SkASSERT(fUsed < 3);
     if (only_end_pts_in_common(q1, q2)) {
         return fUsed;
     }
     if (only_end_pts_in_common(q2, q1)) {
         return fUsed;
     }
     // see if either quad is really a line
+    // FIXME: figure out why reduce step didn't find this earlier
     if (is_linear(q1, q2, this)) {
         return fUsed;
     }
     SkIntersections swapped;
     if (is_linear(q2, q1, &swapped)) {
         swapped.swapPts();
         set(swapped);
         return fUsed;
     }
+    SkIntersections copyI(*this);
+    lookNearEnd(q1, q2, 0, *this, false, &copyI);
+    lookNearEnd(q1, q2, 1, *this, false, &copyI);
+    lookNearEnd(q2, q1, 0, *this, true, &copyI);
+    lookNearEnd(q2, q1, 1, *this, true, &copyI);
+    int innerEqual = 0;
+    if (copyI.fUsed >= 2) {
+        SkASSERT(copyI.fUsed <= 4);
+        double width = copyI[0][1] - copyI[0][0];
+        int midEnd = 1;
+        for (int index = 2; index < copyI.fUsed; ++index) {
+            double testWidth = copyI[0][index] - copyI[0][index - 1];
+            if (testWidth <= width) {
+                continue;
+            }
+            midEnd = index;
+        }
+        for (int index = 0; index < 2; ++index) {
+            double testT = (copyI[0][midEnd] * (index + 1)
+                    + copyI[0][midEnd - 1] * (2 - index)) / 3;
+            SkDPoint testPt1 = q1.ptAtT(testT);
+            testT = (copyI[1][midEnd] * (index + 1) + copyI[1][midEnd - 1] * (2 - index)) / 3;
+            SkDPoint testPt2 = q2.ptAtT(testT);
+            innerEqual += testPt1.approximatelyEqual(testPt2);
+        }
+    }
+    bool expectCoincident = copyI.fUsed >= 2 && innerEqual == 2;
+    if (expectCoincident) {
+        reset();
+        insertCoincident(copyI[0][0], copyI[1][0], copyI.fPt[0]);
+        int last = copyI.fUsed - 1;
+        insertCoincident(copyI[0][last], copyI[1][last], copyI.fPt[last]);
+        return fUsed;
+    }
     SkDQuadImplicit i1(q1);
     SkDQuadImplicit i2(q2);
-    if (i1.match(i2)) {
-        // FIXME: compute T values
-        // compute the intersections of the ends to find the coincident span
-        reset();
-        bool useVertical = fabs(q1[0].fX - q1[2].fX) < fabs(q1[0].fY - q1[2].fY);
-        double t;
-        if ((t = SkIntersections::Axial(q1, q2[0], useVertical)) >= 0) {
-            insertCoincident(t, 0, q2[0]);
-        }
-        if ((t = SkIntersections::Axial(q1, q2[2], useVertical)) >= 0) {
-            insertCoincident(t, 1, q2[2]);
-        }
-        useVertical = fabs(q2[0].fX - q2[2].fX) < fabs(q2[0].fY - q2[2].fY);
-        if ((t = SkIntersections::Axial(q2, q1[0], useVertical)) >= 0) {
-            insertCoincident(0, t, q1[0]);
-        }
-        if ((t = SkIntersections::Axial(q2, q1[2], useVertical)) >= 0) {
-            insertCoincident(1, t, q1[2]);
-        }
-        SkASSERT(coincidentUsed() <= 2);
-        return fUsed;
-    }
     int index;
     bool flip1 = q1[2] == q2[0];
     bool flip2 = q1[0] == q2[2];
     bool useCubic = q1[0] == q2[0];
     double roots1[4];
     int rootCount = findRoots(i2, q1, roots1, useCubic, flip1, 0);
     // OPTIMIZATION: could short circuit here if all roots are < 0 or > 1
     double roots1Copy[4];
     int r1Count = addValidRoots(roots1, rootCount, roots1Copy);
     SkDPoint pts1[4];
     for (index = 0; index < r1Count; ++index) {
-        pts1[index] = q1.xyAtT(roots1Copy[index]);
+        pts1[index] = q1.ptAtT(roots1Copy[index]);
     }
     double roots2[4];
     int rootCount2 = findRoots(i1, q2, roots2, useCubic, flip2, 0);
     double roots2Copy[4];
     int r2Count = addValidRoots(roots2, rootCount2, roots2Copy);
     SkDPoint pts2[4];
     for (index = 0; index < r2Count; ++index) {
-        pts2[index] = q2.xyAtT(roots2Copy[index]);
+        pts2[index] = q2.ptAtT(roots2Copy[index]);
     }
     if (r1Count == r2Count && r1Count <= 1) {
         if (r1Count == 1) {
             if (pts1[0].approximatelyEqualHalf(pts2[0])) {
                 insert(roots1Copy[0], roots2Copy[0], pts1[0]);
             } else if (pts1[0].moreRoughlyEqual(pts2[0])) {
                 // experiment: try to find intersection by chasing t
                 rootCount = findRoots(i2, q1, roots1, useCubic, flip1, 0);
                 (void) addValidRoots(roots1, rootCount, roots1Copy);
                 rootCount2 = findRoots(i1, q2, roots2, useCubic, flip2, 0);
@@ skipping 56 matching lines @@
         }
         if (lowestIndex < 0) {
             break;
         }
         insert(roots1Copy[lowestIndex], roots2Copy[closest[lowestIndex]],
                 pts1[lowestIndex]);
         closest[lowestIndex] = -1;
     } while (++used < r1Count);
     return fUsed;
 }