blob: 9af6fff7a29a8cf5aa3d1ac7eeb3f2afb7ac2010 [file] [log] [blame]
/*
* 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 "include/core/SkBitmap.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathUtils.h"
#include "include/utils/SkParsePath.h"
#include "tools/viewer/ClickHandlerSlide.h"
#include "src/core/SkGeometry.h"
#include <vector>
namespace {
//////////////////////////////////////////////////////////////////////////////
static SkPoint rotate90(const SkPoint& p) { return {p.fY, -p.fX}; }
static SkPoint rotate180(const SkPoint& p) { return p * -1; }
static SkPoint setLength(SkPoint p, float len) {
if (!p.setLength(len)) {
SkDebugf("Failed to set point length\n");
}
return p;
}
static bool isClockwise(const SkPoint& a, const SkPoint& b) { return a.cross(b) > 0; }
//////////////////////////////////////////////////////////////////////////////
// Testing ground for a new stroker implementation
/** Helper class for constructing paths, with undo support */
class PathRecorder {
public:
SkPath getPath() const {
return SkPath::Make(fPoints.data(), fPoints.size(), fVerbs.data(), fVerbs.size(), nullptr,
0, SkPathFillType::kWinding);
}
void moveTo(SkPoint p) {
fVerbs.push_back(SkPath::kMove_Verb);
fPoints.push_back(p);
}
void lineTo(SkPoint p) {
fVerbs.push_back(SkPath::kLine_Verb);
fPoints.push_back(p);
}
void close() { fVerbs.push_back(SkPath::kClose_Verb); }
void rewind() {
fVerbs.clear();
fPoints.clear();
}
int countPoints() const { return fPoints.size(); }
int countVerbs() const { return fVerbs.size(); }
bool getLastPt(SkPoint* lastPt) const {
if (fPoints.empty()) {
return false;
}
*lastPt = fPoints.back();
return true;
}
void setLastPt(SkPoint lastPt) {
if (fPoints.empty()) {
moveTo(lastPt);
} else {
fPoints.back().set(lastPt.fX, lastPt.fY);
}
}
const std::vector<uint8_t>& verbs() const { return fVerbs; }
const std::vector<SkPoint>& points() const { return fPoints; }
private:
std::vector<uint8_t> fVerbs;
std::vector<SkPoint> fPoints;
};
class SkPathStroker2 {
public:
// Returns the fill path
SkPath getFillPath(const SkPath& path, const SkPaint& paint);
private:
struct PathSegment {
SkPath::Verb fVerb;
SkPoint fPoints[4];
};
float fRadius;
SkPaint::Cap fCap;
SkPaint::Join fJoin;
PathRecorder fInner, fOuter;
// Initialize stroker state
void initForPath(const SkPath& path, const SkPaint& paint);
// Strokes a line segment
void strokeLine(const PathSegment& line, bool needsMove);
// Adds an endcap to fOuter
enum class CapLocation { Start, End };
void endcap(CapLocation loc);
// Adds a join between the two segments
void join(const PathSegment& prev, const PathSegment& curr);
// Appends path in reverse to result
static void appendPathReversed(const PathRecorder& path, PathRecorder* result);
// Returns the segment unit normal
static SkPoint unitNormal(const PathSegment& seg, float t);
// Returns squared magnitude of line segments.
static float squaredLineLength(const PathSegment& lineSeg);
};
void SkPathStroker2::initForPath(const SkPath& path, const SkPaint& paint) {
fRadius = paint.getStrokeWidth() / 2;
fCap = paint.getStrokeCap();
fJoin = paint.getStrokeJoin();
fInner.rewind();
fOuter.rewind();
}
SkPath SkPathStroker2::getFillPath(const SkPath& path, const SkPaint& paint) {
initForPath(path, paint);
// 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;
bool firstSegment = true;
while ((segment.fVerb = it.next(segment.fPoints)) != SkPath::kDone_Verb) {
// Join to the previous segment
if (!firstSegment) {
join(prevSegment, segment);
}
// Stroke the current segment
switch (segment.fVerb) {
case SkPath::kLine_Verb:
strokeLine(segment, firstSegment);
break;
case SkPath::kMove_Verb:
// Don't care about multiple contours currently
continue;
default:
SkDebugf("Unhandled path verb %d\n", segment.fVerb);
break;
}
std::swap(segment, prevSegment);
firstSegment = false;
}
// Open contour => endcap at the end
const bool isClosed = path.isLastContourClosed();
if (isClosed) {
SkDebugf("Unhandled closed contour\n");
} else {
endcap(CapLocation::End);
}
// Walk inner path in reverse, appending to result
appendPathReversed(fInner, &fOuter);
endcap(CapLocation::Start);
return fOuter.getPath();
}
void SkPathStroker2::strokeLine(const PathSegment& line, bool needsMove) {
const SkPoint tangent = line.fPoints[1] - line.fPoints[0];
const SkPoint normal = rotate90(tangent);
const SkPoint offset = setLength(normal, fRadius);
if (needsMove) {
fOuter.moveTo(line.fPoints[0] + offset);
fInner.moveTo(line.fPoints[0] - offset);
}
fOuter.lineTo(line.fPoints[1] + offset);
fInner.lineTo(line.fPoints[1] - offset);
}
void SkPathStroker2::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 SkPathStroker2::join(const PathSegment& prev, const PathSegment& curr) {
const auto miterJoin = [this](const PathSegment& prev, const PathSegment& curr) {
// Common path endpoint of the two segments is the midpoint of the miter line.
const SkPoint miterMidpt = curr.fPoints[0];
SkPoint before = unitNormal(prev, 1);
SkPoint after = unitNormal(curr, 0);
// Check who's inside and who's outside.
PathRecorder *outer = &fOuter, *inner = &fInner;
if (!isClockwise(before, after)) {
std::swap(inner, outer);
before = rotate180(before);
after = rotate180(after);
}
const float cosTheta = before.dot(after);
if (SkScalarNearlyZero(1 - cosTheta)) {
// Nearly identical normals: don't bother.
return;
}
// 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 = fRadius / sinHalfTheta;
miterVec.setLength(halfMiterLength); // TODO: miter length limit
// Outer: connect to the miter point, and then to t=0 (on outside stroke) of next segment.
const SkPoint dest = setLength(after, fRadius);
outer->lineTo(miterMidpt + miterVec);
outer->lineTo(miterMidpt + dest);
// Inner miter is more involved. We're already at t=1 (on inside stroke) of 'prev'.
// Check 2 cases to see we can directly connect to the inner miter point
// (midpoint - miterVec), or if we need to add extra "loop" geometry.
const SkPoint prevUnitTangent = rotate90(before);
const float radiusSquared = fRadius * fRadius;
// 'alpha' is angle between prev tangent and the curr inwards normal
const float cosAlpha = prevUnitTangent.dot(-after);
// Solve triangle for len^2: radius^2 = len^2 + (radius * sin(alpha))^2
// This is the point at which the inside "corner" of curr at t=0 will lie on a
// line connecting the inner and outer corners of prev at t=0. If len is below
// this threshold, the inside corner of curr will "poke through" the start of prev,
// and we'll need the inner loop geometry.
const float threshold1 = radiusSquared * cosAlpha * cosAlpha;
// Solve triangle for len^2: halfMiterLen^2 = radius^2 + len^2
// This is the point at which the inner miter point will lie on the inner stroke
// boundary of the curr segment. If len is below this threshold, the miter point
// moves 'inside' of the stroked outline, and we'll need the inner loop geometry.
const float threshold2 = halfMiterLength * halfMiterLength - radiusSquared;
// If a segment length is smaller than the larger of the two thresholds,
// we'll have to add the inner loop geometry.
const float maxLenSqd = std::max(threshold1, threshold2);
const bool needsInnerLoop =
squaredLineLength(prev) < maxLenSqd || squaredLineLength(curr) < maxLenSqd;
if (needsInnerLoop) {
// Connect to the miter midpoint (common path endpoint of the two segments),
// and then to t=0 (on inside) of the next segment. This adds an interior "loop" of
// geometry that handles edge cases where segment lengths are shorter than the
// stroke width.
inner->lineTo(miterMidpt);
inner->lineTo(miterMidpt - dest);
} else {
// Directly connect to inner miter point.
inner->setLastPt(miterMidpt - miterVec);
}
};
switch (fJoin) {
case SkPaint::kMiter_Join:
miterJoin(prev, curr);
break;
default:
SkDebugf("Unhandled join %d\n", fJoin);
miterJoin(prev, curr);
break;
}
}
void SkPathStroker2::appendPathReversed(const PathRecorder& path, PathRecorder* result) {
const int numVerbs = path.countVerbs();
const int numPoints = path.countPoints();
const std::vector<uint8_t>& verbs = path.verbs();
const std::vector<SkPoint>& points = path.points();
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::kMove_Verb:
// Ignore
break;
default:
SkASSERT(false);
break;
}
}
}
SkPoint SkPathStroker2::unitNormal(const PathSegment& seg, float t) {
if (seg.fVerb != SkPath::kLine_Verb) {
SkDebugf("Unhandled verb for unit normal %d\n", seg.fVerb);
}
(void)t; // Not needed for lines
const SkPoint tangent = seg.fPoints[1] - seg.fPoints[0];
const SkPoint normal = rotate90(tangent);
return setLength(normal, 1);
}
float SkPathStroker2::squaredLineLength(const PathSegment& lineSeg) {
SkASSERT(lineSeg.fVerb == SkPath::kLine_Verb);
const SkPoint diff = lineSeg.fPoints[1] - lineSeg.fPoints[0];
return diff.dot(diff);
}
} // namespace
//////////////////////////////////////////////////////////////////////////////
class SimpleStrokerSlide : public ClickHandlerSlide {
bool fShowSkiaStroke, fShowHidden, fShowSkeleton;
float fWidth = 175;
SkPaint fPtsPaint, fStrokePaint, fMirrorStrokePaint, fNewFillPaint, fHiddenPaint,
fSkeletonPaint;
inline static constexpr int kN = 3;
public:
SkPoint fPts[kN];
SimpleStrokerSlide() : fShowSkiaStroke(true), fShowHidden(true), fShowSkeleton(true) {
fPts[0] = {500, 200};
fPts[1] = {300, 200};
fPts[2] = {100, 100};
fPtsPaint.setAntiAlias(true);
fPtsPaint.setStrokeWidth(10);
fPtsPaint.setStrokeCap(SkPaint::kRound_Cap);
fStrokePaint.setAntiAlias(true);
fStrokePaint.setStyle(SkPaint::kStroke_Style);
fStrokePaint.setColor(0x80FF0000);
fMirrorStrokePaint.setAntiAlias(true);
fMirrorStrokePaint.setStyle(SkPaint::kStroke_Style);
fMirrorStrokePaint.setColor(0x80FFFF00);
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);
fName = "SimpleStroker";
}
bool onChar(SkUnichar uni) override {
switch (uni) {
case '1':
this->toggle(fShowSkeleton);
return true;
case '2':
this->toggle(fShowSkiaStroke);
return true;
case '3':
this->toggle(fShowHidden);
return true;
case '-':
fWidth -= 5;
return true;
case '=':
fWidth += 5;
return true;
default:
break;
}
return false;
}
void draw(SkCanvas* canvas) override {
canvas->drawColor(0xFFEEEEEE);
SkPath path;
this->makePath(&path);
fStrokePaint.setStrokeWidth(fWidth);
// The correct result
if (fShowSkiaStroke) {
canvas->drawPath(path, fStrokePaint);
}
// Simple stroker result
SkPathStroker2 stroker;
SkPath fillPath = stroker.getFillPath(path, fStrokePaint);
canvas->drawPath(fillPath, fNewFillPaint);
if (fShowHidden) {
canvas->drawPath(fillPath, fHiddenPaint);
}
if (fShowSkeleton) {
canvas->drawPath(path, fSkeletonPaint);
}
canvas->drawPoints(SkCanvas::kPoints_PointMode, kN, fPts, fPtsPaint);
// Draw a mirror but using Skia's stroker.
canvas->translate(0, 400);
fMirrorStrokePaint.setStrokeWidth(fWidth);
canvas->drawPath(path, fMirrorStrokePaint);
if (fShowHidden) {
SkPath hidden;
skpathutils::FillPathWithPaint(path, fStrokePaint, &hidden);
canvas->drawPath(hidden, fHiddenPaint);
}
if (fShowSkeleton) {
canvas->drawPath(path, fSkeletonPaint);
}
}
protected:
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 (int i = 0; i < kN; ++i) {
if (r.intersects(SkRect::MakeXYWH(fPts[i].fX, fPts[i].fY, 1, 1))) {
return new Click([this, i](Click* c) {
fPts[i] = c->fCurr;
return true;
});
}
}
return nullptr;
}
bool onClick(ClickHandlerSlide::Click *) override { return false; }
private:
void toggle(bool& value) { value = !value; }
void makePath(SkPath* path) {
path->moveTo(fPts[0]);
for (int i = 1; i < kN; ++i) {
path->lineTo(fPts[i]);
}
}
};
DEF_SLIDE(return new SimpleStrokerSlide;)