compute initial winding from projected rays

tests/PathOpsDebug.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "PathOpsTSectDebug.h"
 #include "SkOpCoincidence.h"
 #include "SkOpContour.h"
@@ skipping 280 matching lines @@
 }
 
 const SkOpSegment* SkPathOpsDebug::DebugSpanSegment(const SkOpSpanBase* span, int id) {
     return span->debugSegment(id);
 }
 
 const SkOpSpanBase* SkPathOpsDebug::DebugSpanSpan(const SkOpSpanBase* span, int id) {
     return span->debugSpan(id);
 }
 
-void SkPathOpsDebug::DumpContours(SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dump();
-    }
+void SkOpContour::dumpContours() const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dump();
+    } while ((contour = contour->next()));
 }
 
-void SkPathOpsDebug::DumpContoursAll(SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpAll();
-    }
+void SkOpContour::dumpContoursAll() const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dumpAll();
+    } while ((contour = contour->next()));
 }
 
-void SkPathOpsDebug::DumpContoursAngles(const SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpAngles();
-    }
+void SkOpContour::dumpContoursAngles() const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dumpAngles();
+    } while ((contour = contour->next()));
 }
 
-void SkPathOpsDebug::DumpContoursPts(const SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpPts();
-    }
+void SkOpContour::dumpContoursPts() const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dumpPts();
+    } while ((contour = contour->next()));
 }
 
-void SkPathOpsDebug::DumpContoursPt(const SkTDArray<SkOpContour* >* contours, int segmentID) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpPt(segmentID);
-    }
+void SkOpContour::dumpContoursPt(int segmentID) const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dumpPt(segmentID);
+    } while ((contour = contour->next()));
 }
 
-void SkPathOpsDebug::DumpContoursSegment(const SkTDArray<SkOpContour* >* contours,
-        int segmentID) {
-    if (contours->count()) {
-        (*contours)[0]->dumpSegment(segmentID);
-    }
+void SkOpContour::dumpContoursSegment(int segmentID) const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dumpSegment(segmentID);
+    } while ((contour = contour->next()));
 }
 
-void SkPathOpsDebug::DumpContoursSpan(const SkTDArray<SkOpContour* >* contours,
-        int spanID) {
-    if (contours->count()) {
-        (*contours)[0]->dumpSpan(spanID);
-    }
+void SkOpContour::dumpContoursSpan(int spanID) const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dumpSpan(spanID);
+    } while ((contour = contour->next()));
 }
 
-void SkPathOpsDebug::DumpContoursSpans(const SkTDArray<SkOpContour* >* contours) {
-    int count = contours->count();
-    for (int index = 0; index < count; ++index) {
-        (*contours)[index]->dumpSpans();
-    }
+void SkOpContour::dumpContoursSpans() const {
+    SkOpContour* contour = this->globalState()->contourHead();
+    do {
+        contour->dumpSpans();
+    } while ((contour = contour->next()));
 }
 
 template <typename TCurve, typename OppCurve>
 const SkTSpan<TCurve, OppCurve>* DebugSpan(const SkTSect<TCurve, OppCurve>* sect, int id) {
     return sect->debugSpan(id);
 }
 
 void DontCallDebugSpan(int id);
 void DontCallDebugSpan(int id) {  // exists to instantiate the templates
     SkDQuad quad;
@@ skipping 356 matching lines @@
 }
 
 const SkOpPtT* SkOpAngle::debugPtT(int id) const {
     return this->segment()->debugPtT(id);
 }
 
 const SkOpSegment* SkOpAngle::debugSegment(int id) const {
     return this->segment()->debugSegment(id);
 }
 
+int SkOpAngle::debugSign() const {
+    SkASSERT(fStart->t() != fEnd->t());
+    return fStart->t() < fEnd->t() ? -1 : 1;
+}
+
 const SkOpSpanBase* SkOpAngle::debugSpan(int id) const {
     return this->segment()->debugSpan(id);
 }
 
 void SkOpAngle::dump() const {
     dumpOne(true);
     SkDebugf("\n");
 }
 
 void SkOpAngle::dumpOne(bool functionHeader) const {
 //    fSegment->debugValidate();
     const SkOpSegment* segment = this->segment();
     const SkOpSpan& mSpan = *fStart->starter(fEnd);
     if (functionHeader) {
         SkDebugf("%s ", __FUNCTION__);
     }
     SkDebugf("[%d", segment->debugID());
     SkDebugf("/%d", debugID());
     SkDebugf("] next=");
     if (fNext) {
         SkDebugf("%d", fNext->fStart->segment()->debugID());
         SkDebugf("/%d", fNext->debugID());
     } else {
         SkDebugf("?");
     }
     SkDebugf(" sect=%d/%d ", fSectorStart, fSectorEnd);
     SkDebugf(" s=%1.9g [%d] e=%1.9g [%d]", fStart->t(), fStart->debugID(),
                 fEnd->t(), fEnd->debugID());
-    SkDebugf(" sgn=%d windVal=%d", this->sign(), mSpan.windValue());
+    SkDebugf(" sgn=%d windVal=%d", this->debugSign(), mSpan.windValue());
 
     SkDebugf(" windSum=");
     SkPathOpsDebug::WindingPrintf(mSpan.windSum());
     if (mSpan.oppValue() != 0 || mSpan.oppSum() != SK_MinS32) {
         SkDebugf(" oppVal=%d", mSpan.oppValue());
         SkDebugf(" oppSum=");
         SkPathOpsDebug::WindingPrintf(mSpan.oppSum());
     }
     if (mSpan.done()) {
         SkDebugf(" done");
     }
     if (unorderable()) {
         SkDebugf(" unorderable");
     }
     if (segment->operand()) {
         SkDebugf(" operand");
     }
-    if (fStop) {
-        SkDebugf(" stop");
-    }
 }
 
 void SkOpAngle::dumpTo(const SkOpSegment* segment, const SkOpAngle* to) const {
     const SkOpAngle* first = this;
     const SkOpAngle* next = this;
     const char* indent = "";
     do {
         SkDebugf("%s", indent);
         next->dumpOne(false);
         if (segment == next->fStart->segment()) {
@@ skipping 264 matching lines @@
     } while (!span->final() && (span = span->upCast()->next()));
 }
 
 void SkOpSegment::dumpCoin() const {
     const SkOpSpan* span = &fHead;
     do {
         span->dumpCoin();
     } while ((span = span->next()->upCastable()));
 }
 
-void SkOpSegment::dumpPts() const {
+void SkOpSegment::dumpPtsInner() const {
     int last = SkPathOpsVerbToPoints(fVerb);
     SkDebugf("seg=%d {{", this->debugID());
     if (fVerb == SkPath::kConic_Verb) {
         SkDebugf("{");
     }
     int index = 0;
     do {
         SkDPoint::Dump(fPts[index]);
         SkDebugf(", ");
     } while (++index < last);
     SkDPoint::Dump(fPts[index]);
     SkDebugf("}}");
     if (fVerb == SkPath::kConic_Verb) {
         SkDebugf(", %1.9gf}", fWeight);
     }
+}
+
+void SkOpSegment::dumpPts() const {
+    dumpPtsInner();
     SkDebugf("\n");
 }
 
 void SkCoincidentSpans::dump() const {
     SkDebugf("- seg=%d span=%d ptT=%d ", fCoinPtTStart->segment()->debugID(),
         fCoinPtTStart->span()->debugID(), fCoinPtTStart->debugID());
     fCoinPtTStart->dumpBase();
     SkDebugf(" span=%d ptT=%d ", fCoinPtTEnd->span()->debugID(), fCoinPtTEnd->debugID());
     fCoinPtTEnd->dumpBase();
     if (fCoinPtTStart->segment()->operand()) {
@@ skipping 18 matching lines @@
 }
 
 void SkOpCoincidence::dump() const {
     SkCoincidentSpans* span = fHead;
     while (span) {
         span->dump();
         span = span->fNext;
     }
 }
 
-void SkOpContour::dump() {
+void SkOpContour::dump() const {
     SkDebugf("contour=%d count=%d op=%d xor=%d\n", this->debugID(), fCount, fOperand, fXor);
     if (!fCount) {
         return;
     }
     const SkOpSegment* segment = &fHead;
-    SkDEBUGCODE(fIndent = 0);
-    indentDump();
+    SkDEBUGCODE(fDebugIndent = 0);
+    this->indentDump();
     do {
         segment->dump();
     } while ((segment = segment->next()));
-    outdentDump();
+    this->outdentDump();
 }
 
-void SkOpContour::dumpAll() {
+void SkOpContour::dumpAll() const {
     SkDebugf("contour=%d count=%d op=%d xor=%d\n", this->debugID(), fCount, fOperand, fXor);
     if (!fCount) {
         return;
     }
     const SkOpSegment* segment = &fHead;
-    SkDEBUGCODE(fIndent = 0);
-    indentDump();
+    SkDEBUGCODE(fDebugIndent = 0);
+    this->indentDump();
     do {
         segment->dumpAll();
     } while ((segment = segment->next()));
-    outdentDump();
+    this->outdentDump();
 }
 
 
 void SkOpContour::dumpAngles() const {
     SkDebugf("contour=%d\n", this->debugID());
     const SkOpSegment* segment = &fHead;
     do {
         SkDebugf("  seg=%d ", segment->debugID());
         segment->dumpAngles();
     } while ((segment = segment->next()));
@@ skipping 64 matching lines @@
     SkDebugf("{{");
     int index;
     for (index = 0; index <= count - 1; ++index) {
         SkDebugf("{%1.9gf,%1.9gf}, ", fPts[index].fX, fPts[index].fY);
     }
     SkDebugf("{%1.9gf,%1.9gf}}}\n", fPts[index].fX, fPts[index].fY);
 }
 
 #ifdef SK_DEBUG
 const SkOpAngle* SkOpGlobalState::debugAngle(int id) const {
-    const SkOpContour* contour = fHead;
+    const SkOpContour* contour = fContourHead;
     do {
         const SkOpSegment* segment = contour->first();
         while (segment) {
             const SkOpSpan* span = segment->head();
             do {
                 SkOpAngle* angle = span->fromAngle();
                 if (angle && angle->debugID() == id) {
                     return angle;
                 }
                 angle = span->toAngle();
                 if (angle && angle->debugID() == id) {
                     return angle;
                 }
             } while ((span = span->next()->upCastable()));
             const SkOpSpanBase* tail = segment->tail();
             SkOpAngle* angle = tail->fromAngle();
             if (angle && angle->debugID() == id) {
                 return angle;
             }
             segment = segment->next();
         }
     } while ((contour = contour->next()));
     return NULL;
 }
 
 SkOpContour* SkOpGlobalState::debugContour(int id) {
-    SkOpContour* contour = fHead;
+    SkOpContour* contour = fContourHead;
     do {
         if (contour->debugID() == id) {
             return contour;
         }
     } while ((contour = contour->next()));
     return NULL;
 }
 
 const SkOpPtT* SkOpGlobalState::debugPtT(int id) const {
-    const SkOpContour* contour = fHead;
+    const SkOpContour* contour = fContourHead;
     do {
         const SkOpSegment* segment = contour->first();
         while (segment) {
             const SkOpSpan* span = segment->head();
             do {
                 const SkOpPtT* ptT = span->ptT();
                 if (ptT->debugMatchID(id)) {
                     return ptT;
                 }
             } while ((span = span->next()->upCastable()));
             const SkOpSpanBase* tail = segment->tail();
             const SkOpPtT* ptT = tail->ptT();
             if (ptT->debugMatchID(id)) {
                 return ptT;
             }
             segment = segment->next();
         }
     } while ((contour = contour->next()));
     return NULL;
 }
 
 const SkOpSegment* SkOpGlobalState::debugSegment(int id) const {
-    const SkOpContour* contour = fHead;
+    const SkOpContour* contour = fContourHead;
     do {
         const SkOpSegment* segment = contour->first();
         while (segment) {
             if (segment->debugID() == id) {
                 return segment;
             }
             segment = segment->next();
         }
     } while ((contour = contour->next()));
     return NULL;
 }
 
 const SkOpSpanBase* SkOpGlobalState::debugSpan(int id) const {
-    const SkOpContour* contour = fHead;
+    const SkOpContour* contour = fContourHead;
     do {
         const SkOpSegment* segment = contour->first();
         while (segment) {
             const SkOpSpan* span = segment->head();
             do {
                 if (span->debugID() == id) {
                     return span;
                 }
             } while ((span = span->next()->upCastable()));
             const SkOpSpanBase* tail = segment->tail();
             if (tail->debugID() == id) {
                 return tail;
             }
             segment = segment->next();
         }
     } while ((contour = contour->next()));
     return NULL;
 }
 #endif
 
-const SkOpAngle* DebugAngle(const SkTDArray<SkOpContour* >* contours, int id) {
-    return (*contours)[0]->debugAngle(id);
-}
-
-SkOpContour* DumpContour(const SkTDArray<SkOpContour* >* contours, int id) {
-    return (*contours)[0]->debugContour(id);
-}
-
-const SkOpPtT* DebugPtT(const SkTDArray<SkOpContour* >* contours, int id) {
-    return (*contours)[0]->debugPtT(id);
-}
-
-const SkOpSegment* DebugSegment(const SkTDArray<SkOpContour* >* contours, int id) {
-    return (*contours)[0]->debugSegment(id);
-}
-
-const SkOpSpanBase* DebugSpan(const SkTDArray<SkOpContour* >* contours, int id) {
-    return (*contours)[0]->debugSpan(id);
-}
-
-void Dump(SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContours(contours);
-}
-
-void DumpAll(SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursAll(contours);
-}
-
-void DumpAngles(const SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursAngles(contours);
-}
-
-void DumpSegment(const SkTDArray<SkOpContour* >* contours, int segmentID) {
-    SkPathOpsDebug::DumpContoursSegment(contours, segmentID);
-}
-
-void DumpSpan(const SkTDArray<SkOpContour* >* contours, int spanID) {
-    SkPathOpsDebug::DumpContoursSpan(contours, spanID);
-}
-
-void DumpSpans(const SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursSpans(contours);
-}
-
-void DumpPt(const SkTDArray<SkOpContour* >* contours, int segmentID) {
-    SkPathOpsDebug::DumpContoursPt(contours, segmentID);
-}
-
-void DumpPts(const SkTDArray<SkOpContour* >* contours) {
-    SkPathOpsDebug::DumpContoursPts(contours);
-}
-
 #if DEBUG_T_SECT_DUMP > 1
 int gDumpTSectNum;
 #endif