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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: tests/PathOpsDebug.cpp

Issue 1029993002: Revert of pathops version two (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: 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 9930453d01ea9fb0a7d37af298ebc1fa59a4b7ad..c4fbbfa69517610c7168e6fb9e6f361b2c455e78 100755
--- a/tests/PathOpsDebug.cpp
+++ b/tests/PathOpsDebug.cpp
@@ -1,12 +1,3 @@
-/*
- * 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"
@@ -59,6 +50,7 @@
SkDebugf(", ");
}
}
+ SkDebugf(");\n");
}
static void showPathContours(SkPath::RawIter& iter, const char* pathName) {
@@ -69,27 +61,18 @@
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);
@@ -185,393 +168,6 @@
}
#endif
-void SkDCubic::dump() const {
- dumpInner();
- SkDebugf("}},\n");
-}
-
-void SkDCubic::dumpID(int id) const {
- dumpInner();
- SkDebugf("}} id=%d\n", id);
-}
-
-static inline bool double_is_NaN(double x) { return x != x; }
-
-void SkDCubic::dumpInner() const {
- SkDebugf("{{");
- int index = 0;
- do {
- if (index != 0) {
- if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
- return;
- }
- SkDebugf(", ");
- }
- fPts[index].dump();
- } while (++index < 3);
- if (double_is_NaN(fPts[index].fX) && double_is_NaN(fPts[index].fY)) {
- return;
- }
- SkDebugf(", ");
- fPts[index].dump();
-}
-
-void SkDLine::dump() const {
- SkDebugf("{{");
- fPts[0].dump();
- SkDebugf(", ");
- fPts[1].dump();
- SkDebugf("}},\n");
-}
-
-void SkDPoint::dump() const {
- SkDebugf("{");
- DebugDumpDouble(fX);
- SkDebugf(", ");
- DebugDumpDouble(fY);
- SkDebugf("}");
-}
-
-void SkDPoint::Dump(const SkPoint& pt) {
- SkDebugf("{");
- DebugDumpFloat(pt.fX);
- SkDebugf(", ");
- DebugDumpFloat(pt.fY);
- SkDebugf("}");
-}
-
-void SkDPoint::DumpHex(const SkPoint& pt) {
- SkDebugf("{");
- DebugDumpHexFloat(pt.fX);
- SkDebugf(", ");
- DebugDumpHexFloat(pt.fY);
- SkDebugf("}");
-}
-
-void SkDQuad::dump() const {
- dumpInner();
- SkDebugf("}},\n");
-}
-
-void SkDQuad::dumpID(int id) const {
- dumpInner();
- SkDebugf("}} id=%d\n", id);
-}
-
-void SkDQuad::dumpInner() const {
- SkDebugf("{{");
- int index = 0;
- do {
- fPts[index].dump();
- SkDebugf(", ");
- } while (++index < 2);
- fPts[index].dump();
-}
-
-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 SkOpAngle* SkPathOpsDebug::DebugAngleAngle(const SkOpAngle* angle, int id) {
- return angle->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugAngleContour(SkOpAngle* angle, int id) {
- return angle->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugAnglePtT(const SkOpAngle* angle, int id) {
- return angle->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugAngleSegment(const SkOpAngle* angle, int id) {
- return angle->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugAngleSpan(const SkOpAngle* angle, int id) {
- return angle->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugContourAngle(SkOpContour* contour, int id) {
- return contour->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugContourContour(SkOpContour* contour, int id) {
- return contour->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugContourPtT(SkOpContour* contour, int id) {
- return contour->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugContourSegment(SkOpContour* contour, int id) {
- return contour->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugContourSpan(SkOpContour* contour, int id) {
- return contour->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugPtTAngle(const SkOpPtT* ptT, int id) {
- return ptT->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugPtTContour(SkOpPtT* ptT, int id) {
- return ptT->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugPtTPtT(const SkOpPtT* ptT, int id) {
- return ptT->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugPtTSegment(const SkOpPtT* ptT, int id) {
- return ptT->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugPtTSpan(const SkOpPtT* ptT, int id) {
- return ptT->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugSegmentAngle(const SkOpSegment* span, int id) {
- return span->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugSegmentContour(SkOpSegment* span, int id) {
- return span->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugSegmentPtT(const SkOpSegment* span, int id) {
- return span->debugPtT(id);
-}
-
-const SkOpSegment* SkPathOpsDebug::DebugSegmentSegment(const SkOpSegment* span, int id) {
- return span->debugSegment(id);
-}
-
-const SkOpSpanBase* SkPathOpsDebug::DebugSegmentSpan(const SkOpSegment* span, int id) {
- return span->debugSpan(id);
-}
-
-const SkOpAngle* SkPathOpsDebug::DebugSpanAngle(const SkOpSpanBase* span, int id) {
- return span->debugAngle(id);
-}
-
-SkOpContour* SkPathOpsDebug::DebugSpanContour(SkOpSpanBase* span, int id) {
- return span->debugContour(id);
-}
-
-const SkOpPtT* SkPathOpsDebug::DebugSpanPtT(const SkOpSpanBase* span, int id) {
- return span->debugPtT(id);
-}
-
-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 SkPathOpsDebug::DumpContoursAll(SkTDArray<SkOpContour* >* contours) {
- int count = contours->count();
- for (int index = 0; index < count; ++index) {
- (*contours)[index]->dumpAll();
- }
-}
-
-void SkPathOpsDebug::DumpContoursAngles(const SkTDArray<SkOpContour* >* contours) {
- int count = contours->count();
- for (int index = 0; index < count; ++index) {
- (*contours)[index]->dumpAngles();
- }
-}
-
-void SkPathOpsDebug::DumpContoursPts(const SkTDArray<SkOpContour* >* contours) {
- int count = contours->count();
- for (int index = 0; index < count; ++index) {
- (*contours)[index]->dumpPts();
- }
-}
-
-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 SkPathOpsDebug::DumpContoursSegment(const SkTDArray<SkOpContour* >* contours,
- int segmentID) {
- if (contours->count()) {
- (*contours)[0]->dumpSegment(segmentID);
- }
-}
-
-void SkPathOpsDebug::DumpContoursSpan(const SkTDArray<SkOpContour* >* contours,
- int spanID) {
- if (contours->count()) {
- (*contours)[0]->dumpSpan(spanID);
- }
-}
-
-void SkPathOpsDebug::DumpContoursSpans(const SkTDArray<SkOpContour* >* contours) {
- int count = contours->count();
- for (int index = 0; index < count; ++index) {
- (*contours)[index]->dumpSpans();
- }
-}
-
-const SkTSpan<SkDCubic>* DebugSpan(const SkTSect<SkDCubic>* sect, int id) {
- return sect->debugSpan(id);
-}
-
-const SkTSpan<SkDQuad>* DebugSpan(const SkTSect<SkDQuad>* sect, int id) {
- return sect->debugSpan(id);
-}
-
-const SkTSpan<SkDCubic>* DebugT(const SkTSect<SkDCubic>* sect, double t) {
- return sect->debugT(t);
-}
-
-const SkTSpan<SkDQuad>* DebugT(const SkTSect<SkDQuad>* sect, double t) {
- return sect->debugT(t);
-}
-
-const SkTSpan<SkDCubic>* DebugSpan(const SkTSpan<SkDCubic>* span, int id) {
- return span->debugSpan(id);
-}
-
-const SkTSpan<SkDQuad>* DebugSpan(const SkTSpan<SkDQuad>* span, int id) {
- return span->debugSpan(id);
-}
-
-const SkTSpan<SkDCubic>* DebugT(const SkTSpan<SkDCubic>* span, double t) {
- return span->debugT(t);
-}
-
-const SkTSpan<SkDQuad>* DebugT(const SkTSpan<SkDQuad>* span, double t) {
- return span->debugT(t);
-}
-
-void Dump(const SkTSect<SkDCubic>* sect) {
- sect->dump();
-}
-
-void Dump(const SkTSect<SkDQuad>* sect) {
- sect->dump();
-}
-
-void Dump(const SkTSpan<SkDCubic>* span) {
- span->dump();
-}
-
-void Dump(const SkTSpan<SkDQuad>* span) {
- span->dump();
-}
-
-void DumpBoth(SkTSect<SkDCubic>* sect1, SkTSect<SkDCubic>* sect2) {
- sect1->dumpBoth(sect2);
-}
-
-void DumpBoth(SkTSect<SkDQuad>* sect1, SkTSect<SkDQuad>* sect2) {
- sect1->dumpBoth(sect2);
-}
-
-void DumpCoin(SkTSect<SkDCubic>* sect1) {
- sect1->dumpCoin();
-}
-
-void DumpCoin(SkTSect<SkDQuad>* sect1) {
- sect1->dumpCoin();
-}
-
-void DumpCoinCurves(SkTSect<SkDCubic>* sect1) {
- sect1->dumpCoinCurves();
-}
-
-void DumpCoinCurves(SkTSect<SkDQuad>* sect1) {
- sect1->dumpCoinCurves();
-}
-
-void DumpCurves(const SkTSect<SkDQuad>* sect) {
- sect->dumpCurves();
-}
-
-void DumpCurves(const SkTSect<SkDCubic>* sect) {
- sect->dumpCurves();
-}
-
-static void dumpTestCase(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
- SkDebugf("\n<div id=\"quad%d\">\n", testNo);
- quad1.dumpInner();
- SkDebugf("}}, ");
- quad2.dump();
- SkDebugf("</div>\n\n");
-}
-
-static void dumpTestTrailer() {
- SkDebugf("</div>\n\n<script type=\"text/javascript\">\n\n");
- SkDebugf(" var testDivs = [\n");
-}
-
-static void dumpTestList(int testNo, double min) {
- SkDebugf(" quad%d,", testNo);
- if (min > 0) {
- SkDebugf(" // %1.9g", min);
- }
- SkDebugf("\n");
-}
-
-void DumpQ(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
- SkDebugf("\n");
- dumpTestCase(quad1, quad2, testNo);
- dumpTestTrailer();
- dumpTestList(testNo, 0);
- SkDebugf("\n");
-}
-
-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");
@@ -579,39 +175,44 @@
void SkOpAngle::dumpOne(bool functionHeader) const {
// fSegment->debugValidate();
- const SkOpSegment* segment = this->segment();
- const SkOpSpan& mSpan = *fStart->starter(fEnd);
+ const SkOpSpan& mSpan = fSegment->span(SkMin32(fStart, fEnd));
if (functionHeader) {
SkDebugf("%s ", __FUNCTION__);
}
- SkDebugf("[%d", segment->debugID());
+ SkDebugf("[%d", fSegment->debugID());
SkDebugf("/%d", debugID());
SkDebugf("] next=");
if (fNext) {
- SkDebugf("%d", fNext->fStart->segment()->debugID());
+ 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]", fStart->t(), fStart->debugID(),
- fEnd->t(), fEnd->debugID());
- SkDebugf(" sgn=%d windVal=%d", this->sign(), mSpan.windValue());
+ 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.windSum());
- if (mSpan.oppValue() != 0 || mSpan.oppSum() != SK_MinS32) {
- SkDebugf(" oppVal=%d", mSpan.oppValue());
+ SkPathOpsDebug::WindingPrintf(mSpan.fWindSum);
+ if (mSpan.fOppValue != 0 || mSpan.fOppSum != SK_MinS32) {
+ SkDebugf(" oppVal=%d", mSpan.fOppValue);
SkDebugf(" oppSum=");
- SkPathOpsDebug::WindingPrintf(mSpan.oppSum());
- }
- if (mSpan.done()) {
+ SkPathOpsDebug::WindingPrintf(mSpan.fOppSum);
+ }
+ if (mSpan.fDone) {
SkDebugf(" done");
}
if (unorderable()) {
SkDebugf(" unorderable");
}
- if (segment->operand()) {
+ if (small()) {
+ SkDebugf(" small");
+ }
+ if (mSpan.fTiny) {
+ SkDebugf(" tiny");
+ }
+ if (fSegment->operand()) {
SkDebugf(" operand");
}
if (fStop) {
@@ -626,7 +227,7 @@
do {
SkDebugf("%s", indent);
next->dumpOne(false);
- if (segment == next->fStart->segment()) {
+ if (segment == next->fSegment) {
if (this == fNext) {
SkDebugf(" << from");
}
@@ -636,15 +237,6 @@
}
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);
}
@@ -659,250 +251,248 @@
} while (next && next != first);
}
-void SkOpAngle::dumpTest() const {
+void SkOpAngle::dumpPartials() 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->fCurvePart.dumpNumber();
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;
+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 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::dump() const {
+ SkDebugf("{{");
+ int index = 0;
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;
+ fPts[index].dump();
+ SkDebugf(", ");
+ } while (++index < 3);
+ fPts[index].dump();
+ SkDebugf("}}\n");
+}
+
+void SkDCubic::dumpNumber() const {
+ SkDebugf("{{");
+ int index = 0;
+ bool dumpedOne = false;
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) {
+ if (!(fPts[index].fX == fPts[index].fX && fPts[index].fY == fPts[index].fY)) {
+ continue;
+ }
+ if (dumpedOne) {
+ 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();
+ }
+ SkDebugf("}}\n");
+}
+
+void SkDLine::dump() const {
+ SkDebugf("{{");
+ fPts[0].dump();
+ SkDebugf(", ");
+ fPts[1].dump();
+ SkDebugf("}}\n");
+}
+
+void SkDPoint::dump() const {
+ SkDebugf("{");
+ DebugDumpDouble(fX);
+ SkDebugf(", ");
+ DebugDumpDouble(fY);
+ SkDebugf("}");
+}
+
+void SkDPoint::Dump(const SkPoint& pt) {
+ SkDebugf("{");
+ DebugDumpFloat(pt.fX);
+ SkDebugf(", ");
+ DebugDumpFloat(pt.fY);
+ SkDebugf("}");
+}
+
+void SkDPoint::DumpHex(const SkPoint& pt) {
+ SkDebugf("{");
+ DebugDumpHexFloat(pt.fX);
+ SkDebugf(", ");
+ DebugDumpHexFloat(pt.fY);
+ SkDebugf("}");
+}
+
+void SkDQuad::dump() const {
+ dumpComma("");
+}
+
+void SkDQuad::dumpComma(const char* comma) const {
+ SkDebugf("{{");
+ int index = 0;
+ do {
+ fPts[index].dump();
+ 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]);
+ }
+}
+
+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;
+ }
+}
+
+void SkOpSegment::dumpContour(int firstID, int lastID) const {
+ if (debugID() < 0) {
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()));
+ const SkOpSegment* test = this - (debugID() - 1);
+ test += (firstID - 1);
+ const SkOpSegment* last = test + (lastID - firstID);
+ while (test <= last) {
+ test->dumpSpans();
+ ++test;
+ }
}
void SkOpSegment::dumpPts() const {
int last = SkPathOpsVerbToPoints(fVerb);
- SkDebugf("seg=%d {{", this->debugID());
+ SkDebugf("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
int index = 0;
do {
SkDPoint::Dump(fPts[index]);
@@ -912,288 +502,396 @@
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");
+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");
+}
+
+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");
+}
+
+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();
+ }
+}
+
+void SkPathOpsDebug::DumpCoincidence(const SkTArray<SkOpContour, true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index].dumpCoincidences();
+ }
+}
+
+void SkPathOpsDebug::DumpCoincidence(const SkTArray<SkOpContour* , true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index]->dumpCoincidences();
+ }
+}
+
+void SkPathOpsDebug::DumpContours(const SkTArray<SkOpContour, true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index].dump();
+ }
+}
+
+void SkPathOpsDebug::DumpContours(const SkTArray<SkOpContour* , true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index]->dump();
+ }
+}
+
+void SkPathOpsDebug::DumpContourAngles(const SkTArray<SkOpContour, true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index].dumpAngles();
+ }
+}
+
+void SkPathOpsDebug::DumpContourAngles(const SkTArray<SkOpContour* , true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index]->dumpAngles();
+ }
+}
+
+void SkPathOpsDebug::DumpContourPts(const SkTArray<SkOpContour, true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index].dumpPts();
+ }
+}
+
+void SkPathOpsDebug::DumpContourPts(const SkTArray<SkOpContour* , true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index]->dumpPts();
+ }
+}
+
+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);
+ }
+}
+
+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);
+ }
+}
+
+void SkPathOpsDebug::DumpContourSpans(const SkTArray<SkOpContour, true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index].dumpSpans();
+ }
+}
+
+void SkPathOpsDebug::DumpContourSpans(const SkTArray<SkOpContour* , true>& contours) {
+ int count = contours.count();
+ for (int index = 0; index < count; ++index) {
+ contours[index]->dumpSpans();
+ }
+}
+
+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);
+ }
+}
+
+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);
+ }
+}
+
+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;
+}
+
+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");
- 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");
+}
+
+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();
+}
+
+void Dump(const SkTArray<class SkOpContour, true>& contours) {
+ SkPathOpsDebug::DumpContours(contours);
+}
+
+void Dump(const SkTArray<class SkOpContour* , true>& contours) {
+ SkPathOpsDebug::DumpContours(contours);
+}
+
+void Dump(const SkTArray<class SkOpContour, true>* contours) {
+ SkPathOpsDebug::DumpContours(*contours);
+}
+
+void Dump(const SkTArray<class SkOpContour* , true>* contours) {
+ SkPathOpsDebug::DumpContours(*contours);
+}
+
+void Dump(const SkTDArray<SkOpSpan *>& chase) {
+ SkPathOpsDebug::DumpSpans(chase);
+}
+
+void Dump(const SkTDArray<SkOpSpan *>* chase) {
+ SkPathOpsDebug::DumpSpans(*chase);
+}
+
+void DumpAngles(const SkTArray<class SkOpContour, true>& contours) {
+ SkPathOpsDebug::DumpContourAngles(contours);
+}
+
+void DumpAngles(const SkTArray<class SkOpContour* , true>& contours) {
+ SkPathOpsDebug::DumpContourAngles(contours);
+}
+
+void DumpAngles(const SkTArray<class SkOpContour, true>* contours) {
+ SkPathOpsDebug::DumpContourAngles(*contours);
+}
+
+void DumpAngles(const SkTArray<class SkOpContour* , true>* contours) {
+ SkPathOpsDebug::DumpContourAngles(*contours);
+}
+
+void DumpCoin(const SkTArray<class SkOpContour, true>& contours) {
+ SkPathOpsDebug::DumpCoincidence(contours);
+}
+
+void DumpCoin(const SkTArray<class SkOpContour* , true>& contours) {
+ SkPathOpsDebug::DumpCoincidence(contours);
+}
+
+void DumpCoin(const SkTArray<class SkOpContour, true>* contours) {
+ SkPathOpsDebug::DumpCoincidence(*contours);
+}
+
+void DumpCoin(const SkTArray<class SkOpContour* , true>* contours) {
+ SkPathOpsDebug::DumpCoincidence(*contours);
+}
+
+void DumpSpans(const SkTArray<class SkOpContour, true>& contours) {
+ SkPathOpsDebug::DumpContourSpans(contours);
+}
+
+void DumpSpans(const SkTArray<class SkOpContour* , true>& contours) {
+ SkPathOpsDebug::DumpContourSpans(contours);
+}
+
+void DumpSpans(const SkTArray<class SkOpContour, true>* contours) {
+ SkPathOpsDebug::DumpContourSpans(*contours);
+}
+
+void DumpSpans(const SkTArray<class SkOpContour* , true>* contours) {
+ SkPathOpsDebug::DumpContourSpans(*contours);
+}
+
+void DumpSpan(const SkTArray<class SkOpContour, true>& contours, int segmentID) {
+ SkPathOpsDebug::DumpContourSpan(contours, segmentID);
+}
+
+void DumpSpan(const SkTArray<class SkOpContour* , true>& contours, int segmentID) {
+ SkPathOpsDebug::DumpContourSpan(contours, segmentID);
+}
+
+void DumpSpan(const SkTArray<class SkOpContour, true>* contours, int segmentID) {
+ SkPathOpsDebug::DumpContourSpan(*contours, segmentID);
+}
+
+void DumpSpan(const SkTArray<class SkOpContour* , true>* contours, int segmentID) {
+ SkPathOpsDebug::DumpContourSpan(*contours, segmentID);
+}
+
+void DumpPts(const SkTArray<class SkOpContour, true>& contours) {
+ SkPathOpsDebug::DumpContourPts(contours);
+}
+
+void DumpPts(const SkTArray<class SkOpContour* , true>& contours) {
+ SkPathOpsDebug::DumpContourPts(contours);
+}
+
+void DumpPts(const SkTArray<class SkOpContour, true>* contours) {
+ SkPathOpsDebug::DumpContourPts(*contours);
+}
+
+void DumpPts(const SkTArray<class SkOpContour* , true>* contours) {
+ SkPathOpsDebug::DumpContourPts(*contours);
+}
+
+void DumpPt(const SkTArray<class SkOpContour, true>& contours, int segmentID) {
+ SkPathOpsDebug::DumpContourPt(contours, segmentID);
+}
+
+void DumpPt(const SkTArray<class SkOpContour* , true>& contours, int segmentID) {
+ SkPathOpsDebug::DumpContourPt(contours, segmentID);
+}
+
+void DumpPt(const SkTArray<class SkOpContour, true>* contours, int segmentID) {
+ SkPathOpsDebug::DumpContourPt(*contours, segmentID);
+}
+
+void DumpPt(const SkTArray<class SkOpContour* , true>* contours, int segmentID) {
+ SkPathOpsDebug::DumpContourPt(*contours, segmentID);
+}
+
+static void dumpTestCase(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
+ SkDebugf("<div id=\"quad%d\">\n", testNo);
+ quad1.dumpComma(",");
+ quad2.dump();
+ SkDebugf("</div>\n\n");
+}
+
+static void dumpTestTrailer() {
+ SkDebugf("</div>\n\n<script type=\"text/javascript\">\n\n");
+ SkDebugf(" var testDivs = [\n");
+}
+
+static void dumpTestList(int testNo, double min) {
+ SkDebugf(" quad%d,", testNo);
+ if (min > 0) {
+ SkDebugf(" // %1.9g", min);
}
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
+void DumpQ(const SkDQuad& quad1, const SkDQuad& quad2, int testNo) {
+ SkDebugf("\n");
+ dumpTestCase(quad1, quad2, testNo);
+ dumpTestTrailer();
+ dumpTestList(testNo, 0);
+ SkDebugf("\n");
+}
+
+void DumpT(const SkDQuad& quad, double t) {
+ SkDLine line = {{quad.ptAtT(t), quad[0]}};
+ line.dump();
+}
« 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