pathops tiger checkpoint

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 "SkMutex.h"
 #include "SkOpCoincidence.h"
 #include "SkOpContour.h"
@@ skipping 251 matching lines @@
 #if DEBUG_COINCIDENCE_VERBOSE
     GlitchLog glitches;
     const SkOpContour* contour = contourList;
     const SkOpCoincidence* coincidence = contour->globalState()->coincidence();
     coincidence->debugCheckValid(id, &glitches); // don't call validate; spans may be inconsistent
     do {
         contour->debugCheckHealth(id, &glitches);
         contour->debugMissingCoincidence(id, &glitches);
     } while ((contour = contour->next()));
     coincidence->debugRemoveCollapsed(id, &glitches);
-    coincidence->debugAddMissing(id, &glitches);
+    bool added;
+    coincidence->debugAddMissing(id, &glitches, &added);
     coincidence->debugExpand(id, &glitches);
     coincidence->debugAddExpanded(id, &glitches);
     coincidence->debugMark(id, &glitches);
     coincidence->debugReorder(id, &glitches);
     unsigned mask = 0;
     for (int index = 0; index < glitches.fGlitches.count(); ++index) {
         const SpanGlitch& glitch = glitches.fGlitches[index];
         mask |= 1 << glitch.fType;
     }
     for (int index = 0; index < kGlitchType_Count; ++index) {
@@ skipping 1103 matching lines @@
         return;
     }
     log->record(kAddIfMissingCoin_Glitch, id, outer->coinPtTStart(), outer->coinPtTEnd(), over1s, over1e);
     this->debugValidate();
     return;
 }
 
 /* Commented-out lines keep this in sync addIfMissing() */
 // note that over1s, over1e, over2s, over2e are ordered
 void SkOpCoincidence::debugAddIfMissing(const char* id, SkPathOpsDebug::GlitchLog* log, const SkOpPtT* over1s, const SkOpPtT* over2s,
-        double tStart, double tEnd, const SkOpSegment* coinSeg, const SkOpSegment* oppSeg,
+        double tStart, double tEnd, const SkOpSegment* coinSeg, const SkOpSegment* oppSeg, bool* added,
         const SkOpPtT* over1e, const SkOpPtT* over2e) const {
     SkASSERT(tStart < tEnd);
     SkASSERT(over1s->fT < over1e->fT);
     SkASSERT(between(over1s->fT, tStart, over1e->fT));
     SkASSERT(between(over1s->fT, tEnd, over1e->fT));
     SkASSERT(over2s->fT < over2e->fT);
     SkASSERT(between(over2s->fT, tStart, over2e->fT));
     SkASSERT(between(over2s->fT, tEnd, over2e->fT));
     SkASSERT(over1s->segment() == over1e->segment());
     SkASSERT(over2s->segment() == over2e->segment());
     SkASSERT(over1s->segment() == over2s->segment());
     SkASSERT(over1s->segment() != coinSeg);
     SkASSERT(over1s->segment() != oppSeg);
     SkASSERT(coinSeg != oppSeg);
     double coinTs, coinTe, oppTs, oppTe;
     coinTs = TRange(over1s, tStart, coinSeg  SkDEBUGPARAMS(over1e));
     coinTe = TRange(over1s, tEnd, coinSeg  SkDEBUGPARAMS(over1e));
     if (coinSeg->collapsed(coinTs, coinTe)) {
         return log->record(kAddIfCollapsed_Glitch, id, coinSeg);
     }
     oppTs = TRange(over2s, tStart, oppSeg  SkDEBUGPARAMS(over2e));
     oppTe = TRange(over2s, tEnd, oppSeg  SkDEBUGPARAMS(over2e));
     if (oppSeg->collapsed(oppTs, oppTe)) {
         return log->record(kAddIfCollapsed_Glitch, id, oppSeg);
     }
     if (coinTs > coinTe) {
         SkTSwap(coinTs, coinTe);
         SkTSwap(oppTs, oppTe);
     }
-    return this->debugAddOrOverlap(id, log, coinSeg, oppSeg, coinTs, coinTe, oppTs, oppTe
+    return this->debugAddOrOverlap(id, log, coinSeg, oppSeg, coinTs, coinTe, oppTs, oppTe, added
             );
 }
 
 /* Commented-out lines keep this in sync addOrOverlap() */
 // If this is called by addEndMovedSpans(), a returned false propogates out to an abort.
 // If this is called by AddIfMissing(), a returned false indicates there was nothing to add
 void SkOpCoincidence::debugAddOrOverlap(const char* id, SkPathOpsDebug::GlitchLog* log,
         const SkOpSegment* coinSeg, const SkOpSegment* oppSeg,
-        double coinTs, double coinTe, double oppTs, double oppTe) const {
+        double coinTs, double coinTe, double oppTs, double oppTe, bool* added) const {
     SkTDArray<SkCoincidentSpans*> overlaps;
     SkASSERT(!fTop);   // this is (correctly) reversed in addifMissing()
-    if (fTop && !this->checkOverlap(fTop, coinSeg, oppSeg, coinTs, coinTe, oppTs, oppTe, &overlaps)) {
+    if (fTop && !this->checkOverlap(fTop, coinSeg, oppSeg, coinTs, coinTe, oppTs, oppTe,
+            &overlaps)) {
         return;
     }
     if (fHead && !this->checkOverlap(fHead, coinSeg, oppSeg, coinTs,
             coinTe, oppTs, oppTe, &overlaps)) {
         return;
     }
     const SkCoincidentSpans* overlap = overlaps.count() ? overlaps[0] : nullptr;
     for (int index = 1; index < overlaps.count(); ++index) { // combine overlaps before continuing
         const SkCoincidentSpans* test = overlaps[index];
         if (overlap->coinPtTStart()->fT > test->coinPtTStart()->fT) {
@@ skipping 92 matching lines @@
 #endif
     }
     this->debugValidate();
     return (void) result;
 }
 
 // Extra commented-out lines keep this in sync with addMissing()
 /* detects overlaps of different coincident runs on same segment */
 /* does not detect overlaps for pairs without any segments in common */
 // returns true if caller should loop again
-void SkOpCoincidence::debugAddMissing(const char* id, SkPathOpsDebug::GlitchLog* log) const {
+void SkOpCoincidence::debugAddMissing(const char* id, SkPathOpsDebug::GlitchLog* log, bool* added) const {
     const SkCoincidentSpans* outer = fHead;
     if (!outer) {
         return;
     }
     // bool added = false;
     // fTop = outer;
     // fHead = nullptr;
     do {
     // addifmissing can modify the list that this is walking
     // save head so that walker can iterate over old data unperturbed
@@ skipping 22 matching lines @@
             SkASSERT(!innerOpp->done());
 //            SkOpSegment* innerCoinWritable = const_cast<SkOpSegment*>(innerCoin);
 //            SkOpSegment* innerOppWritable = const_cast<SkOpSegment*>(innerOpp);
             if (outerCoin == innerCoin) {
                 const SkOpPtT* oce = outer->coinPtTEnd();
                 SkASSERT(!oce->deleted());
                 const SkOpPtT* ice = inner->coinPtTEnd();
                 SkASSERT(!ice->deleted());
                 if (outerOpp != innerOpp && this->overlap(ocs, oce, ics, ice, &overS, &overE)) {
                     this->debugAddIfMissing(id, log, ocs->starter(oce), ics->starter(ice),
-                            overS, overE, outerOpp, innerOpp,
+                            overS, overE, outerOpp, innerOpp, added,
                             ocs->debugEnder(oce),
                             ics->debugEnder(ice));
                 }
             } else if (outerCoin == innerOpp) {
                 const SkOpPtT* oce = outer->coinPtTEnd();
                 SkASSERT(!oce->deleted());
                 const SkOpPtT* ioe = inner->oppPtTEnd();
                 SkASSERT(!ioe->deleted());
                 if (outerOpp != innerCoin && this->overlap(ocs, oce, ios, ioe, &overS, &overE)) {
                     this->debugAddIfMissing(id, log, ocs->starter(oce), ios->starter(ioe),
-                            overS, overE, outerOpp, innerCoin,
+                            overS, overE, outerOpp, innerCoin, added,
                             ocs->debugEnder(oce),
                             ios->debugEnder(ioe));
                 }
             } else if (outerOpp == innerCoin) {
                 const SkOpPtT* ooe = outer->oppPtTEnd();
                 SkASSERT(!ooe->deleted());
                 const SkOpPtT* ice = inner->coinPtTEnd();
                 SkASSERT(!ice->deleted());
                 SkASSERT(outerCoin != innerOpp);
                 if (this->overlap(oos, ooe, ics, ice, &overS, &overE)) {
                     this->debugAddIfMissing(id, log, oos->starter(ooe), ics->starter(ice),
-                            overS, overE, outerCoin, innerOpp,
+                            overS, overE, outerCoin, innerOpp, added,
                             oos->debugEnder(ooe),
                             ics->debugEnder(ice));
                 }
             } else if (outerOpp == innerOpp) {
                 const SkOpPtT* ooe = outer->oppPtTEnd();
                 SkASSERT(!ooe->deleted());
                 const SkOpPtT* ioe = inner->oppPtTEnd();
                 SkASSERT(!ioe->deleted());
                 SkASSERT(outerCoin != innerCoin);
                 if (this->overlap(oos, ooe, ios, ioe, &overS, &overE)) {
                     this->debugAddIfMissing(id, log, oos->starter(ooe), ios->starter(ioe),
-                            overS, overE, outerCoin, innerCoin,
+                            overS, overE, outerCoin, innerCoin, added,
                             oos->debugEnder(ooe),
                             ios->debugEnder(ioe));
                 }
             }
             this->debugValidate();
         }
     } while ((outer = outer->next()));
     // this->restoreHead();
     return;
 }
@@ skipping 326 matching lines @@
     // check for overlapping coincident spans
     const SkCoincidentSpans* test = head;
     while (test) {
         const SkCoincidentSpans* next = test->next();
         DebugCheckOverlap(test, next, id, log);
         DebugCheckOverlap(test, opt, id, log);
         test = next;
     }
 }
 
-#if DEBUG_COINCIDENCE_VERBOSE
-void SkOpCoincidence::debugCheckOverlap(const char* id, SkPathOpsDebug::GlitchLog* log) const {
-    DebugCheckOverlapTop(fHead, fTop, id, log);
-    DebugCheckOverlapTop(fTop, nullptr, id, log);
-}
-#endif
-
 static void DebugValidate(const SkCoincidentSpans* head, const SkCoincidentSpans* opt,
         const char* id, SkPathOpsDebug::GlitchLog* log) {
     // look for pts inside coincident spans that are not inside the opposite spans
     const SkCoincidentSpans* coin = head;
     while (coin) {
         SkASSERT(SkOpCoincidence::Ordered(coin->coinPtTStart()->segment(),
                 coin->oppPtTStart()->segment()));
         SkASSERT(coin->coinPtTStart()->span()->ptT() == coin->coinPtTStart());
         SkASSERT(coin->coinPtTEnd()->span()->ptT() == coin->coinPtTEnd());
         SkASSERT(coin->oppPtTStart()->span()->ptT() == coin->oppPtTStart());
@@ skipping 649 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);
 }