turn off debugging printfs

src/pathops/SkIntersections.cpp

 /*
  * 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"
 
 int (SkIntersections::*CurveVertical[])(const SkPoint[], SkScalar, SkScalar, SkScalar, bool) = {
@@ skipping 36 matching lines @@
     cubic.set(pts);
     return intersectRay(cubic, line);
 }
 
 void SkIntersections::flip() {
     for (int index = 0; index < fUsed; ++index) {
         fT[1][index] = 1 - fT[1][index];
     }
 }
 
-void SkIntersections::insertCoincidentPair(double s1, double e1, double s2, double e2,
-        const SkDPoint& startPt, const SkDPoint& endPt) {
-    SkASSERT(s1 < e1);
-    SkASSERT(s2 != e2);
-    if (coincidentUsed() != fUsed) { // if the curve is partially coincident, treat it as fully so
-        for (int index = fUsed - 1; index >= 0; --index) {
-            if (fIsCoincident[0] & (1 << index)) {
-                continue;
-            }
-            double nonCoinT = fT[0][index];
-            if (!between(s1, nonCoinT, e1)) {
-                if (s1 > nonCoinT) {
-                    s1 = nonCoinT;
-                } else {
-                    e1 = nonCoinT;
-                }
-            }
-            nonCoinT = fT[1][index];
-            if (!between(s2, nonCoinT, e2)) {
-                if ((s2 > nonCoinT) ^ (s2 > e2)) {
-                    s2 = nonCoinT;
-                } else {
-                    e2 = nonCoinT;
-                }
-            }
-            removeOne(index);
-        }
-    }
-    SkASSERT(coincidentUsed() == fUsed);
-    SkASSERT((coincidentUsed() & 1) != 1);
-    int i1 = 0;
-    int i2 = 0;
-    do {
-        while (i1 < fUsed && !(fIsCoincident[fSwap] & (1 << i1))) {
-            ++i1;
-        }
-        if (i1 == fUsed) {
-            break;
-        }
-        SkASSERT(i1 < fUsed);
-        int iEnd1 = i1 + 1;
-        while (!(fIsCoincident[fSwap] & (1 << iEnd1))) {
-            ++iEnd1;
-        }
-        SkASSERT(iEnd1 < fUsed);
-        double cs1 = fT[fSwap][i1];
-        double ce1 = fT[fSwap][iEnd1];
-        bool s1in = between(cs1, s1, ce1) || startPt.approximatelyEqual(fPt[i1])
-                || startPt.approximatelyEqual(fPt[iEnd1]);
-        bool e1in = between(cs1, e1, ce1) || endPt.approximatelyEqual(fPt[i1])
-                || endPt.approximatelyEqual(fPt[iEnd1]);
-        while (i2 < fUsed && !(fIsCoincident[fSwap ^ 1] & (1 << i2))) {
-            ++i2;
-        }
-        int iEnd2 = i2 + 1;
-        while (!(fIsCoincident[fSwap ^ 1] & (1 << iEnd2))) {
-            ++iEnd2;
-        }
-        SkASSERT(iEnd2 < fUsed);
-        double cs2 = fT[fSwap ^ 1][i2];
-        double ce2 = fT[fSwap ^ 1][iEnd2];
-        bool s2in = between(cs2, s2, ce2) || startPt.approximatelyEqual(fPt[i2])
-                || startPt.approximatelyEqual(fPt[iEnd2]);
-        bool e2in = between(cs2, e2, ce2) || endPt.approximatelyEqual(fPt[i2])
-                || endPt.approximatelyEqual(fPt[iEnd2]);
-        if ((s1in | e1in) & (s2in | e2in)) {
-            if (s1 < cs1) {
-                fT[fSwap][i1] = s1;
-                fPt[i1] = startPt;
-            } else if (e1 < cs1) {
-                fT[fSwap][i1] = e1;
-                fPt[i1] = endPt;
-            }
-            if (s1 > ce1) {
-                fT[fSwap][iEnd1] = s1;
-                fPt[iEnd1] = startPt;
-            } else if (e1 > ce1) {
-                fT[fSwap][iEnd1] = e1;
-                fPt[iEnd1] = endPt;
-            }
-            if (s2 > e2) {
-                SkTSwap(cs2, ce2);
-                SkTSwap(i2, iEnd2);
-            }
-            if (s2 < cs2) {
-                fT[fSwap ^ 1][i2] = s2;
-            } else if (e2 < cs2) {
-                fT[fSwap ^ 1][i2] = e2;
-            }
-            if (s2 > ce2) {
-                fT[fSwap ^ 1][iEnd2] = s2;
-            } else if (e2 > ce2) {
-                fT[fSwap ^ 1][iEnd2] = e2;
-            }
-            return;
-        }
-    } while (true);
-    SkASSERT(fUsed < 9);
-    insertCoincident(s1, s2, startPt);
-    insertCoincident(e1, e2, endPt);
-}
-
 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];
@@ skipping 113 matching lines @@
     quad.set(a);
     return vertical(quad, top, bottom, x, flipped);
 }
 
 int SkIntersections::verticalCubic(const SkPoint a[4], SkScalar top, SkScalar bottom,
         SkScalar x, bool flipped) {
     SkDCubic cubic;
     cubic.set(a);
     return vertical(cubic, top, bottom, x, flipped);
 }