path ops work in progress

src/pathops/SkPathOpsCommon.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 "SkOpEdgeBuilder.h"
 #include "SkPathOpsCommon.h"
 #include "SkPathWriter.h"
 #include "SkTSort.h"
@@ skipping 232 matching lines @@
             if (!contour->done()) {
                 *done = false;
             }
         }
         if (!topStart) {
             return NULL;
         }
         *topLeft = bestXY;
         result = topStart->findTop(index, endIndex, unsortable, onlySortable);
     } while (!result);
+    if (result) {
+        *unsortable = false;
+    }
     return result;
 }
 
 static int rightAngleWinding(const SkTArray<SkOpContour*, true>& contourList,
                              SkOpSegment** current, int* index, int* endIndex, double* tHit,
                              SkScalar* hitDx, bool* tryAgain, bool opp) {
     double test = 0.9;
     int contourWinding;
     do {
         contourWinding = contourRangeCheckY(contourList, current, index, endIndex, tHit, hitDx,
@@ skipping 18 matching lines @@
         if (contour->done()) {
             continue;
         }
         *current = contour->nonVerticalSegment(index, endIndex);
         if (*current) {
             return;
         }
     }
 }
 
-SkOpSegment* FindSortableTop(const SkTArray<SkOpContour*, true>& contourList, bool* firstContour,
-                             int* indexPtr, int* endIndexPtr, SkPoint* topLeft, bool* unsortable,
-                             bool* done,  bool binary) {
+SkOpSegment* FindSortableTop(const SkTArray<SkOpContour*, true>& contourList,
+        SkOpAngle::IncludeType angleIncludeType, bool* firstContour, int* indexPtr,
+        int* endIndexPtr, SkPoint* topLeft, bool* unsortable, bool* done) {
     SkOpSegment* current = findSortableTop(contourList, indexPtr, endIndexPtr, topLeft, unsortable,
             done, true);
     if (!current) {
         return NULL;
     }
     const int index = *indexPtr;
     const int endIndex = *endIndexPtr;
     if (*firstContour) {
         current->initWinding(index, endIndex);
         *firstContour = false;
         return current;
     }
     int minIndex = SkMin32(index, endIndex);
     int sumWinding = current->windSum(minIndex);
     if (sumWinding != SK_MinS32) {
         return current;
     }
-    sumWinding = current->computeSum(index, endIndex, binary);
-    if (sumWinding != SK_MinS32) {
+    SkASSERT(current->windSum(SkMin32(index, endIndex)) == SK_MinS32);
+    SkSTArray<SkOpAngle::kStackBasedCount, SkOpAngle, true> angles;
+    SkSTArray<SkOpAngle::kStackBasedCount, SkOpAngle*, true> sorted;
+    sumWinding = current->computeSum(index, endIndex, angleIncludeType, &angles, &sorted);
+    if (sumWinding != SK_MinS32 && sumWinding != SK_NaN32) {
         return current;
     }
     int contourWinding;
     int oppContourWinding = 0;
     // the simple upward projection of the unresolved points hit unsortable angles
     // shoot rays at right angles to the segment to find its winding, ignoring angle cases
     bool tryAgain;
     double tHit;
     SkScalar hitDx = 0;
     SkScalar hitOppDx = 0;
     do {
         // if current is vertical, find another candidate which is not
         // if only remaining candidates are vertical, then they can be marked done
         SkASSERT(*indexPtr != *endIndexPtr && *indexPtr >= 0 && *endIndexPtr >= 0);
         skipVertical(contourList, &current, indexPtr, endIndexPtr);
 
         SkASSERT(*indexPtr != *endIndexPtr && *indexPtr >= 0 && *endIndexPtr >= 0);
         tryAgain = false;
         contourWinding = rightAngleWinding(contourList, &current, indexPtr, endIndexPtr, &tHit,
                 &hitDx, &tryAgain, false);
         if (tryAgain) {
             continue;
         }
-        if (!binary) {
+        if (angleIncludeType < SkOpAngle::kBinarySingle) {
             break;
         }
         oppContourWinding = rightAngleWinding(contourList, &current, indexPtr, endIndexPtr, &tHit,
                 &hitOppDx, &tryAgain, true);
     } while (tryAgain);
     current->initWinding(*indexPtr, *endIndexPtr, tHit, contourWinding, hitDx, oppContourWinding,
             hitOppDx);
     return current;
 }
 
 void CheckEnds(SkTArray<SkOpContour*, true>* contourList) {
     // it's hard to determine if the end of a cubic or conic nearly intersects another curve.
     // instead, look to see if the connecting curve intersected at that same end.
     int contourCount = (*contourList).count();
     for (int cTest = 0; cTest < contourCount; ++cTest) {
         SkOpContour* contour = (*contourList)[cTest];
         contour->checkEnds();
     }
 }
 
+// A tiny interval may indicate an undiscovered coincidence. Find and fix.
+void CheckTiny(SkTArray<SkOpContour*, true>* contourList) {
+    int contourCount = (*contourList).count();
+    for (int cTest = 0; cTest < contourCount; ++cTest) {
+        SkOpContour* contour = (*contourList)[cTest];
+        contour->checkTiny();
+    }
+}
+
 void FixOtherTIndex(SkTArray<SkOpContour*, true>* contourList) {
     int contourCount = (*contourList).count();
     for (int cTest = 0; cTest < contourCount; ++cTest) {
         SkOpContour* contour = (*contourList)[cTest];
         contour->fixOtherTIndex();
     }
 }
 
 void SortSegments(SkTArray<SkOpContour*, true>* contourList) {
     int contourCount = (*contourList).count();
@@ skipping 218 matching lines @@
             }
         }
     } while (rIndex < count);
 #if DEBUG_ASSEMBLE
     for (rIndex = 0; rIndex < count; ++rIndex) {
        SkASSERT(sLink[rIndex] == SK_MaxS32);
        SkASSERT(eLink[rIndex] == SK_MaxS32);
     }
 #endif
 }