compute initial winding from projected rays

src/pathops/SkPathOpsDebug.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPathOpsDebug.h"
 #include "SkPath.h"
 #include "SkString.h"
 #include "SkThread.h"
 
 #if DEBUG_VALIDATE
 extern bool FLAGS_runFail;
 #endif
 
+#if DEBUG_SORT
+int SkPathOpsDebug::gSortCountDefault = SK_MaxS32;
+int SkPathOpsDebug::gSortCount;
+#endif
+
+#if DEBUG_ACTIVE_OP
+const char* SkPathOpsDebug::kPathOpStr[] = {"diff", "sect", "union", "xor"};
+#endif
+
 #if defined SK_DEBUG || !FORCE_RELEASE
 
 const char* SkPathOpsDebug::kLVerbStr[] = {"", "line", "quad", "cubic"};
 
 #if defined(SK_DEBUG) || !FORCE_RELEASE
 int SkPathOpsDebug::gContourID = 0;
 int SkPathOpsDebug::gSegmentID = 0;
 #endif
 
-#if DEBUG_SORT || DEBUG_SWAP_TOP
-int SkPathOpsDebug::gSortCountDefault = SK_MaxS32;
-int SkPathOpsDebug::gSortCount;
-#endif
-
-#if DEBUG_ACTIVE_OP
-const char* SkPathOpsDebug::kPathOpStr[] = {"diff", "sect", "union", "xor"};
-#endif
-
 bool SkPathOpsDebug::ChaseContains(const SkTDArray<SkOpSpanBase* >& chaseArray,
         const SkOpSpanBase* span) {
     for (int index = 0; index < chaseArray.count(); ++index) {
         const SkOpSpanBase* entry = chaseArray[index];
         if (entry == span) {
             return true;
         }
     }
     return false;
 }
@@ skipping 83 matching lines @@
 
 void SkPathOpsDebug::ShowPath(const SkPath& a, const SkPath& b, SkPathOp shapeOp,
         const char* testName) {
     SkAutoMutexAcquire ac(gTestMutex);
     show_function_header(testName);
     ShowOnePath(a, "path", true);
     ShowOnePath(b, "pathB", true);
     show_op(shapeOp, "path", "pathB");
 }
 
+#include "SkPathOpsCubic.h"
+#include "SkPathOpsQuad.h"
+
+SkDCubic SkDQuad::debugToCubic() const {
+    SkDCubic cubic;
+    cubic[0] = fPts[0];
+    cubic[2] = fPts[1];
+    cubic[3] = fPts[2];
+    cubic[1].fX = (cubic[0].fX + cubic[2].fX * 2) / 3;
+    cubic[1].fY = (cubic[0].fY + cubic[2].fY * 2) / 3;
+    cubic[2].fX = (cubic[3].fX + cubic[2].fX * 2) / 3;
+    cubic[2].fY = (cubic[3].fY + cubic[2].fY * 2) / 3;
+    return cubic;
+}
+
 #include "SkOpAngle.h"
+#include "SkOpCoincidence.h"
 #include "SkOpSegment.h"
 
-#if DEBUG_SWAP_TOP
-int SkOpSegment::debugInflections(const SkOpSpanBase* start, const SkOpSpanBase* end) const {
-    if (fVerb != SkPath::kCubic_Verb) {
-        return false;
-    }
-    SkDCubic dst = SkDCubic::SubDivide(fPts, start->t(), end->t());
-    double inflections[2];
-    return dst.findInflections(inflections);
-}
-#endif
-
 SkOpAngle* SkOpSegment::debugLastAngle() {
     SkOpAngle* result = NULL;
     SkOpSpan* span = this->head();
     do {
         if (span->toAngle()) {
             SkASSERT(!result);
             result = span->toAngle();
         }
     } while ((span = span->next()->upCastable()));
     SkASSERT(result);
@@ skipping 26 matching lines @@
         SkDebugf(" (%1.9g,%1.9g", fPts[0].fX, fPts[0].fY);
         for (int vIndex = 1; vIndex <= SkPathOpsVerbToPoints(fVerb); ++vIndex) {
             SkDebugf(" %1.9g,%1.9g", fPts[vIndex].fX, fPts[vIndex].fY);
         }
         if (SkPath::kConic_Verb == fVerb) {
             SkDebugf(" %1.9gf", fWeight);
         }
         const SkOpPtT* ptT = span->ptT();
         SkDebugf(") t=%1.9g (%1.9g,%1.9g)", ptT->fT, ptT->fPt.fX, ptT->fPt.fY);
         SkDebugf(" tEnd=%1.9g", span->next()->t());
-        SkDebugf(" windSum=");
         if (span->windSum() == SK_MinS32) {
-            SkDebugf("?");
+            SkDebugf(" windSum=?");
         } else {
-            SkDebugf("%d", span->windSum());
+            SkDebugf(" windSum=%d", span->windSum());
         }
-        SkDebugf(" windValue=%d oppValue=%d", span->windValue(), span->oppValue());
+        if (span->oppValue() && span->oppSum() == SK_MinS32) {
+            SkDebugf(" oppSum=?");
+        } else if (span->oppValue() || span->oppSum() != SK_MinS32) {
+            SkDebugf(" oppSum=%d", span->oppSum());
+        }
+        SkDebugf(" windValue=%d", span->windValue());
+        if (span->oppValue() || span->oppSum() != SK_MinS32) {
+            SkDebugf(" oppValue=%d", span->oppValue());
+        }
         SkDebugf("\n");
    } while ((span = span->next()->upCastable()));
 }
 #endif
 
 #if DEBUG_MARK_DONE
 void SkOpSegment::debugShowNewWinding(const char* fun, const SkOpSpan* span, int winding) {
     const SkPoint& pt = span->ptT()->fPt;
     SkDebugf("%s id=%d", fun, this->debugID());
     SkDebugf(" (%1.9g,%1.9g", fPts[0].fX, fPts[0].fY);
@@ skipping 75 matching lines @@
             result.printf(CUBIC_DEBUG_STR " id=%d", CUBIC_DEBUG_DATA(fCurvePart),
                     this->segment()->debugID());
             break;
         default:
             SkASSERT(0);
     } 
     return result;
 }
 #endif
 
-#if DEBUG_SORT || DEBUG_SWAP_TOP
+#if DEBUG_SORT
 void SkOpAngle::debugLoop() const {
     const SkOpAngle* first = this;
     const SkOpAngle* next = this;
     do {
         next->dumpOne(true);
         SkDebugf("\n");
         next = next->fNext;
     } while (next && next != first);
     next = first;
     do {
@@ skipping 21 matching lines @@
         }
         bool op = next->segment()->operand();
         bool isXor = next->segment()->isXor();
         bool oppXor = next->segment()->oppXor();
         SkASSERT(!DEBUG_LIMIT_WIND_SUM || between(0, minSpan->windValue(), DEBUG_LIMIT_WIND_SUM));
         SkASSERT(!DEBUG_LIMIT_WIND_SUM
                 || between(-DEBUG_LIMIT_WIND_SUM, minSpan->oppValue(), DEBUG_LIMIT_WIND_SUM));
         bool useXor = op ? oppXor : isXor;
         SkASSERT(lastXor == -1 || lastXor == (int) useXor);
         lastXor = (int) useXor;
-        wind += next->sign() * (op ? minSpan->oppValue() : minSpan->windValue());
+        wind += next->debugSign() * (op ? minSpan->oppValue() : minSpan->windValue());
         if (useXor) {
             wind &= 1;
         }
         useXor = op ? isXor : oppXor;
         SkASSERT(lastOppXor == -1 || lastOppXor == (int) useXor);
         lastOppXor = (int) useXor;
-        opp += next->sign() * (op ? minSpan->windValue() : minSpan->oppValue());
+        opp += next->debugSign() * (op ? minSpan->windValue() : minSpan->oppValue());
         if (useXor) {
             opp &= 1;
         }
         next = next->fNext;
     } while (next && next != first);
     SkASSERT(wind == 0);
     SkASSERT(opp == 0 || !FLAGS_runFail);
 #endif
 }
 
@@ skipping 10 matching lines @@
             break;
         }
         SK_ALWAYSBREAK(!angles.contains(next));
         if (!next) {
             return;
         }
     } while (true);
 #endif
 }
 
+void SkOpCoincidence::debugShowCoincidence() const {
+    SkCoincidentSpans* span = fHead;
+    while (span) {
+        SkDebugf("%s - id=%d t=%1.9g tEnd=%1.9g\n", __FUNCTION__,
+                span->fCoinPtTStart->segment()->debugID(),
+                span->fCoinPtTStart->fT, span->fCoinPtTEnd->fT);
+        SkDebugf("%s + id=%d t=%1.9g tEnd=%1.9g\n", __FUNCTION__,
+                span->fOppPtTStart->segment()->debugID(),
+                span->fOppPtTStart->fT, span->fOppPtTEnd->fT);
+        span = span->fNext;
+    }
+}
+
 void SkOpSegment::debugValidate() const {
 #if DEBUG_VALIDATE
     const SkOpSpanBase* span = &fHead;
     double lastT = -1;
     const SkOpSpanBase* prev = NULL;
     int count = 0;
     int done = 0;
     do {
         if (!span->final()) {
             ++count;
@@ skipping 77 matching lines @@
                     SkDebugf("*** bad coincident loop ***\n");
                     return false;
                 }
             }
         }
         ++loop;
     } while ((next = nextCoin) && next != this);
     return true;
 }
 
+// called only by test code
+int SkIntersections::debugCoincidentUsed() const {
+    if (!fIsCoincident[0]) {
+        SkASSERT(!fIsCoincident[1]);
+        return 0;
+    }
+    int count = 0;
+    SkDEBUGCODE(int count2 = 0;)
+    for (int index = 0; index < fUsed; ++index) {
+        if (fIsCoincident[0] & (1 << index)) {
+            ++count;
+        }
+#ifdef SK_DEBUG
+        if (fIsCoincident[1] & (1 << index)) {
+            ++count2;
+        }
+#endif
+    }
+    SkASSERT(count == count2);
+    return count;
+}
+
 #include "SkOpContour.h"
 
 int SkOpPtT::debugLoopLimit(bool report) const {
     int loop = 0;
     const SkOpPtT* next = this;
     do {
         for (int check = 1; check < loop - 1; ++check) {
             const SkOpPtT* checkPtT = this->fNext;
             const SkOpPtT* innerPtT = checkPtT;
             for (int inner = check + 1; inner < loop; ++inner) {
@@ skipping 119 matching lines @@
 #endif
     SkPath::FillType fillType = path.getFillType();
     SkASSERT(fillType >= SkPath::kWinding_FillType && fillType <= SkPath::kInverseEvenOdd_FillType);
     if (includeDeclaration) {
         SkDebugf("    SkPath %s;\n", name);
     }
     SkDebugf("    %s.setFillType(SkPath::%s);\n", name, gFillTypeStr[fillType]);
     iter.setPath(path);
     showPathContours(iter, name);
 }