add conics to path ops

src/pathops/SkPathOpsCubic.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 "SkGeometry.h"
 #include "SkLineParameters.h"
+#include "SkPathOpsConic.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsLine.h"
 #include "SkPathOpsQuad.h"
 #include "SkPathOpsRect.h"
 #include "SkTSort.h"
 
 const int SkDCubic::gPrecisionUnit = 256;  // FIXME: test different values in test framework
 
 // give up when changing t no longer moves point
 // also, copy point rather than recompute it when it does change
@@ skipping 79 matching lines @@
             && between(fPts[0].fY, fPts[2].fY, fPts[3].fY));
 }
 
 // Do a quick reject by rotating all points relative to a line formed by
 // a pair of one cubic's points. If the 2nd cubic's points
 // are on the line or on the opposite side from the 1st cubic's 'odd man', the
 // curves at most intersect at the endpoints.
 /* 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 SkDCubic& c2, bool* isLinear) const {
+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];
@@ skipping 11 matching lines @@
             continue;
         }
         if (approximately_zero(sign)) {
             sign = sign2;
             if (approximately_zero(sign)) {
                 continue;
             }
         }
         linear = false;
         bool foundOutlier = false;
-        for (int n = 0; n < kPointCount; ++n) {
-            double test = (c2[n].fY - origY) * adj - (c2[n].fX - origX) * opp;
+        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;
 }
 
+bool SkDCubic::hullIntersects(const SkDCubic& c2, bool* isLinear) const {
+    return hullIntersects(c2.fPts, c2.kPointCount, isLinear);
+}
+
+bool SkDCubic::hullIntersects(const SkDQuad& quad, bool* isLinear) const {
+    return hullIntersects(quad.fPts, quad.kPointCount, isLinear);
+}
+
+bool SkDCubic::hullIntersects(const SkDConic& conic, bool* isLinear) const {
+
+    return hullIntersects(conic.fPts, isLinear);
+}
+
 bool SkDCubic::isLinear(int startIndex, int endIndex) const {
     SkLineParameters lineParameters;
     lineParameters.cubicEndPoints(*this, startIndex, endIndex);
     // FIXME: maybe it's possible to avoid this and compare non-normalized
     lineParameters.normalize();
     double tiniest = SkTMin(SkTMin(SkTMin(SkTMin(SkTMin(SkTMin(SkTMin(fPts[0].fX, fPts[0].fY),
             fPts[1].fX), fPts[1].fY), fPts[2].fX), fPts[2].fY), fPts[3].fX), fPts[3].fY);
     double largest = SkTMax(SkTMax(SkTMax(SkTMax(SkTMax(SkTMax(SkTMax(fPts[0].fX, fPts[0].fY),
             fPts[1].fX), fPts[1].fY), fPts[2].fX), fPts[2].fY), fPts[3].fX), fPts[3].fY);
     largest = SkTMax(largest, -tiniest);
@@ skipping 458 matching lines @@
         dst.pts[4].fY = (fPts[1].fY + 2 * fPts[2].fY + fPts[3].fY) / 4;
         dst.pts[5].fX = (fPts[2].fX + fPts[3].fX) / 2;
         dst.pts[5].fY = (fPts[2].fY + fPts[3].fY) / 2;
         dst.pts[6] = fPts[3];
         return dst;
     }
     interp_cubic_coords(&fPts[0].fX, &dst.pts[0].fX, t);
     interp_cubic_coords(&fPts[0].fY, &dst.pts[0].fY, t);
     return dst;
 }