add conics to path ops

src/pathops/SkOpSegment.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 "SkOpCoincidence.h"
 #include "SkOpContour.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
@@ skipping 104 matching lines @@
         }
         {
             const SkPoint& xy = span->pt();
             if (topPt.fY > xy.fY || (topPt.fY == xy.fY && topPt.fX > xy.fX)) {
                 topPt = xy;
                 if (firstSpan) {
                     *firstSpan = span;
                 }
             }
             if (fVerb != SkPath::kLine_Verb && !lastDone) {
-                SkPoint curveTop = (*CurveTop[SkPathOpsVerbToPoints(fVerb)])(fPts, lastT,
-                        span->t());
+                SkPoint curveTop = (*CurveTop[fVerb])(fPts, fWeight, lastT, span->t());
                 if (topPt.fY > curveTop.fY || (topPt.fY == curveTop.fY
                         && topPt.fX > curveTop.fX)) {
                     topPt = curveTop;
                     if (firstSpan) {
                         *firstSpan = span;
                     }
                 }
             }
             lastT = span->t();
         }
@@ skipping 58 matching lines @@
     int maxWinding;
     setUpWinding(start, end, &maxWinding, sumWinding);
     bool from = maxWinding != 0;
     bool to = *sumWinding  != 0;
     bool result = gUnaryActiveEdge[from][to];
     return result;
 }
 
 void SkOpSegment::addCurveTo(const SkOpSpanBase* start, const SkOpSpanBase* end,
         SkPathWriter* path, bool active) const {
-    SkPoint edge[4];
+    SkOpCurve edge;
     const SkPoint* ePtr;
+    SkScalar eWeight;
     if ((start == &fHead && end == &fTail) || (start == &fTail && end == &fHead)) {
         ePtr = fPts;
+        eWeight = fWeight;
     } else {
     // OPTIMIZE? if not active, skip remainder and return xyAtT(end)
-        subDivide(start, end, edge);
-        ePtr = edge;
+        subDivide(start, end, &edge);
+        ePtr = edge.fPts;
+        eWeight = edge.fWeight;
     }
     if (active) {
         bool reverse = ePtr == fPts && start != &fHead;
         if (reverse) {
             path->deferredMoveLine(ePtr[SkPathOpsVerbToPoints(fVerb)]);
             switch (fVerb) {
                 case SkPath::kLine_Verb:
                     path->deferredLine(ePtr[0]);
                     break;
                 case SkPath::kQuad_Verb:
                     path->quadTo(ePtr[1], ePtr[0]);
                     break;
+                case SkPath::kConic_Verb:
+                    path->conicTo(ePtr[1], ePtr[0], eWeight);
+                    break;
                 case SkPath::kCubic_Verb:
                     path->cubicTo(ePtr[2], ePtr[1], ePtr[0]);
                     break;
                 default:
                     SkASSERT(0);
             }
        } else {
             path->deferredMoveLine(ePtr[0]);
             switch (fVerb) {
                 case SkPath::kLine_Verb:
                     path->deferredLine(ePtr[1]);
                     break;
                 case SkPath::kQuad_Verb:
                     path->quadTo(ePtr[1], ePtr[2]);
                     break;
+                case SkPath::kConic_Verb:
+                    path->conicTo(ePtr[1], ePtr[2], eWeight);
+                    break;
                 case SkPath::kCubic_Verb:
                     path->cubicTo(ePtr[1], ePtr[2], ePtr[3]);
                     break;
                 default:
                     SkASSERT(0);
             }
         }
     }
 }
 
@@ skipping 219 matching lines @@
         angle = span->toAngle();
         if (angle && angle->fCheckCoincidence) {
             angle->checkNearCoincidence();
         }
     } while ((base = span->next()));
 }
 
 // from http://stackoverflow.com/questions/1165647/how-to-determine-if-a-list-of-polygon-points-are-in-clockwise-order
 bool SkOpSegment::clockwise(const SkOpSpanBase* start, const SkOpSpanBase* end, bool* swap) const {
     SkASSERT(fVerb != SkPath::kLine_Verb);
-    SkPoint edge[4];
+    SkOpCurve edge;
     if (fVerb == SkPath::kCubic_Verb) {
         double startT = start->t();
         double endT = end->t();
         bool flip = startT > endT;
         SkDCubic cubic;
         cubic.set(fPts);
         double inflectionTs[2];
         int inflections = cubic.findInflections(inflectionTs);
         for (int index = 0; index < inflections; ++index) {
             double inflectionT = inflectionTs[index];
             if (between(startT, inflectionT, endT)) {
                 if (flip) {
-                    if (inflectionT != endT) {
-                        startT = inflectionT;
+                    if (!roughly_equal(inflectionT, endT)) {
+                    startT = inflectionT;
                     }
                 } else {
-                    if (inflectionT != startT) {
+                    if (!roughly_equal(inflectionT, startT)) {
                         endT = inflectionT;
                     }
                 }
             }
         }
         SkDCubic part = cubic.subDivide(startT, endT);
-        for (int index = 0; index < 4; ++index) {
-            edge[index] = part[index].asSkPoint();
-        }
+        edge.set(part);
     } else {
-    subDivide(start, end, edge);
+        subDivide(start, end, &edge);
     }
     bool sumSet = false;
     int points = SkPathOpsVerbToPoints(fVerb);
     double sum = (edge[0].fX - edge[points].fX) * (edge[0].fY + edge[points].fY);
     if (!sumSet) {
         for (int idx = 0; idx < points; ++idx){
             sum += (edge[idx + 1].fX - edge[idx].fX) * (edge[idx + 1].fY + edge[idx].fY);
         }
     }
     if (fVerb == SkPath::kCubic_Verb) {
         SkDCubic cubic;
-        cubic.set(edge);
+        cubic.set(edge.fPts);
         *swap = sum > 0 && !cubic.monotonicInY();
     } else {
         SkDQuad quad;
-        quad.set(edge);
+        quad.set(edge.fPts);
         *swap = sum > 0 && !quad.monotonicInY();
     }
     return sum <= 0;
 }
 
 void SkOpSegment::ComputeOneSum(const SkOpAngle* baseAngle, SkOpAngle* nextAngle,
         SkOpAngle::IncludeType includeType) {
     const SkOpSegment* baseSegment = baseAngle->segment();
     int sumMiWinding = baseSegment->updateWindingReverse(baseAngle);
     int sumSuWinding;
@@ skipping 141 matching lines @@
     if (fBounds.fLeft == fBounds.fRight) {
         // if vertical, and directly above test point, wait for another one
         *vertical = AlmostEqualUlps(basePt.fX, fBounds.fLeft);
         return NULL;
     }
     // intersect ray starting at basePt with edge
     SkIntersections intersections;
     // OPTIMIZE: use specialty function that intersects ray with curve,
     // returning t values only for curve (we don't care about t on ray)
     intersections.allowNear(false);
-    int pts = (intersections.*CurveVertical[SkPathOpsVerbToPoints(fVerb)])
-            (fPts, top, bottom, basePt.fX, false);
+    int pts = (intersections.*CurveVertical[fVerb])(fPts, fWeight, top, bottom, basePt.fX, false);
     if (pts == 0 || (current && pts == 1)) {
         return NULL;
     }
     if (current) {
         SkASSERT(pts > 1);
         int closestIdx = 0;
         double closest = fabs(intersections[0][0] - mid);
         for (int idx = 1; idx < pts; ++idx) {
             double test = fabs(intersections[0][idx] - mid);
             if (closest > test) {
                 closestIdx = idx;
                 closest = test;
             }
         }
         intersections.quickRemoveOne(closestIdx, --pts);
     }
     double bestT = -1;
     for (int index = 0; index < pts; ++index) {
         double foundT = intersections[0][index];
         if (approximately_less_than_zero(foundT)
                     || approximately_greater_than_one(foundT)) {
             continue;
         }
-        SkScalar testY = (*CurvePointAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, foundT).fY;
+        SkScalar testY = (*CurvePointAtT[fVerb])(fPts, fWeight, foundT).fY;
         if (approximately_negative(testY - *bestY)
                 || approximately_negative(basePt.fY - testY)) {
             continue;
         }
         if (pts > 1 && fVerb == SkPath::kLine_Verb) {
             *vertical = true;
             return NULL;  // if the intersection is edge on, wait for another one
         }
         if (fVerb > SkPath::kLine_Verb) {
-            SkScalar dx = (*CurveSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, foundT).fX;
+            SkScalar dx = (*CurveSlopeAtT[fVerb])(fPts, fWeight, foundT).fX;
             if (approximately_zero(dx)) {
                 *vertical = true;
                 return NULL;  // hit vertical, wait for another one
             }
         }
         *bestY = testY;
         bestT = foundT;
     }
     if (bestT < 0) {
         return NULL;
@@ skipping 29 matching lines @@
 }
 
 double SkOpSegment::distSq(double t, SkOpAngle* oppAngle) {
     SkDPoint testPt = this->dPtAtT(t);
     SkDLine testPerp = {{ testPt, testPt }};
     SkDVector slope = this->dSlopeAtT(t);
     testPerp[1].fX += slope.fY;
     testPerp[1].fY -= slope.fX;
     SkIntersections i;
     SkOpSegment* oppSegment = oppAngle->segment();
-    int oppPtCount = SkPathOpsVerbToPoints(oppSegment->verb());
-    (*CurveIntersectRay[oppPtCount])(oppSegment->pts(), testPerp, &i);
+    (*CurveIntersectRay[oppSegment->verb()])(oppSegment->pts(), oppSegment->weight(), testPerp, &i);
     double closestDistSq = SK_ScalarInfinity;
     for (int index = 0; index < i.used(); ++index) {
         if (!between(oppAngle->start()->t(), i[0][index], oppAngle->end()->t())) {
             continue;
         }
         double testDistSq = testPt.distanceSquared(i.pt(index));
         if (closestDistSq > testDistSq) {
             closestDistSq = testDistSq;
         }
     }
@@ skipping 372 matching lines @@
                     __FUNCTION__,
                     swap, leftSegment->debugInflections(start, end),
                     leftSegment->monotonicInY(start, end));
     #endif
             if (swap) {
     // FIXME: I doubt it makes sense to (necessarily) swap if the edge was not the first
     // sorted but merely the first not already processed (i.e., not done)
                 SkTSwap(*startPtr, *endPtr);
             }
         }
+        // FIXME: clockwise isn't reliable -- try computing swap from tangent ?
     }
     return leftSegment;
 }
 
 SkOpGlobalState* SkOpSegment::globalState() const {
     return contour()->globalState(); 
 }
 
-void SkOpSegment::init(SkPoint pts[], SkOpContour* contour, SkPath::Verb verb) {
+void SkOpSegment::init(SkPoint pts[], SkScalar weight, SkOpContour* contour, SkPath::Verb verb) {
     fContour = contour;
     fNext = NULL;
     fPts = pts;
+    fWeight = weight;
     fVerb = verb;
     fCount = 0;
     fDoneCount = 0;
     fVisited = false;
     SkOpSpan* zeroSpan = &fHead;
     zeroSpan->init(this, NULL, 0, fPts[0]);
     SkOpSpanBase* oneSpan = &fTail;
     zeroSpan->setNext(oneSpan);
     oneSpan->initBase(this, zeroSpan, 1, fPts[SkPathOpsVerbToPoints(fVerb)]);
-    PATH_OPS_DEBUG_CODE(fID = globalState()->nextSegmentID());
+    SkDEBUGCODE(fID = globalState()->nextSegmentID());
 }
 
 void SkOpSegment::initWinding(SkOpSpanBase* start, SkOpSpanBase* end,
         SkOpAngle::IncludeType angleIncludeType) {
     int local = SkOpSegment::SpanSign(start, end);
     SkDEBUGCODE(bool success);
     if (angleIncludeType == SkOpAngle::kBinarySingle) {
         int oppLocal = SkOpSegment::OppSign(start, end);
         SkDEBUGCODE(success =) markAndChaseWinding(start, end, local, oppLocal, NULL);
     // OPTIMIZATION: the reverse mark and chase could skip the first marking
@@ skipping 12 matching lines @@
 sign or not. However, this isn't enough.
 If the supplied sign (winding) is zero, then we didn't hit another vertical span, so dx is needed.
 If there was a winding, then it may or may not need adjusting. If the span the winding was borrowed
 from has the same x direction as this span, the winding should change. If the dx is opposite, then
 the same winding is shared by both.
 */
 bool SkOpSegment::initWinding(SkOpSpanBase* start, SkOpSpanBase* end, double tHit,
         int winding, SkScalar hitDx, int oppWind, SkScalar hitOppDx) {
     SkASSERT(this == start->segment());
     SkASSERT(hitDx || !winding);
-    SkScalar dx = (*CurveSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, tHit).fX;
+    SkScalar dx = (*CurveSlopeAtT[fVerb])(fPts, fWeight, tHit).fX;
 //    SkASSERT(dx);
     int windVal = start->starter(end)->windValue();
 #if DEBUG_WINDING_AT_T
     SkDebugf("%s id=%d oldWinding=%d hitDx=%c dx=%c windVal=%d", __FUNCTION__, debugID(), winding,
             hitDx ? hitDx > 0 ? '+' : '-' : '0', dx > 0 ? '+' : '-', windVal);
 #endif
     int sideWind = winding + (dx < 0 ? windVal : -windVal);
     if (abs(winding) < abs(sideWind)) {
         winding = sideWind;
     }
@@ skipping 13 matching lines @@
 #endif
     // if this fails to mark (because the edges are too small) inform caller to try again
     bool success = markAndChaseWinding(start, end, winding, oppWind, NULL);
     // OPTIMIZATION: the reverse mark and chase could skip the first marking
     success |= markAndChaseWinding(end, start, winding, oppWind, NULL);
     return success;
 }
 
 bool SkOpSegment::isClose(double t, const SkOpSegment* opp) const {
     SkDPoint cPt = this->dPtAtT(t);
-    int pts = SkPathOpsVerbToPoints(this->verb());
-    SkDVector dxdy = (*CurveDSlopeAtT[pts])(this->pts(), t);
+    SkDVector dxdy = (*CurveDSlopeAtT[this->verb()])(this->pts(), this->weight(), t);
     SkDLine perp = {{ cPt, {cPt.fX + dxdy.fY, cPt.fY - dxdy.fX} }};
     SkIntersections i;
-    int oppPts = SkPathOpsVerbToPoints(opp->verb());
-    (*CurveIntersectRay[oppPts])(opp->pts(), perp, &i);
+    (*CurveIntersectRay[opp->verb()])(opp->pts(), opp->weight(), perp, &i);
     int used = i.used();
     for (int index = 0; index < used; ++index) {
         if (cPt.roughlyEqual(i.pt(index))) {
             return true;
         }
     }
     return false;
 }
 
 bool SkOpSegment::isXor() const {
@@ skipping 178 matching lines @@
     }
     return NULL;
 }
 
 bool SkOpSegment::monotonicInY(const SkOpSpanBase* start, const SkOpSpanBase* end) const {
     SkASSERT(fVerb != SkPath::kLine_Verb);
     if (fVerb == SkPath::kQuad_Verb) {
         SkDQuad dst = SkDQuad::SubDivide(fPts, start->t(), end->t());
         return dst.monotonicInY();
     }
+    if (fVerb == SkPath::kConic_Verb) {
+        SkDConic dst = SkDConic::SubDivide(fPts, fWeight, start->t(), end->t());
+        return dst.monotonicInY();
+    }
     SkASSERT(fVerb == SkPath::kCubic_Verb);
     SkDCubic dst = SkDCubic::SubDivide(fPts, start->t(), end->t());
     return dst.monotonicInY();
 }
 
 bool SkOpSegment::NextCandidate(SkOpSpanBase* span, SkOpSpanBase** start,
         SkOpSpanBase** end) {
     while (span->final() || span->upCast()->done()) {
         if (span->final()) {
             return false;
@@ skipping 142 matching lines @@
             {
                 // average t, find mid pt
                 double midT = (prior->t() + span->t()) / 2;
                 SkPoint midPt = this->ptAtT(midT);
                 coincident = true;
                 // if the mid pt is not near either end pt, project perpendicular through opp seg
                 if (!SkDPoint::ApproximatelyEqual(priorPtT->fPt, midPt)
                         && !SkDPoint::ApproximatelyEqual(ptT->fPt, midPt)) {
                     coincident = false;
                     SkIntersections i;
-                    int ptCount = SkPathOpsVerbToPoints(this->verb());
-                    SkVector dxdy = (*CurveSlopeAtT[ptCount])(pts(), midT);
+                    SkVector dxdy = (*CurveSlopeAtT[fVerb])(this->pts(), this->weight(), midT);
                     SkDLine ray = {{{midPt.fX, midPt.fY},
                             {midPt.fX + dxdy.fY, midPt.fY - dxdy.fX}}};
-                    int oppPtCount = SkPathOpsVerbToPoints(opp->verb());
-                    (*CurveIntersectRay[oppPtCount])(opp->pts(), ray, &i);
+                    (*CurveIntersectRay[opp->verb()])(opp->pts(), opp->weight(), ray, &i);
                     // measure distance and see if it's small enough to denote coincidence
                     for (int index = 0; index < i.used(); ++index) {
                         SkDPoint oppPt = i.pt(index);
                         if (oppPt.approximatelyEqual(midPt)) {
-                            SkVector oppDxdy = (*CurveSlopeAtT[oppPtCount])(opp->pts(),
-                                    i[index][0]);
+                            SkVector oppDxdy = (*CurveSlopeAtT[opp->verb()])(opp->pts(),
+                                    opp->weight(), i[index][0]);
                             oppDxdy.normalize();
                             dxdy.normalize();
                             SkScalar flatness = SkScalarAbs(dxdy.cross(oppDxdy) / FLT_EPSILON);
                             coincident |= flatness < 5000;  // FIXME: replace with tuned value
                         }
                     }
                 }
             }
             if (coincident) {
             // mark coincidence
@@ skipping 182 matching lines @@
             baseAngle = NULL;
         }
 #if DEBUG_SORT
         SkASSERT(!baseAngle || baseAngle->loopCount() > 1);
 #endif
     } while (!span->final() && (span = span->upCast()->next()));
 }
 
 // return true if midpoints were computed
 bool SkOpSegment::subDivide(const SkOpSpanBase* start, const SkOpSpanBase* end,
-        SkPoint edge[4]) const {
+        SkOpCurve* edge) const {
     SkASSERT(start != end);
     const SkOpPtT& startPtT = *start->ptT();
     const SkOpPtT& endPtT = *end->ptT();
-    edge[0] = startPtT.fPt;
+    SkDEBUGCODE(edge->fVerb = fVerb);
+    edge->fPts[0] = startPtT.fPt;
     int points = SkPathOpsVerbToPoints(fVerb);
-    edge[points] = endPtT.fPt;
+    edge->fPts[points] = endPtT.fPt;
+    edge->fWeight = 1;
     if (fVerb == SkPath::kLine_Verb) {
         return false;
     }
     double startT = startPtT.fT;
     double endT = endPtT.fT;
     if ((startT == 0 || endT == 0) && (startT == 1 || endT == 1)) {
         // don't compute midpoints if we already have them
         if (fVerb == SkPath::kQuad_Verb) {
-            edge[1] = fPts[1];
+            edge->fPts[1] = fPts[1];
+            return false;
+        }
+        if (fVerb == SkPath::kConic_Verb) {
+            edge->fPts[1] = fPts[1];
+            edge->fWeight = fWeight;
             return false;
         }
         SkASSERT(fVerb == SkPath::kCubic_Verb);
         if (start < end) {
-            edge[1] = fPts[1];
-            edge[2] = fPts[2];
+            edge->fPts[1] = fPts[1];
+            edge->fPts[2] = fPts[2];
             return false;
         }
-        edge[1] = fPts[2];
-        edge[2] = fPts[1];
+        edge->fPts[1] = fPts[2];
+        edge->fPts[2] = fPts[1];
         return false;
     }
-    const SkDPoint sub[2] = {{ edge[0].fX, edge[0].fY}, {edge[points].fX, edge[points].fY }};
+    const SkDPoint sub[2] = {{ edge->fPts[0].fX, edge->fPts[0].fY},
+            {edge->fPts[points].fX, edge->fPts[points].fY }};
     if (fVerb == SkPath::kQuad_Verb) {
-        edge[1] = SkDQuad::SubDivide(fPts, sub[0], sub[1], startT, endT).asSkPoint();
+        edge->fPts[1] = SkDQuad::SubDivide(fPts, sub[0], sub[1], startT, endT).asSkPoint();
+    } else if (fVerb == SkPath::kConic_Verb) {
+        edge->fPts[1] = SkDConic::SubDivide(fPts, fWeight, sub[0], sub[1],
+                startT, endT, &edge->fWeight).asSkPoint();
     } else {
         SkASSERT(fVerb == SkPath::kCubic_Verb);
         SkDPoint ctrl[2];
         SkDCubic::SubDivide(fPts, sub[0], sub[1], startT, endT, ctrl);
-        edge[1] = ctrl[0].asSkPoint();
-        edge[2] = ctrl[1].asSkPoint();
+        edge->fPts[1] = ctrl[0].asSkPoint();
+        edge->fPts[2] = ctrl[1].asSkPoint();
     }
     return true;
 }
 
 bool SkOpSegment::subDivide(const SkOpSpanBase* start, const SkOpSpanBase* end,
-        SkDCubic* result) const {
+        SkDCurve* edge) const {
     SkASSERT(start != end);
     const SkOpPtT& startPtT = *start->ptT();
     const SkOpPtT& endPtT = *end->ptT();
-    (*result)[0].set(startPtT.fPt);
+    SkDEBUGCODE(edge->fVerb = fVerb);
+    edge->fCubic[0].set(startPtT.fPt);
     int points = SkPathOpsVerbToPoints(fVerb);
-    (*result)[points].set(endPtT.fPt);
+    edge->fCubic[points].set(endPtT.fPt);
     if (fVerb == SkPath::kLine_Verb) {
         return false;
     }
     double startT = startPtT.fT;
     double endT = endPtT.fT;
     if ((startT == 0 || endT == 0) && (startT == 1 || endT == 1)) {
         // don't compute midpoints if we already have them
         if (fVerb == SkPath::kQuad_Verb) {
-            (*result)[1].set(fPts[1]);
+            edge->fLine[1].set(fPts[1]);
+            return false;
+        }
+        if (fVerb == SkPath::kConic_Verb) {
+            edge->fConic[1].set(fPts[1]);
+            edge->fConic.fWeight = fWeight;
             return false;
         }
         SkASSERT(fVerb == SkPath::kCubic_Verb);
         if (startT == 0) {
-            (*result)[1].set(fPts[1]);
-            (*result)[2].set(fPts[2]);
+            edge->fCubic[1].set(fPts[1]);
+            edge->fCubic[2].set(fPts[2]);
             return false;
         }
-        (*result)[1].set(fPts[2]);
-        (*result)[2].set(fPts[1]);
+        edge->fCubic[1].set(fPts[2]);
+        edge->fCubic[2].set(fPts[1]);
         return false;
     }
     if (fVerb == SkPath::kQuad_Verb) {
-        (*result)[1] = SkDQuad::SubDivide(fPts, (*result)[0], (*result)[2], startT, endT);
+        edge->fQuad[1] = SkDQuad::SubDivide(fPts, edge->fQuad[0], edge->fQuad[2], startT, endT);
+    } else if (fVerb == SkPath::kConic_Verb) {
+        edge->fConic[1] = SkDConic::SubDivide(fPts, fWeight, edge->fQuad[0], edge->fQuad[2],
+            startT, endT, &edge->fConic.fWeight);
     } else {
         SkASSERT(fVerb == SkPath::kCubic_Verb);
-        SkDCubic::SubDivide(fPts, (*result)[0], (*result)[3], startT, endT, &(*result)[1]);
+        SkDCubic::SubDivide(fPts, edge->fCubic[0], edge->fCubic[3], startT, endT, &edge->fCubic[1]);
     }
     return true;
 }
 
 void SkOpSegment::subDivideBounds(const SkOpSpanBase* start, const SkOpSpanBase* end,
         SkPathOpsBounds* bounds) const {
-    SkPoint edge[4];
-    subDivide(start, end, edge);
-    (bounds->*SetCurveBounds[SkPathOpsVerbToPoints(fVerb)])(edge);
+    SkOpCurve edge;
+    subDivide(start, end, &edge);
+    (bounds->*SetCurveBounds[fVerb])(edge.fPts, edge.fWeight);
 }
 
 void SkOpSegment::undoneSpan(SkOpSpanBase** start, SkOpSpanBase** end) {
     SkOpSpan* span = this->head();
     do {
         if (!span->done()) {
             break;
         }
     } while ((span = span->next()->upCastable()));
     SkASSERT(span);
@@ skipping 68 matching lines @@
         return SK_MinS32;
     }
     int winding = crossOpp ? span->oppSum() : span->windSum();
     SkASSERT(winding != SK_MinS32);
     int windVal = crossOpp ? span->oppValue() : span->windValue();
 #if DEBUG_WINDING_AT_T
     SkDebugf("%s id=%d opp=%d tHit=%1.9g t=%1.9g oldWinding=%d windValue=%d", __FUNCTION__,
             debugID(), crossOpp, tHit, span->t(), winding, windVal);
 #endif
     // see if a + change in T results in a +/- change in X (compute x'(T))
-    *dx = (*CurveSlopeAtT[SkPathOpsVerbToPoints(fVerb)])(fPts, tHit).fX;
+    *dx = (*CurveSlopeAtT[fVerb])(fPts, fWeight, tHit).fX;
     if (fVerb > SkPath::kLine_Verb && approximately_zero(*dx)) {
         *dx = fPts[2].fX - fPts[1].fX - *dx;
     }
     if (*dx == 0) {
 #if DEBUG_WINDING_AT_T
         SkDebugf(" dx=0 winding=SK_MinS32\n");
 #endif
         return SK_MinS32;
     }
     if (windVal < 0) {  // reverse sign if opp contour traveled in reverse
             *dx = -*dx;
     }
     if (winding * *dx > 0) {  // if same signs, result is negative
         winding += *dx > 0 ? -windVal : windVal;
     }
 #if DEBUG_WINDING_AT_T
     SkDebugf(" dx=%c winding=%d\n", *dx > 0 ? '+' : '-', winding);
 #endif
     return winding;
 }
 
 int SkOpSegment::windSum(const SkOpAngle* angle) const {
     const SkOpSpan* minSpan = angle->start()->starter(angle->end());
     return minSpan->windSum();
 }