turn off debugging printfs

src/pathops/SkDCubicIntersection.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"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
@@ skipping 103 matching lines @@
         #endif
             SkIntersections locals;
             intersectWithOrder(s1.fQuad, o1, s2.fQuad, o2, locals);
             double coStart[2] = { -1 };
             SkDPoint coPoint;
             int tCount = locals.used();
             for (int tIdx = 0; tIdx < tCount; ++tIdx) {
                 double to1 = t1Start + (t1 - t1Start) * locals[0][tIdx];
                 double to2 = t2Start + (t2 - t2Start) * locals[1][tIdx];
     // if the computed t is not sufficiently precise, iterate
-                SkDPoint p1 = cubic1.xyAtT(to1);
-                SkDPoint p2 = cubic2.xyAtT(to2);
+                SkDPoint p1 = cubic1.ptAtT(to1);
+                SkDPoint p2 = cubic2.ptAtT(to2);
                 if (p1.approximatelyEqual(p2)) {
                     if (locals.isCoincident(tIdx)) {
                         if (coStart[0] < 0) {
                             coStart[0] = to1;
                             coStart[1] = to2;
                             coPoint = p1;
                         } else {
                             i.insertCoincidentPair(coStart[0], to1, coStart[1], to2, coPoint, p1);
                             coStart[0] = -1;
                         }
@@ skipping 246 matching lines @@
 #endif
     return;
 }
 
 const double CLOSE_ENOUGH = 0.001;
 
 static bool closeStart(const SkDCubic& cubic, int cubicIndex, SkIntersections& i, SkDPoint& pt) {
     if (i[cubicIndex][0] != 0 || i[cubicIndex][1] > CLOSE_ENOUGH) {
         return false;
     }
-    pt = cubic.xyAtT((i[cubicIndex][0] + i[cubicIndex][1]) / 2);
+    pt = cubic.ptAtT((i[cubicIndex][0] + i[cubicIndex][1]) / 2);
     return true;
 }
 
 static bool closeEnd(const SkDCubic& cubic, int cubicIndex, SkIntersections& i, SkDPoint& pt) {
     int last = i.used() - 1;
     if (i[cubicIndex][last] != 1 || i[cubicIndex][last - 1] < 1 - CLOSE_ENOUGH) {
         return false;
     }
-    pt = cubic.xyAtT((i[cubicIndex][last] + i[cubicIndex][last - 1]) / 2);
+    pt = cubic.ptAtT((i[cubicIndex][last] + i[cubicIndex][last - 1]) / 2);
     return true;
 }
 
 int SkIntersections::intersect(const SkDCubic& c1, const SkDCubic& c2) {
     ::intersect(c1, 0, 1, c2, 0, 1, 1, *this);
     // FIXME: pass in cached bounds from caller
     SkDRect c1Bounds, c2Bounds;
     c1Bounds.setBounds(c1);  // OPTIMIZE use setRawBounds ?
     c2Bounds.setBounds(c2);
     intersectEnd(c1, false, c2, c2Bounds, *this);
@@ skipping 21 matching lines @@
         removeOne(used() - 2);
     }
     // vet the pairs of t values to see if the mid value is also on the curve. If so, mark
     // the span as coincident
     if (fUsed >= 2 && !coincidentUsed()) {
         int last = fUsed - 1;
         int match = 0;
         for (int index = 0; index < last; ++index) {
             double mid1 = (fT[0][index] + fT[0][index + 1]) / 2;
             double mid2 = (fT[1][index] + fT[1][index + 1]) / 2;
-            pt[0] = c1.xyAtT(mid1);
-            pt[1] = c2.xyAtT(mid2);
+            pt[0] = c1.ptAtT(mid1);
+            pt[1] = c2.ptAtT(mid2);
             if (pt[0].approximatelyEqual(pt[1])) {
                 match |= 1 << index;
             }
         }
         if (match) {
             if (((match + 1) & match) != 0) {
                 SkDebugf("%s coincident hole\n", __FUNCTION__);
             }
             // for now, assume that everything from start to finish is coincident
             if (fUsed > 2) {
@@ skipping 32 matching lines @@
     }
     (void) intersect(c, c);
     if (used() > 0) {
         SkASSERT(used() == 1);
         if (fT[0][0] > fT[1][0]) {
             swapPts();
         }
     }
     return used();
 }