Modifying SkPath to store all verbs provided by the user, and to give
correct results for all stroke and fill modes even on the various types
of degenerate paths.
The goals of this patch include:
1. Have Skia store all of the verbs implied by path construction methods, even
if those define degenerate paths. The SVG implementation in WebKit, which is
backed by Skia, needs to know about all elements of the path, even degenerate
ones, for the correct drawing of markers and line caps. For example, in SVG you
should be able to draw a scatter plot by specifying a marker for vertices and
then giving a sequence of moveTo commands. Skia will not store the moveTos,
requiring a different storage mechanism.
2. Assuming 1, maintain the current Skia behavior. That is, make Skia robust to
degenerate paths.
3. Fix an existing bug in Skia where a degenerate moveTo-lineTo pair spits out
warnings from rasterization and produces incorrect results in inverse-fill
renderings.
4. Adds extensive testing for degenerate paths and path rendering in general.
To meet these goals, the patch I am proposing will result in minor additional
storage for degenerate paths (a few bytes per degenerate path, only if the user
defines such paths). There is also some additional overhead in the iteration
code, with the path now cleaned to remove degenerate segments as part of the
iteration process. I suspect this will also fix issues with computing normal
vectors to degenerate segments. Benchmarking suggests that this change may
result in slightly (< 1%) slower path drawing due to the checks for
degeneracy. This overhead could be removed (in fact, a significant speedup
could occur) if the results of iterating to clean up the path were cached.
This would cost memory, of course, and quite a bit of it.
BUG=398
TEST=tests/PathTest.cpp
gm/cubicpaths.cpp
gm/degeneratesegments.cpp
gm/movepaths.cpp
gm/linepaths.cpp
gm/quadpaths.cpp
Review URL: http://codereview.appspot.com/5482051
git-svn-id: http://skia.googlecode.com/svn/trunk@2901 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/gm/cubicpaths.cpp b/gm/cubicpaths.cpp
new file mode 100644
index 0000000..80e38ca
--- /dev/null
+++ b/gm/cubicpaths.cpp
@@ -0,0 +1,189 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "gm.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkRandom.h"
+
+namespace skiagm {
+
+class CubicPathsGM : public GM {
+public:
+ CubicPathsGM() {}
+
+protected:
+ SkString onShortName() {
+ return SkString("cubicpaths");
+ }
+
+ SkISize onISize() { return make_isize(1800, 1110); }
+
+ void drawPath(SkPath& path,SkCanvas* canvas,SkColor color,
+ const SkRect& clip,SkPaint::Cap cap,
+ SkPaint::Style style, SkPath::FillType fill,
+ SkScalar strokeWidth) {
+ path.setFillType(fill);
+ SkPaint paint;
+ paint.setStrokeCap(cap);
+ paint.setStrokeWidth(strokeWidth);
+ paint.setColor(color);
+ paint.setStyle(style);
+ canvas->save();
+ canvas->clipRect(clip);
+ canvas->drawPath(path, paint);
+ canvas->restore();
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ struct FillAndName {
+ SkPath::FillType fFill;
+ const char* fName;
+ };
+ static const FillAndName gFills[] = {
+ {SkPath::kWinding_FillType, "Winding"},
+ {SkPath::kEvenOdd_FillType, "Even / Odd"},
+ {SkPath::kInverseWinding_FillType, "Inverse Winding"},
+ {SkPath::kInverseEvenOdd_FillType, "Inverse Even / Odd"},
+ };
+ struct StyleAndName {
+ SkPaint::Style fStyle;
+ const char* fName;
+ };
+ static const StyleAndName gStyles[] = {
+ {SkPaint::kFill_Style, "Fill"},
+ {SkPaint::kStroke_Style, "Stroke"},
+ {SkPaint::kStrokeAndFill_Style, "Stroke And Fill"},
+ };
+ struct CapAndName {
+ SkPaint::Cap fCap;
+ const char* fName;
+ };
+ static const CapAndName gCaps[] = {
+ {SkPaint::kButt_Cap, "Butt"},
+ {SkPaint::kRound_Cap, "Round"},
+ {SkPaint::kSquare_Cap, "Square"},
+ };
+ struct PathAndName {
+ SkPath fPath;
+ const char* fName;
+ };
+ PathAndName gPaths[4];
+ gPaths[0].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[0].fPath.cubicTo(50*SK_Scalar1, 15*SK_Scalar1,
+ 50*SK_Scalar1, 15*SK_Scalar1,
+ 50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[0].fName = "moveTo-zerocubic";
+ gPaths[1].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[1].fPath.cubicTo(50*SK_Scalar1, 15*SK_Scalar1,
+ 50*SK_Scalar1, 15*SK_Scalar1,
+ 50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[1].fPath.close();
+ gPaths[1].fName = "moveTo-zerocubic-close";
+ gPaths[2].fPath.moveTo(30*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[2].fPath.cubicTo(40*SK_Scalar1, 20*SK_Scalar1,
+ 60*SK_Scalar1, 20*SK_Scalar1,
+ 70*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[2].fName = "moveTo-cubic";
+ gPaths[3].fPath.moveTo(30*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[3].fPath.cubicTo(40*SK_Scalar1, 20*SK_Scalar1,
+ 60*SK_Scalar1, 20*SK_Scalar1,
+ 70*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[3].fPath.close();
+ gPaths[3].fName = "moveTo-cubic-close";
+
+ SkPaint titlePaint;
+ titlePaint.setColor(SK_ColorBLACK);
+ titlePaint.setAntiAlias(true);
+ titlePaint.setLCDRenderText(true);
+ titlePaint.setTextSize(15 * SK_Scalar1);
+ const char title[] = "Cubic Paths Drawn Into Rectangle Clips With "
+ "Indicated Style, Fill and Linecaps, "
+ "with random stroke widths";
+ canvas->drawText(title, strlen(title),
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
+
+ SkRandom rand;
+ SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
+ canvas->save();
+ canvas->translate(10 * SK_Scalar1, 30 * SK_Scalar1);
+ canvas->save();
+ for (size_t path = 0; path < SK_ARRAY_COUNT(gPaths); ++path) {
+ if (0 < path) {
+ canvas->translate(0, (rect.height() + 60 * SK_Scalar1) * 3);
+ }
+ canvas->save();
+ for (size_t cap = 0; cap < SK_ARRAY_COUNT(gCaps); ++cap) {
+ if (0 < cap) {
+ canvas->translate((rect.width() + 40 * SK_Scalar1) * 4, 0);
+ }
+ canvas->save();
+ for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
+ if (0 < style) {
+ canvas->translate(0, rect.height() + 60 * SK_Scalar1);
+ }
+ canvas->save();
+ for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
+ if (0 < fill) {
+ canvas->translate(rect.width() + 40 * SK_Scalar1, 0);
+ }
+
+ SkColor color = 0xff007000;
+ this->drawPath(gPaths[path].fPath, canvas, color, rect,
+ gCaps[cap].fCap, gStyles[style].fStyle,
+ gFills[fill].fFill, SK_Scalar1*10);
+
+ SkPaint rectPaint;
+ rectPaint.setColor(SK_ColorBLACK);
+ rectPaint.setStyle(SkPaint::kStroke_Style);
+ rectPaint.setStrokeWidth(-1);
+ rectPaint.setAntiAlias(true);
+ canvas->drawRect(rect, rectPaint);
+
+ SkPaint labelPaint;
+ labelPaint.setColor(color);
+ labelPaint.setAntiAlias(true);
+ labelPaint.setLCDRenderText(true);
+ labelPaint.setTextSize(10 * SK_Scalar1);
+ canvas->drawText(gStyles[style].fName,
+ strlen(gStyles[style].fName),
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gFills[fill].fName,
+ strlen(gFills[fill].fName),
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gCaps[cap].fName,
+ strlen(gCaps[cap].fName),
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gPaths[path].fName,
+ strlen(gPaths[path].fName),
+ 0, rect.height() + 48 * SK_Scalar1,
+ labelPaint);
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ canvas->restore();
+ }
+
+private:
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new CubicPathsGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gm/degeneratesegments.cpp b/gm/degeneratesegments.cpp
new file mode 100644
index 0000000..7288d95
--- /dev/null
+++ b/gm/degeneratesegments.cpp
@@ -0,0 +1,398 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "gm.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkRandom.h"
+
+namespace skiagm {
+
+class DegenerateSegmentsGM : public GM {
+public:
+ DegenerateSegmentsGM() {}
+
+protected:
+ struct PathAndName {
+ SkPath fPath;
+ const char* fName1;
+ const char* fName2;
+ };
+
+ SkString onShortName() {
+ return SkString("degeneratesegments");
+ }
+
+ SkISize onISize() { return make_isize(1368, 1230); }
+
+ typedef SkPoint (*AddSegmentFunc)(SkPath&, SkPoint&);
+
+ // We need to use explicit commands here, instead of addPath, because we
+ // do not want the SkPath::Iter used in addPath to remove the degenerate
+ // segments before we send th epath off for drawing.
+ static SkPoint AddMove(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ return moveToPt;
+ }
+
+ static SkPoint AddMoveClose(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ path.close();
+ return moveToPt;
+ }
+
+ static SkPoint AddDegenLine(SkPath& path, SkPoint& startPt) {
+ path.lineTo(startPt);
+ return startPt;
+ }
+
+ static SkPoint AddMoveDegenLine(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ path.lineTo(moveToPt);
+ return moveToPt;
+ }
+
+ static SkPoint AddMoveDegenLineClose(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ path.lineTo(moveToPt);
+ path.close();
+ return moveToPt;
+ }
+
+ static SkPoint AddDegenQuad(SkPath& path, SkPoint& startPt) {
+ path.quadTo(startPt, startPt);
+ return startPt;
+ }
+
+ static SkPoint AddMoveDegenQuad(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ path.quadTo(moveToPt, moveToPt);
+ return moveToPt;
+ }
+
+ static SkPoint AddMoveDegenQuadClose(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ path.quadTo(moveToPt, moveToPt);
+ path.close();
+ return moveToPt;
+ }
+
+ static SkPoint AddDegenCubic(SkPath& path, SkPoint& startPt) {
+ path.cubicTo(startPt, startPt, startPt);
+ return startPt;
+ }
+
+ static SkPoint AddMoveDegenCubic(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ path.cubicTo(moveToPt, moveToPt, moveToPt);
+ return moveToPt;
+ }
+
+ static SkPoint AddMoveDegenCubicClose(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ path.moveTo(moveToPt);
+ path.cubicTo(moveToPt, moveToPt, moveToPt);
+ path.close();
+ return moveToPt;
+ }
+
+ static SkPoint AddClose(SkPath& path, SkPoint& startPt) {
+ path.close();
+ return startPt;
+ }
+
+ static SkPoint AddLine(SkPath& path, SkPoint& startPt) {
+ SkPoint endPt = startPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.lineTo(endPt);
+ return endPt;
+ }
+
+ static SkPoint AddMoveLine(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ SkPoint endPt = moveToPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.moveTo(moveToPt);
+ path.lineTo(endPt);
+ return endPt;
+ }
+
+ static SkPoint AddMoveLineClose(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ SkPoint endPt = moveToPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.moveTo(moveToPt);
+ path.lineTo(endPt);
+ path.close();
+ return endPt;
+ }
+
+ static SkPoint AddQuad(SkPath& path, SkPoint& startPt) {
+ SkPoint midPt = startPt + SkPoint::Make(20*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint endPt = startPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.quadTo(midPt, endPt);
+ return endPt;
+ }
+
+ static SkPoint AddMoveQuad(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ SkPoint midPt = moveToPt + SkPoint::Make(20*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint endPt = moveToPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.moveTo(moveToPt);
+ path.quadTo(midPt, endPt);
+ return endPt;
+ }
+
+ static SkPoint AddMoveQuadClose(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ SkPoint midPt = moveToPt + SkPoint::Make(20*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint endPt = moveToPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.moveTo(moveToPt);
+ path.quadTo(midPt, endPt);
+ path.close();
+ return endPt;
+ }
+
+ static SkPoint AddCubic(SkPath& path, SkPoint& startPt) {
+ SkPoint t1Pt = startPt + SkPoint::Make(15*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint t2Pt = startPt + SkPoint::Make(25*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint endPt = startPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.cubicTo(t1Pt, t2Pt, endPt);
+ return endPt;
+ }
+
+ static SkPoint AddMoveCubic(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ SkPoint t1Pt = moveToPt + SkPoint::Make(15*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint t2Pt = moveToPt + SkPoint::Make(25*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint endPt = moveToPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.moveTo(moveToPt);
+ path.cubicTo(t1Pt, t2Pt, endPt);
+ return endPt;
+ }
+
+ static SkPoint AddMoveCubicClose(SkPath& path, SkPoint& startPt) {
+ SkPoint moveToPt = startPt + SkPoint::Make(0, 10*SK_Scalar1);
+ SkPoint t1Pt = moveToPt + SkPoint::Make(15*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint t2Pt = moveToPt + SkPoint::Make(25*SK_Scalar1, 5*SK_Scalar1);
+ SkPoint endPt = moveToPt + SkPoint::Make(40*SK_Scalar1, 0);
+ path.moveTo(moveToPt);
+ path.cubicTo(t1Pt, t2Pt, endPt);
+ path.close();
+ return endPt;
+ }
+
+ void drawPath(SkPath& path, SkCanvas* canvas, SkColor color,
+ const SkRect& clip, SkPaint::Cap cap,
+ SkPaint::Style style, SkPath::FillType fill,
+ SkScalar strokeWidth) {
+ path.setFillType(fill);
+ SkPaint paint;
+ paint.setStrokeCap(cap);
+ paint.setStrokeWidth(strokeWidth);
+ paint.setColor(color);
+ paint.setStyle(style);
+ canvas->save();
+ canvas->clipRect(clip);
+ canvas->drawPath(path, paint);
+ canvas->restore();
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ static const AddSegmentFunc gSegmentFunctions[] = {
+ AddMove,
+ AddMoveClose,
+ AddDegenLine,
+ AddMoveDegenLine,
+ AddMoveDegenLineClose,
+ AddDegenQuad,
+ AddMoveDegenQuad,
+ AddMoveDegenQuadClose,
+ AddDegenCubic,
+ AddMoveDegenCubic,
+ AddMoveDegenCubicClose,
+ AddClose,
+ AddLine,
+ AddMoveLine,
+ AddMoveLineClose,
+ AddQuad,
+ AddMoveQuad,
+ AddMoveQuadClose,
+ AddCubic,
+ AddMoveCubic,
+ AddMoveCubicClose
+ };
+ static const char* gSegmentNames[] = {
+ "Move",
+ "MoveClose",
+ "DegenLine",
+ "MoveDegenLine",
+ "MoveDegenLineClose",
+ "DegenQuad",
+ "MoveDegenQuad",
+ "MoveDegenQuadClose",
+ "DegenCubic",
+ "MoveDegenCubic",
+ "MoveDegenCubicClose",
+ "Close",
+ "Line",
+ "MoveLine",
+ "MoveLineClose",
+ "Quad",
+ "MoveQuad",
+ "MoveQuadClose",
+ "Cubic",
+ "MoveCubic",
+ "MoveCubicClose"
+ };
+
+ struct FillAndName {
+ SkPath::FillType fFill;
+ const char* fName;
+ };
+ static const FillAndName gFills[] = {
+ {SkPath::kWinding_FillType, "Winding"},
+ {SkPath::kEvenOdd_FillType, "Even / Odd"},
+ {SkPath::kInverseWinding_FillType, "Inverse Winding"},
+ {SkPath::kInverseEvenOdd_FillType, "Inverse Even / Odd"}
+ };
+ struct StyleAndName {
+ SkPaint::Style fStyle;
+ const char* fName;
+ };
+ static const StyleAndName gStyles[] = {
+ {SkPaint::kFill_Style, "Fill"},
+ {SkPaint::kStroke_Style, "Stroke 10"},
+ {SkPaint::kStrokeAndFill_Style, "Stroke 10 And Fill"}
+ };
+ struct CapAndName {
+ SkPaint::Cap fCap;
+ const char* fName;
+ };
+ static const CapAndName gCaps[] = {
+ {SkPaint::kButt_Cap, "Butt"},
+ {SkPaint::kRound_Cap, "Round"},
+ {SkPaint::kSquare_Cap, "Square"}
+ };
+
+ SkPaint titlePaint;
+ titlePaint.setColor(SK_ColorBLACK);
+ titlePaint.setAntiAlias(true);
+ titlePaint.setLCDRenderText(true);
+ titlePaint.setTextSize(15 * SK_Scalar1);
+ const char title[] = "Random Paths Drawn Into Rectangle Clips With "
+ "Indicated Style, Fill and Linecaps, "
+ "with Stroke width 6";
+ canvas->drawText(title, strlen(title),
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
+
+ SkRandom rand;
+ SkRect rect = SkRect::MakeWH(220*SK_Scalar1, 50*SK_Scalar1);
+ canvas->save();
+ canvas->translate(2*SK_Scalar1, 30 * SK_Scalar1); // The title
+ canvas->save();
+ unsigned numSegments = SK_ARRAY_COUNT(gSegmentFunctions);
+ unsigned numCaps = SK_ARRAY_COUNT(gCaps);
+ unsigned numStyles = SK_ARRAY_COUNT(gStyles);
+ unsigned numFills = SK_ARRAY_COUNT(gFills);
+ for (size_t row = 0; row < 8; ++row) {
+ if (0 < row) {
+ canvas->translate(0, rect.height() + 100*SK_Scalar1);
+ }
+ canvas->save();
+ for (size_t column = 0; column < 6; ++column) {
+ if (0 < column) {
+ canvas->translate(rect.width() + 4*SK_Scalar1, 0);
+ }
+
+ SkColor color = 0xff007000;
+ StyleAndName style = gStyles[(rand.nextU() >> 16) % numStyles];
+ CapAndName cap = gCaps[(rand.nextU() >> 16) % numCaps];
+ FillAndName fill = gFills[(rand.nextU() >> 16) % numFills];
+ SkPath path;
+ unsigned s1 = (rand.nextU() >> 16) % numSegments;
+ unsigned s2 = (rand.nextU() >> 16) % numSegments;
+ unsigned s3 = (rand.nextU() >> 16) % numSegments;
+ unsigned s4 = (rand.nextU() >> 16) % numSegments;
+ unsigned s5 = (rand.nextU() >> 16) % numSegments;
+ SkPoint pt = SkPoint::Make(10*SK_Scalar1, 0);
+ pt = gSegmentFunctions[s1](path, pt);
+ pt = gSegmentFunctions[s2](path, pt);
+ pt = gSegmentFunctions[s3](path, pt);
+ pt = gSegmentFunctions[s4](path, pt);
+ pt = gSegmentFunctions[s5](path, pt);
+
+ this->drawPath(path, canvas, color, rect,
+ cap.fCap, style.fStyle,
+ fill.fFill, SK_Scalar1*6);
+
+ SkPaint rectPaint;
+ rectPaint.setColor(SK_ColorBLACK);
+ rectPaint.setStyle(SkPaint::kStroke_Style);
+ rectPaint.setStrokeWidth(-1);
+ rectPaint.setAntiAlias(true);
+ canvas->drawRect(rect, rectPaint);
+
+ SkPaint labelPaint;
+ labelPaint.setColor(color);
+ labelPaint.setAntiAlias(true);
+ labelPaint.setLCDRenderText(true);
+ labelPaint.setTextSize(10 * SK_Scalar1);
+ canvas->drawText(style.fName,
+ strlen(style.fName),
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(fill.fName,
+ strlen(fill.fName),
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(cap.fName,
+ strlen(cap.fName),
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gSegmentNames[s1],
+ strlen(gSegmentNames[s1]),
+ 0, rect.height() + 48 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gSegmentNames[s2],
+ strlen(gSegmentNames[s2]),
+ 0, rect.height() + 60 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gSegmentNames[s3],
+ strlen(gSegmentNames[s3]),
+ 0, rect.height() + 72 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gSegmentNames[s4],
+ strlen(gSegmentNames[s4]),
+ 0, rect.height() + 84 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gSegmentNames[s5],
+ strlen(gSegmentNames[s5]),
+ 0, rect.height() + 96 * SK_Scalar1,
+ labelPaint);
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ canvas->restore();
+ }
+
+private:
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new DegenerateSegmentsGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gm/linepaths.cpp b/gm/linepaths.cpp
new file mode 100644
index 0000000..2a33920
--- /dev/null
+++ b/gm/linepaths.cpp
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "gm.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkRandom.h"
+
+namespace skiagm {
+
+class LinePathsGM : public GM {
+public:
+ LinePathsGM() {}
+
+protected:
+ SkString onShortName() {
+ return SkString("linepaths");
+ }
+
+ SkISize onISize() { return make_isize(1800, 1110); }
+
+ void drawPath(SkPath& path,SkCanvas* canvas,SkColor color,
+ const SkRect& clip,SkPaint::Cap cap,
+ SkPaint::Style style, SkPath::FillType fill,
+ SkScalar strokeWidth) {
+ path.setFillType(fill);
+ SkPaint paint;
+ paint.setStrokeCap(cap);
+ paint.setStrokeWidth(strokeWidth);
+ paint.setColor(color);
+ paint.setStyle(style);
+ canvas->save();
+ canvas->clipRect(clip);
+ canvas->drawPath(path, paint);
+ canvas->restore();
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ struct FillAndName {
+ SkPath::FillType fFill;
+ const char* fName;
+ };
+ static const FillAndName gFills[] = {
+ {SkPath::kWinding_FillType, "Winding"},
+ {SkPath::kEvenOdd_FillType, "Even / Odd"},
+ {SkPath::kInverseWinding_FillType, "Inverse Winding"},
+ {SkPath::kInverseEvenOdd_FillType, "Inverse Even / Odd"},
+ };
+ struct StyleAndName {
+ SkPaint::Style fStyle;
+ const char* fName;
+ };
+ static const StyleAndName gStyles[] = {
+ {SkPaint::kFill_Style, "Fill"},
+ {SkPaint::kStroke_Style, "Stroke"},
+ {SkPaint::kStrokeAndFill_Style, "Stroke And Fill"},
+ };
+ struct CapAndName {
+ SkPaint::Cap fCap;
+ const char* fName;
+ };
+ static const CapAndName gCaps[] = {
+ {SkPaint::kButt_Cap, "Butt"},
+ {SkPaint::kRound_Cap, "Round"},
+ {SkPaint::kSquare_Cap, "Square"},
+ };
+ struct PathAndName {
+ SkPath fPath;
+ const char* fName;
+ };
+ PathAndName gPaths[4];
+ gPaths[0].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[0].fPath.lineTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[0].fName = "moveTo-zeroline";
+ gPaths[1].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[1].fPath.lineTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[1].fPath.close();
+ gPaths[1].fName = "moveTo-zeroline-close";
+ gPaths[2].fPath.moveTo(30*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[2].fPath.lineTo(70*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[2].fName = "moveTo-line";
+ gPaths[3].fPath.moveTo(30*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[3].fPath.lineTo(70*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[3].fPath.close();
+ gPaths[3].fName = "moveTo-line-close";
+
+ SkPaint titlePaint;
+ titlePaint.setColor(SK_ColorBLACK);
+ titlePaint.setAntiAlias(true);
+ titlePaint.setLCDRenderText(true);
+ titlePaint.setTextSize(15 * SK_Scalar1);
+ const char title[] = "Line Paths Drawn Into Rectangle Clips With "
+ "Indicated Style, Fill and Linecaps, "
+ "with random stroke widths";
+ canvas->drawText(title, strlen(title),
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
+
+ SkRandom rand;
+ SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
+ canvas->save();
+ canvas->translate(10 * SK_Scalar1, 30 * SK_Scalar1);
+ canvas->save();
+ for (size_t path = 0; path < SK_ARRAY_COUNT(gPaths); ++path) {
+ if (0 < path) {
+ canvas->translate(0, (rect.height() + 60 * SK_Scalar1) * 3);
+ }
+ canvas->save();
+ for (size_t cap = 0; cap < SK_ARRAY_COUNT(gCaps); ++cap) {
+ if (0 < cap) {
+ canvas->translate((rect.width() + 40 * SK_Scalar1) * 4, 0);
+ }
+ canvas->save();
+ for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
+ if (0 < style) {
+ canvas->translate(0, rect.height() + 60 * SK_Scalar1);
+ }
+ canvas->save();
+ for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
+ if (0 < fill) {
+ canvas->translate(rect.width() + 40 * SK_Scalar1, 0);
+ }
+
+ SkColor color = 0xff007000;
+ this->drawPath(gPaths[path].fPath, canvas, color, rect,
+ gCaps[cap].fCap, gStyles[style].fStyle,
+ gFills[fill].fFill, SK_Scalar1*10);
+
+ SkPaint rectPaint;
+ rectPaint.setColor(SK_ColorBLACK);
+ rectPaint.setStyle(SkPaint::kStroke_Style);
+ rectPaint.setStrokeWidth(-1);
+ rectPaint.setAntiAlias(true);
+ canvas->drawRect(rect, rectPaint);
+
+ SkPaint labelPaint;
+ labelPaint.setColor(color);
+ labelPaint.setAntiAlias(true);
+ labelPaint.setLCDRenderText(true);
+ labelPaint.setTextSize(10 * SK_Scalar1);
+ canvas->drawText(gStyles[style].fName,
+ strlen(gStyles[style].fName),
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gFills[fill].fName,
+ strlen(gFills[fill].fName),
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gCaps[cap].fName,
+ strlen(gCaps[cap].fName),
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gPaths[path].fName,
+ strlen(gPaths[path].fName),
+ 0, rect.height() + 48 * SK_Scalar1,
+ labelPaint);
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ canvas->restore();
+ }
+
+private:
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new LinePathsGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gm/movepaths.cpp b/gm/movepaths.cpp
new file mode 100644
index 0000000..574058e
--- /dev/null
+++ b/gm/movepaths.cpp
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "gm.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkRandom.h"
+
+namespace skiagm {
+
+class MovePathsGM : public GM {
+public:
+ MovePathsGM() {}
+
+protected:
+ SkString onShortName() {
+ return SkString("movepaths");
+ }
+
+ SkISize onISize() { return make_isize(1800, 1110); }
+
+ void drawPath(SkPath& path,SkCanvas* canvas,SkColor color,
+ const SkRect& clip,SkPaint::Cap cap,
+ SkPaint::Style style, SkPath::FillType fill,
+ SkScalar strokeWidth) {
+ path.setFillType(fill);
+ SkPaint paint;
+ paint.setStrokeCap(cap);
+ paint.setStrokeWidth(strokeWidth);
+ paint.setColor(color);
+ paint.setStyle(style);
+ canvas->save();
+ canvas->clipRect(clip);
+ canvas->drawPath(path, paint);
+ canvas->restore();
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ struct FillAndName {
+ SkPath::FillType fFill;
+ const char* fName;
+ };
+ static const FillAndName gFills[] = {
+ {SkPath::kWinding_FillType, "Winding"},
+ {SkPath::kEvenOdd_FillType, "Even / Odd"},
+ {SkPath::kInverseWinding_FillType, "Inverse Winding"},
+ {SkPath::kInverseEvenOdd_FillType, "Inverse Even / Odd"},
+ };
+ struct StyleAndName {
+ SkPaint::Style fStyle;
+ const char* fName;
+ };
+ static const StyleAndName gStyles[] = {
+ {SkPaint::kFill_Style, "Fill"},
+ {SkPaint::kStroke_Style, "Stroke"},
+ {SkPaint::kStrokeAndFill_Style, "Stroke And Fill"},
+ };
+ struct CapAndName {
+ SkPaint::Cap fCap;
+ const char* fName;
+ };
+ static const CapAndName gCaps[] = {
+ {SkPaint::kButt_Cap, "Butt"},
+ {SkPaint::kRound_Cap, "Round"},
+ {SkPaint::kSquare_Cap, "Square"},
+ };
+ struct PathAndName {
+ SkPath fPath;
+ const char* fName;
+ };
+ PathAndName gPaths[4];
+ gPaths[0].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[0].fName = "moveTo";
+ gPaths[1].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[1].fPath.close();
+ gPaths[1].fName = "moveTo-close";
+ gPaths[2].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[2].fPath.moveTo(75*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[2].fName = "moveTo-moveTo";
+ gPaths[3].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[3].fPath.close();
+ gPaths[3].fPath.moveTo(75*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[3].fPath.close();
+ gPaths[3].fName = "moveTo-close-moveTo-close";
+
+ SkPaint titlePaint;
+ titlePaint.setColor(SK_ColorBLACK);
+ titlePaint.setAntiAlias(true);
+ titlePaint.setLCDRenderText(true);
+ titlePaint.setTextSize(15 * SK_Scalar1);
+ const char title[] = "MoveTo Paths Drawn Into Rectangle Clips With "
+ "Indicated Style, Fill and Linecaps, "
+ "with random stroke widths";
+ canvas->drawText(title, strlen(title),
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
+
+ SkRandom rand;
+ SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
+ canvas->save();
+ canvas->translate(10 * SK_Scalar1, 30 * SK_Scalar1);
+ canvas->save();
+ for (size_t path = 0; path < SK_ARRAY_COUNT(gPaths); ++path) {
+ if (0 < path) {
+ canvas->translate(0, (rect.height() + 60 * SK_Scalar1) * 3);
+ }
+ canvas->save();
+ for (size_t cap = 0; cap < SK_ARRAY_COUNT(gCaps); ++cap) {
+ if (0 < cap) {
+ canvas->translate((rect.width() + 40 * SK_Scalar1) * 4, 0);
+ }
+ canvas->save();
+ for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
+ if (0 < style) {
+ canvas->translate(0, rect.height() + 60 * SK_Scalar1);
+ }
+ canvas->save();
+ for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
+ if (0 < fill) {
+ canvas->translate(rect.width() + 40 * SK_Scalar1, 0);
+ }
+
+ SkColor color = 0xff007000;
+ this->drawPath(gPaths[path].fPath, canvas, color, rect,
+ gCaps[cap].fCap, gStyles[style].fStyle,
+ gFills[fill].fFill, SK_Scalar1*10);
+
+ SkPaint rectPaint;
+ rectPaint.setColor(SK_ColorBLACK);
+ rectPaint.setStyle(SkPaint::kStroke_Style);
+ rectPaint.setStrokeWidth(-1);
+ rectPaint.setAntiAlias(true);
+ canvas->drawRect(rect, rectPaint);
+
+ SkPaint labelPaint;
+ labelPaint.setColor(color);
+ labelPaint.setAntiAlias(true);
+ labelPaint.setLCDRenderText(true);
+ labelPaint.setTextSize(10 * SK_Scalar1);
+ canvas->drawText(gStyles[style].fName,
+ strlen(gStyles[style].fName),
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gFills[fill].fName,
+ strlen(gFills[fill].fName),
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gCaps[cap].fName,
+ strlen(gCaps[cap].fName),
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gPaths[path].fName,
+ strlen(gPaths[path].fName),
+ 0, rect.height() + 48 * SK_Scalar1,
+ labelPaint);
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ canvas->restore();
+ }
+
+private:
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new MovePathsGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gm/quadpaths.cpp b/gm/quadpaths.cpp
new file mode 100644
index 0000000..32de2f4
--- /dev/null
+++ b/gm/quadpaths.cpp
@@ -0,0 +1,185 @@
+/*
+ * Copyright 2011 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include "gm.h"
+#include "SkCanvas.h"
+#include "SkPaint.h"
+#include "SkRandom.h"
+
+namespace skiagm {
+
+class QuadPathsGM : public GM {
+public:
+ QuadPathsGM() {}
+
+protected:
+ SkString onShortName() {
+ return SkString("quadpaths");
+ }
+
+ SkISize onISize() { return make_isize(1800, 1110); }
+
+ void drawPath(SkPath& path,SkCanvas* canvas,SkColor color,
+ const SkRect& clip,SkPaint::Cap cap,
+ SkPaint::Style style, SkPath::FillType fill,
+ SkScalar strokeWidth) {
+ path.setFillType(fill);
+ SkPaint paint;
+ paint.setStrokeCap(cap);
+ paint.setStrokeWidth(strokeWidth);
+ paint.setColor(color);
+ paint.setStyle(style);
+ canvas->save();
+ canvas->clipRect(clip);
+ canvas->drawPath(path, paint);
+ canvas->restore();
+ }
+
+ virtual void onDraw(SkCanvas* canvas) {
+ struct FillAndName {
+ SkPath::FillType fFill;
+ const char* fName;
+ };
+ static const FillAndName gFills[] = {
+ {SkPath::kWinding_FillType, "Winding"},
+ {SkPath::kEvenOdd_FillType, "Even / Odd"},
+ {SkPath::kInverseWinding_FillType, "Inverse Winding"},
+ {SkPath::kInverseEvenOdd_FillType, "Inverse Even / Odd"},
+ };
+ struct StyleAndName {
+ SkPaint::Style fStyle;
+ const char* fName;
+ };
+ static const StyleAndName gStyles[] = {
+ {SkPaint::kFill_Style, "Fill"},
+ {SkPaint::kStroke_Style, "Stroke"},
+ {SkPaint::kStrokeAndFill_Style, "Stroke And Fill"},
+ };
+ struct CapAndName {
+ SkPaint::Cap fCap;
+ const char* fName;
+ };
+ static const CapAndName gCaps[] = {
+ {SkPaint::kButt_Cap, "Butt"},
+ {SkPaint::kRound_Cap, "Round"},
+ {SkPaint::kSquare_Cap, "Square"},
+ };
+ struct PathAndName {
+ SkPath fPath;
+ const char* fName;
+ };
+ PathAndName gPaths[4];
+ gPaths[0].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[0].fPath.quadTo(50*SK_Scalar1, 15*SK_Scalar1,
+ 50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[0].fName = "moveTo-zeroquad";
+ gPaths[1].fPath.moveTo(50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[1].fPath.quadTo(50*SK_Scalar1, 15*SK_Scalar1,
+ 50*SK_Scalar1, 15*SK_Scalar1);
+ gPaths[1].fPath.close();
+ gPaths[1].fName = "moveTo-zeroquad-close";
+ gPaths[2].fPath.moveTo(30*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[2].fPath.quadTo(50*SK_Scalar1, 20*SK_Scalar1,
+ 70*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[2].fName = "moveTo-quad";
+ gPaths[3].fPath.moveTo(30*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[3].fPath.quadTo(50*SK_Scalar1, 20*SK_Scalar1,
+ 70*SK_Scalar1, 10*SK_Scalar1);
+ gPaths[3].fPath.close();
+ gPaths[3].fName = "moveTo-quad-close";
+
+ SkPaint titlePaint;
+ titlePaint.setColor(SK_ColorBLACK);
+ titlePaint.setAntiAlias(true);
+ titlePaint.setLCDRenderText(true);
+ titlePaint.setTextSize(15 * SK_Scalar1);
+ const char title[] = "Zero Paths Drawn Into Rectangle Clips With "
+ "Indicated Style, Fill and Linecaps, "
+ "with random stroke widths";
+ canvas->drawText(title, strlen(title),
+ 20 * SK_Scalar1,
+ 20 * SK_Scalar1,
+ titlePaint);
+
+ SkRandom rand;
+ SkRect rect = SkRect::MakeWH(100*SK_Scalar1, 30*SK_Scalar1);
+ canvas->save();
+ canvas->translate(10 * SK_Scalar1, 30 * SK_Scalar1);
+ canvas->save();
+ for (size_t path = 0; path < SK_ARRAY_COUNT(gPaths); ++path) {
+ if (0 < path) {
+ canvas->translate(0, (rect.height() + 60 * SK_Scalar1) * 3);
+ }
+ canvas->save();
+ for (size_t cap = 0; cap < SK_ARRAY_COUNT(gCaps); ++cap) {
+ if (0 < cap) {
+ canvas->translate((rect.width() + 40 * SK_Scalar1) * 4, 0);
+ }
+ canvas->save();
+ for (size_t style = 0; style < SK_ARRAY_COUNT(gStyles); ++style) {
+ if (0 < style) {
+ canvas->translate(0, rect.height() + 60 * SK_Scalar1);
+ }
+ canvas->save();
+ for (size_t fill = 0; fill < SK_ARRAY_COUNT(gFills); ++fill) {
+ if (0 < fill) {
+ canvas->translate(rect.width() + 40 * SK_Scalar1, 0);
+ }
+
+ SkColor color = 0xff007000;
+ this->drawPath(gPaths[path].fPath, canvas, color, rect,
+ gCaps[cap].fCap, gStyles[style].fStyle,
+ gFills[fill].fFill, SK_Scalar1*10);
+
+ SkPaint rectPaint;
+ rectPaint.setColor(SK_ColorBLACK);
+ rectPaint.setStyle(SkPaint::kStroke_Style);
+ rectPaint.setStrokeWidth(-1);
+ rectPaint.setAntiAlias(true);
+ canvas->drawRect(rect, rectPaint);
+
+ SkPaint labelPaint;
+ labelPaint.setColor(color);
+ labelPaint.setAntiAlias(true);
+ labelPaint.setLCDRenderText(true);
+ labelPaint.setTextSize(10 * SK_Scalar1);
+ canvas->drawText(gStyles[style].fName,
+ strlen(gStyles[style].fName),
+ 0, rect.height() + 12 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gFills[fill].fName,
+ strlen(gFills[fill].fName),
+ 0, rect.height() + 24 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gCaps[cap].fName,
+ strlen(gCaps[cap].fName),
+ 0, rect.height() + 36 * SK_Scalar1,
+ labelPaint);
+ canvas->drawText(gPaths[path].fName,
+ strlen(gPaths[path].fName),
+ 0, rect.height() + 48 * SK_Scalar1,
+ labelPaint);
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ }
+ canvas->restore();
+ canvas->restore();
+ }
+
+private:
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+static GM* MyFactory(void*) { return new QuadPathsGM; }
+static GMRegistry reg(MyFactory);
+
+}
diff --git a/gyp/gmslides.gypi b/gyp/gmslides.gypi
index 17873d6..d20cf73 100644
--- a/gyp/gmslides.gypi
+++ b/gyp/gmslides.gypi
@@ -9,6 +9,8 @@
'../gm/blurs.cpp',
'../gm/complexclip.cpp',
'../gm/complexclip2.cpp',
+ '../gm/cubicpaths.cpp',
+ '../gm/degeneratesegments.cpp',
'../gm/drawbitmaprect.cpp',
'../gm/emptypath.cpp',
'../gm/filltypes.cpp',
@@ -21,11 +23,14 @@
# See http://code.google.com/p/skia/issues/detail?id=391
# '../gm/imageblur.cpp',
'../gm/lcdtext.cpp',
+ '../gm/linepaths.cpp',
+ '../gm/movepaths.cpp',
'../gm/ninepatchstretch.cpp',
'../gm/nocolorbleed.cpp',
'../gm/pathfill.cpp',
'../gm/points.cpp',
'../gm/poly2poly.cpp',
+ '../gm/quadpaths.cpp',
'../gm/shadertext.cpp',
'../gm/shadows.cpp',
'../gm/shapes.cpp',
diff --git a/include/core/SkPath.h b/include/core/SkPath.h
index 8eedb46..f0fd5e9 100644
--- a/include/core/SkPath.h
+++ b/include/core/SkPath.h
@@ -180,6 +180,35 @@
*/
bool isEmpty() const;
+ /** Test a line for zero length
+
+ @return true if the line is of zero length; otherwise false.
+ */
+ static bool IsLineDegenerate(const SkPoint& p1, const SkPoint& p2) {
+ return p1.equalsWithinTolerance(p2, SK_ScalarNearlyZero);
+ }
+
+ /** Test a quad for zero length
+
+ @return true if the quad is of zero length; otherwise false.
+ */
+ static bool IsQuadDegenerate(const SkPoint& p1, const SkPoint& p2,
+ const SkPoint& p3) {
+ return p1.equalsWithinTolerance(p2, SK_ScalarNearlyZero) &&
+ p2.equalsWithinTolerance(p3, SK_ScalarNearlyZero);
+ }
+
+ /** Test a cubic curve for zero length
+
+ @return true if the cubic is of zero length; otherwise false.
+ */
+ static bool IsCubicDegenerate(const SkPoint& p1, const SkPoint& p2,
+ const SkPoint& p3, const SkPoint& p4) {
+ return p1.equalsWithinTolerance(p2, SK_ScalarNearlyZero) &&
+ p2.equalsWithinTolerance(p3, SK_ScalarNearlyZero) &&
+ p3.equalsWithinTolerance(p4, SK_ScalarNearlyZero);
+ }
+
/** Returns true if the path specifies a rectangle. If so, and if rect is
not null, set rect to the bounds of the path. If the path does not
specify a rectangle, return false and ignore rect.
@@ -633,11 +662,12 @@
SkPoint fLastPt;
SkBool8 fForceClose;
SkBool8 fNeedClose;
- SkBool8 fNeedMoveTo;
SkBool8 fCloseLine;
+ uint8_t fSegmentState;
bool cons_moveTo(SkPoint pts[1]);
Verb autoClose(SkPoint pts[2]);
+ void consumeDegenerateSegments();
};
void dump(bool forceClose, const char title[] = NULL) const;
diff --git a/include/core/SkPoint.h b/include/core/SkPoint.h
index fedc404..de7c0ef 100644
--- a/include/core/SkPoint.h
+++ b/include/core/SkPoint.h
@@ -315,6 +315,13 @@
return a.fX != b.fX || a.fY != b.fY;
}
+ /** Return true if this and the given point are componentwise within tol.
+ */
+ bool equalsWithinTolerance(const SkPoint& v, SkScalar tol) const {
+ return SkScalarNearlyZero(fX - v.fX, tol)
+ && SkScalarNearlyZero(fY - v.fY, tol);
+ }
+
/** Returns a new point whose coordinates are the difference between
a's and b's (a - b)
*/
diff --git a/src/core/SkPath.cpp b/src/core/SkPath.cpp
index 7256021..07e5476 100644
--- a/src/core/SkPath.cpp
+++ b/src/core/SkPath.cpp
@@ -89,13 +89,14 @@
/*
Stores the verbs and points as they are given to us, with exceptions:
- - we only record "Close" if it was immediately preceeded by Line | Quad | Cubic
+ - we only record "Close" if it was immediately preceeded by Move | Line | Quad | Cubic
- we insert a Move(0,0) if Line | Quad | Cubic is our first command
The iterator does more cleanup, especially if forceClose == true
- 1. if we encounter Close, return a cons'd up Line() first (if the curr-pt != start-pt)
- 2. if we encounter Move without a preceeding Close, and forceClose is true, goto #1
- 3. if we encounter Line | Quad | Cubic after Close, cons up a Move
+ 1. If we encounter degenerate segments, remove them
+ 2. if we encounter Close, return a cons'd up Line() first (if the curr-pt != start-pt)
+ 3. if we encounter Move without a preceeding Close, and forceClose is true, goto #2
+ 4. if we encounter Line | Quad | Cubic after Close, cons up a Move
*/
////////////////////////////////////////////////////////////////////////////
@@ -191,16 +192,15 @@
fPts.rewind();
fVerbs.rewind();
GEN_ID_INC;
- fBoundsIsDirty = true;
fConvexity = kUnknown_Convexity;
+ fBoundsIsDirty = true;
fSegmentMask = 0;
}
bool SkPath::isEmpty() const {
SkDEBUGCODE(this->validate();)
- int count = fVerbs.count();
- return count == 0 || (count == 1 && fVerbs[0] == kMove_Verb);
+ return 0 == fVerbs.count();
}
/*
@@ -385,10 +385,10 @@
//////////////////////////////////////////////////////////////////////////////
// Construction methods
-#define DIRTY_AFTER_EDIT \
- do { \
- fBoundsIsDirty = true; \
- fConvexity = kUnknown_Convexity;\
+#define DIRTY_AFTER_EDIT \
+ do { \
+ fBoundsIsDirty = true; \
+ fConvexity = kUnknown_Convexity; \
} while (0)
void SkPath::incReserve(U16CPU inc) {
@@ -406,12 +406,8 @@
int vc = fVerbs.count();
SkPoint* pt;
- if (vc > 0 && fVerbs[vc - 1] == kMove_Verb) {
- pt = &fPts[fPts.count() - 1];
- } else {
- pt = fPts.append();
- *fVerbs.append() = kMove_Verb;
- }
+ pt = fPts.append();
+ *fVerbs.append() = kMove_Verb;
pt->set(x, y);
GEN_ID_INC;
@@ -505,11 +501,12 @@
case kLine_Verb:
case kQuad_Verb:
case kCubic_Verb:
+ case kMove_Verb:
*fVerbs.append() = kClose_Verb;
GEN_ID_INC;
break;
default:
- // don't add a close if the prev wasn't a primitive
+ // don't add a close if it's the first verb or a repeat
break;
}
}
@@ -1143,17 +1140,20 @@
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
-enum NeedMoveToState {
- kAfterClose_NeedMoveToState,
- kAfterCons_NeedMoveToState,
- kAfterPrefix_NeedMoveToState
+enum SegmentState {
+ kAfterClose_SegmentState, // We will need a move next, but we have a
+ // previous close pt to use for the new move.
+ kAfterMove_SegmentState, // We have seen a move, but nothing else.
+ kAfterPrimitive_SegmentState // We have seen a primitive but not yet
+ // closed the path. Also the initial state.
};
SkPath::Iter::Iter() {
#ifdef SK_DEBUG
fPts = NULL;
fMoveTo.fX = fMoveTo.fY = fLastPt.fX = fLastPt.fY = 0;
- fForceClose = fNeedMoveTo = fCloseLine = false;
+ fForceClose = fCloseLine = false;
+ fSegmentState = kAfterPrimitive_SegmentState;
#endif
// need to init enough to make next() harmlessly return kDone_Verb
fVerbs = NULL;
@@ -1169,9 +1169,10 @@
fPts = path.fPts.begin();
fVerbs = path.fVerbs.begin();
fVerbStop = path.fVerbs.end();
+ fLastPt.fX = fLastPt.fY = 0;
fForceClose = SkToU8(forceClose);
fNeedClose = false;
- fNeedMoveTo = kAfterPrefix_NeedMoveToState;
+ fSegmentState = kAfterPrimitive_SegmentState;
}
bool SkPath::Iter::isClosedContour() const {
@@ -1225,23 +1226,27 @@
}
bool SkPath::Iter::cons_moveTo(SkPoint pts[1]) {
- if (fNeedMoveTo == kAfterClose_NeedMoveToState) {
+ if (fSegmentState == kAfterClose_SegmentState) {
+ // We have closed a curve and have a primitive, so we need a move.
+ // Set the first return pt to the most recent move pt
if (pts) {
*pts = fMoveTo;
}
fNeedClose = fForceClose;
- fNeedMoveTo = kAfterCons_NeedMoveToState;
- fVerbs -= 1;
+ fSegmentState = kAfterMove_SegmentState;
+ fVerbs -= 1; // Step back to see the primitive again
return true;
}
- if (fNeedMoveTo == kAfterCons_NeedMoveToState) {
+ if (fSegmentState == kAfterMove_SegmentState) {
+ // Set the first return pt to the move pt
if (pts) {
*pts = fMoveTo;
}
- fNeedMoveTo = kAfterPrefix_NeedMoveToState;
+ fSegmentState = kAfterPrimitive_SegmentState;
} else {
- SkASSERT(fNeedMoveTo == kAfterPrefix_NeedMoveToState);
+ SkASSERT(fSegmentState == kAfterPrimitive_SegmentState);
+ // Set the first return pt to the last pt of the previous primitive.
if (pts) {
*pts = fPts[-1];
}
@@ -1249,9 +1254,91 @@
return false;
}
+void SkPath::Iter::consumeDegenerateSegments() {
+ // We need to step over anything that will not move the current draw point
+ // forward before the next move is seen
+ const uint8_t* lastMoveVerb = 0;
+ const SkPoint* lastMovePt = 0;
+ SkPoint lastPt = fLastPt;
+ while (fVerbs != fVerbStop) {
+ unsigned verb = *fVerbs;
+ switch (verb) {
+ case kMove_Verb:
+ // Set state for the next method.
+ fSegmentState = kAfterMove_SegmentState;
+ fMoveTo = fPts[0];
+
+ // Keep a record of this most recent move
+ lastMoveVerb = fVerbs;
+ lastMovePt = fPts;
+ lastPt = fPts[0];
+ fVerbs++;
+ fPts++;
+ break;
+
+ case kClose_Verb:
+ // A close when we are in a segment is always valid
+ if (fSegmentState == kAfterPrimitive_SegmentState) {
+ return;
+ }
+ // A close at any other time must be ignored
+ fVerbs++;
+ break;
+
+ case kLine_Verb:
+ if (!IsLineDegenerate(lastPt, fPts[0])) {
+ if (lastMoveVerb) {
+ fVerbs = lastMoveVerb;
+ fPts = lastMovePt;
+ return;
+ }
+ return;
+ }
+ // Ignore this line and continue
+ fVerbs++;
+ fPts++;
+ break;
+
+ case kQuad_Verb:
+ if (!IsQuadDegenerate(lastPt, fPts[0], fPts[1])) {
+ if (lastMoveVerb) {
+ fVerbs = lastMoveVerb;
+ fPts = lastMovePt;
+ return;
+ }
+ return;
+ }
+ // Ignore this line and continue
+ fVerbs++;
+ fPts += 2;
+ break;
+
+ case kCubic_Verb:
+ if (!IsCubicDegenerate(lastPt, fPts[0], fPts[1], fPts[2])) {
+ if (lastMoveVerb) {
+ fVerbs = lastMoveVerb;
+ fPts = lastMovePt;
+ return;
+ }
+ return;
+ }
+ // Ignore this line and continue
+ fVerbs++;
+ fPts += 3;
+ break;
+
+ default:
+ SkASSERT(false && "Should never see kDone_Verb");
+ }
+ }
+}
+
SkPath::Verb SkPath::Iter::next(SkPoint pts[4]) {
+ this->consumeDegenerateSegments();
+
if (fVerbs == fVerbStop) {
- if (fNeedClose) {
+ // Close the curve if requested and if there is some curve to close
+ if (fNeedClose && fSegmentState == kAfterPrimitive_SegmentState) {
if (kLine_Verb == this->autoClose(pts)) {
return kLine_Verb;
}
@@ -1277,12 +1364,11 @@
if (fVerbs == fVerbStop) { // might be a trailing moveto
return kDone_Verb;
}
- fMoveTo = *srcPts;
if (pts) {
pts[0] = *srcPts;
}
srcPts += 1;
- fNeedMoveTo = kAfterCons_NeedMoveToState;
+ fLastPt = fMoveTo;
fNeedClose = fForceClose;
break;
case kLine_Verb:
@@ -1322,8 +1408,9 @@
fVerbs -= 1;
} else {
fNeedClose = false;
+ fSegmentState = kAfterClose_SegmentState;
}
- fNeedMoveTo = kAfterClose_NeedMoveToState;
+ fLastPt = fMoveTo;
break;
}
fPts = srcPts;
diff --git a/src/core/SkStroke.cpp b/src/core/SkStroke.cpp
index 0051b19..fa89ab1 100644
--- a/src/core/SkStroke.cpp
+++ b/src/core/SkStroke.cpp
@@ -18,12 +18,6 @@
return !SkPoint::CanNormalize(v.fX, v.fY);
}
-static inline bool degenerate_line(const SkPoint& a, const SkPoint& b,
- SkScalar tolerance = SK_ScalarNearlyZero) {
- return SkScalarNearlyZero(a.fX - b.fX, tolerance) &&
- SkScalarNearlyZero(a.fY - b.fY, tolerance);
-}
-
static inline bool normals_too_curvy(const SkVector& norm0, SkVector& norm1) {
/* root2/2 is a 45-degree angle
make this constant bigger for more subdivisions (but not >= 1)
@@ -219,7 +213,7 @@
}
void SkPathStroker::lineTo(const SkPoint& currPt) {
- if (degenerate_line(fPrevPt, currPt)) {
+ if (SkPath::IsLineDegenerate(fPrevPt, currPt)) {
return;
}
SkVector normal, unitNormal;
@@ -350,8 +344,8 @@
}
void SkPathStroker::quadTo(const SkPoint& pt1, const SkPoint& pt2) {
- bool degenerateAB = degenerate_line(fPrevPt, pt1);
- bool degenerateBC = degenerate_line(pt1, pt2);
+ bool degenerateAB = SkPath::IsLineDegenerate(fPrevPt, pt1);
+ bool degenerateBC = SkPath::IsLineDegenerate(pt1, pt2);
if (degenerateAB | degenerateBC) {
if (degenerateAB ^ degenerateBC) {
@@ -406,9 +400,9 @@
void SkPathStroker::cubicTo(const SkPoint& pt1, const SkPoint& pt2,
const SkPoint& pt3) {
- bool degenerateAB = degenerate_line(fPrevPt, pt1);
- bool degenerateBC = degenerate_line(pt1, pt2);
- bool degenerateCD = degenerate_line(pt2, pt3);
+ bool degenerateAB = SkPath::IsLineDegenerate(fPrevPt, pt1);
+ bool degenerateBC = SkPath::IsLineDegenerate(pt1, pt2);
+ bool degenerateCD = SkPath::IsLineDegenerate(pt2, pt3);
if (degenerateAB + degenerateBC + degenerateCD >= 2) {
this->lineTo(pt3);
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 5e9a520..53752e1 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -522,6 +522,141 @@
}
}
+static void test_zero_length_paths(skiatest::Reporter* reporter) {
+ SkPath p;
+ SkRect bounds;
+
+ // Lone moveTo case
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ bounds.set(0, 0, 0, 0);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 1 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // MoveTo-MoveTo case
+ p.moveTo(SK_Scalar1*2, SK_Scalar1);
+ bounds.set(1, 1, 2, 1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 2 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-close case
+ p.reset();
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ p.close();
+ bounds.set(0, 0, 0, 0);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 1 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-close-moveTo-close case
+ p.moveTo(SK_Scalar1*2, SK_Scalar1);
+ p.close();
+ bounds.set(1, 1, 2, 1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 2 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-line case
+ p.reset();
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ p.lineTo(SK_Scalar1, SK_Scalar1);
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 2 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-lineTo-moveTo-lineTo case
+ p.moveTo(SK_Scalar1*2, SK_Scalar1);
+ p.lineTo(SK_Scalar1*2, SK_Scalar1);
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1*2, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 4 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-line-close case
+ p.reset();
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ p.lineTo(SK_Scalar1, SK_Scalar1);
+ p.close();
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 2 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-line-close-moveTo-line-close case
+ p.moveTo(SK_Scalar1*2, SK_Scalar1);
+ p.lineTo(SK_Scalar1*2, SK_Scalar1);
+ p.close();
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1*2, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 4 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-quadTo case
+ p.reset();
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ p.quadTo(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1);
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 3 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-quadTo-close case
+ p.close();
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 3 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-quadTo-moveTo-quadTo case
+ p.reset();
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ p.quadTo(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1);
+ p.moveTo(SK_Scalar1*2, SK_Scalar1);
+ p.quadTo(SK_Scalar1*2, SK_Scalar1, SK_Scalar1*2, SK_Scalar1);
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1*2, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 6 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-cubicTo case
+ p.reset();
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ p.cubicTo(SK_Scalar1, SK_Scalar1,
+ SK_Scalar1, SK_Scalar1,
+ SK_Scalar1, SK_Scalar1);
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 4 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-quadTo-close case
+ p.close();
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 4 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+
+ // moveTo-quadTo-moveTo-quadTo case
+ p.reset();
+ p.moveTo(SK_Scalar1, SK_Scalar1);
+ p.cubicTo(SK_Scalar1, SK_Scalar1,
+ SK_Scalar1, SK_Scalar1,
+ SK_Scalar1, SK_Scalar1);
+ p.moveTo(SK_Scalar1*2, SK_Scalar1);
+ p.cubicTo(SK_Scalar1*2, SK_Scalar1,
+ SK_Scalar1*2, SK_Scalar1,
+ SK_Scalar1*2, SK_Scalar1);
+ bounds.set(SK_Scalar1, SK_Scalar1, SK_Scalar1*2, SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ REPORTER_ASSERT(reporter, 8 == p.countPoints());
+ REPORTER_ASSERT(reporter, bounds == p.getBounds());
+}
+
+struct SegmentInfo {
+ SkPath fPath;
+ int fPointCount;
+};
+
#define kCurveSegmentMask (SkPath::kQuad_SegmentMask | SkPath::kCubic_SegmentMask)
void TestPath(skiatest::Reporter* reporter);
@@ -540,6 +675,7 @@
SkRect bounds, bounds2;
REPORTER_ASSERT(reporter, p.isEmpty());
+ REPORTER_ASSERT(reporter, 0 == p.countPoints());
REPORTER_ASSERT(reporter, 0 == p.getSegmentMasks());
REPORTER_ASSERT(reporter, p.isConvex());
REPORTER_ASSERT(reporter, p.getFillType() == SkPath::kWinding_FillType);
@@ -555,18 +691,22 @@
check_convex_bounds(reporter, p, bounds);
// we have quads or cubics
REPORTER_ASSERT(reporter, p.getSegmentMasks() & kCurveSegmentMask);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
p.reset();
REPORTER_ASSERT(reporter, 0 == p.getSegmentMasks());
+ REPORTER_ASSERT(reporter, p.isEmpty());
p.addOval(bounds);
check_convex_bounds(reporter, p, bounds);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
p.reset();
p.addRect(bounds);
check_convex_bounds(reporter, p, bounds);
// we have only lines
REPORTER_ASSERT(reporter, SkPath::kLine_SegmentMask == p.getSegmentMasks());
+ REPORTER_ASSERT(reporter, !p.isEmpty());
REPORTER_ASSERT(reporter, p != p2);
REPORTER_ASSERT(reporter, !(p == p2));
@@ -599,7 +739,9 @@
p.moveTo(SK_Scalar1, 0);
p.getLastPt(&pt);
REPORTER_ASSERT(reporter, pt.fX == SK_Scalar1);
+ REPORTER_ASSERT(reporter, !p.isEmpty());
+ test_zero_length_paths(reporter);
test_convexity(reporter);
test_convexity2(reporter);
test_close(reporter);
@@ -608,12 +750,15 @@
p.moveTo(0, 0);
p.quadTo(100, 100, 200, 200);
REPORTER_ASSERT(reporter, SkPath::kQuad_SegmentMask == p.getSegmentMasks());
+ REPORTER_ASSERT(reporter, !p.isEmpty());
p.cubicTo(100, 100, 200, 200, 300, 300);
REPORTER_ASSERT(reporter, kCurveSegmentMask == p.getSegmentMasks());
+ REPORTER_ASSERT(reporter, !p.isEmpty());
p.reset();
p.moveTo(0, 0);
p.cubicTo(100, 100, 200, 200, 300, 300);
REPORTER_ASSERT(reporter, SkPath::kCubic_SegmentMask == p.getSegmentMasks());
+ REPORTER_ASSERT(reporter, !p.isEmpty());
test_flattening(reporter);
test_transform(reporter);