0dc4dd6dda
Reason for revert: ASAN investigation Original issue's description: > pathops version two > > R=reed@google.com > > marked 'no commit' to attempt to get trybots to run > > TBR=reed@google.com > > Committed: https://skia.googlesource.com/skia/+/ccec0f958ffc71a9986d236bc2eb335cb2111119 TBR=caryclark@google.com NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true Review URL: https://codereview.chromium.org/1029993002
898 lines
25 KiB
C++
Executable File
898 lines
25 KiB
C++
Executable File
#include "SkOpContour.h"
|
|
#include "SkIntersectionHelper.h"
|
|
#include "SkOpSegment.h"
|
|
#include "SkString.h"
|
|
|
|
inline void DebugDumpDouble(double x) {
|
|
if (x == floor(x)) {
|
|
SkDebugf("%.0f", x);
|
|
} else {
|
|
SkDebugf("%1.19g", x);
|
|
}
|
|
}
|
|
|
|
inline void DebugDumpFloat(float x) {
|
|
if (x == floorf(x)) {
|
|
SkDebugf("%.0f", x);
|
|
} else {
|
|
SkDebugf("%1.9gf", x);
|
|
}
|
|
}
|
|
|
|
inline void DebugDumpHexFloat(float x) {
|
|
SkDebugf("SkBits2Float(0x%08x)", SkFloat2Bits(x));
|
|
}
|
|
|
|
#if DEBUG_SHOW_TEST_NAME
|
|
|
|
static void output_scalar(SkScalar num) {
|
|
if (num == (int) num) {
|
|
SkDebugf("%d", (int) num);
|
|
} else {
|
|
SkString str;
|
|
str.printf("%1.9g", num);
|
|
int width = (int) str.size();
|
|
const char* cStr = str.c_str();
|
|
while (cStr[width - 1] == '0') {
|
|
--width;
|
|
}
|
|
str.resize(width);
|
|
SkDebugf("%sf", str.c_str());
|
|
}
|
|
}
|
|
|
|
static void output_points(const SkPoint* pts, int count) {
|
|
for (int index = 0; index < count; ++index) {
|
|
output_scalar(pts[index].fX);
|
|
SkDebugf(", ");
|
|
output_scalar(pts[index].fY);
|
|
if (index + 1 < count) {
|
|
SkDebugf(", ");
|
|
}
|
|
}
|
|
SkDebugf(");\n");
|
|
}
|
|
|
|
static void showPathContours(SkPath::RawIter& iter, const char* pathName) {
|
|
uint8_t verb;
|
|
SkPoint pts[4];
|
|
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
|
|
switch (verb) {
|
|
case SkPath::kMove_Verb:
|
|
SkDebugf(" %s.moveTo(", pathName);
|
|
output_points(&pts[0], 1);
|
|
continue;
|
|
case SkPath::kLine_Verb:
|
|
SkDebugf(" %s.lineTo(", pathName);
|
|
output_points(&pts[1], 1);
|
|
break;
|
|
case SkPath::kQuad_Verb:
|
|
SkDebugf(" %s.quadTo(", pathName);
|
|
output_points(&pts[1], 2);
|
|
break;
|
|
case SkPath::kCubic_Verb:
|
|
SkDebugf(" %s.cubicTo(", pathName);
|
|
output_points(&pts[1], 3);
|
|
break;
|
|
case SkPath::kClose_Verb:
|
|
SkDebugf(" %s.close();\n", pathName);
|
|
break;
|
|
default:
|
|
SkDEBUGFAIL("bad verb");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static const char* gFillTypeStr[] = {
|
|
"kWinding_FillType",
|
|
"kEvenOdd_FillType",
|
|
"kInverseWinding_FillType",
|
|
"kInverseEvenOdd_FillType"
|
|
};
|
|
|
|
void SkPathOpsDebug::ShowOnePath(const SkPath& path, const char* name, bool includeDeclaration) {
|
|
SkPath::RawIter iter(path);
|
|
#define SUPPORT_RECT_CONTOUR_DETECTION 0
|
|
#if SUPPORT_RECT_CONTOUR_DETECTION
|
|
int rectCount = path.isRectContours() ? path.rectContours(NULL, NULL) : 0;
|
|
if (rectCount > 0) {
|
|
SkTDArray<SkRect> rects;
|
|
SkTDArray<SkPath::Direction> directions;
|
|
rects.setCount(rectCount);
|
|
directions.setCount(rectCount);
|
|
path.rectContours(rects.begin(), directions.begin());
|
|
for (int contour = 0; contour < rectCount; ++contour) {
|
|
const SkRect& rect = rects[contour];
|
|
SkDebugf("path.addRect(%1.9g, %1.9g, %1.9g, %1.9g, %s);\n", rect.fLeft, rect.fTop,
|
|
rect.fRight, rect.fBottom, directions[contour] == SkPath::kCCW_Direction
|
|
? "SkPath::kCCW_Direction" : "SkPath::kCW_Direction");
|
|
}
|
|
return;
|
|
}
|
|
#endif
|
|
SkPath::FillType fillType = path.getFillType();
|
|
SkASSERT(fillType >= SkPath::kWinding_FillType && fillType <= SkPath::kInverseEvenOdd_FillType);
|
|
if (includeDeclaration) {
|
|
SkDebugf(" SkPath %s;\n", name);
|
|
}
|
|
SkDebugf(" %s.setFillType(SkPath::%s);\n", name, gFillTypeStr[fillType]);
|
|
iter.setPath(path);
|
|
showPathContours(iter, name);
|
|
}
|
|
|
|
static void show_function_header(const char* functionName) {
|
|
SkDebugf("\nstatic void %s(skiatest::Reporter* reporter, const char* filename) {\n", functionName);
|
|
if (strcmp("skphealth_com76", functionName) == 0) {
|
|
SkDebugf("found it\n");
|
|
}
|
|
}
|
|
|
|
static const char* gOpStrs[] = {
|
|
"kDifference_PathOp",
|
|
"kIntersect_PathOp",
|
|
"kUnion_PathOp",
|
|
"kXor_PathOp",
|
|
"kReverseDifference_PathOp",
|
|
};
|
|
|
|
static void show_op(SkPathOp op, const char* pathOne, const char* pathTwo) {
|
|
SkDebugf(" testPathOp(reporter, %s, %s, %s, filename);\n", pathOne, pathTwo, gOpStrs[op]);
|
|
SkDebugf("}\n");
|
|
}
|
|
|
|
SK_DECLARE_STATIC_MUTEX(gTestMutex);
|
|
|
|
void SkPathOpsDebug::ShowPath(const SkPath& a, const SkPath& b, SkPathOp shapeOp,
|
|
const char* testName) {
|
|
SkAutoMutexAcquire ac(gTestMutex);
|
|
show_function_header(testName);
|
|
ShowOnePath(a, "path", true);
|
|
ShowOnePath(b, "pathB", true);
|
|
show_op(shapeOp, "path", "pathB");
|
|
}
|
|
#endif
|
|
|
|
// if not defined by PathOpsDebug.cpp ...
|
|
#if !defined SK_DEBUG && FORCE_RELEASE
|
|
bool SkPathOpsDebug::ValidWind(int wind) {
|
|
return wind > SK_MinS32 + 0xFFFF && wind < SK_MaxS32 - 0xFFFF;
|
|
}
|
|
|
|
void SkPathOpsDebug::WindingPrintf(int wind) {
|
|
if (wind == SK_MinS32) {
|
|
SkDebugf("?");
|
|
} else {
|
|
SkDebugf("%d", 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 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 {
|
|
fPts[index].dump();
|
|
SkDebugf(", ");
|
|
} while (++index < 3);
|
|
fPts[index].dump();
|
|
SkDebugf("}}\n");
|
|
}
|
|
|
|
void SkDCubic::dumpNumber() 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) {
|
|
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;
|
|
}
|
|
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("((SkOpSegment*) 0x%p) [%d] {{", this, debugID());
|
|
int index = 0;
|
|
do {
|
|
SkDPoint::Dump(fPts[index]);
|
|
SkDebugf(", ");
|
|
} while (++index < last);
|
|
SkDPoint::Dump(fPts[index]);
|
|
SkDebugf("}}\n");
|
|
}
|
|
|
|
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");
|
|
}
|
|
|
|
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 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();
|
|
}
|