cumulative pathops patch

src/pathops/SkPathOpsPostSect.cpp

 /*
  * Copyright 2014 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"
 
 bool SkOpPtT::alias() const {
     return this->span()->ptT() != this;
 }
 
 SkOpContour* SkOpPtT::contour() const {
     return segment()->contour();
 }
 
-SkOpDebugState* SkOpPtT::debugState() const {
-    return PATH_OPS_DEBUG_RELEASE(contour()->debugState(), NULL); 
+SkOpGlobalState* SkOpPtT::globalState() const {
+    return PATH_OPS_DEBUG_RELEASE(contour()->globalState(), NULL); 
 }
 
 void SkOpPtT::init(SkOpSpanBase* span, double t, const SkPoint& pt, bool duplicate) {
     fT = t;
     fPt = pt;
     fSpan = span;
     fNext = this;
     fDuplicatePt = duplicate;
     fDeleted = false;
-    PATH_OPS_DEBUG_CODE(fID = ++span->debugState()->fPtTID);
+    PATH_OPS_DEBUG_CODE(fID = ++span->globalState()->fPtTID);
 }
 
 bool SkOpPtT::onEnd() const {
     const SkOpSpanBase* span = this->span();
     if (span->ptT() != this) {
         return false;
     }
     const SkOpSegment* segment = this->segment();
     return span == segment->head() || span == segment->tail();
 }
 
 SkOpPtT* SkOpPtT::remove() {
     SkOpPtT* prev = this;
     do {
         SkOpPtT* next = prev->fNext;
         if (next == this) {
-            prev->removeNext();
+            prev->removeNext(this);
             fDeleted = true;
             return prev;
         }
         prev = next;
     } while (prev != this);
     SkASSERT(0);
     return NULL;
 }
 
-void SkOpPtT::removeNext() {
+void SkOpPtT::removeNext(SkOpPtT* kept) {
     SkASSERT(this->fNext);
     SkOpPtT* next = this->fNext;
     this->fNext = next->fNext;
     SkOpSpanBase* span = next->span();
     next->setDeleted();
     if (span->ptT() == next) {
-        span->upCast()->detach();
+        span->upCast()->detach(kept);
     }
 }
 
 const SkOpSegment* SkOpPtT::segment() const {
     return span()->segment();
 }
 
 SkOpSegment* SkOpPtT::segment() {
     return span()->segment();
 }
@@ skipping 116 matching lines @@
         SkOpPtT* test = ptT;
         do {
             SkOpPtT* prev = test;
             if ((test = test->next()) == stopPtT) {
                 break;
             }
             if (span == test->span() && !span->segment()->ptsDisjoint(*ptT, *test)) {
                 // omit aliases that alignment makes redundant
                 if ((!ptT->alias() || test->alias()) && (ptT->onEnd() || !test->onEnd())) {
                     SkASSERT(test->alias());
-                    prev->removeNext();
+                    prev->removeNext(ptT);
                     test = prev;
                 } else {
                     SkASSERT(ptT->alias());
                     stopPtT = ptT = ptT->remove();
                     break;
                 }
             }
         } while (true);
     } while ((ptT = ptT->next()) != stopPtT);
 }
@@ skipping 19 matching lines @@
             return true;
         }
     }
     return false;
 }
 
 SkOpContour* SkOpSpanBase::contour() const {
     return segment()->contour();
 }
 
-SkOpDebugState* SkOpSpanBase::debugState() const {
-    return PATH_OPS_DEBUG_RELEASE(contour()->debugState(), NULL); 
+SkOpGlobalState* SkOpSpanBase::globalState() const {
+    return PATH_OPS_DEBUG_RELEASE(contour()->globalState(), NULL); 
 }
 
 void SkOpSpanBase::initBase(SkOpSegment* segment, SkOpSpan* prev, double t, const SkPoint& pt) {
     fSegment = segment;
     fPtT.init(this, t, pt, false);
     fCoinEnd = this;
     fFromAngle = NULL;
     fPrev = prev;
     fAligned = true;
     fChased = false;
     PATH_OPS_DEBUG_CODE(fCount = 1);
-    PATH_OPS_DEBUG_CODE(fID = ++debugState()->fSpanID);
+    PATH_OPS_DEBUG_CODE(fID = ++globalState()->fSpanID);
 }
 
 // this pair of spans share a common t value or point; merge them and eliminate duplicates
 // this does not compute the best t or pt value; this merely moves all data into a single list
 void SkOpSpanBase::merge(SkOpSpan* span) {
     SkOpPtT* spanPtT = span->ptT();
     SkASSERT(this->t() != spanPtT->fT);
     SkASSERT(!zero_or_one(spanPtT->fT));
-    span->detach();
+    span->detach(this->ptT());
     SkOpPtT* remainder = spanPtT->next();
     ptT()->insert(spanPtT);
     while (remainder != spanPtT) {
         SkOpPtT* next = remainder->next();
         SkOpPtT* compare = spanPtT->next();
         while (compare != spanPtT) {
             SkOpPtT* nextC = compare->next();
             if (nextC->span() == remainder->span() && nextC->fT == remainder->fT) {
                 goto tryNextRemainder;
             }
@@ skipping 22 matching lines @@
     SkASSERT(this->segment() != segment);
     const SkOpSpan* next = this;
     while ((next = next->fCoincident) != this) {
         if (next->segment() == segment) {
             return true;
         }
     }
     return false;
 }
 
-void SkOpSpan::detach() {
+void SkOpSpan::detach(SkOpPtT* kept) {
     SkASSERT(!final());
     SkOpSpan* prev = this->prev();
     SkASSERT(prev);
     SkOpSpanBase* next = this->next();
     SkASSERT(next);
     prev->setNext(next);
     next->setPrev(prev);
     this->segment()->detach(this);
+    if (this->coincident()) {
+        this->globalState()->fCoincidence->fixUp(this->ptT(), kept);
+    }
     this->ptT()->setDeleted();
 }
 
 void SkOpSpan::init(SkOpSegment* segment, SkOpSpan* prev, double t, const SkPoint& pt) {
     SkASSERT(t != 1);
     initBase(segment, prev, t, pt);
     fCoincident = this;
     fToAngle = NULL;
     fWindSum = fOppSum = SK_MinS32;
     fWindValue = 1;
@@ skipping 167 matching lines @@
                 next->insertCoinEnd(oNext);
             }
             SkOpSpan* nextSpan = next->upCast();
             SkOpSpan* oNextSpan = oNext->upCast();
             if (!nextSpan->containsCoincidence(oNextSpan)) {
                 nextSpan->insertCoincidence(oNextSpan);
             }
         } while (true);
     } while ((coin = coin->fNext));
 }