pathops coincident work

src/pathops/SkOpSpan.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpSpan_DEFINED
 #define SkOpSpan_DEFINED
 
 #include "SkPathOpsDebug.h"
@@ skipping 10 matching lines @@
 struct SkPathOpsBounds;
 
 // subset of op span used by terminal span (when t is equal to one)
 class SkOpPtT {
 public:
     enum {
         kIsAlias = 1,
         kIsDuplicate = 1
     };
 
+    const SkOpPtT* active() const;
+
     // please keep in sync with debugAddOpp()
     void addOpp(SkOpPtT* opp, SkOpPtT* oppPrev) {
         SkOpPtT* oldNext = this->fNext;
         SkASSERT(this != opp);
         this->fNext = opp;
         SkASSERT(oppPrev != oldNext);
         oppPrev->fNext = oldNext;
     }
 
     bool alias() const;
     bool coincident() const { return fCoincident; }
     bool collapsed(const SkOpPtT* ) const;
     bool contains(const SkOpPtT* ) const;
     bool contains(const SkOpSegment*, const SkPoint& ) const;
     bool contains(const SkOpSegment*, double t) const;
     const SkOpPtT* contains(const SkOpSegment* ) const;
     SkOpContour* contour() const;
 
     int debugID() const {
         return SkDEBUGRELEASE(fID, -1);
     }
 
     void debugAddOpp(const SkOpPtT* opp, const SkOpPtT* oppPrev) const;
     const SkOpAngle* debugAngle(int id) const;
     const SkOpCoincidence* debugCoincidence() const;
     bool debugContains(const SkOpPtT* ) const;
     const SkOpPtT* debugContains(const SkOpSegment* check) const;
-    SkOpContour* debugContour(int id);
+    SkOpContour* debugContour(int id) const;
     int debugLoopLimit(bool report) const;
     bool debugMatchID(int id) const;
     const SkOpPtT* debugOppPrev(const SkOpPtT* opp) const;
     const SkOpPtT* debugPtT(int id) const;
     void debugResetCoinT() const;
     const SkOpSegment* debugSegment(int id) const;
     void debugSetCoinT(int ) const;
     const SkOpSpanBase* debugSpan(int id) const;
     void debugValidate() const;
 
@@ skipping 22 matching lines @@
     const SkOpPtT* next() const {
         return fNext;
     }
 
     SkOpPtT* next() {
         return fNext;
     }
 
     bool onEnd() const;
 
-    SkOpPtT* oppPrev(SkOpPtT* opp) const {
+    // returns nullptr if this is already in the opp ptT loop
+    SkOpPtT* oppPrev(const SkOpPtT* opp) const {
         // find the fOpp ptr to opp
         SkOpPtT* oppPrev = opp->fNext;
         if (oppPrev == this) {
             return nullptr;
         }
         while (oppPrev->fNext != opp) {
             oppPrev = oppPrev->fNext;
             if (oppPrev == this) {
                 return nullptr;
             }
@@ skipping 57 matching lines @@
     SkOpPtT* fNext;  // intersection on opposite curve or alias on this curve
     bool fDeleted;  // set if removed from span list
     bool fDuplicatePt;  // set if identical pt is somewhere in the next loop
     // below mutable since referrer is otherwise always const
     mutable bool fCoincident;  // set if at some point a coincident span pointed here
     SkDEBUGCODE(int fID);
 };
 
 class SkOpSpanBase {
 public:
-    void addOppAndMerge(SkOpSpanBase* );
+    SkOpSpanBase* active();
+    void addOpp(SkOpSpanBase* opp);
 
     void bumpSpanAdds() {
         ++fSpanAdds;
     }
 
     bool chased() const {
         return fChased;
     }
 
     void checkForCollapsedCoincidence();
 
     const SkOpSpanBase* coinEnd() const {
         return fCoinEnd;
     }
 
+    bool collapsed(double s, double e) const;
     bool contains(const SkOpSpanBase* ) const;
     const SkOpPtT* contains(const SkOpSegment* ) const;
 
     bool containsCoinEnd(const SkOpSpanBase* coin) const {
         SkASSERT(this != coin);
         const SkOpSpanBase* next = this;
         while ((next = next->fCoinEnd) != this) {
             if (next == coin) {
                 return true;
             }
         }
         return false;
     }
 
     bool containsCoinEnd(const SkOpSegment* ) const;
     SkOpContour* contour() const;
 
-#if DEBUG_COINCIDENCE_VERBOSE
-    void debugAddOppAndMerge(const char* id, SkPathOpsDebug::GlitchLog* , const SkOpSpanBase* ,
-                             bool* del1, bool* del2) const;
-#endif
-
     int debugBumpCount() {
         return SkDEBUGRELEASE(++fCount, -1);
     }
 
     int debugID() const {
         return SkDEBUGRELEASE(fID, -1);
     }
 
+#if DEBUG_COINCIDENCE_VERBOSE
+    void debugAddOpp(const char* id, SkPathOpsDebug::GlitchLog* , const SkOpSpanBase* opp) const;
+#endif
     bool debugAlignedEnd(double t, const SkPoint& pt) const;
     bool debugAlignedInner() const;
     const SkOpAngle* debugAngle(int id) const;
 #if DEBUG_COINCIDENCE_VERBOSE
     void debugCheckForCollapsedCoincidence(const char* id, SkPathOpsDebug::GlitchLog* ) const;
 #endif
     const SkOpCoincidence* debugCoincidence() const;
     bool debugCoinEndLoopCheck() const;
-    SkOpContour* debugContour(int id);
+    SkOpContour* debugContour(int id) const;
 #ifdef SK_DEBUG
-    bool debugDeleted() const { return fDeleted; }
+    bool debugDeleted() const { return fDebugDeleted; }
 #endif
 #if DEBUG_COINCIDENCE_VERBOSE
     void debugInsertCoinEnd(const char* id, SkPathOpsDebug::GlitchLog* ,
                             const SkOpSpanBase* ) const;
     void debugMergeContained(const char* id, SkPathOpsDebug::GlitchLog* ,
                              const SkPathOpsBounds& bounds, bool* deleted) const;
+    void debugMergeMatches(const char* id, SkPathOpsDebug::GlitchLog* log,
+                           const SkOpSpanBase* opp) const;
 #endif
     const SkOpPtT* debugPtT(int id) const;
     void debugResetCoinT() const;
     const SkOpSegment* debugSegment(int id) const;
     void debugSetCoinT(int ) const;
+#ifdef SK_DEBUG
+    void debugSetDeleted() { fDebugDeleted = true; }
+#endif
     const SkOpSpanBase* debugSpan(int id) const;
     const SkOpSpan* debugStarter(SkOpSpanBase const** endPtr) const;
     SkOpGlobalState* globalState() const;
     void debugValidate() const;
 
     bool deleted() const {
         return fPtT.deleted();
     }
 
     void dump() const;  // available to testing only
@@ skipping 21 matching lines @@
         debugValidate();
         SkASSERT(this != coin);
         SkOpSpanBase* coinNext = coin->fCoinEnd;
         coin->fCoinEnd = this->fCoinEnd;
         this->fCoinEnd = coinNext;
         debugValidate();
     }
 
     void merge(SkOpSpan* span);
     void mergeContained(const SkPathOpsBounds& bounds);
+    void mergeMatches(SkOpSpanBase* opp);
 
     const SkOpSpan* prev() const {
         return fPrev;
     }
 
     SkOpSpan* prev() {
         return fPrev;
     }
 
     const SkPoint& pt() const {
@@ skipping 98 matching lines @@
     SkOpPtT fPtT;  // list of points and t values associated with the start of this span
     SkOpSegment* fSegment;  // segment that contains this span
     SkOpSpanBase* fCoinEnd;  // linked list of coincident spans that end here (may point to itself)
     SkOpAngle* fFromAngle;  // points to next angle from span start to end
     SkOpSpan* fPrev;  // previous intersection point
     int fSpanAdds;  // number of times intersections have been added to span
     bool fAligned;
     bool fChased;  // set after span has been added to chase array
     SkDEBUGCODE(int fCount);  // number of pt/t pairs added
     SkDEBUGCODE(int fID);
-    SkDEBUGCODE(bool fDeleted);  // set when span was merged with another span
+    SkDEBUGCODE(bool fDebugDeleted);  // set when span was merged with another span
 };
 
 class SkOpSpan : public SkOpSpanBase {
 public:
     bool alreadyAdded() const {
         if (fAlreadyAdded) {
             return true;
         }
         fAlreadyAdded = true;
         return false;
@@ skipping 21 matching lines @@
         }
         return false;
     }
 
     bool debugCoinLoopCheck() const;
 #if DEBUG_COINCIDENCE_VERBOSE
     void debugInsertCoincidence(const char* , SkPathOpsDebug::GlitchLog* , const SkOpSpan* ) const;
     void debugInsertCoincidence(const char* , SkPathOpsDebug::GlitchLog* ,
                                 const SkOpSegment* , bool flipped) const;
 #endif
-    void release(const SkOpPtT* );
+    void dumpCoin() const;
+    bool dumpSpan() const;
 
     bool done() const {
         SkASSERT(!final());
         return fDone;
     }
 
-    void dumpCoin() const;
-    bool dumpSpan() const;
     void init(SkOpSegment* parent, SkOpSpan* prev, double t, const SkPoint& pt);
     bool insertCoincidence(const SkOpSegment* , bool flipped);
 
     // Please keep this in sync with debugInsertCoincidence()
     void insertCoincidence(SkOpSpan* coin) {
         if (containsCoincidence(coin)) {
             SkASSERT(coin->containsCoincidence(this));
             return;
         }
         debugValidate();
@@ skipping 22 matching lines @@
     int oppSum() const {
         SkASSERT(!final());
         return fOppSum;
     }
 
     int oppValue() const {
         SkASSERT(!final());
         return fOppValue;
     }
 
+    void release(const SkOpPtT* );
+
     SkOpPtT* setCoinStart(SkOpSpan* oldCoinStart, SkOpSegment* oppSegment);
 
     void setDone(bool done) {
         SkASSERT(!final());
         fDone = done;
     }
 
     void setNext(SkOpSpanBase* nextT) {
         SkASSERT(!final());
         fNext = nextT;
@@ skipping 47 matching lines @@
     int fWindSum;  // accumulated from contours surrounding this one.
     int fOppSum;  // for binary operators: the opposite winding sum
     int fWindValue;  // 0 == canceled; 1 == normal; >1 == coincident
     int fOppValue;  // normally 0 -- when binary coincident edges combine, opp value goes here
     int fTopTTry; // specifies direction and t value to try next
     bool fDone;  // if set, this span to next higher T has been processed
     mutable bool fAlreadyAdded;
 };
 
 #endif