optimize pathops coverage

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 "SkIntersections.h"
 #include "SkOpSegment.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
@@ skipping 389 matching lines @@
     fBounds.setQuadBounds(pts);
 }
 
     // Defer all coincident edge processing until
     // after normal intersections have been computed
 
 // no need to be tricky; insert in normal T order
 // resolve overlapping ts when considering coincidence later
 
     // add non-coincident intersection. Resulting edges are sorted in T.
-int SkOpSegment::addT(SkOpSegment* other, const SkPoint& pt, double newT, bool isNear) {
+int SkOpSegment::addT(SkOpSegment* other, const SkPoint& pt, double newT) {
     if (precisely_zero(newT)) {
         newT = 0;
     } else if (precisely_equal(newT, 1)) {
         newT = 1;
     }
     // FIXME: in the pathological case where there is a ton of intercepts,
     //  binary search?
     int insertedAt = -1;
     size_t tCount = fTs.count();
     const SkPoint& firstPt = fPts[0];
@@ skipping 24 matching lines @@
     SkOpSpan* span;
     if (insertedAt >= 0) {
         span = fTs.insert(insertedAt);
     } else {
         insertedAt = tCount;
         span = fTs.append();
     }
     span->fT = newT;
     span->fOther = other;
     span->fPt = pt;
-    span->fNear = isNear;
 #if 0
     // cubics, for instance, may not be exact enough to satisfy this check (e.g., cubicOp69d)
     SkASSERT(approximately_equal(xyAtT(newT).fX, pt.fX)
             && approximately_equal(xyAtT(newT).fY, pt.fY));
 #endif
     span->fWindSum = SK_MinS32;
     span->fOppSum = SK_MinS32;
     span->fWindValue = 1;
     span->fOppValue = 0;
     span->fSmall = false;
@@ skipping 173 matching lines @@
             addCancelOutsides(outsidePts[outCount - 2], outsidePts[outCount - 1], other);
         }
     }
     if (!other->done() && oOutsidePts.count()) {
         other->addCancelOutsides(oOutsidePts[0], oOutsidePts[1], this);
     }
 }
 
 int SkOpSegment::addSelfT(SkOpSegment* other, const SkPoint& pt, double newT) {
     // if the tail nearly intersects itself but not quite, the caller records this separately
-    int result = addT(other, pt, newT, SkOpSpan::kPointIsExact);
+    int result = addT(other, pt, newT);
     SkOpSpan* span = &fTs[result];
     span->fLoop = true;
     return result;
 }
 
 void SkOpSegment::bumpCoincidentThis(const SkOpSpan& oTest, bool binary, int* indexPtr,
         SkTArray<SkPoint, true>* outsideTs) {
     int index = *indexPtr;
     int oWindValue = oTest.fWindValue;
     int oOppValue = oTest.fOppValue;
     if (binary) {
         SkTSwap<int>(oWindValue, oOppValue);
     }
     SkOpSpan* const test = &fTs[index];
     SkOpSpan* end = test;
     const SkPoint& oStartPt = oTest.fPt;
     do {
         if (bumpSpan(end, oWindValue, oOppValue)) {
             TrackOutside(outsideTs, oStartPt);
         }
         end = &fTs[++index];
     } while ((end->fPt == test->fPt || end->fT == test->fT) && end->fT < 1);
     *indexPtr = index;
 }
 
-bool SkOpSegment::bumpCoincident(SkOpSpan* test, bool bigger, bool binary) {
-    if (bigger) {
-        if (binary) {
-            if (fOppXor) {
-                test->fOppValue ^= 1;
-            } else {
-                test->fOppValue++;
-            }
-        } else {
-            if (fXor) {
-                test->fWindValue ^= 1;
-            } else {
-                test->fWindValue++;
-            }
-        }
-        if (!test->fWindValue && !test->fOppValue) {
-            test->fDone = true;
-            ++fDoneSpans;
-            return true;
-        }
-        return false;
-    }
-    return decrementSpan(test);
-}
-
 // because of the order in which coincidences are resolved, this and other
 // may not have the same intermediate points. Compute the corresponding
 // intermediate T values (using this as the master, other as the follower)
 // and walk other conditionally -- hoping that it catches up in the end
 void SkOpSegment::bumpCoincidentOther(const SkOpSpan& test, int* oIndexPtr,
         SkTArray<SkPoint, true>* oOutsidePts) {
     int oIndex = *oIndexPtr;
     SkOpSpan* const oTest = &fTs[oIndex];
     SkOpSpan* oEnd = oTest;
     const SkPoint& startPt = test.fPt;
@@ skipping 133 matching lines @@
             SkDebugf("%s addTPair duplicate this=%d %1.9g other=%d %1.9g\n",
                     __FUNCTION__, fID, t, other->fID, otherT);
 #endif
             return;
         }
     }
 #if DEBUG_ADD_T_PAIR
     SkDebugf("%s addTPair this=%d %1.9g other=%d %1.9g\n",
             __FUNCTION__, fID, t, other->fID, otherT);
 #endif
-    int insertedAt = addT(other, pt, t, SkOpSpan::kPointIsExact);
-    int otherInsertedAt = other->addT(this, pt, otherT, SkOpSpan::kPointIsExact);
+    int insertedAt = addT(other, pt, t);
+    int otherInsertedAt = other->addT(this, pt, otherT);
     addOtherT(insertedAt, otherT, otherInsertedAt);
     other->addOtherT(otherInsertedAt, t, insertedAt);
     matchWindingValue(insertedAt, t, borrowWind);
     other->matchWindingValue(otherInsertedAt, otherT, borrowWind);
 }
 
 void SkOpSegment::addTwoAngles(int start, int end, SkTArray<SkOpAngle, true>* angles) const {
     // add edge leading into junction
     int min = SkMin32(end, start);
     if (fTs[min].fWindValue > 0 || fTs[min].fOppValue != 0) {
         addAngle(angles, end, start);
     }
     // add edge leading away from junction
     int step = SkSign32(end - start);
     int tIndex = nextExactSpan(end, step);
     min = SkMin32(end, tIndex);
     if (tIndex >= 0 && (fTs[min].fWindValue > 0 || fTs[min].fOppValue != 0)) {
         addAngle(angles, end, tIndex);
     }
 }
 
-SkOpSegment::MissingSpan::Command SkOpSegment::adjustThisNear(double startT, const SkPoint& startPt,
-            const SkPoint& endPt, SkTArray<MissingSpan, true>* missingSpans) {
-    // see if endPt exists on this curve, and if it has the same t or a different T than the startT
-    int count = this->count();
-    SkASSERT(count > 0);
-    int startIndex, endIndex, step;
-    if (startT == 0) {
-        startIndex = 0;
-        endIndex = count;
-        step = 1;
-    } else {
-        SkASSERT(startT == 1);
-        startIndex = count - 1;
-        endIndex = -1;
-        step = -1;
-    }
-    int index = startIndex;
-    do {
-        const SkOpSpan& span = fTs[index];
-        if (span.fPt != endPt) {
-            continue;
-        }
-        if (span.fT == startT) {
-            // check to see if otherT matches some other mid curve intersection
-            int inner = startIndex;
-            do {
-                if (inner == index) {
-                    continue;
-                }
-                const SkOpSpan& matchSpan = fTs[inner];
-                double matchT = span.fOther->missingNear(span.fOtherT, matchSpan.fOther, startPt,
-                        endPt);
-                if (matchT >= 0) {
-                    SkASSERT(missingSpans);
-                    MissingSpan& missingSpan = missingSpans->push_back();
-                    SkDEBUGCODE(sk_bzero(&missingSpan, sizeof(missingSpan)));
-                    missingSpan.fCommand = MissingSpan::kRemoveNear;
-                    missingSpan.fT = startT;
-                    missingSpan.fSegment = this;
-                    missingSpan.fOther = span.fOther;
-                    missingSpan.fOtherT = matchT;
-                    return missingSpan.fCommand;
-                }
-            } while ((inner += step) != endIndex);
-            break;
-        }
-        double midT = (startT + span.fT) / 2;
-        if (betweenPoints(midT, startPt, endPt)) {
-            if (!missingSpans) {
-                return MissingSpan::kZeroSpan;
-            }
-            MissingSpan& missingSpan = missingSpans->push_back();
-            SkDEBUGCODE(sk_bzero(&missingSpan, sizeof(missingSpan)));
-            missingSpan.fCommand = MissingSpan::kZeroSpan;
-            missingSpan.fT = SkTMin(startT, span.fT);
-            missingSpan.fEndT = SkTMax(startT, span.fT);
-            missingSpan.fSegment = this;
-            return missingSpan.fCommand;
-        }
-    } while ((index += step) != endIndex);
-    return MissingSpan::kNoAction;
-}
-
-void SkOpSegment::adjustOtherNear(double startT, const SkPoint& startPt, const SkPoint& endPt,
-        SkTArray<MissingSpan, true>* missingSpans) {
-    int count = this->count();
-    SkASSERT(count > 0);
-    int startIndex, endIndex, step;
-    if (startT == 0) {
-        startIndex = 0;
-        endIndex = count;
-        step = 1;
-    } else {
-        SkASSERT(startT == 1);
-        startIndex = count - 1;
-        endIndex = -1;
-        step = -1;
-    }
-    int index = startIndex;
-    do {
-        const SkOpSpan& span = fTs[index];
-        if (span.fT != startT) {
-            return;
-        }
-        SkOpSegment* other = span.fOther;
-        if (other->fPts[0] == endPt) {
-            other->adjustThisNear(0, endPt, startPt, missingSpans);
-        } else if (other->fPts[0] == startPt) {
-            other->adjustThisNear(0, startPt, endPt, missingSpans);
-        }
-        if (other->ptAtT(1) == endPt) {
-            other->adjustThisNear(1, endPt, startPt, missingSpans);
-        } else if (other->ptAtT(1) == startPt) {
-            other->adjustThisNear(1, startPt, endPt, missingSpans);
-        }
-    } while ((index += step) != endIndex);
-}
-
-void SkOpSegment::adjustMissingNear(const SkPoint& startPt, const SkPoint& endPt,
-        SkTArray<MissingSpan, true>* missingSpans) {
-    int count = missingSpans->count();
-    for (int index = 0; index < count; ) {
-        MissingSpan& missing = (*missingSpans)[index];
-        SkOpSegment* other = missing.fOther;
-        MissingSpan::Command command = MissingSpan::kNoAction;
-        if (missing.fPt == startPt) {
-            if (missingNear(missing.fT, other, startPt, endPt) >= 0) {
-                command = MissingSpan::kZeroSpan;
-            } else if (other->ptAtT(0) == endPt) {
-                command = other->adjustThisNear(0, endPt, startPt, NULL);
-            } else if (other->ptAtT(1) == endPt) {
-                command = other->adjustThisNear(1, endPt, startPt, NULL);
-            }
-        } else if (missing.fPt == endPt) {
-            if (missingNear(missing.fT, other, endPt, startPt) >= 0) {
-                command = MissingSpan::kZeroSpan;
-            } else if (other->ptAtT(0) == startPt) {
-                command = other->adjustThisNear(0, startPt, endPt, NULL);
-            } else if (other->ptAtT(1) == startPt) {
-                command = other->adjustThisNear(1, startPt, endPt, NULL);
-            }
-        }
-        if (command == MissingSpan::kZeroSpan) {
-#if 1
-            missing = missingSpans->back();
-            missingSpans->pop_back();
-#else // if this is supported in the future ...
-            missingSpans->removeShuffle(index);
-#endif
-            --count;
-            continue;
-        }
-        ++index;
-    }
-}
-
-void SkOpSegment::adjustNear(double startT, const SkPoint& endPt,
-        SkTArray<MissingSpan, true>* missingSpans) {
-    const SkPoint startPt = ptAtT(startT);
-    adjustMissingNear(startPt, endPt, missingSpans);
-    adjustThisNear(startT, startPt, endPt, missingSpans);
-    adjustOtherNear(startT, startPt, endPt, missingSpans);
-}
-
-int SkOpSegment::advanceCoincidentThis(int index) {
-    SkOpSpan* const test = &fTs[index];
-    SkOpSpan* end;
-    do {
-        end = &fTs[++index];
-    } while (approximately_negative(end->fT - test->fT));
-    return index;
-}
-
-int SkOpSegment::advanceCoincidentOther(double oEndT, int oIndex) {
-    SkOpSpan* const oTest = &fTs[oIndex];
-    SkOpSpan* oEnd = oTest;
-    const double oStartT = oTest->fT;
-    while (!approximately_negative(oEndT - oEnd->fT)
-            && approximately_negative(oEnd->fT - oStartT)) {
-        oEnd = &fTs[++oIndex];
-    }
-    return oIndex;
-}
-
 bool SkOpSegment::betweenPoints(double midT, const SkPoint& pt1, const SkPoint& pt2) const {
     const SkPoint midPt = ptAtT(midT);
     SkPathOpsBounds bounds;
     bounds.set(pt1.fX, pt1.fY, pt2.fX, pt2.fY);
     bounds.sort();
     return bounds.almostContains(midPt);
 }
 
 bool SkOpSegment::betweenTs(int lesser, double testT, int greater) const {
     if (lesser > greater) {
@@ skipping 178 matching lines @@
         }
     }
     SkOpSegment* nextSegment = nextAngle->segment();
     int maxWinding, sumWinding;
     SkOpSpan* last;
     if (binary) {
         int oppMaxWinding, oppSumWinding;
         nextSegment->setUpWindings(nextAngle->start(), nextAngle->end(), &sumMiWinding,
                 &sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
         last = nextSegment->markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding,
-                true, nextAngle);
+                nextAngle);
     } else {
         nextSegment->setUpWindings(nextAngle->start(), nextAngle->end(), &sumMiWinding,
                 &maxWinding, &sumWinding);
-        last = nextSegment->markAngle(maxWinding, sumWinding, true, nextAngle);
+        last = nextSegment->markAngle(maxWinding, sumWinding, nextAngle);
     }
     nextAngle->setLastMarked(last);
 }
 
 void SkOpSegment::ComputeOneSumReverse(const SkOpAngle* baseAngle, SkOpAngle* nextAngle,
         SkOpAngle::IncludeType includeType) {
     const SkOpSegment* baseSegment = baseAngle->segment();
     int sumMiWinding = baseSegment->updateWinding(baseAngle);
     int sumSuWinding;
     bool binary = includeType >= SkOpAngle::kBinarySingle;
     if (binary) {
         sumSuWinding = baseSegment->updateOppWinding(baseAngle);
         if (baseSegment->operand()) {
             SkTSwap<int>(sumMiWinding, sumSuWinding);
         }
     }
     SkOpSegment* nextSegment = nextAngle->segment();
     int maxWinding, sumWinding;
     SkOpSpan* last;
     if (binary) {
         int oppMaxWinding, oppSumWinding;
         nextSegment->setUpWindings(nextAngle->end(), nextAngle->start(), &sumMiWinding,
                 &sumSuWinding, &maxWinding, &sumWinding, &oppMaxWinding, &oppSumWinding);
         last = nextSegment->markAngle(maxWinding, sumWinding, oppMaxWinding, oppSumWinding,
-                true, nextAngle);
+                nextAngle);
     } else {
         nextSegment->setUpWindings(nextAngle->end(), nextAngle->start(), &sumMiWinding,
                 &maxWinding, &sumWinding);
-        last = nextSegment->markAngle(maxWinding, sumWinding, true, nextAngle);
+        last = nextSegment->markAngle(maxWinding, sumWinding, nextAngle);
     }
     nextAngle->setLastMarked(last);
 }
 
 int SkOpSegment::crossedSpanY(const SkPoint& basePt, SkScalar* bestY, double* hitT,
                               bool* hitSomething, double mid, bool opp, bool current) const {
     SkScalar bottom = fBounds.fBottom;
     int bestTIndex = -1;
     if (bottom <= *bestY) {
         return bestTIndex;
@@ skipping 180 matching lines @@
                         goto nextPeekIndex;
                     }
                     double midT = (tSpan.fOtherT + matchT) / 2;
                     if (match->betweenPoints(midT, tSpan.fPt, peekSpan.fPt)) {
                         goto nextPeekIndex;
                     }
                 }
             }
             if (missingSpans.count() > 0) {
                 const MissingSpan& lastMissing = missingSpans.back();
-                if (lastMissing.fCommand == MissingSpan::kAddMissing
-                        && lastMissing.fT == t
+                if (lastMissing.fT == t
                         && lastMissing.fOther == match
                         && lastMissing.fOtherT == matchT) {
                     SkASSERT(lastMissing.fPt == peekSpan.fPt);
                     continue;
                 }
             }
 #if DEBUG_CHECK_ENDS
             SkDebugf("%s id=%d missing t=%1.9g other=%d otherT=%1.9g pt=(%1.9g,%1.9g)\n",
                     __FUNCTION__, fID, t, match->fID, matchT, peekSpan.fPt.fX, peekSpan.fPt.fY);
 #endif
             // this segment is missing a entry that the other contains
             // remember so we can add the missing one and recompute the indices
             {
                 MissingSpan& missing = missingSpans.push_back();
                 SkDEBUGCODE(sk_bzero(&missing, sizeof(missing)));
-                missing.fCommand = MissingSpan::kAddMissing;
                 missing.fT = t;
                 missing.fOther = match;
                 missing.fOtherT = matchT;
                 missing.fPt = peekSpan.fPt;
             }
             break;
 nextPeekIndex:
             ;
         }
     }
     if (missingSpans.count() == 0) {
         debugValidate();
         return;
     }
-    // if one end is near the other point, look for a coincident span
-    for (int index = 0; index < count; ++index) {
-        const SkOpSpan& span = fTs[index];
-        if (span.fT > 0) {
-            break;
-        }
-        const SkOpSpan& otherSpan = span.fOther->span(span.fOtherIndex);
-        if (span.fNear) {
-            SkASSERT(otherSpan.fPt == fPts[0]);
-            adjustNear(0, span.fPt, &missingSpans);
-            continue;
-        }
-        if (otherSpan.fNear) {
-            SkASSERT(span.fPt == fPts[0]);
-            adjustNear(0, otherSpan.fPt, &missingSpans);
-        }
-    }
-    for (int index = count; --index >= 0; ) {
-        const SkOpSpan& span = fTs[index];
-        if (span.fT < 1) {
-            break;
-        }
-        const SkOpSegment* other = span.fOther;
-        if (span.fNear) {
-            SkASSERT(other->ptAtT(span.fOtherT) == ptAtT(1));
-            const SkPoint& otherPt = other->xyAtT(span.fOtherIndex);
-            SkASSERT(otherPt != ptAtT(1));
-            adjustNear(1, otherPt, &missingSpans);
-            continue;
-        }
-        const SkOpSpan& otherSpan = other->span(span.fOtherIndex);
-        if (otherSpan.fNear) {
-            SkASSERT(otherSpan.fPt == ptAtT(1));
-            SkPoint otherPt = other->ptAtT(span.fOtherT);
-            SkASSERT(otherPt != ptAtT(1));
-            adjustNear(1, otherPt, &missingSpans);
-        }
-    }
     debugValidate();
     int missingCount = missingSpans.count();
     for (int index = 0; index < missingCount; ++index)  {
         MissingSpan& missing = missingSpans[index];
-        switch (missing.fCommand) {
-            case MissingSpan::kNoAction:
-                break;
-            case MissingSpan::kAddMissing:
-                addTPair(missing.fT, missing.fOther, missing.fOtherT, false, missing.fPt);
-                break;
-            case MissingSpan::kRemoveNear: {
-                SkOpSegment* segment = missing.fSegment;
-                int count = segment->count();
-                for (int inner = 0; inner < count; ++inner) {
-                    const SkOpSpan& span = segment->span(inner);
-                    if (span.fT != missing.fT && span.fOther != missing.fOther) {
-                        continue;
-                    }
-                    SkASSERT(span.fNear);
-                    SkOpSegment* other = span.fOther;
-                    int otherCount = other->count();
-                    for (int otherIndex = 0; otherIndex < otherCount; ++otherIndex) {
-                        const SkOpSpan& otherSpan = other->span(otherIndex);
-                        if (otherSpan.fT == span.fOtherT && otherSpan.fOther == segment
-                                && otherSpan.fOtherT == span.fT) {
-                            if (otherSpan.fDone) {
-                                other->fDoneSpans--;
-                            }
-                            other->fTs.remove(otherIndex);
-                            // FIXME: remove may leave a tiny dangling -- recompute tiny w/index
-                            break;
-                        }
-                    }
-                    if (span.fDone) {
-                        segment->fDoneSpans--;
-                    }
-                    segment->fTs.remove(inner);
-                    // FIXME: remove may leave a tiny dangling -- recompute tiny w/index
-                    break;
-                }
-                break;
-            }
-            case MissingSpan::kZeroSpan: {
-                SkOpSegment* segment = missing.fSegment;
-                int count = segment->count();
-                for (int inner = 0; inner < count; ++inner) {
-                    SkOpSpan& span = segment->fTs[inner];
-                    if (span.fT < missing.fT) {
-                        continue;
-                    }
-                    if (span.fT >= missing.fEndT) {
-                        break;
-                    }
-                    span.fWindValue = span.fOppValue = 0;
-                    if (!span.fDone) {
-                        span.fDone = true;
-                        ++segment->fDoneSpans;
-                    }
-                }
-                break;
-            }
-        }
+        addTPair(missing.fT, missing.fOther, missing.fOtherT, false, missing.fPt);
     }
     fixOtherTIndex();
     // OPTIMIZATION: this may fix indices more than once. Build an array of unique segments to
     // avoid this
     for (int index = 0; index < missingCount; ++index)  {
-        const MissingSpan& missing = missingSpans[index];
-        switch (missing.fCommand) {
-            case MissingSpan::kNoAction:
-                break;
-            case MissingSpan::kAddMissing:
-                missing.fOther->fixOtherTIndex();
-                break;
-            case MissingSpan::kRemoveNear:
-                missing.fSegment->fixOtherTIndex();
-                missing.fOther->fixOtherTIndex();
-                break;
-            case MissingSpan::kZeroSpan:
-                break;
-        }
+        missingSpans[index].fOther->fixOtherTIndex();
     }
     debugValidate();
 }
 
 bool SkOpSegment::checkSmall(int index) const {
     if (fTs[index].fSmall) {
         return true;
     }
     double tBase = fTs[index].fT;
     while (index > 0 && precisely_negative(tBase - fTs[--index].fT))
@@ skipping 47 matching lines @@
                     continue;
                 }
 #if DEBUG_CHECK_TINY
                 SkDebugf("%s [%d] add coincidence [%d] [%d]\n", __FUNCTION__, fID,
                     thisOther->fID, nextOther->fID);
 #endif
                 // this segment is missing a entry that the other contains
                 // remember so we can add the missing one and recompute the indices
                 MissingSpan& missing = missingSpans.push_back();
                 SkDEBUGCODE(sk_bzero(&missing, sizeof(missing)));
-                missing.fCommand = MissingSpan::kAddMissing;
                 missing.fSegment = thisOther;
                 missing.fT = thisSpan->fOtherT;
                 missing.fOther = nextOther;
                 missing.fOtherT = nextSpan->fOtherT;
                 missing.fPt = thisSpan->fPt;
             }
         }
     }
     int missingCount = missingSpans.count();
     if (!missingCount) {
@@ skipping 698 matching lines @@
 
 bool SkOpSegment::isTiny(int index) const {
     return fTs[index].fTiny;
 }
 
 // look pair of active edges going away from coincident edge
 // one of them should be the continuation of other
 // if both are active, look to see if they both the connect to another coincident pair
 // if one at least one is a line, then make the pair coincident
 // if neither is a line, test for coincidence
-bool SkOpSegment::joinCoincidence(bool end, SkOpSegment* other, double otherT, int step,
+bool SkOpSegment::joinCoincidence(SkOpSegment* other, double otherT, int step,
         bool cancel) {
     int otherTIndex = other->findT(otherT, this);
     int next = other->nextExactSpan(otherTIndex, step);
     int otherMin = SkTMin(otherTIndex, next);
     int otherWind = other->span(otherMin).fWindValue;
     if (otherWind == 0) {
         return false;
     }
     SkASSERT(next >= 0);
-    if (end) {
-        int tIndex = count() - 1;
-        do {
-            SkOpSpan* test = &fTs[tIndex];
-            SkASSERT(test->fT == 1);
-            if (test->fOther == other || test->fOtherT != 0) {
-                continue;
+    int tIndex = 0;
+    do {
+        SkOpSpan* test = &fTs[tIndex];
+        SkASSERT(test->fT == 0);
+        if (test->fOther == other || test->fOtherT != 1) {
+            continue;
+        }
+        SkPoint startPt, endPt;
+        double endT;
+        if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) {
+            SkOpSegment* match = test->fOther;
+            if (cancel) {
+                match->addTCancel(startPt, endPt, other);
+            } else {
+                match->addTCoincident(startPt, endPt, endT, other);
             }
-            SkPoint startPt, endPt;
-            double endT;
-            if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) {
-                SkOpSegment* match = test->fOther;
-                if (cancel) {
-                    match->addTCancel(startPt, endPt, other);
-                } else {
-                    match->addTCoincident(startPt, endPt, endT, other);
-                }
-                return true;
-            }
-        } while (fTs[--tIndex].fT == 1);
-    } else {
-        int tIndex = 0;
-        do {
-            SkOpSpan* test = &fTs[tIndex];
-            SkASSERT(test->fT == 0);
-            if (test->fOther == other || test->fOtherT != 1) {
-                continue;
-            }
-            SkPoint startPt, endPt;
-            double endT;
-            if (findCoincidentMatch(test, other, otherTIndex, next, step, &startPt, &endPt, &endT)) {
-                SkOpSegment* match = test->fOther;
-                if (cancel) {
-                    match->addTCancel(startPt, endPt, other);
-                } else {
-                    match->addTCoincident(startPt, endPt, endT, other);
-                }
-                return true;
-            }
-        } while (fTs[++tIndex].fT == 0);
-    }
+            return true;
+        }
+    } while (fTs[++tIndex].fT == 0);
     return false;
 }
 
 // this span is excluded by the winding rule -- chase the ends
 // as long as they are unambiguous to mark connections as done
 // and give them the same winding value
-SkOpSpan* SkOpSegment::markAndChaseDone(int index, int endIndex, int winding) {
-    int step = SkSign32(endIndex - index);
-    int min = SkMin32(index, endIndex);
-    markDone(min, winding);
-    SkOpSpan* last;
-    SkOpSegment* other = this;
-    while ((other = other->nextChase(&index, step, &min, &last))) {
-        other->markDone(min, winding);
-    }
-    return last;
-}
-
-SkOpSpan* SkOpSegment::markAndChaseDoneBinary(const SkOpAngle* angle, int winding, int oppWinding) {
-    int index = angle->start();
-    int endIndex = angle->end();
-    int step = SkSign32(endIndex - index);
-    int min = SkMin32(index, endIndex);
-    markDoneBinary(min, winding, oppWinding);
-    SkOpSpan* last;
-    SkOpSegment* other = this;
-    while ((other = other->nextChase(&index, step, &min, &last))) {
-        other->markDoneBinary(min, winding, oppWinding);
-    }
-    return last;
-}
 
 SkOpSpan* SkOpSegment::markAndChaseDoneBinary(int index, int endIndex) {
     int step = SkSign32(endIndex - index);
     int min = SkMin32(index, endIndex);
     markDoneBinary(min);
     SkOpSpan* last;
     SkOpSegment* other = this;
     while ((other = other->nextChase(&index, step, &min, &last))) {
         if (other->done()) {
             return NULL;
@@ skipping 11 matching lines @@
     SkOpSegment* other = this;
     while ((other = other->nextChase(&index, step, &min, &last))) {
         if (other->done()) {
             return NULL;
         }
         other->markDoneUnary(min);
     }
     return last;
 }
 
-SkOpSpan* SkOpSegment::markAndChaseDoneUnary(const SkOpAngle* angle, int winding) {
-    int index = angle->start();
-    int endIndex = angle->end();
-    return markAndChaseDone(index, endIndex, winding);
-}
-
 SkOpSpan* SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, const int winding) {
     int index = angle->start();
     int endIndex = angle->end();
     int step = SkSign32(endIndex - index);
     int min = SkMin32(index, endIndex);
     markWinding(min, winding);
     SkOpSpan* last;
     SkOpSegment* other = this;
     while ((other = other->nextChase(&index, step, &min, &last))) {
         if (other->fTs[min].fWindSum != SK_MinS32) {
@@ skipping 20 matching lines @@
     }
     return last;
 }
 
 SkOpSpan* SkOpSegment::markAndChaseWinding(const SkOpAngle* angle, int winding, int oppWinding) {
     int start = angle->start();
     int end = angle->end();
     return markAndChaseWinding(start, end, winding, oppWinding);
 }
 
-SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, bool activeAngle,
-                                const SkOpAngle* angle) {
+SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, const SkOpAngle* angle) {
     SkASSERT(angle->segment() == this);
     if (UseInnerWinding(maxWinding, sumWinding)) {
         maxWinding = sumWinding;
     }
-    SkOpSpan* last;
-    if (activeAngle) {
-        last = markAndChaseWinding(angle, maxWinding);
-    } else {
-        last = markAndChaseDoneUnary(angle, maxWinding);
-    }
+    SkOpSpan* last = markAndChaseWinding(angle, maxWinding);
 #if DEBUG_WINDING
     if (last) {
         SkDebugf("%s last id=%d windSum=", __FUNCTION__,
                 last->fOther->fTs[last->fOtherIndex].fOther->debugID());
         SkPathOpsDebug::WindingPrintf(last->fWindSum);
         SkDebugf(" small=%d\n", last->fSmall);
     }
 #endif
     return last;
 }
 
 SkOpSpan* SkOpSegment::markAngle(int maxWinding, int sumWinding, int oppMaxWinding,
-                                 int oppSumWinding, bool activeAngle, const SkOpAngle* angle) {
+                                 int oppSumWinding, const SkOpAngle* angle) {
     SkASSERT(angle->segment() == this);
     if (UseInnerWinding(maxWinding, sumWinding)) {
         maxWinding = sumWinding;
     }
     if (oppMaxWinding != oppSumWinding && UseInnerWinding(oppMaxWinding, oppSumWinding)) {
         oppMaxWinding = oppSumWinding;
     }
-    SkOpSpan* last;
-    if (activeAngle) {
-        last = markAndChaseWinding(angle, maxWinding, oppMaxWinding);
-    } else {
-        last = markAndChaseDoneBinary(angle, maxWinding, oppMaxWinding);
-    }
+    SkOpSpan* last = markAndChaseWinding(angle, maxWinding, oppMaxWinding);
 #if DEBUG_WINDING
     if (last) {
         SkDebugf("%s last id=%d windSum=", __FUNCTION__,
                 last->fOther->fTs[last->fOtherIndex].fOther->debugID());
         SkPathOpsDebug::WindingPrintf(last->fWindSum);
         SkDebugf(" small=%d\n", last->fSmall);
     }
 #endif
     return last;
 }
 
 // FIXME: this should also mark spans with equal (x,y)
 // This may be called when the segment is already marked done. While this
 // wastes time, it shouldn't do any more than spin through the T spans.
 // OPTIMIZATION: abort on first done found (assuming that this code is
 // always called to mark segments done).
 void SkOpSegment::markDone(int index, int winding) {
   //  SkASSERT(!done());
     SkASSERT(winding);
     double referenceT = fTs[index].fT;
     int lesser = index;
     while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
         markOneDone(__FUNCTION__, lesser, winding);
     }
     do {
         markOneDone(__FUNCTION__, index, winding);
     } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
 }
 
-void SkOpSegment::markDoneBinary(int index, int winding, int oppWinding) {
-  //  SkASSERT(!done());
-    SkASSERT(winding || oppWinding);
-    double referenceT = fTs[index].fT;
-    int lesser = index;
-    while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
-        markOneDoneBinary(__FUNCTION__, lesser, winding, oppWinding);
-    }
-    do {
-        markOneDoneBinary(__FUNCTION__, index, winding, oppWinding);
-    } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
-}
-
 void SkOpSegment::markDoneBinary(int index) {
     double referenceT = fTs[index].fT;
     int lesser = index;
     while (--lesser >= 0 && precisely_negative(referenceT - fTs[lesser].fT)) {
         markOneDoneBinary(__FUNCTION__, lesser);
     }
     do {
         markOneDoneBinary(__FUNCTION__, index);
     } while (++index < fTs.count() && precisely_negative(fTs[index].fT - referenceT));
 }
@@ skipping 20 matching lines @@
 
 void SkOpSegment::markOneDoneBinary(const char* funName, int tIndex) {
     SkOpSpan* span = verifyOneWinding(funName, tIndex);
     if (!span) {
         return;
     }
     span->fDone = true;
     fDoneSpans++;
 }
 
-void SkOpSegment::markOneDoneBinary(const char* funName, int tIndex, int winding, int oppWinding) {
-    SkOpSpan* span = markOneWinding(funName, tIndex, winding, oppWinding);
-    if (!span) {
-        return;
-    }
-    span->fDone = true;
-    fDoneSpans++;
-}
-
 void SkOpSegment::markOneDoneUnary(const char* funName, int tIndex) {
     SkOpSpan* span = verifyOneWindingU(funName, tIndex);
     if (!span) {
         return;
     }
     span->fDone = true;
     fDoneSpans++;
 }
 
 SkOpSpan* SkOpSegment::markOneWinding(const char* funName, int tIndex, int winding) {
@@ skipping 76 matching lines @@
 }
 
 SkOpSpan* SkOpSegment::verifyOneWinding(const char* funName, int tIndex) {
     SkOpSpan& span = fTs[tIndex];
     if (span.fDone) {
         return NULL;
     }
 #if DEBUG_MARK_DONE
     debugShowNewWinding(funName, span, span.fWindSum, span.fOppSum);
 #endif
-    SkASSERT(span.fWindSum != SK_MinS32);
-    SkASSERT(span.fOppSum != SK_MinS32);
+// If the prior angle in the sort is unorderable, the winding sum may not be computable.
+// To enable the assert, the 'prior is unorderable' state could be
+// piped down to this test, but not sure it's worth it.
+// (Once the sort order is stored in the span, this test may be feasible.)
+//    SkASSERT(span.fWindSum != SK_MinS32);
+//    SkASSERT(span.fOppSum != SK_MinS32);
     return &span;
 }
 
 SkOpSpan* SkOpSegment::verifyOneWindingU(const char* funName, int tIndex) {
     SkOpSpan& span = fTs[tIndex];
     if (span.fDone) {
         return NULL;
     }
 #if DEBUG_MARK_DONE
     debugShowNewWinding(funName, span, span.fWindSum);
 #endif
-    SkASSERT(span.fWindSum != SK_MinS32);
+// If the prior angle in the sort is unorderable, the winding sum may not be computable.
+// To enable the assert, the 'prior is unorderable' state could be
+// piped down to this test, but not sure it's worth it.
+// (Once the sort order is stored in the span, this test may be feasible.)
+//    SkASSERT(span.fWindSum != SK_MinS32);
     return &span;
 }
 
 // note that just because a span has one end that is unsortable, that's
 // not enough to mark it done. The other end may be sortable, allowing the
 // span to be added.
 // FIXME: if abs(start - end) > 1, mark intermediates as unsortable on both ends
 void SkOpSegment::markUnsortable(int start, int end) {
     SkOpSpan* span = &fTs[start];
     if (start < end) {
@@ skipping 67 matching lines @@
         SkOpSpan& newSpan = fTs[tIndex];
         newSpan.fWindValue = nextDoorWind;
         newSpan.fOppValue = nextOppWind;
         if (!nextDoorWind && !nextOppWind && !newSpan.fDone) {
             newSpan.fDone = true;
             ++fDoneSpans;
         }
     }
 }
 
-double SkOpSegment::missingNear(double t, const SkOpSegment* other, const SkPoint& startPt,
-        const SkPoint& endPt) const {
-    int count = this->count();
-    for (int index = 0; index < count; ++index) {
-        const SkOpSpan& span = this->span(index);
-        if (span.fOther == other && span.fPt == startPt) {
-            double midT = (t + span.fT) / 2;
-            if (betweenPoints(midT, startPt, endPt)) {
-                return span.fT;
-            }
-        }
-    }
-    return -1;
-}
-
 // return span if when chasing, two or more radiating spans are not done
 // OPTIMIZATION: ? multiple spans is detected when there is only one valid
 // candidate and the remaining spans have windValue == 0 (canceled by
 // coincidence). The coincident edges could either be removed altogether,
 // or this code could be more complicated in detecting this case. Worth it?
 bool SkOpSegment::multipleSpans(int end) const {
     return end > 0 && end < fTs.count() - 1;
 }
 
 bool SkOpSegment::nextCandidate(int* start, int* end) const {
@@ skipping 404 matching lines @@
     return winding;
 }
 
 int SkOpSegment::windSum(const SkOpAngle* angle) const {
     int start = angle->start();
     int end = angle->end();
     int index = SkMin32(start, end);
     return windSum(index);
 }
 
-int SkOpSegment::windValue(const SkOpAngle* angle) const {
-    int start = angle->start();
-    int end = angle->end();
-    int index = SkMin32(start, end);
-    return windValue(index);
-}
-
-int SkOpSegment::windValueAt(double t) const {
-    int count = fTs.count();
-    for (int index = 0; index < count; ++index) {
-        if (fTs[index].fT == t) {
-            return fTs[index].fWindValue;
-        }
-    }
-    SkASSERT(0);
-    return 0;
-}
-
 void SkOpSegment::zeroSpan(SkOpSpan* span) {
     SkASSERT(span->fWindValue > 0 || span->fOppValue != 0);
     span->fWindValue = 0;
     span->fOppValue = 0;
     if (span->fTiny || span->fSmall) {
         return;
     }
     SkASSERT(!span->fDone);
     span->fDone = true;
     ++fDoneSpans;
@@ skipping 370 matching lines @@
 
 void SkOpSegment::dumpSpans() const {
     int count = this->count();
     for (int index = 0; index < count; ++index) {
         const SkOpSpan& span = this->span(index);
         SkDebugf("[%d] ", index);
         span.dump();
     }
 }
 #endif