fix tiger b

src/pathops/SkPathOpsTSect.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkPathOpsTSect_DEFINED
 #define SkPathOpsTSect_DEFINED
 
 #include "SkChunkAlloc.h"
@@ skipping 13 matching lines @@
 class SkTCoincident {
 public:
     SkTCoincident() {
         this->init();
     }
 
     void debugInit() {
 #ifdef SK_DEBUG
         this->fPerpPt.fX = this->fPerpPt.fY = SK_ScalarNaN;
         this->fPerpT = SK_ScalarNaN;
-        this->fCoincident = 0xFF;
+        this->fMatch = 0xFF;
 #endif
     }
 
     char dumpIsCoincidentStr() const;
     void dump() const;
 
-    bool isCoincident() const {
-        SkASSERT(!!fCoincident == fCoincident);
-        return SkToBool(fCoincident);
+    bool isMatch() const {
+        SkASSERT(!!fMatch == fMatch);
+        return SkToBool(fMatch);
     }
 
     void init() {
         fPerpT = -1;
-        fCoincident = false;
+        fMatch = false;
         fPerpPt.fX = fPerpPt.fY = SK_ScalarNaN;
     }
 
     void markCoincident() {
-        if (!fCoincident) {
+        if (!fMatch) {
             fPerpT = -1;
         }
-        fCoincident = true;
+        fMatch = true;
     }
 
     const SkDPoint& perpPt() const {
         return fPerpPt;
     }
 
     double perpT() const {
         return fPerpT;
     }
 
     void setPerp(const TCurve& c1, double t, const SkDPoint& cPt, const OppCurve& );
 
 private:
     SkDPoint fPerpPt;
     double fPerpT;  // perpendicular intersection on opposite curve
-    SkOpDebugBool fCoincident;
+    SkOpDebugBool fMatch;
 };
 
 template<typename TCurve, typename OppCurve> class SkTSect;
 template<typename TCurve, typename OppCurve> class SkTSpan;
 
 template<typename TCurve, typename OppCurve>
 struct SkTSpanBounded {
     SkTSpan<TCurve, OppCurve>* fBounded;
     SkTSpanBounded* fNext;
 };
@@ skipping 240 matching lines @@
                        SkTSpan<OppCurve, TCurve>* oppFirst);
     void validate() const;
     void validateBounded() const;
 
     const TCurve& fCurve;
     SkChunkAlloc fHeap;
     SkTSpan<TCurve, OppCurve>* fHead;
     SkTSpan<TCurve, OppCurve>* fCoincident;
     SkTSpan<TCurve, OppCurve>* fDeleted;
     int fActiveCount;
+    bool fRemovedStartT;
+    bool fRemovedEndT;
     SkDEBUGCODE(SkOpGlobalState* fDebugGlobalState);
     SkDEBUGCODE(SkTSect<OppCurve, TCurve>* fOppSect);
     PATH_OPS_DEBUG_T_SECT_CODE(int fID);
     PATH_OPS_DEBUG_T_SECT_CODE(int fDebugCount);
 #if DEBUG_T_SECT
     int fDebugAllocatedCount;
 #endif
     friend class SkTSpan<TCurve, OppCurve>;
     friend class SkTSpan<OppCurve, TCurve>;
     friend class SkTSect<OppCurve, TCurve>;
@@ skipping 22 matching lines @@
         if (dist2Sq < distSq) {
             fPerpT = i[0][1];
             fPerpPt = i.pt(1);
         }
     }
 #if DEBUG_T_SECT
     SkDebugf("setPerp t=%1.9g cPt=(%1.9g,%1.9g) %s oppT=%1.9g fPerpPt=(%1.9g,%1.9g)\n",
             t, cPt.fX, cPt.fY,
             cPt.approximatelyEqual(fPerpPt) ? "==" : "!=", fPerpT, fPerpPt.fX, fPerpPt.fY);
 #endif
-    fCoincident = cPt.approximatelyEqual(fPerpPt);
+    fMatch = cPt.approximatelyEqual(fPerpPt);
 #if DEBUG_T_SECT
-    if (fCoincident) {
+    if (fMatch) {
         SkDebugf("");  // allow setting breakpoint
     }
 #endif
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::addBounded(SkTSpan<OppCurve, TCurve>* span, SkChunkAlloc* heap) {
     SkTSpanBounded<OppCurve, TCurve>* bounded = new (heap->allocThrow(
             sizeof(SkTSpanBounded<OppCurve, TCurve>)))(SkTSpanBounded<OppCurve, TCurve>);
     bounded->fBounded = span;
@@ skipping 406 matching lines @@
     this->validateBounded();
 #endif
 #if DEBUG_T_SECT
     SkASSERT(fBounds.width() || fBounds.height() || fCollapsed);
     SkASSERT(fBoundsMax == SkTMax(fBounds.width(), fBounds.height()) || fCollapsed == 0xFF);
     SkASSERT(0 <= fStartT);
     SkASSERT(fEndT <= 1);
     SkASSERT(fStartT <= fEndT);
     SkASSERT(fBounded || fCollapsed == 0xFF);
     if (fHasPerp) {
-        if (fCoinStart.isCoincident()) {
+        if (fCoinStart.isMatch()) {
             validatePerpT(fCoinStart.perpT());
             validatePerpPt(fCoinStart.perpT(), fCoinStart.perpPt());
         }
-        if (fCoinEnd.isCoincident()) {
+        if (fCoinEnd.isMatch()) {
             validatePerpT(fCoinEnd.perpT());
             validatePerpPt(fCoinEnd.perpT(), fCoinEnd.perpPt());
         }
     }
 #endif
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSpan<TCurve, OppCurve>::validateBounded() const {
 #if DEBUG_VALIDATE
@@ skipping 100 matching lines @@
         }
         work.initBounds(fCurve);
         if (work.fCollapsed) {
             return false;
         }
         if (last.approximatelyEqual(work.fPart[0])) {
             break;
         }
         last = work.fPart[0];
         work.fCoinStart.setPerp(fCurve, work.fStartT, last, opp);
-        if (work.fCoinStart.isCoincident()) {
+        if (work.fCoinStart.isMatch()) {
 #if DEBUG_T_SECT
             work.validatePerpPt(work.fCoinStart.perpT(), work.fCoinStart.perpPt());
 #endif
             double oppTTest = work.fCoinStart.perpT();
             if (sect2->fHead->contains(oppTTest)) {
                 *oppT = oppTTest;
                 oppPt = work.fCoinStart.perpPt();
                 contained = true;
                 SkASSERT(down ? result > work.fStartT : result < work.fStartT);
                 result = work.fStartT;
@@ skipping 136 matching lines @@
     const OppCurve& opp = sect2->fCurve;
     SkTSpan<TCurve, OppCurve>* work = first;
     SkTSpan<TCurve, OppCurve>* prior = nullptr;
     do {
         if (!work->fHasPerp && !work->fCollapsed) {
             if (prior) {
                 work->fCoinStart = prior->fCoinEnd;
             } else {
                 work->fCoinStart.setPerp(fCurve, work->fStartT, work->fPart[0], opp);
             }
-            if (work->fCoinStart.isCoincident()) {
+            if (work->fCoinStart.isMatch()) {
                 double perpT = work->fCoinStart.perpT();
                 if (sect2->coincidentHasT(perpT)) {
                     work->fCoinStart.init();
                 } else {
                     sect2->addForPerp(work, perpT);
                 }
             }
             work->fCoinEnd.setPerp(fCurve, work->fEndT, work->fPart[TCurve::kPointLast], opp);
-            if (work->fCoinEnd.isCoincident()) {
+            if (work->fCoinEnd.isMatch()) {
                 double perpT = work->fCoinEnd.perpT();
                 if (sect2->coincidentHasT(perpT)) {
                     work->fCoinEnd.init();
                 } else {
                     sect2->addForPerp(work, perpT);
                 }
             }
             work->fHasPerp = true;
         }
         if (work == last) {
@@ skipping 62 matching lines @@
     first = findCoincidentRun(first, &last);
     if (!first || !last) {
         *result = nullptr;
         return true;
     }
     // march outwards to find limit of coincidence from here to previous and next spans
     double startT = first->fStartT;
     double oppStartT SK_INIT_TO_AVOID_WARNING;
     double oppEndT SK_INIT_TO_AVOID_WARNING;
     SkTSpan<TCurve, OppCurve>* prev = first->fPrev;
-    SkASSERT(first->fCoinStart.isCoincident());
+    SkASSERT(first->fCoinStart.isMatch());
     SkTSpan<OppCurve, TCurve>* oppFirst = first->findOppT(first->fCoinStart.perpT());
-    SkOPASSERT(last->fCoinEnd.isCoincident());
+    SkOPASSERT(last->fCoinEnd.isMatch());
     bool oppMatched = first->fCoinStart.perpT() < first->fCoinEnd.perpT();
     double coinStart;
     SkDEBUGCODE(double coinEnd);
     SkTSpan<OppCurve, TCurve>* cutFirst;
     if (prev && prev->fEndT == startT
             && this->binarySearchCoin(sect2, startT, prev->fStartT - startT, &coinStart,
                                       &oppStartT)
             && prev->fStartT < coinStart && coinStart < startT
             && (cutFirst = prev->oppT(oppStartT))) {
         oppFirst = cutFirst;
@@ skipping 10 matching lines @@
                 oppFirst->markCoincident();
                 oppHalf->fCoinStart.markCoincident();
             }
         }
     } else {
         SkDEBUGCODE(coinStart = first->fStartT);
         SkDEBUGCODE(oppStartT = oppMatched ? oppFirst->fStartT : oppFirst->fEndT);
     }
     // FIXME: incomplete : if we're not at the end, find end of coin
     SkTSpan<OppCurve, TCurve>* oppLast;
-    SkOPASSERT(last->fCoinEnd.isCoincident());
+    SkOPASSERT(last->fCoinEnd.isMatch());
     oppLast = last->findOppT(last->fCoinEnd.perpT());
     SkDEBUGCODE(coinEnd = last->fEndT);
 #ifdef SK_DEBUG
     if (!this->globalState() || !this->globalState()->debugSkipAssert()) {
         oppEndT = oppMatched ? oppLast->fEndT : oppLast->fStartT;
     }
 #endif
     if (!oppMatched) {
         SkTSwap(oppFirst, oppLast);
         SkTSwap(oppStartT, oppEndT);
@@ skipping 50 matching lines @@
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::findCoincidentRun(
         SkTSpan<TCurve, OppCurve>* first, SkTSpan<TCurve, OppCurve>** lastPtr) {
     SkTSpan<TCurve, OppCurve>* work = first;
     SkTSpan<TCurve, OppCurve>* lastCandidate = nullptr;
     first = nullptr;
     // find the first fully coincident span
     do {
-        if (work->fCoinStart.isCoincident()) {
+        if (work->fCoinStart.isMatch()) {
 #if DEBUG_T_SECT
             work->validatePerpT(work->fCoinStart.perpT());
             work->validatePerpPt(work->fCoinStart.perpT(), work->fCoinStart.perpPt());
 #endif
             SkASSERT(work->hasOppT(work->fCoinStart.perpT()));
-            if (!work->fCoinEnd.isCoincident()) {
+            if (!work->fCoinEnd.isMatch()) {
                 break;
             }
             lastCandidate = work;
             if (!first) {
                 first = work;
             }
         } else if (first && work->fCollapsed) {
             *lastPtr = lastCandidate;
             return first;
         } else {
@@ skipping 226 matching lines @@
     SkDPoint workPt;
     do {
         tStep *= 0.5;
         if (precisely_zero(tStep)) {
             return 0;
         }
         workT += tStep;
         workPt = fCurve.ptAtT(workT);
         coinW.setPerp(fCurve, workT, workPt, opp->fCurve);
         double perpT = coinW.perpT();
-        if (coinW.isCoincident() ? !between(oppSpan->fStartT, perpT, oppSpan->fEndT) : perpT < 0) {
+        if (coinW.isMatch() ? !between(oppSpan->fStartT, perpT, oppSpan->fEndT) : perpT < 0) {
             continue;
         }
         SkDVector perpW = workPt - coinW.perpPt();
         if ((perpS.dot(perpW) >= 0) == (tStep < 0)) {
             tStep = -tStep;
         }
         if (workPt.approximatelyEqual(coinW.perpPt())) {
             break;
         }
     } while (true);
@@ skipping 75 matching lines @@
             larger = test;
         } while ((prior = test), (test = test->fNext));
         if (!larger) {
             continue;
         }
         // check middle t value to see if it is coincident as well
         double midT = (smaller->fEndT + larger->fStartT) / 2;
         SkDPoint midPt = fCurve.ptAtT(midT);
         SkTCoincident<TCurve, OppCurve> coin;
         coin.setPerp(fCurve, midT, midPt, sect2->fCurve);
-        if (coin.isCoincident()) {
+        if (coin.isMatch()) {
             smaller->fEndT = larger->fEndT;
             smaller->fCoinEnd = larger->fCoinEnd;
             if (largerPrior) {
                 largerPrior->fNext = larger->fNext;
                 largerPrior->validate();
             } else {
                 fCoincident = larger->fNext;
             }
         }
     } while (true);
@@ skipping 79 matching lines @@
         --fActiveCount;
         span->fNext = fCoincident;
         fCoincident = span;
     } else {
         this->markSpanGone(span);
     }
 }
 
 template<typename TCurve, typename OppCurve>
 bool SkTSect<TCurve, OppCurve>::removeSpan(SkTSpan<TCurve, OppCurve>* span) {
+    if (!span->fStartT) {
+        fRemovedStartT = true;
+    }
+    if (1 == span->fEndT) {
+        fRemovedEndT = true;
+    }
     this->unlinkSpan(span);
     return this->markSpanGone(span);
 }
 
 template<typename TCurve, typename OppCurve>
 void SkTSect<TCurve, OppCurve>::removeSpanRange(SkTSpan<TCurve, OppCurve>* first,
         SkTSpan<TCurve, OppCurve>* last) {
     if (first == last) {
         return;
     }
@@ skipping 378 matching lines @@
     int coinLoopCount = kMaxCoinLoopCount;
     double start1s SK_INIT_TO_AVOID_WARNING;
     double start1e SK_INIT_TO_AVOID_WARNING;
     do {
         // find the largest bounds
         SkTSpan<TCurve, OppCurve>* largest1 = sect1->boundsMax();
         if (!largest1) {
             break;
         }
         SkTSpan<OppCurve, TCurve>* largest2 = sect2->boundsMax();
+        sect1->fRemovedStartT = sect1->fRemovedEndT = false;
+        sect2->fRemovedStartT = sect2->fRemovedEndT = false;
         // split it
         if (!largest2 || (largest1 && (largest1->fBoundsMax > largest2->fBoundsMax
                 || (!largest1->fCollapsed && largest2->fCollapsed)))) {
             if (largest1->fCollapsed) {
                 break;
             }
             // trim parts that don't intersect the opposite
             SkTSpan<TCurve, OppCurve>* half1 = sect1->addOne();
             SkDEBUGCODE(half1->debugSetGlobalState(sect1->globalState()));
             if (!half1->split(largest1, &sect1->fHeap)) {
@@ skipping 68 matching lines @@
     } while (true);
     SkTSpan<TCurve, OppCurve>* coincident = sect1->fCoincident;
     if (coincident) {
         // if there is more than one coincident span, check loosely to see if they should be joined
         if (coincident->fNext) {
             sect1->mergeCoincidence(sect2);
             coincident = sect1->fCoincident;
         }
         SkASSERT(sect2->fCoincident);  // courtesy check : coincidence only looks at sect 1
         do {
-            if (!coincident->fCoinStart.isCoincident()) {
+            if (!coincident->fCoinStart.isMatch()) {
                 continue;
             }
-            if (!coincident->fCoinEnd.isCoincident()) {
+            if (!coincident->fCoinEnd.isMatch()) {
                 continue;
             }
             int index = intersections->insertCoincident(coincident->fStartT,
                     coincident->fCoinStart.perpT(), coincident->fPart[0]);
             if ((intersections->insertCoincident(coincident->fEndT,
                     coincident->fCoinEnd.perpT(),
                     coincident->fPart[TCurve::kPointLast]) < 0) && index >= 0) {
                 intersections->clearCoincidence(index);
             }
         } while ((coincident = coincident->fNext));
     }
     int zeroOneSet = EndsEqual(sect1, sect2, intersections);
     if (!sect1->fHead || !sect2->fHead) {
+        // if the final iteration contains an end (0 or 1),
+        if (sect1->fRemovedStartT && !(zeroOneSet & kZeroS1Set)) {
+            SkTCoincident<TCurve, OppCurve> perp;   // intersect perpendicular with opposite curve
+            perp.setPerp(sect1->fCurve, 0, sect1->fCurve.fPts[0], sect2->fCurve);
+            if (perp.isMatch()) {
+                intersections->insert(0, perp.perpT(), perp.perpPt());
+            }
+        }
+        if (sect1->fRemovedEndT && !(zeroOneSet & kOneS1Set)) {
+            SkTCoincident<TCurve, OppCurve> perp;
+            perp.setPerp(sect1->fCurve, 1, sect1->fCurve.fPts[TCurve::kPointLast], sect2->fCurve);
+            if (perp.isMatch()) {
+                intersections->insert(1, perp.perpT(), perp.perpPt());
+            }
+        }
+        if (sect2->fRemovedStartT && !(zeroOneSet & kZeroS2Set)) {
+            SkTCoincident<OppCurve, TCurve> perp;
+            perp.setPerp(sect2->fCurve, 0, sect2->fCurve.fPts[0], sect1->fCurve);
+            if (perp.isMatch()) {
+                intersections->insert(perp.perpT(), 0, perp.perpPt());
+            }
+        }
+        if (sect2->fRemovedEndT && !(zeroOneSet & kOneS2Set)) {
+            SkTCoincident<OppCurve, TCurve> perp;
+            perp.setPerp(sect2->fCurve, 1, sect2->fCurve.fPts[OppCurve::kPointLast], sect1->fCurve);
+            if (perp.isMatch()) {
+                intersections->insert(perp.perpT(), 1, perp.perpPt());
+            }
+        }
         return;
     }
     sect1->recoverCollapsed();
     sect2->recoverCollapsed();
     SkTSpan<TCurve, OppCurve>* result1 = sect1->fHead;
     // check heads and tails for zero and ones and insert them if we haven't already done so
     const SkTSpan<TCurve, OppCurve>* head1 = result1;
     if (!(zeroOneSet & kZeroS1Set) && approximately_less_than_zero(head1->fStartT)) {
         const SkDPoint& start1 = sect1->fCurve[0];
         if (head1->isBounded()) {
@@ skipping 28 matching lines @@
         const SkDPoint& end2 = sect2->fCurve[OppCurve::kPointLast];
         if (tail2->isBounded()) {
             double t = tail2->closestBoundedT(end2);
             if (sect1->fCurve.ptAtT(t).approximatelyEqual(end2)) {
                 intersections->insert(t, 1, end2);
             }
         }
     }
     SkClosestSect<TCurve, OppCurve> closest;
     do {
-        while (result1 && result1->fCoinStart.isCoincident() && result1->fCoinEnd.isCoincident()) {
+        while (result1 && result1->fCoinStart.isMatch() && result1->fCoinEnd.isMatch()) {
             result1 = result1->fNext;
         }
         if (!result1) {
             break;
         }
         SkTSpan<OppCurve, TCurve>* result2 = sect2->fHead;
         bool found = false;
         while (result2) {
             found |= closest.find(result1, result2  SkDEBUGPARAMS(intersections));
             result2 = result2->fNext;
         }
     } while ((result1 = result1->fNext));
     closest.finish(intersections);
     // if there is more than one intersection and it isn't already coincident, check
     int last = intersections->used() - 1;
     for (int index = 0; index < last; ) {
         if (intersections->isCoincident(index) && intersections->isCoincident(index + 1)) {
             ++index;
             continue;
         }
         double midT = ((*intersections)[0][index] + (*intersections)[0][index + 1]) / 2;
         SkDPoint midPt = sect1->fCurve.ptAtT(midT);
         // intersect perpendicular with opposite curve
         SkTCoincident<TCurve, OppCurve> perp;
         perp.setPerp(sect1->fCurve, midT, midPt, sect2->fCurve);
-        if (!perp.isCoincident()) {
+        if (!perp.isMatch()) {
             ++index;
             continue;
         }
         if (intersections->isCoincident(index)) {
             intersections->removeOne(index);
             --last;
         } else if (intersections->isCoincident(index + 1)) {
             intersections->removeOne(index + 1);
             --last;
         } else {
             intersections->setCoincident(index++);
         }
         intersections->setCoincident(index);
     }
     SkASSERT(intersections->used() <= TCurve::kMaxIntersections);
 }
 
 #endif