path ops work in progress

src/pathops/SkPathOpsOp.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 "SkOpEdgeBuilder.h"
 #include "SkPathOpsCommon.h"
 #include "SkPathWriter.h"
@@ skipping 31 matching lines @@
         int angleCount = sorted.count();
 #if DEBUG_SORT
         sorted[0]->segment()->debugShowSort(__FUNCTION__, sorted, 0, sortable);
 #endif
         if (!sortable) {
             continue;
         }
         // find first angle, initialize winding to computed fWindSum
         int firstIndex = -1;
         const SkOpAngle* angle;
+        bool foundAngle = true;
         do {
-            angle = sorted[++firstIndex];
+            ++firstIndex;
+            if (firstIndex >= angleCount) {
+                foundAngle = false;
+                break;
+            }
+            angle = sorted[firstIndex];
             segment = angle->segment();
         } while (segment->windSum(angle) == SK_MinS32);
+        if (!foundAngle) {
+            continue;
+        }
     #if DEBUG_SORT
         segment->debugShowSort(__FUNCTION__, sorted, firstIndex, sortable);
     #endif
         int sumMiWinding = segment->updateWindingReverse(angle);
         int sumSuWinding = segment->updateOppWindingReverse(angle);
         if (segment->operand()) {
             SkTSwap<int>(sumMiWinding, sumSuWinding);
         }
         int nextIndex = firstIndex + 1;
         int lastIndex = firstIndex != 0 ? firstIndex : angleCount;
@@ skipping 62 matching lines @@
 
 static bool bridgeOp(SkTArray<SkOpContour*, true>& contourList, const SkPathOp op,
         const int xorMask, const int xorOpMask, SkPathWriter* simple) {
     bool firstContour = true;
     bool unsortable = false;
     bool topUnsortable = false;
     SkPoint topLeft = {SK_ScalarMin, SK_ScalarMin};
     do {
         int index, endIndex;
         bool done;
-        SkOpSegment* current = FindSortableTop(contourList, &firstContour, &index, &endIndex,
-                &topLeft, &topUnsortable, &done, true);
+        SkOpSegment* current = FindSortableTop(contourList, SkOpAngle::kBinarySingle, &firstContour,
+                &index, &endIndex, &topLeft, &topUnsortable, &done);
         if (!current) {
             if (topUnsortable || !done) {
                 topUnsortable = false;
                 SkASSERT(topLeft.fX != SK_ScalarMin && topLeft.fY != SK_ScalarMin);
                 topLeft.fX = topLeft.fY = SK_ScalarMin;
                 continue;
             }
             break;
         }
         SkTDArray<SkOpSpan*> chaseArray;
@@ skipping 28 matching lines @@
                     current->debugID(), current->xyAtT(index).fX, current->xyAtT(index).fY,
                     current->xyAtT(endIndex).fX, current->xyAtT(endIndex).fY);
         #endif
                     current->addCurveTo(index, endIndex, simple, true);
                     current = next;
                     index = nextStart;
                     endIndex = nextEnd;
                 } while (!simple->isClosed() && (!unsortable
                         || !current->done(SkMin32(index, endIndex))));
                 if (current->activeWinding(index, endIndex) && !simple->isClosed()) {
+                    // FIXME : add to simplify, xor cpaths
+                    int min = SkMin32(index, endIndex);
+                    if (!unsortable && !simple->isEmpty()) {
+                        unsortable = current->checkSmall(min);
+                    }
                     SkASSERT(unsortable || simple->isEmpty());
-                    int min = SkMin32(index, endIndex);
                     if (!current->done(min)) {
                         current->addCurveTo(index, endIndex, simple, true);
                         current->markDoneBinary(min);
                     }
                 }
                 simple->close();
             } else {
                 SkOpSpan* last = current->markAndChaseDoneBinary(index, endIndex);
                 if (last && !last->fLoop) {
                     *chaseArray.append() = last;
@@ skipping 28 matching lines @@
     {{ false, false }, { false, true }},  // sect
     {{ false, true }, { true, true }},    // union
     {{ false, true }, { true, false }},   // xor
     {{ false, true }, { false, false }},  // rev diff
 };
 
 bool Op(const SkPath& one, const SkPath& two, SkPathOp op, SkPath* result) {
 #if DEBUG_SHOW_TEST_NAME
     char* debugName = DEBUG_FILENAME_STRING;
     if (debugName && debugName[0]) {
-        DebugBumpTestName(debugName);
-        DebugShowPath(one, two, op, debugName);
+        SkPathOpsDebug::BumpTestName(debugName);
+        SkPathOpsDebug::ShowPath(one, two, op, debugName);
     }
 #endif
     op = gOpInverse[op][one.isInverseFillType()][two.isInverseFillType()];
     SkPath::FillType fillType = gOutInverse[op][one.isInverseFillType()][two.isInverseFillType()]
             ? SkPath::kInverseEvenOdd_FillType : SkPath::kEvenOdd_FillType;
     const SkPath* minuend = &one;
     const SkPath* subtrahend = &two;
     if (op == kReverseDifference_PathOp) {
         minuend = &two;
         subtrahend = &one;
         op = kDifference_PathOp;
     }
 #if DEBUG_SORT || DEBUG_SWAP_TOP
-    gDebugSortCount = gDebugSortCountDefault;
+    SkPathOpsDebug::gSortCount = SkPathOpsDebug::gSortCountDefault;
 #endif
     // turn path into list of segments
     SkTArray<SkOpContour> contours;
     // FIXME: add self-intersecting cubics' T values to segment
     SkOpEdgeBuilder builder(*minuend, contours);
     const int xorMask = builder.xorMask();
     builder.addOperand(*subtrahend);
     if (!builder.finish()) {
         return false;
     }
@@ skipping 29 matching lines @@
     }
 #if DEBUG_SHOW_WINDING
     SkOpContour::debugShowWindingValues(contourList);
 #endif
     CoincidenceCheck(&contourList, total);
 #if DEBUG_SHOW_WINDING
     SkOpContour::debugShowWindingValues(contourList);
 #endif
     FixOtherTIndex(&contourList);
     CheckEnds(&contourList);
+    CheckTiny(&contourList);
     SortSegments(&contourList);
 #if DEBUG_ACTIVE_SPANS || DEBUG_ACTIVE_SPANS_FIRST_ONLY
     DebugShowActiveSpans(contourList);
 #endif
     // construct closed contours
     SkPathWriter wrapper(*result);
     bridgeOp(contourList, op, xorMask, xorOpMask, &wrapper);
     {  // if some edges could not be resolved, assemble remaining fragments
         SkPath temp;
         temp.setFillType(fillType);
         SkPathWriter assembled(temp);
         Assemble(wrapper, &assembled);
         *result = *assembled.nativePath();
         result->setFillType(fillType);
     }
     return true;
 }