working on initial winding for cubics

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 "SkPathOpsCurve.h"
 #include "SkPathOpsQuad.h"
 
 /* started with at_most_end_pts_in_common from SkDQuadIntersection.cpp */
 // Do a quick reject by rotating all points relative to a line formed by
 // a pair of one quad's points. If the 2nd quad's points
 // are on the line or on the opposite side from the 1st quad's 'odd man', the
 // curves at most intersect at the endpoints.
 /* if returning true, check contains true if quad's hull collapsed, making the cubic linear
    if returning false, check contains true if the the quad pair have only the end point in common
 */
@@ skipping 78 matching lines @@
             distMin = dist;
             bestIndex = index;
         }
     }
     if (bestIndex >= 0) {
         return ts[bestIndex];
     }
     return d0 < d2 ? 0 : 1;
 }
 
-SkDPoint SkDQuad::top(double startT, double endT) const {
-    SkDQuad sub = subDivide(startT, endT);
-    SkDPoint topPt = sub[0];
-    if (topPt.fY > sub[2].fY || (topPt.fY == sub[2].fY && topPt.fX > sub[2].fX)) {
-        topPt = sub[2];
-    }
-    if (!between(sub[0].fY, sub[1].fY, sub[2].fY)) {
-        double extremeT;
-        if (FindExtrema(sub[0].fY, sub[1].fY, sub[2].fY, &extremeT)) {
-            extremeT = startT + (endT - startT) * extremeT;
-            SkDPoint test = ptAtT(extremeT);
-            if (topPt.fY > test.fY || (topPt.fY == test.fY && topPt.fX > test.fX)) {
-                topPt = test;
-            }
-        }
-    }
-    return topPt;
-}
-
 int SkDQuad::AddValidTs(double s[], int realRoots, double* t) {
     int foundRoots = 0;
     for (int index = 0; index < realRoots; ++index) {
         double tValue = s[index];
         if (approximately_zero_or_more(tValue) && approximately_one_or_less(tValue)) {
             if (approximately_less_than_zero(tValue)) {
                 tValue = 0;
             } else if (approximately_greater_than_one(tValue)) {
                 tValue = 1;
             }
@@ skipping 197 matching lines @@
         b.fX = c.fX;
     }
     if (AlmostBequalUlps(b.fY, a.fY)) {
         b.fY = a.fY;
     } else if (AlmostBequalUlps(b.fY, c.fY)) {
         b.fY = c.fY;
     }
     return b;
 }
 
+SkDPoint SkDQuad::top(double startT, double endT, double* topT) const {
+    SkDQuad sub = subDivide(startT, endT);
+    SkDPoint topPt = sub[0];
+    *topT = startT;
+    if (topPt.fY > sub[2].fY || (topPt.fY == sub[2].fY && topPt.fX > sub[2].fX)) {
+        *topT = endT;
+        topPt = sub[2];
+    }
+    if (!between(sub[0].fY, sub[1].fY, sub[2].fY)) {
+        double extremeT;
+        if (FindExtrema(sub[0].fY, sub[1].fY, sub[2].fY, &extremeT)) {
+            extremeT = startT + (endT - startT) * extremeT;
+            SkDPoint test = ptAtT(extremeT);
+            if (topPt.fY > test.fY || (topPt.fY == test.fY && topPt.fX > test.fX)) {
+                *topT = extremeT;
+                topPt = test;
+            }
+        }
+    }
+    return topPt;
+}
+
 /* classic one t subdivision */
 static void interp_quad_coords(const double* src, double* dst, double t) {
     double ab = SkDInterp(src[0], src[2], t);
     double bc = SkDInterp(src[2], src[4], t);
     dst[0] = src[0];
     dst[2] = ab;
     dst[4] = SkDInterp(ab, bc, t);
     dst[6] = bc;
     dst[8] = src[4];
 }
 
 SkDQuadPair SkDQuad::chopAt(double t) const
 {
     SkDQuadPair dst;
     interp_quad_coords(&fPts[0].fX, &dst.pts[0].fX, t);
     interp_quad_coords(&fPts[0].fY, &dst.pts[0].fY, t);
     return dst;
 }
 
+bool SkDQuad::Clockwise(const SkOpCurve& edge, bool* swap) {
+    SkDQuad temp;
+    double sum = (edge[0].fX - edge[kPointLast].fX) * (edge[0].fY + edge[kPointLast].fY);
+    for (int idx = 0; idx < kPointLast; ++idx){
+        sum += (edge[idx + 1].fX - edge[idx].fX) * (edge[idx + 1].fY + edge[idx].fY);
+    }
+    temp.set(edge.fPts);
+    *swap = sum > 0 && !temp.monotonicInY();
+    return sum <= 0;
+}
+
 static int valid_unit_divide(double numer, double denom, double* ratio)
 {
     if (numer < 0) {
         numer = -numer;
         denom = -denom;
     }
     if (denom == 0 || numer == 0 || numer >= denom) {
         return 0;
     }
     double r = numer / denom;
@@ skipping 23 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
 }