add conics to path ops

src/pathops/SkPathOpsQuad.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 "SkLineParameters.h"
 #include "SkPathOpsCubic.h"
 #include "SkPathOpsQuad.h"
@@ skipping 29 matching lines @@
             }
         }
         if (!foundOutlier) {
             return false;
         }
     }
     *isLinear = linear;
     return true;
 }
 
+bool SkDQuad::hullIntersects(const SkDConic& conic, bool* isLinear) const {
+    return conic.hullIntersects(*this, isLinear);
+}
+
+bool SkDQuad::hullIntersects(const SkDCubic& cubic, bool* isLinear) const {
+    return cubic.hullIntersects(*this, isLinear);
+}
+
 /* bit twiddling for finding the off curve index (x&~m is the pair in [0,1,2] excluding oddMan)
 oddMan    opp   x=oddMan^opp  x=x-oddMan  m=x>>2   x&~m
     0       1         1            1         0       1
             2         2            2         0       2
     1       1         0           -1        -1       0
             2         3            2         0       2
     2       1         3            1         0       1
             2         0           -2        -1       0
 */
 void SkDQuad::otherPts(int oddMan, const SkDPoint* endPt[2]) const {
@@ skipping 131 matching lines @@
     lineParameters.normalize();
     double distance = lineParameters.controlPtDistance(*this);
     double tiniest = SkTMin(SkTMin(SkTMin(SkTMin(SkTMin(fPts[0].fX, fPts[0].fY),
             fPts[1].fX), fPts[1].fY), fPts[2].fX), fPts[2].fY);
     double largest = SkTMax(SkTMax(SkTMax(SkTMax(SkTMax(fPts[0].fX, fPts[0].fY),
             fPts[1].fX), fPts[1].fY), fPts[2].fX), fPts[2].fY);
     largest = SkTMax(largest, -tiniest);
     return approximately_zero_when_compared_to(distance, largest);
 }
 
+SkDConic SkDQuad::toConic() const {
+    SkDConic conic;
+    memcpy(conic.fPts.fPts, fPts, sizeof(fPts));
+    conic.fWeight = 1;
+    return conic;
+}
+
 SkDCubic SkDQuad::toCubic() const {
     SkDCubic cubic;
     cubic[0] = fPts[0];
     cubic[2] = fPts[1];
     cubic[3] = fPts[2];
     cubic[1].fX = (cubic[0].fX + cubic[2].fX * 2) / 3;
     cubic[1].fY = (cubic[0].fY + cubic[2].fY * 2) / 3;
     cubic[2].fX = (cubic[3].fX + cubic[2].fX * 2) / 3;
     cubic[2].fY = (cubic[3].fY + cubic[2].fY * 2) / 3;
     return cubic;
@@ skipping 18 matching lines @@
     }
     double one_t = 1 - t;
     double a = one_t * one_t;
     double b = 2 * one_t * t;
     double c = t * t;
     SkDPoint result = { a * fPts[0].fX + b * fPts[1].fX + c * fPts[2].fX,
             a * fPts[0].fY + b * fPts[1].fY + c * fPts[2].fY };
     return result;
 }
 
+static double interp_quad_coords(const double* src, double t) {
+    double ab = SkDInterp(src[0], src[2], t);
+    double bc = SkDInterp(src[2], src[4], t);
+    double abc = SkDInterp(ab, bc, t);
+    return abc;
+}
+
+bool SkDQuad::monotonicInY() const {
+    return between(fPts[0].fY, fPts[1].fY, fPts[2].fY);
+}
+
 /*
 Given a quadratic q, t1, and t2, find a small quadratic segment.
 
 The new quadratic is defined by A, B, and C, where
  A = c[0]*(1 - t1)*(1 - t1) + 2*c[1]*t1*(1 - t1) + c[2]*t1*t1
  C = c[3]*(1 - t1)*(1 - t1) + 2*c[2]*t1*(1 - t1) + c[1]*t1*t1
 
 To find B, compute the point halfway between t1 and t2:
 
 q(at (t1 + t2)/2) == D
 
 Next, compute where D must be if we know the value of B:
 
 _12 = A/2 + B/2
 12_ = B/2 + C/2
 123 = A/4 + B/2 + C/4
     = D
 
 Group the known values on one side:
 
 B   = D*2 - A/2 - C/2
 */
 
-static double interp_quad_coords(const double* src, double t) {
-    double ab = SkDInterp(src[0], src[2], t);
-    double bc = SkDInterp(src[2], src[4], t);
-    double abc = SkDInterp(ab, bc, t);
-    return abc;
-}
-
-bool SkDQuad::monotonicInY() const {
-    return between(fPts[0].fY, fPts[1].fY, fPts[2].fY);
-}
-
+// OPTIMIZE : special case either or both of t1 = 0, t2 = 1 
 SkDQuad SkDQuad::subDivide(double t1, double t2) const {
     SkDQuad dst;
     double ax = dst[0].fX = interp_quad_coords(&fPts[0].fX, t1);
     double ay = dst[0].fY = interp_quad_coords(&fPts[0].fY, t1);
     double dx = interp_quad_coords(&fPts[0].fX, (t1 + t2) / 2);
     double dy = interp_quad_coords(&fPts[0].fY, (t1 + t2) / 2);
     double cx = dst[2].fX = interp_quad_coords(&fPts[0].fX, t2);
     double cy = dst[2].fY = interp_quad_coords(&fPts[0].fY, t2);
-    /* bx = */ dst[1].fX = 2*dx - (ax + cx)/2;
-    /* by = */ dst[1].fY = 2*dy - (ay + cy)/2;
+    /* bx = */ dst[1].fX = 2 * dx - (ax + cx) / 2;
+    /* by = */ dst[1].fY = 2 * dy - (ay + cy) / 2;
     return dst;
 }
 
 void SkDQuad::align(int endIndex, SkDPoint* dstPt) const {
     if (fPts[endIndex].fX == fPts[1].fX) {
         dstPt->fX = fPts[endIndex].fX;
     }
     if (fPts[endIndex].fY == fPts[1].fY) {
         dstPt->fY = fPts[endIndex].fY;
     }
@@ skipping 87 matching lines @@
  * c =             C
  */
 void SkDQuad::SetABC(const double* quad, double* a, double* b, double* c) {
     *a = quad[0];      // a = A
     *b = 2 * quad[2];  // b =     2*B
     *c = quad[4];      // c =             C
     *b -= *c;          // b =     2*B -   C
     *a -= *b;          // a = A - 2*B +   C
     *b -= *c;          // b =     2*B - 2*C
 }