path ops work in progress

src/pathops/SkOpContour.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #ifndef SkOpContour_DEFINED
 #define SkOpContour_DEFINED
 
 #include "SkOpSegment.h"
 #include "SkTArray.h"
 
 class SkIntersections;
 class SkOpContour;
 class SkPathWriter;
 
 struct SkCoincidence {
-    SkOpContour* fContours[2];
+    SkOpContour* fOther;
     int fSegments[2];
     double fTs[2][2];
     SkPoint fPts[2];
 };
 
 class SkOpContour {
 public:
     SkOpContour() {
         reset();
-#if DEBUG_DUMP
-        fID = ++gContourID;
+#ifdef SK_DEBUG
+        fID = ++SkPathOpsDebug::gContourID;
 #endif
     }
 
     bool operator<(const SkOpContour& rh) const {
         return fBounds.fTop == rh.fBounds.fTop
                 ? fBounds.fLeft < rh.fBounds.fLeft
                 : fBounds.fTop < rh.fBounds.fTop;
     }
 
     void addCoincident(int index, SkOpContour* other, int otherIndex,
@@ skipping 16 matching lines @@
 
     int addLine(const SkPoint pts[2]) {
         fSegments.push_back().addLine(pts, fOperand, fXor);
         return fSegments.count();
     }
 
     void addOtherT(int segIndex, int tIndex, double otherT, int otherIndex) {
         fSegments[segIndex].addOtherT(tIndex, otherT, otherIndex);
     }
 
+    void addPartialCoincident(int index, SkOpContour* other, int otherIndex,
+                       const SkIntersections& ts, int ptIndex, bool swap);
+
     int addQuad(const SkPoint pts[3]) {
         fSegments.push_back().addQuad(pts, fOperand, fXor);
         fContainsCurves = true;
         return fSegments.count();
     }
 
-    int addT(int segIndex, SkOpContour* other, int otherIndex, const SkPoint& pt, double newT) {
+    int addT(int segIndex, SkOpContour* other, int otherIndex, const SkPoint& pt, double newT,
+            bool isNear) {
         setContainsIntercepts();
-        return fSegments[segIndex].addT(&other->fSegments[otherIndex], pt, newT);
+        return fSegments[segIndex].addT(&other->fSegments[otherIndex], pt, newT, isNear);
     }
 
     int addSelfT(int segIndex, SkOpContour* other, int otherIndex, const SkPoint& pt, double newT) {
         setContainsIntercepts();
         return fSegments[segIndex].addSelfT(&other->fSegments[otherIndex], pt, newT);
     }
 
-    int addUnsortableT(int segIndex, SkOpContour* other, int otherIndex, bool start,
-                       const SkPoint& pt, double newT) {
-        return fSegments[segIndex].addUnsortableT(&other->fSegments[otherIndex], start, pt, newT);
-    }
-
     const SkPathOpsBounds& bounds() const {
         return fBounds;
     }
 
     void calcCoincidentWinding();
+    void calcPartialCoincidentWinding();
 
     void checkEnds() {
         if (!fContainsCurves) {
             return;
         }
         int segmentCount = fSegments.count();
         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
             SkOpSegment* segment = &fSegments[sIndex];
             if (segment->verb() == SkPath::kLine_Verb) {
                 continue;
             }
-            fSegments[sIndex].checkEnds();
+            segment->checkEnds();
         }
     }
 
+    // if same point has different T values, choose a common T
+    void checkTiny() {
+        int segmentCount = fSegments.count();
+        if (segmentCount <= 2) {
+            return;
+        }
+        for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
+            fSegments[sIndex].checkTiny();
+        }
+    }
+
     void complete() {
         setBounds();
         fContainsIntercepts = false;
     }
 
     bool containsCubics() const {
         return fContainsCubics;
     }
 
     bool crosses(const SkOpContour* crosser) const {
         for (int index = 0; index < fCrosses.count(); ++index) {
             if (fCrosses[index] == crosser) {
                 return true;
             }
         }
         return false;
     }
 
     bool done() const {
         return fDone;
     }
 
     const SkPoint& end() const {
         const SkOpSegment& segment = fSegments.back();
         return segment.pts()[SkPathOpsVerbToPoints(segment.verb())];
     }
 
-    void findTooCloseToCall() {
-        int segmentCount = fSegments.count();
-        for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
-            fSegments[sIndex].findTooCloseToCall();
-        }
-    }
-
     void fixOtherTIndex() {
         int segmentCount = fSegments.count();
         for (int sIndex = 0; sIndex < segmentCount; ++sIndex) {
             fSegments[sIndex].fixOtherTIndex();
         }
     }
 
     SkOpSegment* nonVerticalSegment(int* start, int* end);
 
     bool operand() const {
@@ skipping 74 matching lines @@
         }
     }
 #endif
 
 #if DEBUG_SHOW_WINDING
     int debugShowWindingValues(int totalSegments, int ofInterest);
     static void debugShowWindingValues(const SkTArray<SkOpContour*, true>& contourList);
 #endif
 
 private:
+    void calcCommonCoincidentWinding(const SkCoincidence& coincidence);
     void setBounds();
 
     SkTArray<SkOpSegment> fSegments;
     SkTArray<SkOpSegment*, true> fSortedSegments;
     int fFirstSorted;
     SkTArray<SkCoincidence, true> fCoincidences;
+    SkTArray<SkCoincidence, true> fPartialCoincidences;
     SkTArray<const SkOpContour*, true> fCrosses;
     SkPathOpsBounds fBounds;
     bool fContainsIntercepts;  // FIXME: is this used by anybody?
     bool fContainsCubics;
     bool fContainsCurves;
     bool fDone;
     bool fOperand;  // true for the second argument to a binary operator
     bool fXor;
     bool fOppXor;
-#if DEBUG_DUMP
+#ifdef SK_DEBUG
     int fID;
 #endif
 };
 
 #endif