nc seal breaks simplify

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 297 matching lines @@
     void mergeCoincidence(SkTSect<OppCurve, TCurve>* sect2);
     SkTSpan<TCurve, OppCurve>* prev(SkTSpan<TCurve, OppCurve>* ) const;
     void removeByPerpendicular(SkTSect<OppCurve, TCurve>* opp);
     void recoverCollapsed();
     void removeCoincident(SkTSpan<TCurve, OppCurve>* span, bool isBetween);
     void removeAllBut(const SkTSpan<OppCurve, TCurve>* keep, SkTSpan<TCurve, OppCurve>* span,
                       SkTSect<OppCurve, TCurve>* opp);
     bool removeSpan(SkTSpan<TCurve, OppCurve>* span);
     void removeSpanRange(SkTSpan<TCurve, OppCurve>* first, SkTSpan<TCurve, OppCurve>* last);
     void removeSpans(SkTSpan<TCurve, OppCurve>* span, SkTSect<OppCurve, TCurve>* opp);
+    void removedEndCheck(SkTSpan<TCurve, OppCurve>* span);
+
+    void resetRemovedEnds() { 
+        fRemovedStartT = fRemovedEndT = false;
+    }
+
     SkTSpan<TCurve, OppCurve>* spanAtT(double t, SkTSpan<TCurve, OppCurve>** priorSpan);
     SkTSpan<TCurve, OppCurve>* tail();
     bool trim(SkTSpan<TCurve, OppCurve>* span, SkTSect<OppCurve, TCurve>* opp);
     void unlinkSpan(SkTSpan<TCurve, OppCurve>* span);
     bool updateBounded(SkTSpan<TCurve, OppCurve>* first, SkTSpan<TCurve, OppCurve>* last,
                        SkTSpan<OppCurve, TCurve>* oppFirst);
     void validate() const;
     void validateBounded() const;
 
     const TCurve& fCurve;
@@ skipping 530 matching lines @@
     : fCurve(c)
     , fHeap(sizeof(SkTSpan<TCurve, OppCurve>) * 4)
     , fCoincident(nullptr)
     , fDeleted(nullptr)
     , fActiveCount(0)
     SkDEBUGPARAMS(fDebugGlobalState(debugGlobalState))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fID(id))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fDebugCount(0))
     PATH_OPS_DEBUG_T_SECT_PARAMS(fDebugAllocatedCount(0))
 {
-    fHead = addOne();
+    this->resetRemovedEnds();
+    fHead = this->addOne();
     SkDEBUGCODE(fHead->debugSetGlobalState(debugGlobalState));
     fHead->init(c);
 }
 
 template<typename TCurve, typename OppCurve>
 SkTSpan<TCurve, OppCurve>* SkTSect<TCurve, OppCurve>::addOne() {
     SkTSpan<TCurve, OppCurve>* result;
     if (fDeleted) {
         result = fDeleted;
         fDeleted = result->fNext;
@@ skipping 474 matching lines @@
     }
     if (span->fIsLine && oppSpan->fIsLine) {
         SkIntersections i;
         int sects = this->linesIntersect(span, opp, oppSpan, &i);
         if (sects == 2) {
             return *oppResult = 1;
         }
         if (!sects) {
             return -1;
         }
+        this->removedEndCheck(span);
         span->fStartT = span->fEndT = i[0][0];
+        opp->removedEndCheck(oppSpan);
         oppSpan->fStartT = oppSpan->fEndT = i[1][0];
         return *oppResult = 2;
     }
     if (span->fIsLinear || oppSpan->fIsLinear) {
         return *oppResult = (int) span->linearsIntersect(oppSpan);
     }
     return *oppResult = 1;
 }
 
 template<typename TCurve>
@@ skipping 354 matching lines @@
     if (isBetween || between(0, span->fCoinStart.perpT(), 1)) {
         --fActiveCount;
         span->fNext = fCoincident;
         fCoincident = span;
     } else {
         this->markSpanGone(span);
     }
 }
 
 template<typename TCurve, typename OppCurve>
-bool SkTSect<TCurve, OppCurve>::removeSpan(SkTSpan<TCurve, OppCurve>* span) {
+void SkTSect<TCurve, OppCurve>::removedEndCheck(SkTSpan<TCurve, OppCurve>* span) {
     if (!span->fStartT) {
         fRemovedStartT = true;
     }
     if (1 == span->fEndT) {
         fRemovedEndT = true;
     }
+}
+
+template<typename TCurve, typename OppCurve>
+bool SkTSect<TCurve, OppCurve>::removeSpan(SkTSpan<TCurve, OppCurve>* span) {\
+    this->removedEndCheck(span);
     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 379 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;
             }
+            sect1->resetRemovedEnds();
+            sect2->resetRemovedEnds();
             // 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)) {
                 break;
             }
             if (!sect1->trim(largest1, sect2)) {
                 SkOPOBJASSERT(intersections, 0);
                 return;
             }
             if (!sect1->trim(half1, sect2)) {
                 SkOPOBJASSERT(intersections, 0);
                 return;
             }
         } else {
             if (largest2->fCollapsed) {
                 break;
             }
+            sect1->resetRemovedEnds();
+            sect2->resetRemovedEnds();
             // trim parts that don't intersect the opposite
             SkTSpan<OppCurve, TCurve>* half2 = sect2->addOne();
             SkDEBUGCODE(half2->debugSetGlobalState(sect2->globalState()));
             if (!half2->split(largest2, &sect2->fHeap)) {
                 break;
             }
             if (!sect2->trim(largest2, sect1)) {
                 SkOPOBJASSERT(intersections, 0);
                 return;
             }
@@ skipping 75 matching lines @@
             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 (!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[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[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[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[OppCurve::kPointLast], sect1->fCurve);
             if (perp.isMatch()) {
                 intersections->insert(perp.perpT(), 1, perp.perpPt());
             }
         }
+//    }
+    if (!sect1->fHead || !sect2->fHead) {
         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 73 matching lines @@
             --last;
         } else {
             intersections->setCoincident(index++);
         }
         intersections->setCoincident(index);
     }
     SkOPOBJASSERT(intersections, intersections->used() <= TCurve::kMaxIntersections);
 }
 
 #endif