path ops work in progress

src/pathops/SkAddIntersections.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "SkAddIntersections.h"
 #include "SkPathOpsBounds.h"
 
 #if DEBUG_ADD_INTERSECTING_TS
@@ skipping 158 matching lines @@
         const SkIntersectionHelper& , const SkIntersections& ) {
 }
 
 static void debugShowCubicIntersection(int , const SkIntersectionHelper& ,
         const SkIntersections& ) {
 }
 #endif
 
 bool AddIntersectTs(SkOpContour* test, SkOpContour* next) {
     if (test != next) {
-        if (test->bounds().fBottom < next->bounds().fTop) {
+        if (AlmostLessUlps(test->bounds().fBottom, next->bounds().fTop)) {
             return false;
         }
+        // OPTIMIZATION: outset contour bounds a smidgen instead?
         if (!SkPathOpsBounds::Intersects(test->bounds(), next->bounds())) {
             return true;
         }
     }
     SkIntersectionHelper wt;
     wt.init(test);
     bool foundCommonContour = test == next;
     do {
         SkIntersectionHelper wn;
         wn.init(next);
@@ skipping 174 matching lines @@
                     continue;
                 }
                 if (wn.segmentType() >= SkIntersectionHelper::kQuad_Segment
                         && wt.segmentType() >= SkIntersectionHelper::kQuad_Segment
                         && ts.isCoincident(0)) {
                     SkASSERT(ts.coincidentUsed() == 2);
                     wt.addCoincident(wn, ts, swap);
                     continue;
                 }
             }
+            if (pts >= 2) {
+                for (int pt = 0; pt < pts - 1; ++pt) {
+                    const SkDPoint& point = ts.pt(pt);
+                    const SkDPoint& next = ts.pt(pt + 1);
+                    if (wt.isNear(ts[swap][pt], ts[swap][pt + 1], point, next)
+                            && wn.isNear(ts[!swap][pt], ts[!swap][pt + 1], point, next)) {
+                        wt.addPartialCoincident(wn, ts, pt, swap);
+                    }
+                }
+            }
             for (int pt = 0; pt < pts; ++pt) {
                 SkASSERT(ts[0][pt] >= 0 && ts[0][pt] <= 1);
                 SkASSERT(ts[1][pt] >= 0 && ts[1][pt] <= 1);
                 SkPoint point = ts.pt(pt).asSkPoint();
-                int testTAt = wt.addT(wn, point, ts[swap][pt]);
-                int nextTAt = wn.addT(wt, point, ts[!swap][pt]);
+                int testTAt = wt.addT(wn, point, ts[swap][pt], swap && ts.isNear(pt));
+                int nextTAt = wn.addT(wt, point, ts[!swap][pt], !swap && ts.isNear(pt));
                 wt.addOtherT(testTAt, ts[!swap][pt], nextTAt);
                 wn.addOtherT(nextTAt, ts[swap][pt], testTAt);
             }
         } while (wn.advance());
     } while (wt.advance());
     return true;
 }
 
 void AddSelfIntersectTs(SkOpContour* test) {
     SkIntersectionHelper wt;
     wt.init(test);
     do {
         if (wt.segmentType() != SkIntersectionHelper::kCubic_Segment) {
             continue;
         }
         SkIntersections ts;
         int pts = ts.cubic(wt.pts());
         debugShowCubicIntersection(pts, wt, ts);
         if (!pts) {
             continue;
         }
         SkASSERT(pts == 1);
         SkASSERT(ts[0][0] >= 0 && ts[0][0] <= 1);
         SkASSERT(ts[1][0] >= 0 && ts[1][0] <= 1);
         SkPoint point = ts.pt(0).asSkPoint();
         int testTAt = wt.addSelfT(wt, point, ts[0][0]);
-        int nextTAt = wt.addT(wt, point, ts[1][0]);
+        int nextTAt = wt.addT(wt, point, ts[1][0], ts.isNear(0));
         wt.addOtherT(testTAt, ts[1][0], nextTAt);
         wt.addOtherT(nextTAt, ts[0][0], testTAt);
     } while (wt.advance());
 }
 
 // resolve any coincident pairs found while intersecting, and
 // see if coincidence is formed by clipping non-concident segments
 void CoincidenceCheck(SkTArray<SkOpContour*, true>* contourList, int total) {
     int contourCount = (*contourList).count();
     for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
         SkOpContour* contour = (*contourList)[cIndex];
         contour->addCoincidentPoints();
     }
     for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
         SkOpContour* contour = (*contourList)[cIndex];
         contour->calcCoincidentWinding();
     }
     for (int cIndex = 0; cIndex < contourCount; ++cIndex) {
         SkOpContour* contour = (*contourList)[cIndex];
-        contour->findTooCloseToCall();
+        contour->calcPartialCoincidentWinding();
     }
 }