| /* |
| * 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;) |