8762fb67bc
(fixing msan/asan/ubsan failure) Pathops used templates for curve intersection. Since only one template is required if curves share an abstract base, remove the template altogether. This makes the code easier to read, and incidentally makes it slightly smaller and much faster. This also removes debugging code specific to templates, and removes Simplify code which isn't covered by tests or fuzz. This shaves the execution time of pathops_unittest -V -x from 6m to 3m23s. R=kjlubick@google.com Bug: skia: Change-Id: I3392df98244083d0327ce9c787dfe24d326ef4ed Reviewed-on: https://skia-review.googlesource.com/c/162742 Commit-Queue: Cary Clark <caryclark@skia.org> Reviewed-by: Kevin Lubick <kjlubick@google.com>
1526 lines
37 KiB
C++
1526 lines
37 KiB
C++
/*
|
|
* 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 "PathOpsDebug.h"
|
|
#include "PathOpsTSectDebug.h"
|
|
#include "SkOpCoincidence.h"
|
|
#include "SkOpContour.h"
|
|
#include "SkIntersectionHelper.h"
|
|
#include "SkMutex.h"
|
|
#include "SkOpSegment.h"
|
|
#include "SkString.h"
|
|
|
|
bool PathOpsDebug::gJson;
|
|
bool PathOpsDebug::gMarkJsonFlaky;
|
|
bool PathOpsDebug::gOutFirst;
|
|
bool PathOpsDebug::gCheckForDuplicateNames;
|
|
bool PathOpsDebug::gOutputSVG;
|
|
FILE* PathOpsDebug::gOut;
|
|
|
|
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 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
|
|
|
|
static void DumpID(int id) {
|
|
SkDebugf("} ");
|
|
if (id >= 0) {
|
|
SkDebugf("id=%d", id);
|
|
}
|
|
SkDebugf("\n");
|
|
}
|
|
|
|
void SkDConic::dump() const {
|
|
dumpInner();
|
|
SkDebugf("},\n");
|
|
}
|
|
|
|
void SkDConic::dumpID(int id) const {
|
|
dumpInner();
|
|
DumpID(id);
|
|
}
|
|
|
|
void SkDConic::dumpInner() const {
|
|
SkDebugf("{");
|
|
fPts.dumpInner();
|
|
SkDebugf("}}, %1.9gf", fWeight);
|
|
}
|
|
|
|
void SkDCubic::dump() const {
|
|
this->dumpInner();
|
|
SkDebugf("}},\n");
|
|
}
|
|
|
|
void SkDCubic::dumpID(int id) const {
|
|
this->dumpInner();
|
|
SkDebugf("}");
|
|
DumpID(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 SkDCurve::dump() const {
|
|
dumpID(-1);
|
|
}
|
|
|
|
void SkDCurve::dumpID(int id) const {
|
|
#ifndef SK_RELEASE
|
|
switch(fVerb) {
|
|
case SkPath::kLine_Verb:
|
|
fLine.dumpID(id);
|
|
break;
|
|
case SkPath::kQuad_Verb:
|
|
fQuad.dumpID(id);
|
|
break;
|
|
case SkPath::kConic_Verb:
|
|
fConic.dumpID(id);
|
|
break;
|
|
case SkPath::kCubic_Verb:
|
|
fCubic.dumpID(id);
|
|
break;
|
|
default:
|
|
SkASSERT(0);
|
|
}
|
|
#else
|
|
fCubic.dumpID(id);
|
|
#endif
|
|
}
|
|
|
|
void SkDLine::dump() const {
|
|
this->dumpInner();
|
|
SkDebugf("}},\n");
|
|
}
|
|
|
|
void SkDLine::dumpID(int id) const {
|
|
this->dumpInner();
|
|
SkDebugf("}");
|
|
DumpID(id);
|
|
}
|
|
|
|
void SkDLine::dumpInner() const {
|
|
SkDebugf("{{");
|
|
fPts[0].dump();
|
|
SkDebugf(", ");
|
|
fPts[1].dump();
|
|
}
|
|
|
|
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("}");
|
|
DumpID(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* AngleAngle(const SkOpAngle* angle, int id) {
|
|
return angle->debugAngle(id);
|
|
}
|
|
|
|
SkOpContour* AngleContour(SkOpAngle* angle, int id) {
|
|
return angle->debugContour(id);
|
|
}
|
|
|
|
const SkOpPtT* AnglePtT(const SkOpAngle* angle, int id) {
|
|
return angle->debugPtT(id);
|
|
}
|
|
|
|
const SkOpSegment* AngleSegment(const SkOpAngle* angle, int id) {
|
|
return angle->debugSegment(id);
|
|
}
|
|
|
|
const SkOpSpanBase* AngleSpan(const SkOpAngle* angle, int id) {
|
|
return angle->debugSpan(id);
|
|
}
|
|
|
|
const SkOpAngle* ContourAngle(SkOpContour* contour, int id) {
|
|
return contour->debugAngle(id);
|
|
}
|
|
|
|
SkOpContour* ContourContour(SkOpContour* contour, int id) {
|
|
return contour->debugContour(id);
|
|
}
|
|
|
|
const SkOpPtT* ContourPtT(SkOpContour* contour, int id) {
|
|
return contour->debugPtT(id);
|
|
}
|
|
|
|
const SkOpSegment* ContourSegment(SkOpContour* contour, int id) {
|
|
return contour->debugSegment(id);
|
|
}
|
|
|
|
const SkOpSpanBase* ContourSpan(SkOpContour* contour, int id) {
|
|
return contour->debugSpan(id);
|
|
}
|
|
|
|
const SkOpAngle* CoincidenceAngle(SkOpCoincidence* coin, int id) {
|
|
return coin->debugAngle(id);
|
|
}
|
|
|
|
SkOpContour* CoincidenceContour(SkOpCoincidence* coin, int id) {
|
|
return coin->debugContour(id);
|
|
}
|
|
|
|
const SkOpPtT* CoincidencePtT(SkOpCoincidence* coin, int id) {
|
|
return coin->debugPtT(id);
|
|
}
|
|
|
|
const SkOpSegment* CoincidenceSegment(SkOpCoincidence* coin, int id) {
|
|
return coin->debugSegment(id);
|
|
}
|
|
|
|
const SkOpSpanBase* CoincidenceSpan(SkOpCoincidence* coin, int id) {
|
|
return coin->debugSpan(id);
|
|
}
|
|
|
|
const SkOpAngle* PtTAngle(const SkOpPtT* ptT, int id) {
|
|
return ptT->debugAngle(id);
|
|
}
|
|
|
|
SkOpContour* PtTContour(SkOpPtT* ptT, int id) {
|
|
return ptT->debugContour(id);
|
|
}
|
|
|
|
const SkOpPtT* PtTPtT(const SkOpPtT* ptT, int id) {
|
|
return ptT->debugPtT(id);
|
|
}
|
|
|
|
const SkOpSegment* PtTSegment(const SkOpPtT* ptT, int id) {
|
|
return ptT->debugSegment(id);
|
|
}
|
|
|
|
const SkOpSpanBase* PtTSpan(const SkOpPtT* ptT, int id) {
|
|
return ptT->debugSpan(id);
|
|
}
|
|
|
|
const SkOpAngle* SegmentAngle(const SkOpSegment* span, int id) {
|
|
return span->debugAngle(id);
|
|
}
|
|
|
|
SkOpContour* SegmentContour(SkOpSegment* span, int id) {
|
|
return span->debugContour(id);
|
|
}
|
|
|
|
const SkOpPtT* SegmentPtT(const SkOpSegment* span, int id) {
|
|
return span->debugPtT(id);
|
|
}
|
|
|
|
const SkOpSegment* SegmentSegment(const SkOpSegment* span, int id) {
|
|
return span->debugSegment(id);
|
|
}
|
|
|
|
const SkOpSpanBase* SegmentSpan(const SkOpSegment* span, int id) {
|
|
return span->debugSpan(id);
|
|
}
|
|
|
|
const SkOpAngle* SpanAngle(const SkOpSpanBase* span, int id) {
|
|
return span->debugAngle(id);
|
|
}
|
|
|
|
SkOpContour* SpanContour(SkOpSpanBase* span, int id) {
|
|
return span->debugContour(id);
|
|
}
|
|
|
|
const SkOpPtT* SpanPtT(const SkOpSpanBase* span, int id) {
|
|
return span->debugPtT(id);
|
|
}
|
|
|
|
const SkOpSegment* SpanSegment(const SkOpSpanBase* span, int id) {
|
|
return span->debugSegment(id);
|
|
}
|
|
|
|
const SkOpSpanBase* SpanSpan(const SkOpSpanBase* span, int id) {
|
|
return span->debugSpan(id);
|
|
}
|
|
|
|
#if DEBUG_COIN
|
|
void SkPathOpsDebug::DumpCoinDict() {
|
|
SkPathOpsDebug::gCoinSumChangedDict.dump("unused coin algorithm", false);
|
|
SkPathOpsDebug::gCoinSumVisitedDict.dump("visited coin function", true);
|
|
}
|
|
|
|
void SkPathOpsDebug::CoinDict::dump(const char* str, bool visitCheck) const {
|
|
int count = fDict.count();
|
|
for (int index = 0; index < count; ++index) {
|
|
const auto& entry = fDict[index];
|
|
if (visitCheck || entry.fGlitchType == kUninitialized_Glitch) {
|
|
SkDebugf("%s %s : line %d iteration %d", str, entry.fFunctionName,
|
|
entry.fLineNumber, entry.fIteration);
|
|
DumpGlitchType(entry.fGlitchType);
|
|
SkDebugf("\n");
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void SkOpContour::dumpContours() const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dump();
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpContoursAll() const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dumpAll();
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpContoursAngles() const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dumpAngles();
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpContoursPts() const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dumpPts();
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpContoursPt(int segmentID) const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dumpPt(segmentID);
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpContoursSegment(int segmentID) const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dumpSegment(segmentID);
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpContoursSpan(int spanID) const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dumpSpan(spanID);
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpContoursSpans() const {
|
|
SkOpContour* contour = this->globalState()->contourHead();
|
|
do {
|
|
contour->dumpSpans();
|
|
} while ((contour = contour->next()));
|
|
}
|
|
|
|
#ifdef SK_DEBUG
|
|
const SkTSpan* DebugSpan(const SkTSect* sect, int id) {
|
|
return sect->debugSpan(id);
|
|
}
|
|
|
|
const SkTSpan* DebugT(const SkTSect* sect, double t) {
|
|
return sect->debugT(t);
|
|
}
|
|
#endif
|
|
|
|
void Dump(const SkTSect* sect) {
|
|
sect->dump();
|
|
}
|
|
|
|
void DumpBoth(SkTSect* sect1, SkTSect* sect2) {
|
|
sect1->dumpBoth(sect2);
|
|
}
|
|
|
|
void DumpBounded(SkTSect* sect1, int id) {
|
|
sect1->dumpBounded(id);
|
|
}
|
|
|
|
void DumpBounds(SkTSect* sect1) {
|
|
sect1->dumpBounds();
|
|
}
|
|
|
|
void DumpCoin(SkTSect* sect1) {
|
|
sect1->dumpCoin();
|
|
}
|
|
|
|
void DumpCoinCurves(SkTSect* sect1) {
|
|
sect1->dumpCoinCurves();
|
|
}
|
|
|
|
void DumpCurves(const SkTSect* sect) {
|
|
sect->dumpCurves();
|
|
}
|
|
|
|
void Dump(const SkTSpan* span) {
|
|
span->dump();
|
|
}
|
|
|
|
void DumpAll(const SkTSpan* span) {
|
|
span->dumpAll();
|
|
}
|
|
|
|
void DumpBounded(const SkTSpan* span) {
|
|
span->dumpBounded(0);
|
|
}
|
|
|
|
void DumpCoin(const SkTSpan* span) {
|
|
span->dumpCoin();
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
const SkOpCoincidence* SkOpAngle::debugCoincidence() const {
|
|
return this->segment()->debugCoincidence();
|
|
}
|
|
|
|
SkOpContour* SkOpAngle::debugContour(int id) const {
|
|
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);
|
|
}
|
|
|
|
int SkOpAngle::debugSign() const {
|
|
SkASSERT(fStart->t() != fEnd->t());
|
|
return fStart->t() < fEnd->t() ? -1 : 1;
|
|
}
|
|
|
|
const SkOpSpanBase* SkOpAngle::debugSpan(int id) const {
|
|
return this->segment()->debugSpan(id);
|
|
}
|
|
|
|
void SkOpAngle::dump() const {
|
|
dumpOne(true);
|
|
SkDebugf("\n");
|
|
}
|
|
|
|
void SkOpAngle::dumpOne(bool functionHeader) const {
|
|
// fSegment->debugValidate();
|
|
const SkOpSegment* segment = this->segment();
|
|
const SkOpSpan& mSpan = *fStart->starter(fEnd);
|
|
if (functionHeader) {
|
|
SkDebugf("%s ", __FUNCTION__);
|
|
}
|
|
SkDebugf("[%d", segment->debugID());
|
|
SkDebugf("/%d", debugID());
|
|
SkDebugf("] next=");
|
|
if (fNext) {
|
|
SkDebugf("%d", fNext->fStart->segment()->debugID());
|
|
SkDebugf("/%d", fNext->debugID());
|
|
} else {
|
|
SkDebugf("?");
|
|
}
|
|
SkDebugf(" sect=%d/%d ", fSectorStart, fSectorEnd);
|
|
SkDebugf(" s=%1.9g [%d] e=%1.9g [%d]", fStart->t(), fStart->debugID(),
|
|
fEnd->t(), fEnd->debugID());
|
|
SkDebugf(" sgn=%d windVal=%d", this->debugSign(), mSpan.windValue());
|
|
|
|
SkDebugf(" windSum=");
|
|
SkPathOpsDebug::WindingPrintf(mSpan.windSum());
|
|
if (mSpan.oppValue() != 0 || mSpan.oppSum() != SK_MinS32) {
|
|
SkDebugf(" oppVal=%d", mSpan.oppValue());
|
|
SkDebugf(" oppSum=");
|
|
SkPathOpsDebug::WindingPrintf(mSpan.oppSum());
|
|
}
|
|
if (mSpan.done()) {
|
|
SkDebugf(" done");
|
|
}
|
|
if (unorderable()) {
|
|
SkDebugf(" unorderable");
|
|
}
|
|
if (segment->operand()) {
|
|
SkDebugf(" operand");
|
|
}
|
|
}
|
|
|
|
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->fPart.fCurve.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) const {
|
|
return this->span()->debugContour(id);
|
|
}
|
|
|
|
const SkOpCoincidence* SkOpPtT::debugCoincidence() const {
|
|
return this->span()->debugCoincidence();
|
|
}
|
|
|
|
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%s", this->fT, this->fPt.fX, this->fPt.fY,
|
|
this->fCoincident ? " coin" : "",
|
|
this->fDuplicatePt ? " dup" : "", this->fDeleted ? " deleted" : "");
|
|
}
|
|
|
|
const SkOpAngle* SkOpSpanBase::debugAngle(int id) const {
|
|
return this->segment()->debugAngle(id);
|
|
}
|
|
|
|
const SkOpCoincidence* SkOpSpanBase::debugCoincidence() const {
|
|
return this->segment()->debugCoincidence();
|
|
}
|
|
|
|
SkOpContour* SkOpSpanBase::debugContour(int id) const {
|
|
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->dumpHead();
|
|
this->fPtT.dump();
|
|
}
|
|
|
|
void SkOpSpanBase::dumpHead() const {
|
|
SkDebugf("%.*s", contour()->debugIndent(), " ");
|
|
SkDebugf("seg=%d span=%d", this->segment()->debugID(), this->debugID());
|
|
this->dumpBase();
|
|
SkDebugf("\n");
|
|
}
|
|
|
|
void SkOpSpanBase::dumpAll() const {
|
|
this->dumpHead();
|
|
this->fPtT.dumpAll();
|
|
}
|
|
|
|
void SkOpSpanBase::dumpBase() const {
|
|
if (this->fAligned) {
|
|
SkDebugf(" aligned");
|
|
}
|
|
if (this->fChased) {
|
|
SkDebugf(" chased");
|
|
}
|
|
#ifdef SK_DEBUG
|
|
if (this->fDebugDeleted) {
|
|
SkDebugf(" deleted");
|
|
}
|
|
#endif
|
|
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());
|
|
}
|
|
SkDebugf(" adds=%d", fSpanAdds);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
const SkOpCoincidence* SkOpSegment::debugCoincidence() const {
|
|
return this->contour()->debugCoincidence();
|
|
}
|
|
|
|
SkOpContour* SkOpSegment::debugContour(int id) const {
|
|
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() ? nullptr : 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::dumpPtsInner(const char* prefix) const {
|
|
int last = SkPathOpsVerbToPoints(fVerb);
|
|
SkDebugf("%s=%d {{", prefix, this->debugID());
|
|
if (fVerb == SkPath::kConic_Verb) {
|
|
SkDebugf("{");
|
|
}
|
|
int index = 0;
|
|
do {
|
|
SkDPoint::Dump(fPts[index]);
|
|
SkDebugf(", ");
|
|
} while (++index < last);
|
|
SkDPoint::Dump(fPts[index]);
|
|
SkDebugf("}}");
|
|
if (fVerb == SkPath::kConic_Verb) {
|
|
SkDebugf(", %1.9gf}", fWeight);
|
|
}
|
|
}
|
|
|
|
void SkOpSegment::dumpPts(const char* prefix) const {
|
|
dumpPtsInner(prefix);
|
|
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->next();
|
|
}
|
|
if (!fTop || fHead == fTop) {
|
|
return;
|
|
}
|
|
SkDebugf("top:\n");
|
|
span = fTop;
|
|
int count = 0;
|
|
while (span) {
|
|
span->dump();
|
|
span = span->next();
|
|
SkCoincidentSpans* check = fTop;
|
|
++count;
|
|
for (int index = 0; index < count; ++index) {
|
|
if (span == check) {
|
|
SkDebugf("(loops to #%d)\n", index);
|
|
return;
|
|
}
|
|
check = check->next();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SkOpContour::dump() const {
|
|
SkDebugf("contour=%d count=%d op=%d xor=%d\n", this->debugID(), fCount, fOperand, fXor);
|
|
if (!fCount) {
|
|
return;
|
|
}
|
|
const SkOpSegment* segment = &fHead;
|
|
SkDEBUGCODE(fDebugIndent = 0);
|
|
this->indentDump();
|
|
do {
|
|
segment->dump();
|
|
} while ((segment = segment->next()));
|
|
this->outdentDump();
|
|
}
|
|
|
|
void SkOpContour::dumpAll() const {
|
|
SkDebugf("contour=%d count=%d op=%d xor=%d\n", this->debugID(), fCount, fOperand, fXor);
|
|
if (!fCount) {
|
|
return;
|
|
}
|
|
const SkOpSegment* segment = &fHead;
|
|
SkDEBUGCODE(fDebugIndent = 0);
|
|
this->indentDump();
|
|
do {
|
|
segment->dumpAll();
|
|
} while ((segment = segment->next()));
|
|
this->outdentDump();
|
|
}
|
|
|
|
|
|
void SkOpContour::dumpAngles() const {
|
|
SkDebugf("contour=%d\n", this->debugID());
|
|
const SkOpSegment* segment = &fHead;
|
|
do {
|
|
SkDebugf(" seg=%d ", segment->debugID());
|
|
segment->dumpAngles();
|
|
} while ((segment = segment->next()));
|
|
}
|
|
|
|
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 char* prefix) const {
|
|
SkDebugf("contour=%d\n", this->debugID());
|
|
const SkOpSegment* segment = &fHead;
|
|
do {
|
|
SkDebugf(" %s=%d ", prefix, segment->debugID());
|
|
segment->dumpPts(prefix);
|
|
} while ((segment = segment->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpPtsX(const char* prefix) const {
|
|
if (!this->fCount) {
|
|
SkDebugf("<empty>\n");
|
|
return;
|
|
}
|
|
const SkOpSegment* segment = &fHead;
|
|
do {
|
|
segment->dumpPts(prefix);
|
|
} while ((segment = segment->next()));
|
|
}
|
|
|
|
void SkOpContour::dumpSegment(int index) const {
|
|
debugSegment(index)->dump();
|
|
}
|
|
|
|
void SkOpContour::dumpSegments(const char* prefix, 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(prefix);
|
|
} 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()));
|
|
}
|
|
|
|
void SkOpCurve::dump() const {
|
|
int count = SkPathOpsVerbToPoints(SkDEBUGRELEASE(fVerb, SkPath::kCubic_Verb));
|
|
SkDebugf("{{");
|
|
int index;
|
|
for (index = 0; index <= count - 1; ++index) {
|
|
SkDebugf("{%1.9gf,%1.9gf}, ", fPts[index].fX, fPts[index].fY);
|
|
}
|
|
SkDebugf("{%1.9gf,%1.9gf}}}\n", fPts[index].fX, fPts[index].fY);
|
|
}
|
|
|
|
#ifdef SK_DEBUG
|
|
const SkOpAngle* SkOpGlobalState::debugAngle(int id) const {
|
|
const SkOpContour* contour = fContourHead;
|
|
do {
|
|
const SkOpSegment* segment = contour->first();
|
|
while (segment) {
|
|
const SkOpSpan* span = segment->head();
|
|
do {
|
|
SkOpAngle* angle = span->fromAngle();
|
|
if (angle && angle->debugID() == id) {
|
|
return angle;
|
|
}
|
|
angle = span->toAngle();
|
|
if (angle && angle->debugID() == id) {
|
|
return angle;
|
|
}
|
|
} while ((span = span->next()->upCastable()));
|
|
const SkOpSpanBase* tail = segment->tail();
|
|
SkOpAngle* angle = tail->fromAngle();
|
|
if (angle && angle->debugID() == id) {
|
|
return angle;
|
|
}
|
|
segment = segment->next();
|
|
}
|
|
} while ((contour = contour->next()));
|
|
return nullptr;
|
|
}
|
|
|
|
SkOpContour* SkOpGlobalState::debugContour(int id) const {
|
|
SkOpContour* contour = fContourHead;
|
|
do {
|
|
if (contour->debugID() == id) {
|
|
return contour;
|
|
}
|
|
} while ((contour = contour->next()));
|
|
return nullptr;
|
|
}
|
|
|
|
const SkOpPtT* SkOpGlobalState::debugPtT(int id) const {
|
|
const SkOpContour* contour = fContourHead;
|
|
do {
|
|
const SkOpSegment* segment = contour->first();
|
|
while (segment) {
|
|
const SkOpSpan* span = segment->head();
|
|
do {
|
|
const SkOpPtT* ptT = span->ptT();
|
|
if (ptT->debugMatchID(id)) {
|
|
return ptT;
|
|
}
|
|
} while ((span = span->next()->upCastable()));
|
|
const SkOpSpanBase* tail = segment->tail();
|
|
const SkOpPtT* ptT = tail->ptT();
|
|
if (ptT->debugMatchID(id)) {
|
|
return ptT;
|
|
}
|
|
segment = segment->next();
|
|
}
|
|
} while ((contour = contour->next()));
|
|
return nullptr;
|
|
}
|
|
|
|
const SkOpSegment* SkOpGlobalState::debugSegment(int id) const {
|
|
const SkOpContour* contour = fContourHead;
|
|
do {
|
|
const SkOpSegment* segment = contour->first();
|
|
while (segment) {
|
|
if (segment->debugID() == id) {
|
|
return segment;
|
|
}
|
|
segment = segment->next();
|
|
}
|
|
} while ((contour = contour->next()));
|
|
return nullptr;
|
|
}
|
|
|
|
const SkOpSpanBase* SkOpGlobalState::debugSpan(int id) const {
|
|
const SkOpContour* contour = fContourHead;
|
|
do {
|
|
const SkOpSegment* segment = contour->first();
|
|
while (segment) {
|
|
const SkOpSpan* span = segment->head();
|
|
do {
|
|
if (span->debugID() == id) {
|
|
return span;
|
|
}
|
|
} while ((span = span->next()->upCastable()));
|
|
const SkOpSpanBase* tail = segment->tail();
|
|
if (tail->debugID() == id) {
|
|
return tail;
|
|
}
|
|
segment = segment->next();
|
|
}
|
|
} while ((contour = contour->next()));
|
|
return nullptr;
|
|
}
|
|
#endif
|
|
|
|
char SkTCoincident::dumpIsCoincidentStr() const {
|
|
if (!!fMatch != fMatch) {
|
|
return '?';
|
|
}
|
|
return fMatch ? '*' : 0;
|
|
}
|
|
|
|
void SkTCoincident::dump() const {
|
|
SkDebugf("t=%1.9g pt=(%1.9g,%1.9g)%s\n", fPerpT, fPerpPt.fX, fPerpPt.fY,
|
|
fMatch ? " match" : "");
|
|
}
|
|
|
|
#ifdef SK_DEBUG
|
|
|
|
const SkTSpan* SkTSect::debugSpan(int id) const {
|
|
const SkTSpan* test = fHead;
|
|
do {
|
|
if (test->debugID() == id) {
|
|
return test;
|
|
}
|
|
} while ((test = test->next()));
|
|
return nullptr;
|
|
}
|
|
|
|
const SkTSpan* SkTSect::debugT(double t) const {
|
|
const SkTSpan* test = fHead;
|
|
const SkTSpan* closest = nullptr;
|
|
double bestDist = DBL_MAX;
|
|
do {
|
|
if (between(test->fStartT, t, test->fEndT)) {
|
|
return test;
|
|
}
|
|
double testDist = SkTMin(fabs(test->fStartT - t), fabs(test->fEndT - t));
|
|
if (bestDist > testDist) {
|
|
bestDist = testDist;
|
|
closest = test;
|
|
}
|
|
} while ((test = test->next()));
|
|
SkASSERT(closest);
|
|
return closest;
|
|
}
|
|
|
|
#endif
|
|
|
|
void SkTSect::dump() const {
|
|
dumpCommon(fHead);
|
|
}
|
|
|
|
extern int gDumpTSectNum;
|
|
|
|
void SkTSect::dumpBoth(SkTSect* opp) const {
|
|
#if DEBUG_T_SECT_DUMP <= 2
|
|
#if DEBUG_T_SECT_DUMP == 2
|
|
SkDebugf("%d ", ++gDumpTSectNum);
|
|
#endif
|
|
this->dump();
|
|
SkDebugf("\n");
|
|
opp->dump();
|
|
SkDebugf("\n");
|
|
#elif DEBUG_T_SECT_DUMP == 3
|
|
SkDebugf("<div id=\"sect%d\">\n", ++gDumpTSectNum);
|
|
if (this->fHead) {
|
|
this->dumpCurves();
|
|
}
|
|
if (opp->fHead) {
|
|
opp->dumpCurves();
|
|
}
|
|
SkDebugf("</div>\n\n");
|
|
#endif
|
|
}
|
|
|
|
void SkTSect::dumpBounded(int id) const {
|
|
#ifdef SK_DEBUG
|
|
const SkTSpan* bounded = debugSpan(id);
|
|
if (!bounded) {
|
|
SkDebugf("no span matches %d\n", id);
|
|
return;
|
|
}
|
|
const SkTSpan* test = bounded->debugOpp()->fHead;
|
|
do {
|
|
if (test->findOppSpan(bounded)) {
|
|
test->dump();
|
|
SkDebugf(" ");
|
|
}
|
|
} while ((test = test->next()));
|
|
SkDebugf("\n");
|
|
#endif
|
|
}
|
|
|
|
void SkTSect::dumpBounds() const {
|
|
const SkTSpan* test = fHead;
|
|
do {
|
|
test->dumpBounds();
|
|
} while ((test = test->next()));
|
|
}
|
|
|
|
void SkTSect::dumpCoin() const {
|
|
dumpCommon(fCoincident);
|
|
}
|
|
|
|
void SkTSect::dumpCoinCurves() const {
|
|
dumpCommonCurves(fCoincident);
|
|
}
|
|
|
|
void SkTSect::dumpCommon(const SkTSpan* test) const {
|
|
SkDebugf("id=%d", debugID());
|
|
if (!test) {
|
|
SkDebugf(" (empty)");
|
|
return;
|
|
}
|
|
do {
|
|
SkDebugf(" ");
|
|
test->dump();
|
|
} while ((test = test->next()));
|
|
}
|
|
|
|
void SkTSect::dumpCommonCurves(const SkTSpan* test) const {
|
|
#if DEBUG_T_SECT
|
|
do {
|
|
test->fPart->dumpID(test->debugID());
|
|
} while ((test = test->next()));
|
|
#endif
|
|
}
|
|
|
|
void SkTSect::dumpCurves() const {
|
|
dumpCommonCurves(fHead);
|
|
}
|
|
|
|
#ifdef SK_DEBUG
|
|
|
|
const SkTSpan* SkTSpan::debugSpan(int id) const {
|
|
return fDebugSect->debugSpan(id);
|
|
}
|
|
|
|
const SkTSpan* SkTSpan::debugT(double t) const {
|
|
return fDebugSect->debugT(t);
|
|
}
|
|
|
|
#endif
|
|
|
|
void SkTSpan::dumpAll() const {
|
|
dumpID();
|
|
SkDebugf("=(%g,%g) [", fStartT, fEndT);
|
|
const SkTSpanBounded* testBounded = fBounded;
|
|
while (testBounded) {
|
|
const SkTSpan* span = testBounded->fBounded;
|
|
const SkTSpanBounded* next = testBounded->fNext;
|
|
span->dumpID();
|
|
SkDebugf("=(%g,%g)", span->fStartT, span->fEndT);
|
|
if (next) {
|
|
SkDebugf(" ");
|
|
}
|
|
testBounded = next;
|
|
}
|
|
SkDebugf("]\n");
|
|
}
|
|
|
|
void SkTSpan::dump() const {
|
|
dumpID();
|
|
SkDebugf("=(%g,%g) [", fStartT, fEndT);
|
|
const SkTSpanBounded* testBounded = fBounded;
|
|
while (testBounded) {
|
|
const SkTSpan* span = testBounded->fBounded;
|
|
const SkTSpanBounded* next = testBounded->fNext;
|
|
span->dumpID();
|
|
if (next) {
|
|
SkDebugf(",");
|
|
}
|
|
testBounded = next;
|
|
}
|
|
SkDebugf("]");
|
|
}
|
|
|
|
void SkTSpan::dumpBounded(int id) const {
|
|
SkDEBUGCODE(fDebugSect->dumpBounded(id));
|
|
}
|
|
|
|
void SkTSpan::dumpBounds() const {
|
|
dumpID();
|
|
SkDebugf(" bounds=(%1.9g,%1.9g, %1.9g,%1.9g) boundsMax=%1.9g%s\n",
|
|
fBounds.fLeft, fBounds.fTop, fBounds.fRight, fBounds.fBottom, fBoundsMax,
|
|
fCollapsed ? " collapsed" : "");
|
|
}
|
|
|
|
void SkTSpan::dumpCoin() const {
|
|
dumpID();
|
|
SkDebugf(" coinStart ");
|
|
fCoinStart.dump();
|
|
SkDebugf(" coinEnd ");
|
|
fCoinEnd.dump();
|
|
}
|
|
|
|
void SkTSpan::dumpID() const {
|
|
char cS = fCoinStart.dumpIsCoincidentStr();
|
|
if (cS) {
|
|
SkDebugf("%c", cS);
|
|
}
|
|
SkDebugf("%d", debugID());
|
|
char cE = fCoinEnd.dumpIsCoincidentStr();
|
|
if (cE) {
|
|
SkDebugf("%c", cE);
|
|
}
|
|
}
|
|
|
|
#if DEBUG_T_SECT_DUMP > 1
|
|
int gDumpTSectNum;
|
|
#endif
|
|
|
|
// global path dumps for msvs Visual Studio 17 to use from Immediate Window
|
|
void Dump(const SkOpContour& contour) {
|
|
contour.dump();
|
|
}
|
|
|
|
void DumpAll(const SkOpContour& contour) {
|
|
contour.dumpAll();
|
|
}
|
|
|
|
void DumpAngles(const SkOpContour& contour) {
|
|
contour.dumpAngles();
|
|
}
|
|
|
|
void DumpContours(const SkOpContour& contour) {
|
|
contour.dumpContours();
|
|
}
|
|
|
|
void DumpContoursAll(const SkOpContour& contour) {
|
|
contour.dumpContoursAll();
|
|
}
|
|
|
|
void DumpContoursAngles(const SkOpContour& contour) {
|
|
contour.dumpContoursAngles();
|
|
}
|
|
|
|
void DumpContoursPts(const SkOpContour& contour) {
|
|
contour.dumpContoursPts();
|
|
}
|
|
|
|
void DumpContoursPt(const SkOpContour& contour, int segmentID) {
|
|
contour.dumpContoursPt(segmentID);
|
|
}
|
|
|
|
void DumpContoursSegment(const SkOpContour& contour, int segmentID) {
|
|
contour.dumpContoursSegment(segmentID);
|
|
}
|
|
|
|
void DumpContoursSpan(const SkOpContour& contour, int segmentID) {
|
|
contour.dumpContoursSpan(segmentID);
|
|
}
|
|
|
|
void DumpContoursSpans(const SkOpContour& contour) {
|
|
contour.dumpContoursSpans();
|
|
}
|
|
|
|
void DumpPt(const SkOpContour& contour, int pt) {
|
|
contour.dumpPt(pt);
|
|
}
|
|
|
|
void DumpPts(const SkOpContour& contour, const char* prefix) {
|
|
contour.dumpPts(prefix);
|
|
}
|
|
|
|
void DumpSegment(const SkOpContour& contour, int seg) {
|
|
contour.dumpSegment(seg);
|
|
}
|
|
|
|
void DumpSegments(const SkOpContour& contour, const char* prefix, SkPathOp op) {
|
|
contour.dumpSegments(prefix, op);
|
|
}
|
|
|
|
void DumpSpan(const SkOpContour& contour, int span) {
|
|
contour.dumpSpan(span);
|
|
}
|
|
|
|
void DumpSpans(const SkOpContour& contour ) {
|
|
contour.dumpSpans();
|
|
}
|
|
|
|
void Dump(const SkOpSegment& segment) {
|
|
segment.dump();
|
|
}
|
|
|
|
void DumpAll(const SkOpSegment& segment) {
|
|
segment.dumpAll();
|
|
}
|
|
|
|
void DumpAngles(const SkOpSegment& segment) {
|
|
segment.dumpAngles();
|
|
}
|
|
|
|
void DumpCoin(const SkOpSegment& segment) {
|
|
segment.dumpCoin();
|
|
}
|
|
|
|
void DumpPts(const SkOpSegment& segment, const char* prefix) {
|
|
segment.dumpPts(prefix);
|
|
}
|
|
|
|
void Dump(const SkOpPtT& ptT) {
|
|
ptT.dump();
|
|
}
|
|
|
|
void DumpAll(const SkOpPtT& ptT) {
|
|
ptT.dumpAll();
|
|
}
|
|
|
|
void Dump(const SkOpSpanBase& spanBase) {
|
|
spanBase.dump();
|
|
}
|
|
|
|
void DumpCoin(const SkOpSpanBase& spanBase) {
|
|
spanBase.dumpCoin();
|
|
}
|
|
|
|
void DumpAll(const SkOpSpanBase& spanBase) {
|
|
spanBase.dumpAll();
|
|
}
|
|
|
|
void DumpCoin(const SkOpSpan& span) {
|
|
span.dumpCoin();
|
|
}
|
|
|
|
bool DumpSpan(const SkOpSpan& span) {
|
|
return span.dumpSpan();
|
|
}
|
|
|
|
void Dump(const SkDConic& conic) {
|
|
conic.dump();
|
|
}
|
|
|
|
void DumpID(const SkDConic& conic, int id) {
|
|
conic.dumpID(id);
|
|
}
|
|
|
|
void Dump(const SkDCubic& cubic) {
|
|
cubic.dump();
|
|
}
|
|
|
|
void DumpID(const SkDCubic& cubic, int id) {
|
|
cubic.dumpID(id);
|
|
}
|
|
|
|
void Dump(const SkDLine& line) {
|
|
line.dump();
|
|
}
|
|
|
|
void DumpID(const SkDLine& line, int id) {
|
|
line.dumpID(id);
|
|
}
|
|
|
|
void Dump(const SkDQuad& quad) {
|
|
quad.dump();
|
|
}
|
|
|
|
void DumpID(const SkDQuad& quad, int id) {
|
|
quad.dumpID(id);
|
|
}
|
|
|
|
void Dump(const SkDPoint& point) {
|
|
point.dump();
|
|
}
|
|
|
|
void Dump(const SkOpAngle& angle) {
|
|
angle.dump();
|
|
}
|