You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1392 lines
50 KiB
1392 lines
50 KiB
/*
|
|
* Copyright 2020 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "imgui.h"
|
|
#include "include/core/SkBitmap.h"
|
|
#include "include/core/SkCanvas.h"
|
|
#include "include/core/SkPath.h"
|
|
#include "include/core/SkPathMeasure.h"
|
|
#include "include/utils/SkParsePath.h"
|
|
#include "samplecode/Sample.h"
|
|
|
|
#include "src/core/SkGeometry.h"
|
|
|
|
#include <stack>
|
|
|
|
namespace {
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
constexpr inline SkPoint rotate90(const SkPoint& p) { return {p.fY, -p.fX}; }
|
|
inline SkPoint rotate180(const SkPoint& p) { return p * -1; }
|
|
inline bool isClockwise(const SkPoint& a, const SkPoint& b) { return a.cross(b) > 0; }
|
|
|
|
static SkPoint checkSetLength(SkPoint p, float len, const char* file, int line) {
|
|
if (!p.setLength(len)) {
|
|
SkDebugf("%s:%d: Failed to set point length\n", file, line);
|
|
}
|
|
return p;
|
|
}
|
|
|
|
/** Version of setLength that prints debug msg on failure to help catch edge cases */
|
|
#define setLength(p, len) checkSetLength(p, len, __FILE__, __LINE__)
|
|
|
|
constexpr uint64_t choose(uint64_t n, uint64_t k) {
|
|
SkASSERT(n >= k);
|
|
uint64_t result = 1;
|
|
for (uint64_t i = 1; i <= k; i++) {
|
|
result *= (n + 1 - i);
|
|
result /= i;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* A scalar (float-valued weights) Bezier curve of arbitrary degree.
|
|
*/
|
|
class ScalarBezCurve {
|
|
public:
|
|
static constexpr int kDegreeInvalid = -1;
|
|
|
|
/** Creates an empty curve with invalid degree. */
|
|
ScalarBezCurve() : fDegree(kDegreeInvalid) {}
|
|
|
|
/** Creates a curve of the specified degree with weights initialized to 0. */
|
|
explicit ScalarBezCurve(int degree) : fDegree(degree) {
|
|
SkASSERT(degree >= 0);
|
|
fWeights.resize(degree + 1, {0});
|
|
}
|
|
|
|
/** Creates a curve of specified degree with the given weights. */
|
|
ScalarBezCurve(int degree, const std::vector<float>& weights) : ScalarBezCurve(degree) {
|
|
SkASSERT(degree >= 0);
|
|
SkASSERT(weights.size() == (size_t)degree + 1);
|
|
fWeights.insert(fWeights.begin(), weights.begin(), weights.end());
|
|
}
|
|
|
|
/** Returns the extreme-valued weight */
|
|
float extremumWeight() const {
|
|
float f = 0;
|
|
int sign = 1;
|
|
for (float w : fWeights) {
|
|
if (std::abs(w) > f) {
|
|
f = std::abs(w);
|
|
sign = w >= 0 ? 1 : -1;
|
|
}
|
|
}
|
|
return sign * f;
|
|
}
|
|
|
|
/** Evaluates the curve at t */
|
|
float eval(float t) const { return Eval(*this, t); }
|
|
|
|
/** Evaluates the curve at t */
|
|
static float Eval(const ScalarBezCurve& curve, float t) {
|
|
// Set up starting point of recursion (k=0)
|
|
ScalarBezCurve result = curve;
|
|
|
|
for (int k = 1; k <= curve.fDegree; k++) {
|
|
// k is level of recursion, k-1 has previous level's values.
|
|
for (int i = curve.fDegree; i >= k; i--) {
|
|
result.fWeights[i] = result.fWeights[i - 1] * (1 - t) + result.fWeights[i] * t;
|
|
}
|
|
}
|
|
|
|
return result.fWeights[curve.fDegree];
|
|
}
|
|
|
|
/** Splits this curve at t into two halves (of the same degree) */
|
|
void split(float t, ScalarBezCurve* left, ScalarBezCurve* right) const {
|
|
Split(*this, t, left, right);
|
|
}
|
|
|
|
/** Splits this curve into the subinterval [tmin,tmax]. */
|
|
void split(float tmin, float tmax, ScalarBezCurve* result) const {
|
|
// TODO: I believe there's a more efficient algorithm for this
|
|
const float tRel = tmin / tmax;
|
|
ScalarBezCurve ll, rl, rr;
|
|
this->split(tmax, &rl, &rr);
|
|
rl.split(tRel, &ll, result);
|
|
}
|
|
|
|
/** Splits the curve at t into two halves (of the same degree) */
|
|
static void Split(const ScalarBezCurve& curve,
|
|
float t,
|
|
ScalarBezCurve* left,
|
|
ScalarBezCurve* right) {
|
|
// Set up starting point of recursion (k=0)
|
|
const int degree = curve.fDegree;
|
|
ScalarBezCurve result = curve;
|
|
*left = ScalarBezCurve(degree);
|
|
*right = ScalarBezCurve(degree);
|
|
left->fWeights[0] = curve.fWeights[0];
|
|
right->fWeights[degree] = curve.fWeights[degree];
|
|
|
|
for (int k = 1; k <= degree; k++) {
|
|
// k is level of recursion, k-1 has previous level's values.
|
|
for (int i = degree; i >= k; i--) {
|
|
result.fWeights[i] = result.fWeights[i - 1] * (1 - t) + result.fWeights[i] * t;
|
|
}
|
|
|
|
left->fWeights[k] = result.fWeights[k];
|
|
right->fWeights[degree - k] = result.fWeights[degree];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Increases the degree of the curve to the given degree. Has no effect if the
|
|
* degree is already equal to the given degree.
|
|
*
|
|
* This process is always exact (NB the reverse, degree reduction, is not exact).
|
|
*/
|
|
void elevateDegree(int newDegree) {
|
|
if (newDegree == fDegree) {
|
|
return;
|
|
}
|
|
|
|
fWeights = ElevateDegree(*this, newDegree).fWeights;
|
|
fDegree = newDegree;
|
|
}
|
|
|
|
/**
|
|
* Increases the degree of the curve to the given degree. Has no effect if the
|
|
* degree is already equal to the given degree.
|
|
*
|
|
* This process is always exact (NB the reverse, degree reduction, is not exact).
|
|
*/
|
|
static ScalarBezCurve ElevateDegree(const ScalarBezCurve& curve, int newDegree) {
|
|
SkASSERT(newDegree >= curve.degree());
|
|
if (newDegree == curve.degree()) {
|
|
return curve;
|
|
}
|
|
|
|
// From Farouki, Rajan, "Algorithms for polynomials in Bernstein form" 1988.
|
|
ScalarBezCurve elevated(newDegree);
|
|
const int r = newDegree - curve.fDegree;
|
|
const int n = curve.fDegree;
|
|
|
|
for (int i = 0; i <= n + r; i++) {
|
|
elevated.fWeights[i] = 0;
|
|
for (int j = std::max(0, i - r); j <= std::min(n, i); j++) {
|
|
const float f =
|
|
(choose(n, j) * choose(r, i - j)) / static_cast<float>(choose(n + r, i));
|
|
elevated.fWeights[i] += curve.fWeights[j] * f;
|
|
}
|
|
}
|
|
|
|
return elevated;
|
|
}
|
|
|
|
/**
|
|
* Returns the zero-set of this curve, which is a list of t values where the curve crosses 0.
|
|
*/
|
|
std::vector<float> zeroSet() const { return ZeroSet(*this); }
|
|
|
|
/**
|
|
* Returns the zero-set of the curve, which is a list of t values where the curve crosses 0.
|
|
*/
|
|
static std::vector<float> ZeroSet(const ScalarBezCurve& curve) {
|
|
constexpr float kTol = 0.001f;
|
|
std::vector<float> result;
|
|
ZeroSetRec(curve, 0, 1, kTol, &result);
|
|
return result;
|
|
}
|
|
|
|
/** Multiplies the curve's weights by a constant value */
|
|
static ScalarBezCurve Mul(const ScalarBezCurve& curve, float f) {
|
|
ScalarBezCurve result = curve;
|
|
for (int k = 0; k <= curve.fDegree; k++) {
|
|
result.fWeights[k] *= f;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Multiplies the two curves and returns the result.
|
|
*
|
|
* Degree of resulting curve is the sum of the degrees of the input curves.
|
|
*/
|
|
static ScalarBezCurve Mul(const ScalarBezCurve& a, const ScalarBezCurve& b) {
|
|
// From G. Elber, "Free form surface analysis using a hybrid of symbolic and numeric
|
|
// computation". PhD thesis, 1992. p.11.
|
|
const int n = a.degree(), m = b.degree();
|
|
const int newDegree = n + m;
|
|
ScalarBezCurve result(newDegree);
|
|
|
|
for (int k = 0; k <= newDegree; k++) {
|
|
result.fWeights[k] = 0;
|
|
for (int i = std::max(0, k - n); i <= std::min(k, m); i++) {
|
|
const float f =
|
|
(choose(m, i) * choose(n, k - i)) / static_cast<float>(choose(m + n, k));
|
|
result.fWeights[k] += a.fWeights[i] * b.fWeights[k - i] * f;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/** Returns a^2 + b^2. This is a specialized method because the loops are easily fused. */
|
|
static ScalarBezCurve AddSquares(const ScalarBezCurve& a, const ScalarBezCurve& b) {
|
|
const int n = a.degree(), m = b.degree();
|
|
const int newDegree = n + m;
|
|
ScalarBezCurve result(newDegree);
|
|
|
|
for (int k = 0; k <= newDegree; k++) {
|
|
float aSq = 0, bSq = 0;
|
|
for (int i = std::max(0, k - n); i <= std::min(k, m); i++) {
|
|
const float f =
|
|
(choose(m, i) * choose(n, k - i)) / static_cast<float>(choose(m + n, k));
|
|
aSq += a.fWeights[i] * a.fWeights[k - i] * f;
|
|
bSq += b.fWeights[i] * b.fWeights[k - i] * f;
|
|
}
|
|
result.fWeights[k] = aSq + bSq;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/** Returns a - b. */
|
|
static ScalarBezCurve Sub(const ScalarBezCurve& a, const ScalarBezCurve& b) {
|
|
ScalarBezCurve result = a;
|
|
result.sub(b);
|
|
return result;
|
|
}
|
|
|
|
/** Subtracts the other curve from this curve */
|
|
void sub(const ScalarBezCurve& other) {
|
|
SkASSERT(other.fDegree == fDegree);
|
|
for (int k = 0; k <= fDegree; k++) {
|
|
fWeights[k] -= other.fWeights[k];
|
|
}
|
|
}
|
|
|
|
/** Subtracts a constant from this curve */
|
|
void sub(float f) {
|
|
for (int k = 0; k <= fDegree; k++) {
|
|
fWeights[k] -= f;
|
|
}
|
|
}
|
|
|
|
/** Returns the curve degree */
|
|
int degree() const { return fDegree; }
|
|
|
|
/** Returns the curve weights */
|
|
const std::vector<float>& weights() const { return fWeights; }
|
|
|
|
float operator[](size_t i) const { return fWeights[i]; }
|
|
float& operator[](size_t i) { return fWeights[i]; }
|
|
|
|
private:
|
|
/** Recursive helper for ZeroSet */
|
|
static void ZeroSetRec(const ScalarBezCurve& curve,
|
|
float tmin,
|
|
float tmax,
|
|
float tol,
|
|
std::vector<float>* result) {
|
|
float lenP = 0;
|
|
bool allPos = curve.fWeights[0] >= 0, allNeg = curve.fWeights[0] < 0;
|
|
for (int i = 1; i <= curve.fDegree; i++) {
|
|
lenP += std::abs(curve.fWeights[i] - curve.fWeights[i - 1]);
|
|
allPos &= curve.fWeights[i] >= 0;
|
|
allNeg &= curve.fWeights[i] < 0;
|
|
}
|
|
if (lenP <= tol) {
|
|
result->push_back((tmin + tmax) * 0.5);
|
|
return;
|
|
} else if (allPos || allNeg) {
|
|
// No zero crossings possible if the coefficients don't change sign (convex hull
|
|
// property)
|
|
return;
|
|
} else if (SkScalarNearlyZero(tmax - tmin)) {
|
|
return;
|
|
} else {
|
|
ScalarBezCurve left(curve.fDegree), right(curve.fDegree);
|
|
Split(curve, 0.5f, &left, &right);
|
|
|
|
const float tmid = (tmin + tmax) * 0.5;
|
|
ZeroSetRec(left, tmin, tmid, tol, result);
|
|
ZeroSetRec(right, tmid, tmax, tol, result);
|
|
}
|
|
}
|
|
|
|
int fDegree;
|
|
std::vector<float> fWeights;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
/** Helper class that measures per-verb path lengths. */
|
|
class PathVerbMeasure {
|
|
public:
|
|
explicit PathVerbMeasure(const SkPath& path) : fPath(path), fIter(path, false) { nextVerb(); }
|
|
|
|
SkScalar totalLength() const;
|
|
|
|
SkScalar currentVerbLength() { return fMeas.getLength(); }
|
|
|
|
void nextVerb();
|
|
|
|
private:
|
|
const SkPath& fPath;
|
|
SkPoint fFirstPointInContour;
|
|
SkPoint fPreviousPoint;
|
|
SkPath fCurrVerb;
|
|
SkPath::Iter fIter;
|
|
SkPathMeasure fMeas;
|
|
};
|
|
|
|
SkScalar PathVerbMeasure::totalLength() const {
|
|
SkPathMeasure meas(fPath, false);
|
|
return meas.getLength();
|
|
}
|
|
|
|
void PathVerbMeasure::nextVerb() {
|
|
SkPoint pts[4];
|
|
SkPath::Verb verb = fIter.next(pts);
|
|
|
|
while (verb == SkPath::kMove_Verb || verb == SkPath::kClose_Verb) {
|
|
if (verb == SkPath::kMove_Verb) {
|
|
fFirstPointInContour = pts[0];
|
|
fPreviousPoint = fFirstPointInContour;
|
|
}
|
|
verb = fIter.next(pts);
|
|
}
|
|
|
|
fCurrVerb.rewind();
|
|
fCurrVerb.moveTo(fPreviousPoint);
|
|
switch (verb) {
|
|
case SkPath::kLine_Verb:
|
|
fCurrVerb.lineTo(pts[1]);
|
|
break;
|
|
case SkPath::kQuad_Verb:
|
|
fCurrVerb.quadTo(pts[1], pts[2]);
|
|
break;
|
|
case SkPath::kCubic_Verb:
|
|
fCurrVerb.cubicTo(pts[1], pts[2], pts[3]);
|
|
break;
|
|
case SkPath::kConic_Verb:
|
|
fCurrVerb.conicTo(pts[1], pts[2], fIter.conicWeight());
|
|
break;
|
|
case SkPath::kDone_Verb:
|
|
break;
|
|
case SkPath::kClose_Verb:
|
|
case SkPath::kMove_Verb:
|
|
SkASSERT(false);
|
|
break;
|
|
}
|
|
|
|
fCurrVerb.getLastPt(&fPreviousPoint);
|
|
fMeas.setPath(&fCurrVerb, false);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
// Several debug-only visualization helpers
|
|
namespace viz {
|
|
std::unique_ptr<ScalarBezCurve> outerErr;
|
|
SkPath outerFirstApprox;
|
|
} // namespace viz
|
|
|
|
/**
|
|
* Prototype variable-width path stroker.
|
|
*
|
|
* Takes as input a path to be stroked, and two distance functions (inside and outside).
|
|
* Produces a fill path with the stroked path geometry.
|
|
*
|
|
* The algorithms in use here are from:
|
|
*
|
|
* G. Elber, E. Cohen. "Error bounded variable distance offset operator for free form curves and
|
|
* surfaces." International Journal of Computational Geometry & Applications 1, no. 01 (1991)
|
|
*
|
|
* G. Elber. "Free form surface analysis using a hybrid of symbolic and numeric computation."
|
|
* PhD diss., Dept. of Computer Science, University of Utah, 1992.
|
|
*/
|
|
class SkVarWidthStroker {
|
|
public:
|
|
/** Metric to use for interpolation of distance function across path segments. */
|
|
enum class LengthMetric {
|
|
/** Each path segment gets an equal interval of t in [0,1] */
|
|
kNumSegments,
|
|
/** Each path segment gets t interval equal to its percent of the total path length */
|
|
kPathLength,
|
|
};
|
|
|
|
/**
|
|
* Strokes the path with a fixed-width distance function. This produces a traditional stroked
|
|
* path.
|
|
*/
|
|
SkPath getFillPath(const SkPath& path, const SkPaint& paint) {
|
|
return getFillPath(path, paint, identityVarWidth(paint.getStrokeWidth()),
|
|
identityVarWidth(paint.getStrokeWidth()));
|
|
}
|
|
|
|
/**
|
|
* Strokes the given path using the two given distance functions for inner and outer offsets.
|
|
*/
|
|
SkPath getFillPath(const SkPath& path,
|
|
const SkPaint& paint,
|
|
const ScalarBezCurve& varWidth,
|
|
const ScalarBezCurve& varWidthInner,
|
|
LengthMetric lengthMetric = LengthMetric::kNumSegments);
|
|
|
|
private:
|
|
/** Helper struct referring to a single segment of an SkPath */
|
|
struct PathSegment {
|
|
SkPath::Verb fVerb;
|
|
std::array<SkPoint, 4> fPoints;
|
|
};
|
|
|
|
struct OffsetSegments {
|
|
std::vector<PathSegment> fInner;
|
|
std::vector<PathSegment> fOuter;
|
|
};
|
|
|
|
/** Initialize stroker state */
|
|
void initForPath(const SkPath& path, const SkPaint& paint);
|
|
|
|
/** Strokes a path segment */
|
|
OffsetSegments strokeSegment(const PathSegment& segment,
|
|
const ScalarBezCurve& varWidth,
|
|
const ScalarBezCurve& varWidthInner,
|
|
bool needsMove);
|
|
|
|
/**
|
|
* Strokes the given segment using the given distance function.
|
|
*
|
|
* Returns a list of quad segments that approximate the offset curve.
|
|
* TODO: no reason this needs to return a vector of quads, can just append to the path
|
|
*/
|
|
std::vector<PathSegment> strokeSegment(const PathSegment& seg,
|
|
const ScalarBezCurve& distFnc) const;
|
|
|
|
/** Adds an endcap to fOuter */
|
|
enum class CapLocation { Start, End };
|
|
void endcap(CapLocation loc);
|
|
|
|
/** Adds a join between the two segments */
|
|
void join(const SkPoint& common,
|
|
float innerRadius,
|
|
float outerRadius,
|
|
const OffsetSegments& prev,
|
|
const OffsetSegments& curr);
|
|
|
|
/** Appends path in reverse to result */
|
|
static void appendPathReversed(const SkPath& path, SkPath* result);
|
|
|
|
/** Returns the segment unit normal and unit tangent if not nullptr */
|
|
static SkPoint unitNormal(const PathSegment& seg, float t, SkPoint* tangentOut);
|
|
|
|
/** Returns the degree of a segment curve */
|
|
static int segmentDegree(const PathSegment& seg);
|
|
|
|
/** Splits a path segment at t */
|
|
static void splitSegment(const PathSegment& seg, float t, PathSegment* segA, PathSegment* segB);
|
|
|
|
/**
|
|
* Returns a quadratic segment that approximates the given segment using the given distance
|
|
* function.
|
|
*/
|
|
static void approximateSegment(const PathSegment& seg,
|
|
const ScalarBezCurve& distFnc,
|
|
PathSegment* approxQuad);
|
|
|
|
/** Returns a constant (deg 0) distance function for the given stroke width */
|
|
static ScalarBezCurve identityVarWidth(float strokeWidth) {
|
|
return ScalarBezCurve(0, {strokeWidth / 2.0f});
|
|
}
|
|
|
|
float fRadius;
|
|
SkPaint::Cap fCap;
|
|
SkPaint::Join fJoin;
|
|
SkPath fInner, fOuter;
|
|
ScalarBezCurve fVarWidth, fVarWidthInner;
|
|
float fCurrT;
|
|
};
|
|
|
|
void SkVarWidthStroker::initForPath(const SkPath& path, const SkPaint& paint) {
|
|
fRadius = paint.getStrokeWidth() / 2;
|
|
fCap = paint.getStrokeCap();
|
|
fJoin = paint.getStrokeJoin();
|
|
fInner.rewind();
|
|
fOuter.rewind();
|
|
fCurrT = 0;
|
|
}
|
|
|
|
SkPath SkVarWidthStroker::getFillPath(const SkPath& path,
|
|
const SkPaint& paint,
|
|
const ScalarBezCurve& varWidth,
|
|
const ScalarBezCurve& varWidthInner,
|
|
LengthMetric lengthMetric) {
|
|
const auto appendStrokes = [this](const OffsetSegments& strokes, bool needsMove) {
|
|
if (needsMove) {
|
|
fOuter.moveTo(strokes.fOuter.front().fPoints[0]);
|
|
fInner.moveTo(strokes.fInner.front().fPoints[0]);
|
|
}
|
|
|
|
for (const PathSegment& seg : strokes.fOuter) {
|
|
fOuter.quadTo(seg.fPoints[1], seg.fPoints[2]);
|
|
}
|
|
|
|
for (const PathSegment& seg : strokes.fInner) {
|
|
fInner.quadTo(seg.fPoints[1], seg.fPoints[2]);
|
|
}
|
|
};
|
|
|
|
initForPath(path, paint);
|
|
fVarWidth = varWidth;
|
|
fVarWidthInner = varWidthInner;
|
|
|
|
// TODO: this assumes one contour:
|
|
PathVerbMeasure meas(path);
|
|
const float totalPathLength = lengthMetric == LengthMetric::kPathLength
|
|
? meas.totalLength()
|
|
: (path.countVerbs() - 1);
|
|
|
|
// Trace the inner and outer paths simultaneously. Inner will therefore be
|
|
// recorded in reverse from how we trace the outline.
|
|
SkPath::Iter it(path, false);
|
|
PathSegment segment, prevSegment;
|
|
OffsetSegments offsetSegs, prevOffsetSegs;
|
|
bool firstSegment = true, prevWasFirst = false;
|
|
|
|
float lenTraveled = 0;
|
|
while ((segment.fVerb = it.next(&segment.fPoints[0])) != SkPath::kDone_Verb) {
|
|
const float verbLength = lengthMetric == LengthMetric::kPathLength
|
|
? (meas.currentVerbLength() / totalPathLength)
|
|
: (1.0f / totalPathLength);
|
|
const float tmin = lenTraveled;
|
|
const float tmax = lenTraveled + verbLength;
|
|
|
|
// Subset the distance function for the current interval.
|
|
ScalarBezCurve partVarWidth, partVarWidthInner;
|
|
fVarWidth.split(tmin, tmax, &partVarWidth);
|
|
fVarWidthInner.split(tmin, tmax, &partVarWidthInner);
|
|
partVarWidthInner = ScalarBezCurve::Mul(partVarWidthInner, -1);
|
|
|
|
// Stroke the current segment
|
|
switch (segment.fVerb) {
|
|
case SkPath::kLine_Verb:
|
|
case SkPath::kQuad_Verb:
|
|
case SkPath::kCubic_Verb:
|
|
offsetSegs = strokeSegment(segment, partVarWidth, partVarWidthInner, firstSegment);
|
|
break;
|
|
case SkPath::kMove_Verb:
|
|
// Don't care about multiple contours currently
|
|
continue;
|
|
default:
|
|
SkDebugf("Unhandled path verb %d\n", segment.fVerb);
|
|
SkASSERT(false);
|
|
break;
|
|
}
|
|
|
|
// Join to the previous segment
|
|
if (!firstSegment) {
|
|
// Append prev inner and outer strokes
|
|
appendStrokes(prevOffsetSegs, prevWasFirst);
|
|
|
|
// Append the join
|
|
const float innerRadius = varWidthInner.eval(tmin);
|
|
const float outerRadius = varWidth.eval(tmin);
|
|
join(segment.fPoints[0], innerRadius, outerRadius, prevOffsetSegs, offsetSegs);
|
|
}
|
|
|
|
std::swap(segment, prevSegment);
|
|
std::swap(offsetSegs, prevOffsetSegs);
|
|
prevWasFirst = firstSegment;
|
|
firstSegment = false;
|
|
lenTraveled += verbLength;
|
|
meas.nextVerb();
|
|
}
|
|
|
|
// Finish appending final offset segments
|
|
appendStrokes(prevOffsetSegs, prevWasFirst);
|
|
|
|
// Open contour => endcap at the end
|
|
const bool isClosed = path.isLastContourClosed();
|
|
if (isClosed) {
|
|
SkDebugf("Unhandled closed contour\n");
|
|
SkASSERT(false);
|
|
} else {
|
|
endcap(CapLocation::End);
|
|
}
|
|
|
|
// Walk inner path in reverse, appending to result
|
|
appendPathReversed(fInner, &fOuter);
|
|
endcap(CapLocation::Start);
|
|
|
|
return fOuter;
|
|
}
|
|
|
|
SkVarWidthStroker::OffsetSegments SkVarWidthStroker::strokeSegment(
|
|
const PathSegment& segment,
|
|
const ScalarBezCurve& varWidth,
|
|
const ScalarBezCurve& varWidthInner,
|
|
bool needsMove) {
|
|
viz::outerErr.reset(nullptr);
|
|
|
|
std::vector<PathSegment> outer = strokeSegment(segment, varWidth);
|
|
std::vector<PathSegment> inner = strokeSegment(segment, varWidthInner);
|
|
return {inner, outer};
|
|
}
|
|
|
|
std::vector<SkVarWidthStroker::PathSegment> SkVarWidthStroker::strokeSegment(
|
|
const PathSegment& seg, const ScalarBezCurve& distFnc) const {
|
|
// Work item for the recursive splitting stack.
|
|
struct Item {
|
|
PathSegment fSeg;
|
|
ScalarBezCurve fDistFnc, fDistFncSqd;
|
|
ScalarBezCurve fSegX, fSegY;
|
|
|
|
Item(const PathSegment& seg,
|
|
const ScalarBezCurve& distFnc,
|
|
const ScalarBezCurve& distFncSqd)
|
|
: fSeg(seg), fDistFnc(distFnc), fDistFncSqd(distFncSqd) {
|
|
const int segDegree = segmentDegree(seg);
|
|
fSegX = ScalarBezCurve(segDegree);
|
|
fSegY = ScalarBezCurve(segDegree);
|
|
for (int i = 0; i <= segDegree; i++) {
|
|
fSegX[i] = seg.fPoints[i].fX;
|
|
fSegY[i] = seg.fPoints[i].fY;
|
|
}
|
|
}
|
|
};
|
|
|
|
// Push the initial segment and distance function
|
|
std::stack<Item> stack;
|
|
stack.push(Item(seg, distFnc, ScalarBezCurve::Mul(distFnc, distFnc)));
|
|
|
|
std::vector<PathSegment> result;
|
|
constexpr int kMaxIters = 5000; /** TODO: this is completely arbitrary */
|
|
int iter = 0;
|
|
while (!stack.empty()) {
|
|
if (iter++ >= kMaxIters) break;
|
|
const Item item = stack.top();
|
|
stack.pop();
|
|
|
|
const ScalarBezCurve& distFnc = item.fDistFnc;
|
|
ScalarBezCurve distFncSqd = item.fDistFncSqd;
|
|
const float kTol = std::abs(0.5f * distFnc.extremumWeight());
|
|
|
|
// Compute a quad that approximates stroke outline
|
|
PathSegment quadApprox;
|
|
approximateSegment(item.fSeg, distFnc, &quadApprox);
|
|
ScalarBezCurve quadApproxX(2), quadApproxY(2);
|
|
for (int i = 0; i < 3; i++) {
|
|
quadApproxX[i] = quadApprox.fPoints[i].fX;
|
|
quadApproxY[i] = quadApprox.fPoints[i].fY;
|
|
}
|
|
|
|
// Compute control polygon for the delta(t) curve. First must elevate to a common degree.
|
|
const int deltaDegree = std::max(quadApproxX.degree(), item.fSegX.degree());
|
|
ScalarBezCurve segX = item.fSegX, segY = item.fSegY;
|
|
segX.elevateDegree(deltaDegree);
|
|
segY.elevateDegree(deltaDegree);
|
|
quadApproxX.elevateDegree(deltaDegree);
|
|
quadApproxY.elevateDegree(deltaDegree);
|
|
|
|
ScalarBezCurve deltaX = ScalarBezCurve::Sub(quadApproxX, segX);
|
|
ScalarBezCurve deltaY = ScalarBezCurve::Sub(quadApproxY, segY);
|
|
|
|
// Compute psi(t) = delta_x(t)^2 + delta_y(t)^2.
|
|
ScalarBezCurve E = ScalarBezCurve::AddSquares(deltaX, deltaY);
|
|
|
|
// Promote E and d(t)^2 to a common degree.
|
|
const int commonDeg = std::max(distFncSqd.degree(), E.degree());
|
|
distFncSqd.elevateDegree(commonDeg);
|
|
E.elevateDegree(commonDeg);
|
|
|
|
// Subtract dist squared curve from E, resulting in:
|
|
// eps(t) = delta_x(t)^2 + delta_y(t)^2 - d(t)^2
|
|
E.sub(distFncSqd);
|
|
|
|
// Purely for debugging/testing, save the first approximation and error function:
|
|
if (viz::outerErr == nullptr) {
|
|
using namespace viz;
|
|
outerErr = std::make_unique<ScalarBezCurve>(E);
|
|
outerFirstApprox.rewind();
|
|
outerFirstApprox.moveTo(quadApprox.fPoints[0]);
|
|
outerFirstApprox.quadTo(quadApprox.fPoints[1], quadApprox.fPoints[2]);
|
|
}
|
|
|
|
// Compute maxErr, which is just the max coefficient of eps (using convex hull property
|
|
// of bez curves)
|
|
float maxAbsErr = std::abs(E.extremumWeight());
|
|
|
|
if (maxAbsErr > kTol) {
|
|
PathSegment left, right;
|
|
splitSegment(item.fSeg, 0.5f, &left, &right);
|
|
|
|
ScalarBezCurve distFncL, distFncR;
|
|
distFnc.split(0.5f, &distFncL, &distFncR);
|
|
|
|
ScalarBezCurve distFncSqdL, distFncSqdR;
|
|
distFncSqd.split(0.5f, &distFncSqdL, &distFncSqdR);
|
|
|
|
stack.push(Item(right, distFncR, distFncSqdR));
|
|
stack.push(Item(left, distFncL, distFncSqdL));
|
|
} else {
|
|
// Approximation is good enough.
|
|
quadApprox.fVerb = SkPath::kQuad_Verb;
|
|
result.push_back(quadApprox);
|
|
}
|
|
}
|
|
SkASSERT(!result.empty());
|
|
return result;
|
|
}
|
|
|
|
void SkVarWidthStroker::endcap(CapLocation loc) {
|
|
const auto buttCap = [this](CapLocation loc) {
|
|
if (loc == CapLocation::Start) {
|
|
// Back at the start of the path: just close the stroked outline
|
|
fOuter.close();
|
|
} else {
|
|
// Inner last pt == first pt when appending in reverse
|
|
SkPoint innerLastPt;
|
|
fInner.getLastPt(&innerLastPt);
|
|
fOuter.lineTo(innerLastPt);
|
|
}
|
|
};
|
|
|
|
switch (fCap) {
|
|
case SkPaint::kButt_Cap:
|
|
buttCap(loc);
|
|
break;
|
|
default:
|
|
SkDebugf("Unhandled endcap %d\n", fCap);
|
|
buttCap(loc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SkVarWidthStroker::join(const SkPoint& common,
|
|
float innerRadius,
|
|
float outerRadius,
|
|
const OffsetSegments& prev,
|
|
const OffsetSegments& curr) {
|
|
const auto miterJoin = [this](const SkPoint& common,
|
|
float leftRadius,
|
|
float rightRadius,
|
|
const OffsetSegments& prev,
|
|
const OffsetSegments& curr) {
|
|
// With variable-width stroke you can actually have a situation where both sides
|
|
// need an "inner" or an "outer" join. So we call the two sides "left" and
|
|
// "right" and they can each independently get an inner or outer join.
|
|
const auto makeJoin = [this, &common, &prev, &curr](bool left, float radius) {
|
|
SkPath* path = left ? &fOuter : &fInner;
|
|
const auto& prevSegs = left ? prev.fOuter : prev.fInner;
|
|
const auto& currSegs = left ? curr.fOuter : curr.fInner;
|
|
SkASSERT(!prevSegs.empty());
|
|
SkASSERT(!currSegs.empty());
|
|
const SkPoint afterEndpt = currSegs.front().fPoints[0];
|
|
SkPoint before = unitNormal(prevSegs.back(), 1, nullptr);
|
|
SkPoint after = unitNormal(currSegs.front(), 0, nullptr);
|
|
|
|
// Don't create any join geometry if the normals are nearly identical.
|
|
const float cosTheta = before.dot(after);
|
|
if (!SkScalarNearlyZero(1 - cosTheta)) {
|
|
bool outerJoin;
|
|
if (left) {
|
|
outerJoin = isClockwise(before, after);
|
|
} else {
|
|
before = rotate180(before);
|
|
after = rotate180(after);
|
|
outerJoin = !isClockwise(before, after);
|
|
}
|
|
|
|
if (outerJoin) {
|
|
// Before and after have the same origin and magnitude, so before+after is the
|
|
// diagonal of their rhombus. Origin of this vector is the midpoint of the miter
|
|
// line.
|
|
SkPoint miterVec = before + after;
|
|
|
|
// Note the relationship (draw a right triangle with the miter line as its
|
|
// hypoteneuse):
|
|
// sin(theta/2) = strokeWidth / miterLength
|
|
// so miterLength = strokeWidth / sin(theta/2)
|
|
// where miterLength is the length of the miter from outer point to inner
|
|
// corner. miterVec's origin is the midpoint of the miter line, so we use
|
|
// strokeWidth/2. Sqrt is just an application of half-angle identities.
|
|
const float sinHalfTheta = sqrtf(0.5 * (1 + cosTheta));
|
|
const float halfMiterLength = radius / sinHalfTheta;
|
|
// TODO: miter length limit
|
|
miterVec = setLength(miterVec, halfMiterLength);
|
|
|
|
// Outer join: connect to the miter point, and then to t=0 of next segment.
|
|
path->lineTo(common + miterVec);
|
|
path->lineTo(afterEndpt);
|
|
} else {
|
|
// Connect to the miter midpoint (common path endpoint of the two segments),
|
|
// and then to t=0 of the next segment. This adds an interior "loop"
|
|
// of geometry that handles edge cases where segment lengths are shorter than
|
|
// the stroke width.
|
|
path->lineTo(common);
|
|
path->lineTo(afterEndpt);
|
|
}
|
|
}
|
|
};
|
|
|
|
makeJoin(true, leftRadius);
|
|
makeJoin(false, rightRadius);
|
|
};
|
|
|
|
switch (fJoin) {
|
|
case SkPaint::kMiter_Join:
|
|
miterJoin(common, innerRadius, outerRadius, prev, curr);
|
|
break;
|
|
default:
|
|
SkDebugf("Unhandled join %d\n", fJoin);
|
|
miterJoin(common, innerRadius, outerRadius, prev, curr);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SkVarWidthStroker::appendPathReversed(const SkPath& path, SkPath* result) {
|
|
const int numVerbs = path.countVerbs();
|
|
const int numPoints = path.countPoints();
|
|
std::vector<uint8_t> verbs;
|
|
std::vector<SkPoint> points;
|
|
verbs.resize(numVerbs);
|
|
points.resize(numPoints);
|
|
path.getVerbs(verbs.data(), numVerbs);
|
|
path.getPoints(points.data(), numPoints);
|
|
|
|
for (int i = numVerbs - 1, j = numPoints; i >= 0; i--) {
|
|
auto verb = static_cast<SkPath::Verb>(verbs[i]);
|
|
switch (verb) {
|
|
case SkPath::kLine_Verb: {
|
|
j -= 1;
|
|
SkASSERT(j >= 1);
|
|
result->lineTo(points[j - 1]);
|
|
break;
|
|
}
|
|
case SkPath::kQuad_Verb: {
|
|
j -= 1;
|
|
SkASSERT(j >= 2);
|
|
result->quadTo(points[j - 1], points[j - 2]);
|
|
j -= 1;
|
|
break;
|
|
}
|
|
case SkPath::kMove_Verb:
|
|
// Ignore
|
|
break;
|
|
default:
|
|
SkASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
int SkVarWidthStroker::segmentDegree(const PathSegment& seg) {
|
|
static constexpr int lut[] = {
|
|
-1, // move,
|
|
1, // line
|
|
2, // quad
|
|
-1, // conic
|
|
3, // cubic
|
|
-1 // done
|
|
};
|
|
const int deg = lut[static_cast<uint8_t>(seg.fVerb)];
|
|
SkASSERT(deg > 0);
|
|
return deg;
|
|
}
|
|
|
|
void SkVarWidthStroker::splitSegment(const PathSegment& seg,
|
|
float t,
|
|
PathSegment* segA,
|
|
PathSegment* segB) {
|
|
// TODO: although general, this is a pretty slow way to do this
|
|
const int degree = segmentDegree(seg);
|
|
ScalarBezCurve x(degree), y(degree);
|
|
for (int i = 0; i <= degree; i++) {
|
|
x[i] = seg.fPoints[i].fX;
|
|
y[i] = seg.fPoints[i].fY;
|
|
}
|
|
|
|
ScalarBezCurve leftX(degree), rightX(degree), leftY(degree), rightY(degree);
|
|
x.split(t, &leftX, &rightX);
|
|
y.split(t, &leftY, &rightY);
|
|
|
|
segA->fVerb = segB->fVerb = seg.fVerb;
|
|
for (int i = 0; i <= degree; i++) {
|
|
segA->fPoints[i] = {leftX[i], leftY[i]};
|
|
segB->fPoints[i] = {rightX[i], rightY[i]};
|
|
}
|
|
}
|
|
|
|
void SkVarWidthStroker::approximateSegment(const PathSegment& seg,
|
|
const ScalarBezCurve& distFnc,
|
|
PathSegment* approxQuad) {
|
|
// This is a simple control polygon transformation.
|
|
// From F. Yzerman. "Precise offsetting of quadratic Bezier curves". 2019.
|
|
// TODO: detect and handle more degenerate cases (e.g. linear)
|
|
// TODO: Tiller-Hanson works better in many cases but does not generalize well
|
|
SkPoint tangentStart, tangentEnd;
|
|
SkPoint offsetStart = unitNormal(seg, 0, &tangentStart);
|
|
SkPoint offsetEnd = unitNormal(seg, 1, &tangentEnd);
|
|
SkPoint offsetMid = offsetStart + offsetEnd;
|
|
|
|
const float radiusStart = distFnc.eval(0);
|
|
const float radiusMid = distFnc.eval(0.5f);
|
|
const float radiusEnd = distFnc.eval(1);
|
|
|
|
offsetStart = radiusStart == 0 ? SkPoint::Make(0, 0) : setLength(offsetStart, radiusStart);
|
|
offsetMid = radiusMid == 0 ? SkPoint::Make(0, 0) : setLength(offsetMid, radiusMid);
|
|
offsetEnd = radiusEnd == 0 ? SkPoint::Make(0, 0) : setLength(offsetEnd, radiusEnd);
|
|
|
|
SkPoint start, mid, end;
|
|
switch (segmentDegree(seg)) {
|
|
case 1:
|
|
start = seg.fPoints[0];
|
|
end = seg.fPoints[1];
|
|
mid = (start + end) * 0.5f;
|
|
break;
|
|
case 2:
|
|
start = seg.fPoints[0];
|
|
mid = seg.fPoints[1];
|
|
end = seg.fPoints[2];
|
|
break;
|
|
case 3:
|
|
start = seg.fPoints[0];
|
|
mid = (seg.fPoints[1] + seg.fPoints[2]) * 0.5f;
|
|
end = seg.fPoints[3];
|
|
break;
|
|
default:
|
|
SkDebugf("Unhandled degree for segment approximation");
|
|
SkASSERT(false);
|
|
break;
|
|
}
|
|
|
|
approxQuad->fPoints[0] = start + offsetStart;
|
|
approxQuad->fPoints[1] = mid + offsetMid;
|
|
approxQuad->fPoints[2] = end + offsetEnd;
|
|
}
|
|
|
|
SkPoint SkVarWidthStroker::unitNormal(const PathSegment& seg, float t, SkPoint* tangentOut) {
|
|
switch (seg.fVerb) {
|
|
case SkPath::kLine_Verb: {
|
|
const SkPoint tangent = setLength(seg.fPoints[1] - seg.fPoints[0], 1);
|
|
const SkPoint normal = rotate90(tangent);
|
|
if (tangentOut) {
|
|
*tangentOut = tangent;
|
|
}
|
|
return normal;
|
|
}
|
|
case SkPath::kQuad_Verb: {
|
|
SkPoint tangent;
|
|
if (t == 0) {
|
|
tangent = seg.fPoints[1] - seg.fPoints[0];
|
|
} else if (t == 1) {
|
|
tangent = seg.fPoints[2] - seg.fPoints[1];
|
|
} else {
|
|
tangent = ((seg.fPoints[1] - seg.fPoints[0]) * (1 - t) +
|
|
(seg.fPoints[2] - seg.fPoints[1]) * t) *
|
|
2;
|
|
}
|
|
if (!tangent.normalize()) {
|
|
SkDebugf("Failed to normalize quad tangent\n");
|
|
SkASSERT(false);
|
|
}
|
|
if (tangentOut) {
|
|
*tangentOut = tangent;
|
|
}
|
|
return rotate90(tangent);
|
|
}
|
|
case SkPath::kCubic_Verb: {
|
|
SkPoint tangent;
|
|
SkEvalCubicAt(seg.fPoints.data(), t, nullptr, &tangent, nullptr);
|
|
if (!tangent.normalize()) {
|
|
SkDebugf("Failed to normalize cubic tangent\n");
|
|
SkASSERT(false);
|
|
}
|
|
if (tangentOut) {
|
|
*tangentOut = tangent;
|
|
}
|
|
return rotate90(tangent);
|
|
}
|
|
default:
|
|
SkDebugf("Unhandled verb for unit normal %d\n", seg.fVerb);
|
|
SkASSERT(false);
|
|
return {};
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
class VariableWidthStroker : public Sample {
|
|
public:
|
|
VariableWidthStroker()
|
|
: fShowHidden(true)
|
|
, fShowSkeleton(true)
|
|
, fShowStrokePoints(false)
|
|
, fShowUI(false)
|
|
, fDifferentInnerFunc(false)
|
|
, fShowErrorCurve(false) {
|
|
resetToDefaults();
|
|
|
|
fPtsPaint.setAntiAlias(true);
|
|
fPtsPaint.setStrokeWidth(10);
|
|
fPtsPaint.setStrokeCap(SkPaint::kRound_Cap);
|
|
|
|
fStrokePointsPaint.setAntiAlias(true);
|
|
fStrokePointsPaint.setStrokeWidth(5);
|
|
fStrokePointsPaint.setStrokeCap(SkPaint::kRound_Cap);
|
|
|
|
fStrokePaint.setAntiAlias(true);
|
|
fStrokePaint.setStyle(SkPaint::kStroke_Style);
|
|
fStrokePaint.setColor(0x80FF0000);
|
|
|
|
fNewFillPaint.setAntiAlias(true);
|
|
fNewFillPaint.setColor(0x8000FF00);
|
|
|
|
fHiddenPaint.setAntiAlias(true);
|
|
fHiddenPaint.setStyle(SkPaint::kStroke_Style);
|
|
fHiddenPaint.setColor(0xFF0000FF);
|
|
|
|
fSkeletonPaint.setAntiAlias(true);
|
|
fSkeletonPaint.setStyle(SkPaint::kStroke_Style);
|
|
fSkeletonPaint.setColor(SK_ColorRED);
|
|
}
|
|
|
|
private:
|
|
/** Selectable menu item for choosing distance functions */
|
|
struct DistFncMenuItem {
|
|
std::string fName;
|
|
int fDegree;
|
|
bool fSelected;
|
|
std::vector<float> fWeights;
|
|
|
|
DistFncMenuItem(const std::string& name, int degree, bool selected) {
|
|
fName = name;
|
|
fDegree = degree;
|
|
fSelected = selected;
|
|
fWeights.resize(degree + 1, 1.0f);
|
|
}
|
|
};
|
|
|
|
SkString name() override { return SkString("VariableWidthStroker"); }
|
|
|
|
void onSizeChange() override {
|
|
fWinSize = SkSize::Make(this->width(), this->height());
|
|
INHERITED::onSizeChange();
|
|
}
|
|
|
|
bool onChar(SkUnichar uni) override {
|
|
switch (uni) {
|
|
case '0':
|
|
this->toggle(fShowUI);
|
|
return true;
|
|
case '1':
|
|
this->toggle(fShowSkeleton);
|
|
return true;
|
|
case '2':
|
|
this->toggle(fShowHidden);
|
|
return true;
|
|
case '3':
|
|
this->toggle(fShowStrokePoints);
|
|
return true;
|
|
case '4':
|
|
this->toggle(fShowErrorCurve);
|
|
return true;
|
|
case '5':
|
|
this->toggle(fLengthMetric);
|
|
return true;
|
|
case 'x':
|
|
resetToDefaults();
|
|
return true;
|
|
case '-':
|
|
fWidth -= 5;
|
|
return true;
|
|
case '=':
|
|
fWidth += 5;
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void toggle(bool& value) { value = !value; }
|
|
void toggle(SkVarWidthStroker::LengthMetric& value) {
|
|
value = value == SkVarWidthStroker::LengthMetric::kPathLength
|
|
? SkVarWidthStroker::LengthMetric::kNumSegments
|
|
: SkVarWidthStroker::LengthMetric::kPathLength;
|
|
}
|
|
|
|
void resetToDefaults() {
|
|
fPathPts[0] = {300, 400};
|
|
fPathPts[1] = {500, 400};
|
|
fPathPts[2] = {700, 400};
|
|
fPathPts[3] = {900, 400};
|
|
fPathPts[4] = {1100, 400};
|
|
|
|
fWidth = 175;
|
|
|
|
fLengthMetric = SkVarWidthStroker::LengthMetric::kPathLength;
|
|
fDistFncs = fDefaultsDistFncs;
|
|
fDistFncsInner = fDefaultsDistFncs;
|
|
}
|
|
|
|
void makePath(SkPath* path) {
|
|
path->moveTo(fPathPts[0]);
|
|
path->quadTo(fPathPts[1], fPathPts[2]);
|
|
path->quadTo(fPathPts[3], fPathPts[4]);
|
|
}
|
|
|
|
static ScalarBezCurve makeDistFnc(const std::vector<DistFncMenuItem>& fncs, float strokeWidth) {
|
|
const float radius = strokeWidth / 2;
|
|
for (const auto& df : fncs) {
|
|
if (df.fSelected) {
|
|
return ScalarBezCurve::Mul(ScalarBezCurve(df.fDegree, df.fWeights), radius);
|
|
}
|
|
}
|
|
SkASSERT(false);
|
|
return ScalarBezCurve(0, {radius});
|
|
}
|
|
|
|
void onDrawContent(SkCanvas* canvas) override {
|
|
canvas->drawColor(0xFFEEEEEE);
|
|
|
|
SkPath path;
|
|
this->makePath(&path);
|
|
|
|
fStrokePaint.setStrokeWidth(fWidth);
|
|
|
|
// Elber-Cohen stroker result
|
|
ScalarBezCurve distFnc = makeDistFnc(fDistFncs, fWidth);
|
|
ScalarBezCurve distFncInner =
|
|
fDifferentInnerFunc ? makeDistFnc(fDistFncsInner, fWidth) : distFnc;
|
|
SkVarWidthStroker stroker;
|
|
SkPath fillPath =
|
|
stroker.getFillPath(path, fStrokePaint, distFnc, distFncInner, fLengthMetric);
|
|
fillPath.setFillType(SkPathFillType::kWinding);
|
|
canvas->drawPath(fillPath, fNewFillPaint);
|
|
|
|
if (fShowHidden) {
|
|
canvas->drawPath(fillPath, fHiddenPaint);
|
|
}
|
|
|
|
if (fShowSkeleton) {
|
|
canvas->drawPath(path, fSkeletonPaint);
|
|
canvas->drawPoints(SkCanvas::kPoints_PointMode, fPathPts.size(), fPathPts.data(),
|
|
fPtsPaint);
|
|
}
|
|
|
|
if (fShowStrokePoints) {
|
|
drawStrokePoints(canvas, fillPath);
|
|
}
|
|
|
|
if (fShowUI) {
|
|
drawUI();
|
|
}
|
|
|
|
if (fShowErrorCurve && viz::outerErr != nullptr) {
|
|
SkPaint firstApproxPaint;
|
|
firstApproxPaint.setStrokeWidth(4);
|
|
firstApproxPaint.setStyle(SkPaint::kStroke_Style);
|
|
firstApproxPaint.setColor(SK_ColorRED);
|
|
canvas->drawPath(viz::outerFirstApprox, firstApproxPaint);
|
|
drawErrorCurve(canvas, *viz::outerErr);
|
|
}
|
|
}
|
|
|
|
Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey modi) override {
|
|
const SkScalar tol = 4;
|
|
const SkRect r = SkRect::MakeXYWH(x - tol, y - tol, tol * 2, tol * 2);
|
|
for (size_t i = 0; i < fPathPts.size(); ++i) {
|
|
if (r.intersects(SkRect::MakeXYWH(fPathPts[i].fX, fPathPts[i].fY, 1, 1))) {
|
|
return new Click([this, i](Click* c) {
|
|
fPathPts[i] = c->fCurr;
|
|
return true;
|
|
});
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void drawStrokePoints(SkCanvas* canvas, const SkPath& fillPath) {
|
|
SkPath::Iter it(fillPath, false);
|
|
SkPoint points[4];
|
|
SkPath::Verb verb;
|
|
std::vector<SkPoint> pointsVec, ctrlPts;
|
|
while ((verb = it.next(&points[0])) != SkPath::kDone_Verb) {
|
|
switch (verb) {
|
|
case SkPath::kLine_Verb:
|
|
pointsVec.push_back(points[1]);
|
|
break;
|
|
case SkPath::kQuad_Verb:
|
|
ctrlPts.push_back(points[1]);
|
|
pointsVec.push_back(points[2]);
|
|
break;
|
|
case SkPath::kMove_Verb:
|
|
pointsVec.push_back(points[0]);
|
|
break;
|
|
case SkPath::kClose_Verb:
|
|
break;
|
|
default:
|
|
SkDebugf("Unhandled path verb %d for stroke points\n", verb);
|
|
SkASSERT(false);
|
|
break;
|
|
}
|
|
}
|
|
|
|
canvas->drawPoints(SkCanvas::kPoints_PointMode, pointsVec.size(), pointsVec.data(),
|
|
fStrokePointsPaint);
|
|
fStrokePointsPaint.setColor(SK_ColorBLUE);
|
|
fStrokePointsPaint.setStrokeWidth(3);
|
|
canvas->drawPoints(SkCanvas::kPoints_PointMode, ctrlPts.size(), ctrlPts.data(),
|
|
fStrokePointsPaint);
|
|
fStrokePointsPaint.setColor(SK_ColorBLACK);
|
|
fStrokePointsPaint.setStrokeWidth(5);
|
|
}
|
|
|
|
void drawErrorCurve(SkCanvas* canvas, const ScalarBezCurve& E) {
|
|
const float winW = fWinSize.width() * 0.75f, winH = fWinSize.height() * 0.25f;
|
|
const float padding = 25;
|
|
const SkRect box = SkRect::MakeXYWH(padding, fWinSize.height() - winH - padding,
|
|
winW - 2 * padding, winH);
|
|
constexpr int nsegs = 100;
|
|
constexpr float dt = 1.0f / nsegs;
|
|
constexpr float dx = 10.0f;
|
|
const int deg = E.degree();
|
|
SkPath path;
|
|
for (int i = 0; i < nsegs; i++) {
|
|
const float tmin = i * dt, tmax = (i + 1) * dt;
|
|
ScalarBezCurve left(deg), right(deg);
|
|
E.split(tmax, &left, &right);
|
|
const float tRel = tmin / tmax;
|
|
ScalarBezCurve rl(deg), rr(deg);
|
|
left.split(tRel, &rl, &rr);
|
|
|
|
const float x = i * dx;
|
|
if (i == 0) {
|
|
path.moveTo(x, -rr[0]);
|
|
}
|
|
path.lineTo(x + dx, -rr[deg]);
|
|
}
|
|
|
|
SkPaint paint;
|
|
paint.setStyle(SkPaint::kStroke_Style);
|
|
paint.setAntiAlias(true);
|
|
paint.setStrokeWidth(0);
|
|
paint.setColor(SK_ColorRED);
|
|
const SkRect pathBounds = path.computeTightBounds();
|
|
constexpr float yAxisMax = 8000;
|
|
const float sx = box.width() / pathBounds.width();
|
|
const float sy = box.height() / (2 * yAxisMax);
|
|
canvas->save();
|
|
canvas->translate(box.left(), box.top() + box.height() / 2);
|
|
canvas->scale(sx, sy);
|
|
canvas->drawPath(path, paint);
|
|
|
|
SkPath axes;
|
|
axes.moveTo(0, 0);
|
|
axes.lineTo(pathBounds.width(), 0);
|
|
axes.moveTo(0, -yAxisMax);
|
|
axes.lineTo(0, yAxisMax);
|
|
paint.setColor(SK_ColorBLACK);
|
|
paint.setAntiAlias(false);
|
|
canvas->drawPath(axes, paint);
|
|
|
|
canvas->restore();
|
|
}
|
|
|
|
void drawUI() {
|
|
static constexpr auto kUIOpacity = 0.35f;
|
|
static constexpr float kUIWidth = 200.0f, kUIHeight = 400.0f;
|
|
ImGui::SetNextWindowBgAlpha(kUIOpacity);
|
|
if (ImGui::Begin("E-C Controls", nullptr,
|
|
ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoResize |
|
|
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings |
|
|
ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoNav)) {
|
|
const SkRect uiArea = SkRect::MakeXYWH(10, 10, kUIWidth, kUIHeight);
|
|
ImGui::SetWindowPos(ImVec2(uiArea.x(), uiArea.y()));
|
|
ImGui::SetWindowSize(ImVec2(uiArea.width(), uiArea.height()));
|
|
|
|
const auto drawControls = [](std::vector<DistFncMenuItem>& distFncs,
|
|
const std::string& menuPfx,
|
|
const std::string& ptPfx) {
|
|
std::string degreeMenuLabel = menuPfx + ": ";
|
|
for (const auto& df : distFncs) {
|
|
if (df.fSelected) {
|
|
degreeMenuLabel += df.fName;
|
|
break;
|
|
}
|
|
}
|
|
if (ImGui::BeginMenu(degreeMenuLabel.c_str())) {
|
|
for (size_t i = 0; i < distFncs.size(); i++) {
|
|
if (ImGui::MenuItem(distFncs[i].fName.c_str(), nullptr,
|
|
distFncs[i].fSelected)) {
|
|
for (size_t j = 0; j < distFncs.size(); j++) {
|
|
distFncs[j].fSelected = j == i;
|
|
}
|
|
}
|
|
}
|
|
ImGui::EndMenu();
|
|
}
|
|
|
|
for (auto& df : distFncs) {
|
|
if (df.fSelected) {
|
|
for (int i = 0; i <= df.fDegree; i++) {
|
|
const std::string label = ptPfx + std::to_string(i);
|
|
ImGui::SliderFloat(label.c_str(), &(df.fWeights[i]), 0, 1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
const std::array<std::pair<std::string, SkVarWidthStroker::LengthMetric>, 2> metrics = {
|
|
std::make_pair("% path length", SkVarWidthStroker::LengthMetric::kPathLength),
|
|
std::make_pair("% segment count",
|
|
SkVarWidthStroker::LengthMetric::kNumSegments),
|
|
};
|
|
if (ImGui::BeginMenu("Interpolation metric:")) {
|
|
for (const auto& metric : metrics) {
|
|
if (ImGui::MenuItem(metric.first.c_str(), nullptr,
|
|
fLengthMetric == metric.second)) {
|
|
fLengthMetric = metric.second;
|
|
}
|
|
}
|
|
ImGui::EndMenu();
|
|
}
|
|
|
|
drawControls(fDistFncs, "Degree", "P");
|
|
|
|
if (ImGui::CollapsingHeader("Inner stroke", true)) {
|
|
fDifferentInnerFunc = true;
|
|
drawControls(fDistFncsInner, "Degree (inner)", "Q");
|
|
} else {
|
|
fDifferentInnerFunc = false;
|
|
}
|
|
}
|
|
ImGui::End();
|
|
}
|
|
|
|
bool fShowHidden, fShowSkeleton, fShowStrokePoints, fShowUI, fDifferentInnerFunc,
|
|
fShowErrorCurve;
|
|
float fWidth = 175;
|
|
SkPaint fPtsPaint, fStrokePaint, fNewFillPaint, fHiddenPaint, fSkeletonPaint,
|
|
fStrokePointsPaint;
|
|
static constexpr int kNPts = 5;
|
|
std::array<SkPoint, kNPts> fPathPts;
|
|
SkSize fWinSize;
|
|
SkVarWidthStroker::LengthMetric fLengthMetric;
|
|
const std::vector<DistFncMenuItem> fDefaultsDistFncs = {
|
|
DistFncMenuItem("Linear", 1, true), DistFncMenuItem("Quadratic", 2, false),
|
|
DistFncMenuItem("Cubic", 3, false), DistFncMenuItem("One Louder (11)", 11, false),
|
|
DistFncMenuItem("30?!", 30, false)};
|
|
std::vector<DistFncMenuItem> fDistFncs = fDefaultsDistFncs;
|
|
std::vector<DistFncMenuItem> fDistFncsInner = fDefaultsDistFncs;
|
|
|
|
using INHERITED = Sample;
|
|
};
|
|
|
|
DEF_SAMPLE(return new VariableWidthStroker;)
|