Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(92)

Unified Diff: tests/PathOpsDebug.cpp

Issue 1002693002: pathops version two (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: fix arm 64 inspired coincident handling Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « tests/PathOpsDTriangleTest.cpp ('k') | tests/PathOpsExtendedTest.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: tests/PathOpsDebug.cpp
diff --git a/tests/PathOpsDebug.cpp b/tests/PathOpsDebug.cpp
index c4fbbfa69517610c7168e6fb9e6f361b2c455e78..9930453d01ea9fb0a7d37af298ebc1fa59a4b7ad 100755
--- a/tests/PathOpsDebug.cpp
+++ b/tests/PathOpsDebug.cpp
@@ -1,3 +1,12 @@
+/*
+ * 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"
#include "SkIntersectionHelper.h"
#include "SkOpSegment.h"
@@ -50,7 +59,6 @@ static void output_points(const SkPoint* pts, int count) {
SkDebugf(", ");
}
}
- SkDebugf(");\n");
}
static void showPathContours(SkPath::RawIter& iter, const char* pathName) {
@@ -61,18 +69,27 @@ static void showPathContours(SkPath::RawIter& iter, const char* pathName) {
case SkPath::kMove_Verb:
SkDebugf(" %s.moveTo(", pathName);
output_points(&pts[0], 1);
+ SkDebugf(");\n");
continue;
case SkPath::kLine_Verb:
SkDebugf(" %s.lineTo(", pathName);
output_points(&pts[1], 1);
+ SkDebugf(");\n");
break;
case SkPath::kQuad_Verb:
SkDebugf(" %s.quadTo(", pathName);
output_points(&pts[1], 2);
+ SkDebugf(");\n");
+ break;
+ case SkPath::kConic_Verb:
+ SkDebugf(" %s.conicTo(", pathName);
+ output_points(&pts[1], 2);
+ SkDebugf(", %1.9gf);\n", iter.conicWeight());
break;
case SkPath::kCubic_Verb:
SkDebugf(" %s.cubicTo(", pathName);
output_points(&pts[1], 3);
+ SkDebugf(");\n");
break;
case SkPath::kClose_Verb:
SkDebugf(" %s.close();\n", pathName);
@@ -168,228 +185,35 @@ void SkPathOpsDebug::WindingPrintf(int wind) {
}
#endif
-void SkOpAngle::dump() const {
- dumpOne(true);
- SkDebugf("\n");
-}
-
-void SkOpAngle::dumpOne(bool functionHeader) const {
-// fSegment->debugValidate();
- const SkOpSpan& mSpan = fSegment->span(SkMin32(fStart, fEnd));
- if (functionHeader) {
- SkDebugf("%s ", __FUNCTION__);
- }
- SkDebugf("[%d", fSegment->debugID());
- SkDebugf("/%d", debugID());
- SkDebugf("] next=");
- if (fNext) {
- SkDebugf("%d", fNext->fSegment->debugID());
- SkDebugf("/%d", fNext->debugID());
- } else {
- SkDebugf("?");
- }
- SkDebugf(" sect=%d/%d ", fSectorStart, fSectorEnd);
- SkDebugf(" s=%1.9g [%d] e=%1.9g [%d]", fSegment->span(fStart).fT, fStart,
- fSegment->span(fEnd).fT, fEnd);
- SkDebugf(" sgn=%d windVal=%d", sign(), mSpan.fWindValue);
-
- SkDebugf(" windSum=");
- SkPathOpsDebug::WindingPrintf(mSpan.fWindSum);
- if (mSpan.fOppValue != 0 || mSpan.fOppSum != SK_MinS32) {
- SkDebugf(" oppVal=%d", mSpan.fOppValue);
- SkDebugf(" oppSum=");
- SkPathOpsDebug::WindingPrintf(mSpan.fOppSum);
- }
- if (mSpan.fDone) {
- SkDebugf(" done");
- }
- if (unorderable()) {
- SkDebugf(" unorderable");
- }
- if (small()) {
- SkDebugf(" small");
- }
- if (mSpan.fTiny) {
- SkDebugf(" tiny");
- }
- if (fSegment->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->fSegment) {
- if (this == fNext) {
- SkDebugf(" << from");
- }
- if (to == fNext) {
- SkDebugf(" << to");
- }
- }
- SkDebugf("\n");
- indent = " ";
- next = next->fNext;
- } while (next && next != first);
-}
-
-void SkOpAngle::dumpLoop() const {
- const SkOpAngle* first = this;
- const SkOpAngle* next = this;
- do {
- next->dumpOne(false);
- SkDebugf("\n");
- next = next->fNext;
- } while (next && next != first);
-}
-
-void SkOpAngle::dumpPartials() const {
- const SkOpAngle* first = this;
- const SkOpAngle* next = this;
- do {
- next->fCurvePart.dumpNumber();
- next = next->fNext;
- } while (next && next != first);
-}
-
-void SkOpAngleSet::dump() const {
- // FIXME: unimplemented
-/* This requires access to the internal SkChunkAlloc data
- Defer implementing this until it is needed for debugging
-*/
- SkASSERT(0);
-}
-
-void SkOpContour::dump() const {
- int segmentCount = fSegments.count();
- SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
- for (int test = 0; test < segmentCount; ++test) {
- SkDebugf(" [%d] ((SkOpSegment*) 0x%p) [%d]\n", test, &fSegments[test],
- fSegments[test].debugID());
- }
-}
-
-void SkOpContour::dumpAngles() const {
- int segmentCount = fSegments.count();
- SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
- for (int test = 0; test < segmentCount; ++test) {
- SkDebugf(" [%d] ", test);
- fSegments[test].dumpAngles();
- }
-}
-
-void SkOpContour::dumpCoincidence(const SkCoincidence& coin) const {
- int thisIndex = coin.fSegments[0];
- const SkOpSegment& s1 = fSegments[thisIndex];
- int otherIndex = coin.fSegments[1];
- const SkOpSegment& s2 = coin.fOther->fSegments[otherIndex];
- SkDebugf("((SkOpSegment*) 0x%p) [%d] ((SkOpSegment*) 0x%p) [%d]\n", &s1, s1.debugID(),
- &s2, s2.debugID());
- for (int index = 0; index < 2; ++index) {
- SkDebugf(" {%1.9gf, %1.9gf}", coin.fPts[0][index].fX, coin.fPts[0][index].fY);
- if (coin.fNearly[index]) {
- SkDebugf(" {%1.9gf, %1.9gf}", coin.fPts[1][index].fX, coin.fPts[1][index].fY);
- }
- SkDebugf(" seg1t=%1.9g seg2t=%1.9g\n", coin.fTs[0][index], coin.fTs[1][index]);
- }
-}
-
-void SkOpContour::dumpCoincidences() const {
- int count = fCoincidences.count();
- if (count > 0) {
- SkDebugf("fCoincidences count=%d\n", count);
- for (int test = 0; test < count; ++test) {
- dumpCoincidence(fCoincidences[test]);
- }
- }
- count = fPartialCoincidences.count();
- if (count == 0) {
- return;
- }
- SkDebugf("fPartialCoincidences count=%d\n", count);
- for (int test = 0; test < count; ++test) {
- dumpCoincidence(fPartialCoincidences[test]);
- }
-}
-
-void SkOpContour::dumpPt(int index) const {
- int segmentCount = fSegments.count();
- for (int test = 0; test < segmentCount; ++test) {
- const SkOpSegment& segment = fSegments[test];
- if (segment.debugID() == index) {
- fSegments[test].dumpPts();
- }
- }
-}
-
-void SkOpContour::dumpPts() const {
- int segmentCount = fSegments.count();
- SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
- for (int test = 0; test < segmentCount; ++test) {
- SkDebugf(" [%d] ", test);
- fSegments[test].dumpPts();
- }
-}
-
-void SkOpContour::dumpSpan(int index) const {
- int segmentCount = fSegments.count();
- for (int test = 0; test < segmentCount; ++test) {
- const SkOpSegment& segment = fSegments[test];
- if (segment.debugID() == index) {
- fSegments[test].dumpSpans();
- }
- }
+void SkDCubic::dump() const {
+ dumpInner();
+ SkDebugf("}},\n");
}
-void SkOpContour::dumpSpans() const {
- int segmentCount = fSegments.count();
- SkDebugf("((SkOpContour*) 0x%p) [%d]\n", this, debugID());
- for (int test = 0; test < segmentCount; ++test) {
- SkDebugf(" [%d] ", test);
- fSegments[test].dumpSpans();
- }
+void SkDCubic::dumpID(int id) const {
+ dumpInner();
+ SkDebugf("}} id=%d\n", id);
}
-void SkDCubic::dump() const {
- SkDebugf("{{");
- int index = 0;
- do {
- fPts[index].dump();
- SkDebugf(", ");
- } while (++index < 3);
- fPts[index].dump();
- SkDebugf("}}\n");
-}
+static inline bool double_is_NaN(double x) { return x != x; }
-void SkDCubic::dumpNumber() const {
+void SkDCubic::dumpInner() const {
SkDebugf("{{");
int index = 0;
- bool dumpedOne = false;
do {
- if (!(fPts[index].fX == fPts[index].fX && fPts[index].fY == fPts[index].fY)) {
- continue;
- }
- if (dumpedOne) {
+ if (index != 0) {
+ if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
+ return;
+ }
SkDebugf(", ");
}
fPts[index].dump();
- dumpedOne = true;
} while (++index < 3);
- if (fPts[index].fX == fPts[index].fX && fPts[index].fY == fPts[index].fY) {
- if (dumpedOne) {
- SkDebugf(", ");
- }
- fPts[index].dump();
+ if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
+ return;
}
- SkDebugf("}}\n");
+ SkDebugf(", ");
+ fPts[index].dump();
}
void SkDLine::dump() const {
@@ -397,7 +221,7 @@ void SkDLine::dump() const {
fPts[0].dump();
SkDebugf(", ");
fPts[1].dump();
- SkDebugf("}}\n");
+ SkDebugf("}},\n");
}
void SkDPoint::dump() const {
@@ -425,10 +249,16 @@ void SkDPoint::DumpHex(const SkPoint& pt) {
}
void SkDQuad::dump() const {
- dumpComma("");
+ dumpInner();
+ SkDebugf("}},\n");
}
-void SkDQuad::dumpComma(const char* comma) const {
+void SkDQuad::dumpID(int id) const {
+ dumpInner();
+ SkDebugf("}} id=%d\n", id);
+}
+
+void SkDQuad::dumpInner() const {
SkDebugf("{{");
int index = 0;
do {
@@ -436,436 +266,262 @@ void SkDQuad::dumpComma(const char* comma) const {
SkDebugf(", ");
} while (++index < 2);
fPts[index].dump();
- SkDebugf("}}%s\n", comma ? comma : "");
}
-void SkIntersectionHelper::dump() const {
- SkDPoint::Dump(pts()[0]);
- SkDPoint::Dump(pts()[1]);
- if (verb() >= SkPath::kQuad_Verb) {
- SkDPoint::Dump(pts()[2]);
- }
- if (verb() >= SkPath::kCubic_Verb) {
- SkDPoint::Dump(pts()[3]);
+void SkIntersections::dump() const {
+ SkDebugf("used=%d of %d", fUsed, fMax);
+ for (int index = 0; index < fUsed; ++index) {
+ SkDebugf(" t=(%s%1.9g,%s%1.9g) pt=(%1.9g,%1.9g)",
+ fIsCoincident[0] & (1 << index) ? "*" : "", fT[0][index],
+ fIsCoincident[1] & (1 << index) ? "*" : "", fT[1][index],
+ fPt[index].fX, fPt[index].fY);
+ if (index < 2 && fNearlySame[index]) {
+ SkDebugf(" pt2=(%1.9g,%1.9g)",fPt2[index].fX, fPt2[index].fY);
+ }
}
+ SkDebugf("\n");
}
-const SkTDArray<SkOpSpan>& SkOpSegment::debugSpans() const {
- return fTs;
-}
-
-void SkOpSegment::dumpAngles() const {
- SkDebugf("((SkOpSegment*) 0x%p) [%d]\n", this, debugID());
- const SkOpAngle* fromAngle = NULL;
- const SkOpAngle* toAngle = NULL;
- for (int index = 0; index < count(); ++index) {
- const SkOpAngle* fAngle = fTs[index].fFromAngle;
- const SkOpAngle* tAngle = fTs[index].fToAngle;
- if (fromAngle == fAngle && toAngle == tAngle) {
- continue;
- }
- if (fAngle) {
- SkDebugf(" [%d] from=%d ", index, fAngle->debugID());
- fAngle->dumpTo(this, tAngle);
- }
- if (tAngle) {
- SkDebugf(" [%d] to=%d ", index, tAngle->debugID());
- tAngle->dumpTo(this, fAngle);
- }
- fromAngle = fAngle;
- toAngle = tAngle;
- }
+const SkOpAngle* SkPathOpsDebug::DebugAngleAngle(const SkOpAngle* angle, int id) {
+ return angle->debugAngle(id);
}
-void SkOpSegment::dumpContour(int firstID, int lastID) const {
- if (debugID() < 0) {
- return;
- }
- const SkOpSegment* test = this - (debugID() - 1);
- test += (firstID - 1);
- const SkOpSegment* last = test + (lastID - firstID);
- while (test <= last) {
- test->dumpSpans();
- ++test;
- }
+SkOpContour* SkPathOpsDebug::DebugAngleContour(SkOpAngle* angle, int id) {
+ return angle->debugContour(id);
}
-void SkOpSegment::dumpPts() const {
- int last = SkPathOpsVerbToPoints(fVerb);
- SkDebugf("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
- int index = 0;
- do {
- SkDPoint::Dump(fPts[index]);
- SkDebugf(", ");
- } while (++index < last);
- SkDPoint::Dump(fPts[index]);
- SkDebugf("}}\n");
+const SkOpPtT* SkPathOpsDebug::DebugAnglePtT(const SkOpAngle* angle, int id) {
+ return angle->debugPtT(id);
}
-void SkOpSegment::dumpHexPts() const {
- int last = SkPathOpsVerbToPoints(fVerb);
- SkDebugf("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
- int index = 0;
- do {
- SkDPoint::DumpHex(fPts[index]);
- SkDebugf(", ");
- } while (++index < last);
- SkDPoint::DumpHex(fPts[index]);
- SkDebugf("}}\n");
+const SkOpSegment* SkPathOpsDebug::DebugAngleSegment(const SkOpAngle* angle, int id) {
+ return angle->debugSegment(id);
}
-void SkOpSegment::dumpDPts() const {
- int count = SkPathOpsVerbToPoints(fVerb);
- SkDebugf("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
- int index = 0;
- do {
- SkDPoint dPt = {fPts[index].fX, fPts[index].fY};
- dPt.dump();
- if (index != count) {
- SkDebugf(", ");
- }
- } while (++index <= count);
- SkDebugf("}}\n");
+const SkOpSpanBase* SkPathOpsDebug::DebugAngleSpan(const SkOpAngle* angle, int id) {
+ return angle->debugSpan(id);
}
-void SkOpSegment::dumpSpans() const {
- int count = this->count();
- SkDebugf("((SkOpSegment*) 0x%p) [%d]\n", this, debugID());
- for (int index = 0; index < count; ++index) {
- const SkOpSpan& span = this->span(index);
- SkDebugf(" [%d] ", index);
- span.dumpOne();
- }
+const SkOpAngle* SkPathOpsDebug::DebugContourAngle(SkOpContour* contour, int id) {
+ return contour->debugAngle(id);
}
-void SkPathOpsDebug::DumpCoincidence(const SkTArray<SkOpContour, true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index].dumpCoincidences();
- }
+SkOpContour* SkPathOpsDebug::DebugContourContour(SkOpContour* contour, int id) {
+ return contour->debugContour(id);
}
-void SkPathOpsDebug::DumpCoincidence(const SkTArray<SkOpContour* , true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index]->dumpCoincidences();
- }
+const SkOpPtT* SkPathOpsDebug::DebugContourPtT(SkOpContour* contour, int id) {
+ return contour->debugPtT(id);
}
-void SkPathOpsDebug::DumpContours(const SkTArray<SkOpContour, true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index].dump();
- }
+const SkOpSegment* SkPathOpsDebug::DebugContourSegment(SkOpContour* contour, int id) {
+ return contour->debugSegment(id);
}
-void SkPathOpsDebug::DumpContours(const SkTArray<SkOpContour* , true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index]->dump();
- }
+const SkOpSpanBase* SkPathOpsDebug::DebugContourSpan(SkOpContour* contour, int id) {
+ return contour->debugSpan(id);
}
-void SkPathOpsDebug::DumpContourAngles(const SkTArray<SkOpContour, true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index].dumpAngles();
- }
+const SkOpAngle* SkPathOpsDebug::DebugPtTAngle(const SkOpPtT* ptT, int id) {
+ return ptT->debugAngle(id);
}
-void SkPathOpsDebug::DumpContourAngles(const SkTArray<SkOpContour* , true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index]->dumpAngles();
- }
+SkOpContour* SkPathOpsDebug::DebugPtTContour(SkOpPtT* ptT, int id) {
+ return ptT->debugContour(id);
}
-void SkPathOpsDebug::DumpContourPts(const SkTArray<SkOpContour, true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index].dumpPts();
- }
+const SkOpPtT* SkPathOpsDebug::DebugPtTPtT(const SkOpPtT* ptT, int id) {
+ return ptT->debugPtT(id);
}
-void SkPathOpsDebug::DumpContourPts(const SkTArray<SkOpContour* , true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index]->dumpPts();
- }
+const SkOpSegment* SkPathOpsDebug::DebugPtTSegment(const SkOpPtT* ptT, int id) {
+ return ptT->debugSegment(id);
}
-void SkPathOpsDebug::DumpContourPt(const SkTArray<SkOpContour, true>& contours, int segmentID) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index].dumpPt(segmentID);
- }
+const SkOpSpanBase* SkPathOpsDebug::DebugPtTSpan(const SkOpPtT* ptT, int id) {
+ return ptT->debugSpan(id);
}
-void SkPathOpsDebug::DumpContourPt(const SkTArray<SkOpContour* , true>& contours, int segmentID) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index]->dumpPt(segmentID);
- }
+const SkOpAngle* SkPathOpsDebug::DebugSegmentAngle(const SkOpSegment* span, int id) {
+ return span->debugAngle(id);
}
-void SkPathOpsDebug::DumpContourSpans(const SkTArray<SkOpContour, true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index].dumpSpans();
- }
+SkOpContour* SkPathOpsDebug::DebugSegmentContour(SkOpSegment* span, int id) {
+ return span->debugContour(id);
}
-void SkPathOpsDebug::DumpContourSpans(const SkTArray<SkOpContour* , true>& contours) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index]->dumpSpans();
- }
+const SkOpPtT* SkPathOpsDebug::DebugSegmentPtT(const SkOpSegment* span, int id) {
+ return span->debugPtT(id);
}
-void SkPathOpsDebug::DumpContourSpan(const SkTArray<SkOpContour, true>& contours, int segmentID) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index].dumpSpan(segmentID);
- }
+const SkOpSegment* SkPathOpsDebug::DebugSegmentSegment(const SkOpSegment* span, int id) {
+ return span->debugSegment(id);
}
-void SkPathOpsDebug::DumpContourSpan(const SkTArray<SkOpContour* , true>& contours, int segmentID) {
- int count = contours.count();
- for (int index = 0; index < count; ++index) {
- contours[index]->dumpSpan(segmentID);
- }
+const SkOpSpanBase* SkPathOpsDebug::DebugSegmentSpan(const SkOpSegment* span, int id) {
+ return span->debugSpan(id);
}
-void SkPathOpsDebug::DumpSpans(const SkTDArray<SkOpSpan *>& spans) {
- int count = spans.count();
- for (int index = 0; index < count; ++index) {
- const SkOpSpan* span = spans[index];
- const SkOpSpan& oSpan = span->fOther->span(span->fOtherIndex);
- const SkOpSegment* segment = oSpan.fOther;
- SkDebugf("((SkOpSegment*) 0x%p) [%d] ", segment, segment->debugID());
- SkDebugf("spanIndex:%d ", oSpan.fOtherIndex);
- span->dumpOne();
- }
-}
-
-// this does not require that other T index is initialized or correct
-const SkOpSegment* SkOpSpan::debugToSegment(ptrdiff_t* spanIndex) const {
- if (!fOther) {
- return NULL;
- }
- int oppCount = fOther->count();
- for (int index = 0; index < oppCount; ++index) {
- const SkOpSpan& otherSpan = fOther->span(index);
- double otherTestT = otherSpan.fT;
- if (otherTestT < fOtherT) {
- continue;
- }
- SkASSERT(otherTestT == fOtherT);
- const SkOpSegment* candidate = otherSpan.fOther;
- const SkOpSpan* first = candidate->debugSpans().begin();
- const SkOpSpan* last = candidate->debugSpans().end() - 1;
- if (first <= this && this <= last) {
- if (spanIndex) {
- *spanIndex = this - first;
- }
- return candidate;
- }
- }
- SkASSERT(0);
- return NULL;
+const SkOpAngle* SkPathOpsDebug::DebugSpanAngle(const SkOpSpanBase* span, int id) {
+ return span->debugAngle(id);
}
-void SkOpSpan::dumpOne() const {
- SkDebugf("t=");
- DebugDumpDouble(fT);
- SkDebugf(" pt=");
- SkDPoint::Dump(fPt);
- if (fOther) {
- SkDebugf(" other.fID=%d", fOther->debugID());
- SkDebugf(" [%d] otherT=", fOtherIndex);
- DebugDumpDouble(fOtherT);
- } else {
- SkDebugf(" other.fID=? [?] otherT=?");
- }
- if (fWindSum != SK_MinS32) {
- SkDebugf(" windSum=%d", fWindSum);
- }
- if (fOppSum != SK_MinS32 && (SkPathOpsDebug::ValidWind(fOppSum) || fOppValue != 0)) {
- SkDebugf(" oppSum=%d", fOppSum);
- }
- SkDebugf(" windValue=%d", fWindValue);
- if (SkPathOpsDebug::ValidWind(fOppSum) || fOppValue != 0) {
- SkDebugf(" oppValue=%d", fOppValue);
- }
- if (fFromAngle && fFromAngle->debugID()) {
- SkDebugf(" from=%d", fFromAngle->debugID());
- }
- if (fToAngle && fToAngle->debugID()) {
- SkDebugf(" to=%d", fToAngle->debugID());
- }
- if (fChased) {
- SkDebugf(" chased");
- }
- if (fCoincident) {
- SkDebugf(" coincident");
- }
- if (fDone) {
- SkDebugf(" done");
- }
- if (fLoop) {
- SkDebugf(" loop");
- }
- if (fMultiple) {
- SkDebugf(" multiple");
- }
- if (fNear) {
- SkDebugf(" near");
- }
- if (fSmall) {
- SkDebugf(" small");
- }
- if (fTiny) {
- SkDebugf(" tiny");
- }
- SkDebugf("\n");
+SkOpContour* SkPathOpsDebug::DebugSpanContour(SkOpSpanBase* span, int id) {
+ return span->debugContour(id);
}
-void SkOpSpan::dump() const {
- ptrdiff_t spanIndex;
- const SkOpSegment* segment = debugToSegment(&spanIndex);
- if (segment) {
- SkDebugf("((SkOpSegment*) 0x%p) [%d]\n", segment, segment->debugID());
- SkDebugf(" [%d] ", spanIndex);
- } else {
- SkDebugf("((SkOpSegment*) ?) [?]\n");
- SkDebugf(" [?] ");
- }
- dumpOne();
+const SkOpPtT* SkPathOpsDebug::DebugSpanPtT(const SkOpSpanBase* span, int id) {
+ return span->debugPtT(id);
}
-void Dump(const SkTArray<class SkOpContour, true>& contours) {
- SkPathOpsDebug::DumpContours(contours);
+const SkOpSegment* SkPathOpsDebug::DebugSpanSegment(const SkOpSpanBase* span, int id) {
+ return span->debugSegment(id);
}
-void Dump(const SkTArray<class SkOpContour* , true>& contours) {
- SkPathOpsDebug::DumpContours(contours);
+const SkOpSpanBase* SkPathOpsDebug::DebugSpanSpan(const SkOpSpanBase* span, int id) {
+ return span->debugSpan(id);
}
-void Dump(const SkTArray<class SkOpContour, true>* contours) {
- SkPathOpsDebug::DumpContours(*contours);
+void SkPathOpsDebug::DumpContours(SkTDArray<SkOpContour* >* contours) {
+ int count = contours->count();
+ for (int index = 0; index < count; ++index) {
+ (*contours)[index]->dump();
+ }
}
-void Dump(const SkTArray<class SkOpContour* , true>* contours) {
- SkPathOpsDebug::DumpContours(*contours);
+void SkPathOpsDebug::DumpContoursAll(SkTDArray<SkOpContour* >* contours) {
+ int count = contours->count();
+ for (int index = 0; index < count; ++index) {
+ (*contours)[index]->dumpAll();
+ }
}
-void Dump(const SkTDArray<SkOpSpan *>& chase) {
- SkPathOpsDebug::DumpSpans(chase);
+void SkPathOpsDebug::DumpContoursAngles(const SkTDArray<SkOpContour* >* contours) {
+ int count = contours->count();
+ for (int index = 0; index < count; ++index) {
+ (*contours)[index]->dumpAngles();
+ }
}
-void Dump(const SkTDArray<SkOpSpan *>* chase) {
- SkPathOpsDebug::DumpSpans(*chase);
+void SkPathOpsDebug::DumpContoursPts(const SkTDArray<SkOpContour* >* contours) {
+ int count = contours->count();
+ for (int index = 0; index < count; ++index) {
+ (*contours)[index]->dumpPts();
+ }
}
-void DumpAngles(const SkTArray<class SkOpContour, true>& contours) {
- SkPathOpsDebug::DumpContourAngles(contours);
+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 DumpAngles(const SkTArray<class SkOpContour* , true>& contours) {
- SkPathOpsDebug::DumpContourAngles(contours);
+void SkPathOpsDebug::DumpContoursSegment(const SkTDArray<SkOpContour* >* contours,
+ int segmentID) {
+ if (contours->count()) {
+ (*contours)[0]->dumpSegment(segmentID);
+ }
}
-void DumpAngles(const SkTArray<class SkOpContour, true>* contours) {
- SkPathOpsDebug::DumpContourAngles(*contours);
+void SkPathOpsDebug::DumpContoursSpan(const SkTDArray<SkOpContour* >* contours,
+ int spanID) {
+ if (contours->count()) {
+ (*contours)[0]->dumpSpan(spanID);
+ }
}
-void DumpAngles(const SkTArray<class SkOpContour* , true>* contours) {
- SkPathOpsDebug::DumpContourAngles(*contours);
+void SkPathOpsDebug::DumpContoursSpans(const SkTDArray<SkOpContour* >* contours) {
+ int count = contours->count();
+ for (int index = 0; index < count; ++index) {
+ (*contours)[index]->dumpSpans();
+ }
}
-void DumpCoin(const SkTArray<class SkOpContour, true>& contours) {
- SkPathOpsDebug::DumpCoincidence(contours);
+const SkTSpan<SkDCubic>* DebugSpan(const SkTSect<SkDCubic>* sect, int id) {
+ return sect->debugSpan(id);
}
-void DumpCoin(const SkTArray<class SkOpContour* , true>& contours) {
- SkPathOpsDebug::DumpCoincidence(contours);
+const SkTSpan<SkDQuad>* DebugSpan(const SkTSect<SkDQuad>* sect, int id) {
+ return sect->debugSpan(id);
}
-void DumpCoin(const SkTArray<class SkOpContour, true>* contours) {
- SkPathOpsDebug::DumpCoincidence(*contours);
+const SkTSpan<SkDCubic>* DebugT(const SkTSect<SkDCubic>* sect, double t) {
+ return sect->debugT(t);
}
-void DumpCoin(const SkTArray<class SkOpContour* , true>* contours) {
- SkPathOpsDebug::DumpCoincidence(*contours);
+const SkTSpan<SkDQuad>* DebugT(const SkTSect<SkDQuad>* sect, double t) {
+ return sect->debugT(t);
}
-void DumpSpans(const SkTArray<class SkOpContour, true>& contours) {
- SkPathOpsDebug::DumpContourSpans(contours);
+const SkTSpan<SkDCubic>* DebugSpan(const SkTSpan<SkDCubic>* span, int id) {
+ return span->debugSpan(id);
}
-void DumpSpans(const SkTArray<class SkOpContour* , true>& contours) {
- SkPathOpsDebug::DumpContourSpans(contours);
+const SkTSpan<SkDQuad>* DebugSpan(const SkTSpan<SkDQuad>* span, int id) {
+ return span->debugSpan(id);
}
-void DumpSpans(const SkTArray<class SkOpContour, true>* contours) {
- SkPathOpsDebug::DumpContourSpans(*contours);
+const SkTSpan<SkDCubic>* DebugT(const SkTSpan<SkDCubic>* span, double t) {
+ return span->debugT(t);
}
-void DumpSpans(const SkTArray<class SkOpContour* , true>* contours) {
- SkPathOpsDebug::DumpContourSpans(*contours);
+const SkTSpan<SkDQuad>* DebugT(const SkTSpan<SkDQuad>* span, double t) {
+ return span->debugT(t);
}
-void DumpSpan(const SkTArray<class SkOpContour, true>& contours, int segmentID) {
- SkPathOpsDebug::DumpContourSpan(contours, segmentID);
+void Dump(const SkTSect<SkDCubic>* sect) {
+ sect->dump();
}
-void DumpSpan(const SkTArray<class SkOpContour* , true>& contours, int segmentID) {
- SkPathOpsDebug::DumpContourSpan(contours, segmentID);
+void Dump(const SkTSect<SkDQuad>* sect) {
+ sect->dump();
}
-void DumpSpan(const SkTArray<class SkOpContour, true>* contours, int segmentID) {
- SkPathOpsDebug::DumpContourSpan(*contours, segmentID);
+void Dump(const SkTSpan<SkDCubic>* span) {
+ span->dump();
}
-void DumpSpan(const SkTArray<class SkOpContour* , true>* contours, int segmentID) {
- SkPathOpsDebug::DumpContourSpan(*contours, segmentID);
+void Dump(const SkTSpan<SkDQuad>* span) {
+ span->dump();
}
-void DumpPts(const SkTArray<class SkOpContour, true>& contours) {
- SkPathOpsDebug::DumpContourPts(contours);
+void DumpBoth(SkTSect<SkDCubic>* sect1, SkTSect<SkDCubic>* sect2) {
+ sect1->dumpBoth(sect2);
}
-void DumpPts(const SkTArray<class SkOpContour* , true>& contours) {
- SkPathOpsDebug::DumpContourPts(contours);
+void DumpBoth(SkTSect<SkDQuad>* sect1, SkTSect<SkDQuad>* sect2) {
+ sect1->dumpBoth(sect2);
}
-void DumpPts(const SkTArray<class SkOpContour, true>* contours) {
- SkPathOpsDebug::DumpContourPts(*contours);
+void DumpCoin(SkTSect<SkDCubic>* sect1) {
+ sect1->dumpCoin();
}
-void DumpPts(const SkTArray<class SkOpContour* , true>* contours) {
- SkPathOpsDebug::DumpContourPts(*contours);
+void DumpCoin(SkTSect<SkDQuad>* sect1) {
+ sect1->dumpCoin();
}
-void DumpPt(const SkTArray<class SkOpContour, true>& contours, int segmentID) {
- SkPathOpsDebug::DumpContourPt(contours, segmentID);
+void DumpCoinCurves(SkTSect<SkDCubic>* sect1) {
+ sect1->dumpCoinCurves();
}
-void DumpPt(const SkTArray<class SkOpContour* , true>& contours, int segmentID) {
- SkPathOpsDebug::DumpContourPt(contours, segmentID);
+void DumpCoinCurves(SkTSect<SkDQuad>* sect1) {
+ sect1->dumpCoinCurves();
}
-void DumpPt(const SkTArray<class SkOpContour, true>* contours, int segmentID) {
- SkPathOpsDebug::DumpContourPt(*contours, segmentID);
+void DumpCurves(const SkTSect<SkDQuad>* sect) {
+ sect->dumpCurves();
}
-void DumpPt(const SkTArray<class SkOpContour* , true>* contours, int segmentID) {
- SkPathOpsDebug::DumpContourPt(*contours, segmentID);
+void DumpCurves(const SkTSect<SkDCubic>* sect) {
+ sect->dumpCurves();
}
static void dumpTestCase(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
- SkDebugf("<div id=\"quad%d\">\n", testNo);
- quad1.dumpComma(",");
+ SkDebugf("\n<div id=\"quad%d\">\n", testNo);
+ quad1.dumpInner();
+ SkDebugf("}}, ");
quad2.dump();
SkDebugf("</div>\n\n");
}
@@ -895,3 +551,649 @@ void DumpT(const SkDQuad& quad, double t) {
SkDLine line = {{quad.ptAtT(t), quad[0]}};
line.dump();
}
+
+const SkOpAngle* SkOpAngle::debugAngle(int id) const {
+ return this->segment()->debugAngle(id);
+}
+
+SkOpContour* SkOpAngle::debugContour(int id) {
+ return this->segment()->debugContour(id);
+}
+
+const SkOpPtT* SkOpAngle::debugPtT(int id) const {
+ return this->segment()->debugPtT(id);
+}
+
+const SkOpSegment* SkOpAngle::debugSegment(int id) const {
+ return this->segment()->debugSegment(id);
+}
+
+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(" 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()) {
+ if (this == fNext) {
+ SkDebugf(" << from");
+ }
+ if (to == fNext) {
+ SkDebugf(" << to");
+ }
+ }
+ SkDebugf("\n");
+ indent = " ";
+ next = next->fNext;
+ } while (next && next != first);
+}
+
+void SkOpAngle::dumpCurves() const {
+ const SkOpAngle* first = this;
+ const SkOpAngle* next = this;
+ do {
+ next->fCurvePart.dumpID(next->segment()->debugID());
+ next = next->fNext;
+ } while (next && next != first);
+}
+
+void SkOpAngle::dumpLoop() const {
+ const SkOpAngle* first = this;
+ const SkOpAngle* next = this;
+ do {
+ next->dumpOne(false);
+ SkDebugf("\n");
+ next = next->fNext;
+ } while (next && next != first);
+}
+
+void SkOpAngle::dumpTest() const {
+ const SkOpAngle* first = this;
+ const SkOpAngle* next = this;
+ do {
+ SkDebugf("{ ");
+ SkOpSegment* segment = next->segment();
+ segment->dumpPts();
+ SkDebugf(", %d, %1.9g, %1.9g, {} },\n", SkPathOpsVerbToPoints(segment->verb()) + 1,
+ next->start()->t(), next->end()->t());
+ next = next->fNext;
+ } while (next && next != first);
+}
+
+bool SkOpPtT::debugMatchID(int id) const {
+ int limit = this->debugLoopLimit(false);
+ int loop = 0;
+ const SkOpPtT* ptT = this;
+ do {
+ if (ptT->debugID() == id) {
+ return true;
+ }
+ } while ((!limit || ++loop <= limit) && (ptT = ptT->next()) && ptT != this);
+ return false;
+}
+
+const SkOpAngle* SkOpPtT::debugAngle(int id) const {
+ return this->span()->debugAngle(id);
+}
+
+SkOpContour* SkOpPtT::debugContour(int id) {
+ return this->span()->debugContour(id);
+}
+
+const SkOpPtT* SkOpPtT::debugPtT(int id) const {
+ return this->span()->debugPtT(id);
+}
+
+const SkOpSegment* SkOpPtT::debugSegment(int id) const {
+ return this->span()->debugSegment(id);
+}
+
+const SkOpSpanBase* SkOpPtT::debugSpan(int id) const {
+ return this->span()->debugSpan(id);
+}
+
+void SkOpPtT::dump() const {
+ SkDebugf("seg=%d span=%d ptT=%d",
+ this->segment()->debugID(), this->span()->debugID(), this->debugID());
+ this->dumpBase();
+ SkDebugf("\n");
+}
+
+void SkOpPtT::dumpAll() const {
+ contour()->indentDump();
+ const SkOpPtT* next = this;
+ int limit = debugLoopLimit(true);
+ int loop = 0;
+ do {
+ SkDebugf("%.*s", contour()->debugIndent(), " ");
+ SkDebugf("seg=%d span=%d ptT=%d",
+ next->segment()->debugID(), next->span()->debugID(), next->debugID());
+ next->dumpBase();
+ SkDebugf("\n");
+ if (limit && ++loop >= limit) {
+ SkDebugf("*** abort loop ***\n");
+ break;
+ }
+ } while ((next = next->fNext) && next != this);
+ contour()->outdentDump();
+}
+
+void SkOpPtT::dumpBase() const {
+ SkDebugf(" t=%1.9g pt=(%1.9g,%1.9g)%s%s", this->fT, this->fPt.fX, this->fPt.fY,
+ this->fDuplicatePt ? " dup" : "", this->fDeleted ? " deleted" : "");
+}
+
+const SkOpAngle* SkOpSpanBase::debugAngle(int id) const {
+ return this->segment()->debugAngle(id);
+}
+
+SkOpContour* SkOpSpanBase::debugContour(int id) {
+ return this->segment()->debugContour(id);
+}
+
+const SkOpPtT* SkOpSpanBase::debugPtT(int id) const {
+ return this->segment()->debugPtT(id);
+}
+
+const SkOpSegment* SkOpSpanBase::debugSegment(int id) const {
+ return this->segment()->debugSegment(id);
+}
+
+const SkOpSpanBase* SkOpSpanBase::debugSpan(int id) const {
+ return this->segment()->debugSpan(id);
+}
+
+void SkOpSpanBase::dump() const {
+ this->dumpAll();
+ SkDebugf("\n");
+}
+
+void SkOpSpanBase::dumpAll() const {
+ SkDebugf("%.*s", contour()->debugIndent(), " ");
+ SkDebugf("seg=%d span=%d", this->segment()->debugID(), this->debugID());
+ this->dumpBase();
+ SkDebugf("\n");
+ this->fPtT.dumpAll();
+}
+
+void SkOpSpanBase::dumpBase() const {
+ if (this->fAligned) {
+ SkDebugf(" aligned");
+ }
+ if (this->fChased) {
+ SkDebugf(" chased");
+ }
+ if (!this->final()) {
+ this->upCast()->dumpSpan();
+ }
+ const SkOpSpanBase* coin = this->coinEnd();
+ if (this != coin) {
+ SkDebugf(" coinEnd seg/span=%d/%d", coin->segment()->debugID(), coin->debugID());
+ } else if (this->final() || !this->upCast()->isCoincident()) {
+ const SkOpPtT* oPt = this->ptT()->next();
+ SkDebugf(" seg/span=%d/%d", oPt->segment()->debugID(), oPt->span()->debugID());
+ }
+}
+
+void SkOpSpanBase::dumpCoin() const {
+ const SkOpSpan* span = this->upCastable();
+ if (!span) {
+ return;
+ }
+ if (!span->isCoincident()) {
+ return;
+ }
+ span->dumpCoin();
+}
+
+void SkOpSpan::dumpCoin() const {
+ const SkOpSpan* coincident = fCoincident;
+ bool ok = debugCoinLoopCheck();
+ this->dump();
+ int loop = 0;
+ do {
+ coincident->dump();
+ if (!ok && ++loop > 10) {
+ SkDebugf("*** abort loop ***\n");
+ break;
+ }
+ } while ((coincident = coincident->fCoincident) != this);
+}
+
+bool SkOpSpan::dumpSpan() const {
+ SkOpSpan* coin = fCoincident;
+ if (this != coin) {
+ SkDebugf(" coinStart seg/span=%d/%d", coin->segment()->debugID(), coin->debugID());
+ }
+ SkDebugf(" windVal=%d", this->windValue());
+ SkDebugf(" windSum=");
+ SkPathOpsDebug::WindingPrintf(this->windSum());
+ if (this->oppValue() != 0 || this->oppSum() != SK_MinS32) {
+ SkDebugf(" oppVal=%d", this->oppValue());
+ SkDebugf(" oppSum=");
+ SkPathOpsDebug::WindingPrintf(this->oppSum());
+ }
+ if (this->done()) {
+ SkDebugf(" done");
+ }
+ return this != coin;
+}
+
+const SkOpAngle* SkOpSegment::debugAngle(int id) const {
+ return this->contour()->debugAngle(id);
+}
+
+SkOpContour* SkOpSegment::debugContour(int id) {
+ return this->contour()->debugContour(id);
+}
+
+const SkOpPtT* SkOpSegment::debugPtT(int id) const {
+ return this->contour()->debugPtT(id);
+}
+
+const SkOpSegment* SkOpSegment::debugSegment(int id) const {
+ return this->contour()->debugSegment(id);
+}
+
+const SkOpSpanBase* SkOpSegment::debugSpan(int id) const {
+ return this->contour()->debugSpan(id);
+}
+
+void SkOpSegment::dump() const {
+ SkDebugf("%.*s", contour()->debugIndent(), " ");
+ this->dumpPts();
+ const SkOpSpanBase* span = &fHead;
+ contour()->indentDump();
+ do {
+ SkDebugf("%.*s span=%d ", contour()->debugIndent(), " ", span->debugID());
+ span->ptT()->dumpBase();
+ span->dumpBase();
+ SkDebugf("\n");
+ } while (!span->final() && (span = span->upCast()->next()));
+ contour()->outdentDump();
+}
+
+void SkOpSegment::dumpAll() const {
+ SkDebugf("%.*s", contour()->debugIndent(), " ");
+ this->dumpPts();
+ const SkOpSpanBase* span = &fHead;
+ contour()->indentDump();
+ do {
+ span->dumpAll();
+ } while (!span->final() && (span = span->upCast()->next()));
+ contour()->outdentDump();
+}
+
+void SkOpSegment::dumpAngles() const {
+ SkDebugf("seg=%d\n", debugID());
+ const SkOpSpanBase* span = &fHead;
+ do {
+ const SkOpAngle* fAngle = span->fromAngle();
+ const SkOpAngle* tAngle = span->final() ? NULL : span->upCast()->toAngle();
+ if (fAngle) {
+ SkDebugf(" span=%d from=%d ", span->debugID(), fAngle->debugID());
+ fAngle->dumpTo(this, tAngle);
+ }
+ if (tAngle) {
+ SkDebugf(" span=%d to=%d ", span->debugID(), tAngle->debugID());
+ tAngle->dumpTo(this, fAngle);
+ }
+ } 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 {
+ int last = SkPathOpsVerbToPoints(fVerb);
+ SkDebugf("seg=%d {{", this->debugID());
+ int index = 0;
+ do {
+ SkDPoint::Dump(fPts[index]);
+ SkDebugf(", ");
+ } while (++index < last);
+ SkDPoint::Dump(fPts[index]);
+ 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()) {
+ SkDebugf(" operand");
+ }
+ if (fCoinPtTStart->segment()->isXor()) {
+ SkDebugf(" xor");
+ }
+ SkDebugf("\n");
+ SkDebugf("+ seg=%d span=%d ptT=%d ", fOppPtTStart->segment()->debugID(),
+ fOppPtTStart->span()->debugID(), fOppPtTStart->debugID());
+ fOppPtTStart->dumpBase();
+ SkDebugf(" span=%d ptT=%d ", fOppPtTEnd->span()->debugID(), fOppPtTEnd->debugID());
+ fOppPtTEnd->dumpBase();
+ if (fOppPtTStart->segment()->operand()) {
+ SkDebugf(" operand");
+ }
+ if (fOppPtTStart->segment()->isXor()) {
+ SkDebugf(" xor");
+ }
+ SkDebugf("\n");
+}
+
+void SkOpCoincidence::dump() const {
+ SkCoincidentSpans* span = fHead;
+ while (span) {
+ span->dump();
+ span = span->fNext;
+ }
+}
+
+void SkOpContour::dump() {
+ SkDebugf("contour=%d count=%d\n", this->debugID(), fCount);
+ if (!fCount) {
+ return;
+ }
+ const SkOpSegment* segment = &fHead;
+ PATH_OPS_DEBUG_CODE(fIndent = 0);
+ indentDump();
+ do {
+ segment->dump();
+ } while ((segment = segment->next()));
+ outdentDump();
+}
+
+void SkOpContour::dumpAll() {
+ SkDebugf("contour=%d count=%d\n", this->debugID(), fCount);
+ if (!fCount) {
+ return;
+ }
+ const SkOpSegment* segment = &fHead;
+ PATH_OPS_DEBUG_CODE(fIndent = 0);
+ indentDump();
+ do {
+ segment->dumpAll();
+ } while ((segment = segment->next()));
+ 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()));
+}
+
+void SkOpContour::dumpPt(int index) const {
+ const SkOpSegment* segment = &fHead;
+ do {
+ if (segment->debugID() == index) {
+ segment->dumpPts();
+ }
+ } while ((segment = segment->next()));
+}
+
+void SkOpContour::dumpPts() const {
+ SkDebugf("contour=%d\n", this->debugID());
+ const SkOpSegment* segment = &fHead;
+ do {
+ SkDebugf(" seg=%d ", segment->debugID());
+ segment->dumpPts();
+ } while ((segment = segment->next()));
+}
+
+void SkOpContour::dumpPtsX() const {
+ if (!this->fCount) {
+ SkDebugf("<empty>\n");
+ return;
+ }
+ const SkOpSegment* segment = &fHead;
+ do {
+ segment->dumpPts();
+ } while ((segment = segment->next()));
+}
+
+void SkOpContour::dumpSegment(int index) const {
+ debugSegment(index)->dump();
+}
+
+void SkOpContour::dumpSegments(SkPathOp op) const {
+ bool firstOp = false;
+ const SkOpContour* c = this;
+ do {
+ if (!firstOp && c->operand()) {
+#if DEBUG_ACTIVE_OP
+ SkDebugf("op %s\n", SkPathOpsDebug::kPathOpStr[op]);
+#endif
+ firstOp = true;
+ }
+ c->dumpPtsX();
+ } while ((c = c->next()));
+}
+
+void SkOpContour::dumpSpan(int index) const {
+ debugSpan(index)->dump();
+}
+
+void SkOpContour::dumpSpans() const {
+ SkDebugf("contour=%d\n", this->debugID());
+ const SkOpSegment* segment = &fHead;
+ do {
+ SkDebugf(" seg=%d ", segment->debugID());
+ segment->dump();
+ } while ((segment = segment->next()));
+}
+
+#ifdef SK_DEBUG
+const SkOpAngle* SkOpGlobalState::debugAngle(int id) const {
+ const SkOpContour* contour = fHead;
+ 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;
+ do {
+ if (contour->debugID() == id) {
+ return contour;
+ }
+ } while ((contour = contour->next()));
+ return NULL;
+}
+
+const SkOpPtT* SkOpGlobalState::debugPtT(int id) const {
+ const SkOpContour* contour = fHead;
+ 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;
+ 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;
+ 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 SkTArray<SkOpContour*, true>* contours, int id) {
+ return (*contours)[0]->debugAngle(id);
+}
+
+SkOpContour* DumpContour(const SkTArray<SkOpContour*, true>* contours, int id) {
+ return (*contours)[0]->debugContour(id);
+}
+
+const SkOpPtT* DebugPtT(const SkTArray<SkOpContour*, true>* contours, int id) {
+ return (*contours)[0]->debugPtT(id);
+}
+
+const SkOpSegment* DebugSegment(const SkTArray<SkOpContour*, true>* contours, int id) {
+ return (*contours)[0]->debugSegment(id);
+}
+
+const SkOpSpanBase* DebugSpan(const SkTArray<SkOpContour*, true>* 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
« no previous file with comments | « tests/PathOpsDTriangleTest.cpp ('k') | tests/PathOpsExtendedTest.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698