align top and bounds computations

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 84 matching lines @@
 }
 
 SkOpAngle* SkOpSegment::activeAngleOther(SkOpSpanBase* start, SkOpSpanBase** startPtr,
         SkOpSpanBase** endPtr, bool* done, bool* sortable) {
     SkOpPtT* oPtT = start->ptT()->next();
     SkOpSegment* other = oPtT->segment();
     SkOpSpanBase* oSpan = oPtT->span();
     return other->activeAngleInner(oSpan, startPtr, endPtr, done, sortable);
 }
 
-SkPoint SkOpSegment::activeLeftTop(SkOpSpanBase** firstSpan) {
+SkDPoint SkOpSegment::activeLeftTop(SkOpSpanBase** firstSpan) {
     SkASSERT(!done());
-    SkPoint topPt = {SK_ScalarMax, SK_ScalarMax};
+    SkDPoint topPt = {SK_ScalarMax, SK_ScalarMax};
     // see if either end is not done since we want smaller Y of the pair
     bool lastDone = true;
     SkOpSpanBase* span = &fHead;
     SkOpSpanBase* lastSpan = NULL;
     do {
         if (!lastDone || (!span->final() && !span->upCast()->done())) {
             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
-                    && fCubicType != SkDCubic::kSplitAtMaxCurvature_SkDCubicType) {
+            if (fVerb != SkPath::kLine_Verb && !lastDone) {
                 double curveTopT;
-                SkPoint curveTop = (*CurveTop[fVerb])(fPts, fWeight, lastSpan->t(), span->t(),
+                SkDCurve curve;
+                this->subDivide(lastSpan, span, &curve);
+                SkDPoint curveTop = (curve.*Top[fVerb])(fPts, fWeight, lastSpan->t(), span->t(),
                         &curveTopT);
                 if (topPt.fY > curveTop.fY || (topPt.fY == curveTop.fY && topPt.fX > curveTop.fX)) {
                     topPt = curveTop;
                     if (firstSpan) {
                         const SkPoint& lastXY = lastSpan->pt();
                         *firstSpan = lastXY.fY > xy.fY || (lastXY.fY == xy.fY && lastXY.fX > xy.fX)
                                 ? span : lastSpan;
                     }
                 }
             }
@@ skipping 950 matching lines @@
     const SkOpAngle* angle = baseAngle;
 #if DEBUG_SWAP_TOP
     SkDebugf("-%s- baseAngle\n", __FUNCTION__);
     baseAngle->debugLoop();
 #endif
     do {
         if (!angle->unorderable()) {
             const SkOpSegment* next = angle->segment();
             SkPathOpsBounds bounds;
             next->subDivideBounds(angle->end(), angle->start(), &bounds);
-            bool nearSame = AlmostEqualUlps(top, bounds.top());
-            bool lowerSector = !firstAngle || angle->sectorEnd() < firstAngle->sectorStart();
-            bool lesserSector = top > bounds.fTop;
-            if (lesserSector && (!nearSame || lowerSector)) {
+            if (top > bounds.fTop) {
                 top = bounds.fTop;
                 firstAngle = angle;
             }
         }
         angle = angle->next();
     } while (angle != baseAngle);
     if (!firstAngle) {
         return NULL;  // if all are unorderable, give up
     }
 #if DEBUG_SWAP_TOP
@@ skipping 336 matching lines @@
     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();
+    if (dst.monotonicInY()) {
+        return true;
+    }
+    SkDCubic whole;
+    whole.set(fPts);
+    return whole.monotonicInY();
 }
 
 bool SkOpSegment::NextCandidate(SkOpSpanBase* span, SkOpSpanBase** start,
         SkOpSpanBase** end) {
     while (span->final() || span->upCast()->done()) {
         if (span->final()) {
             return false;
         }
         span = span->upCast()->next();
     }
@@ skipping 550 matching lines @@
             startT, endT, &edge->fConic.fWeight);
     } else {
         SkASSERT(fVerb == SkPath::kCubic_Verb);
         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 {
-    SkOpCurve edge;
+    SkDCurve edge;
     subDivide(start, end, &edge);
-    (bounds->*SetCurveBounds[fVerb])(edge.fPts, edge.fWeight);
+    (edge.*SetBounds[fVerb])(fPts, fWeight, start->t(), end->t(), bounds);
+}
+
+SkDPoint SkOpSegment::top(const SkOpSpanBase* start, const SkOpSpanBase* end, double* topT) const {
+    SkDCurve edge;
+    subDivide(start, end, &edge);
+    return (edge.*Top[fVerb])(fPts, fWeight, start->t(), end->t(), topT);
 }
 
 void SkOpSegment::undoneSpan(SkOpSpanBase** start, SkOpSpanBase** end) {
     SkOpSpan* span = this->head();
     do {
         if (!span->done()) {
             break;
         }
     } while ((span = span->next()->upCastable()));
     SkASSERT(span);
@@ skipping 94 matching lines @@
 #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();
 }