pathops coincident fixes

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"
+#include "SkPathOpsTypes.h"
 #include "SkPoint.h"
 
 class SkChunkAlloc;
 struct SkOpAngle;
 class SkOpContour;
 class SkOpGlobalState;
 class SkOpSegment;
 class SkOpSpanBase;
 class SkOpSpan;
 
@@ skipping 19 matching lines @@
         }
         
         SkOpPtT* oldNext = this->fNext;
         SkASSERT(this != opp);
         this->fNext = opp;
         SkASSERT(oppPrev != oldNext);
         oppPrev->fNext = oldNext;
     }
 
     bool alias() const;
+    bool contains(const SkOpPtT* ) const;
+    SkOpPtT* contains(const SkOpSegment* );
     SkOpContour* contour() const;
 
     int debugID() const {
         return SkDEBUGRELEASE(fID, -1);
     }
 
     const SkOpAngle* debugAngle(int id) const;
     SkOpContour* debugContour(int id);
     int debugLoopLimit(bool report) const;
     bool debugMatchID(int id) const;
     const SkOpPtT* debugPtT(int id) const;
     const SkOpSegment* debugSegment(int id) const;
     const SkOpSpanBase* debugSpan(int id) const;
     SkOpGlobalState* globalState() const;
     void debugValidate() const;
 
     bool deleted() const {
         return fDeleted;
     }
 
+    SkOpPtT* doppelganger();
+
     bool duplicate() const {
         return fDuplicatePt;
     }
 
     void dump() const;  // available to testing only
     void dumpAll() const;
     void dumpBase() const;
 
+    SkOpPtT* find(SkOpSegment* );
     void init(SkOpSpanBase* , double t, const SkPoint& , bool dup);
 
     void insert(SkOpPtT* span) {
         SkASSERT(span != this);
         span->fNext = fNext;
         fNext = span;
     }
 
     const SkOpPtT* next() const {
         return fNext;
     }
 
     SkOpPtT* next() {
         return fNext;
     }
 
     bool onEnd() const;
+
+    static bool Overlaps(SkOpPtT* s1, SkOpPtT* e1, SkOpPtT* s2, SkOpPtT* e2,
+            SkOpPtT** sOut, SkOpPtT** eOut) {
+        SkOpPtT* start1 = s1->fT < e1->fT ? s1 : e1;
+        SkOpPtT* start2 = s2->fT < e2->fT ? s2 : e2;
+        *sOut = between(s1->fT, start2->fT, e1->fT) ? start2
+                : between(s2->fT, start1->fT, e2->fT) ? start1 : NULL;
+        SkOpPtT* end1 = s1->fT < e1->fT ? e1 : s1;
+        SkOpPtT* end2 = s2->fT < e2->fT ? e2 : s2;
+        *eOut = between(s1->fT, end2->fT, e1->fT) ? end2
+                : between(s2->fT, end1->fT, e2->fT) ? end1 : NULL;
+        if (*sOut == *eOut) {
+            SkASSERT(start1->fT >= end2->fT || start2->fT >= end1->fT);
+            return false;
+        }
+        SkASSERT(!*sOut || *sOut != *eOut);
+        return *sOut && *eOut;
+    }
+
     SkOpPtT* prev();
     SkOpPtT* remove();
     void removeNext(SkOpPtT* kept);
 
     const SkOpSegment* segment() const;
     SkOpSegment* segment();
 
     void setDeleted() {
         SkASSERT(!fDeleted);
         fDeleted = true;
     }
 
     const SkOpSpanBase* span() const {
         return fSpan;
     }
 
     SkOpSpanBase* span() {
         return fSpan;
     }
 
+    const SkOpPtT* starter(const SkOpPtT* end) const {
+        return fT < end->fT ? this : end;
+    }
+
     double fT; 
     SkPoint fPt;   // cache of point value at this t
 protected:
     SkOpSpanBase* fSpan;  // contains winding data
     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
     SkDEBUGCODE(int fID);
 };
 
@@ skipping 337 matching lines @@
     SkOpSpanBase* fNext;  // next intersection point
     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
 };
 
 #endif