Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(447)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: gm/convex_all_line_paths.cpp

Issue 1112603002: Add new GM/bench for line-only convex paths (Closed) Base URL: https://skia.googlesource.com/skia.git@master
Patch Set: Fix another SK_ARRAY_COUNT issue Created 5 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | gyp/gmslides.gypi » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: gm/convex_all_line_paths.cpp
diff --git a/gm/convex_all_line_paths.cpp b/gm/convex_all_line_paths.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d56325b7dba6c0f9eb115c0f1cca3cd3ee541e05
--- /dev/null
+++ b/gm/convex_all_line_paths.cpp
@@ -0,0 +1,321 @@
+/*
+ * Copyright 2015 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"
+
+static void create_ngon(int n, SkPoint* pts, SkScalar width, SkScalar height) {
+ float angleStep = 360.0f / n, angle = 0.0f, sin, cos;
+ if ((n % 2) == 1) {
+ angle = angleStep/2.0f;
+ }
+
+ for (int i = 0; i < n; ++i) {
+ sin = SkScalarSinCos(SkDegreesToRadians(angle), &cos);
+ pts[i].fX = -sin * width;
+ pts[i].fY = cos * height;
+ angle += angleStep;
+ }
+}
+
+namespace skiagm {
+
+// This GM is intended to exercise Ganesh's handling of convex line-only
+// paths
+class ConvexLineOnlyPathsGM : public GM {
+public:
+ ConvexLineOnlyPathsGM() {
+ fOffset.set(0, SkScalarHalf(kMaxPathHeight));
+ this->setBGColor(0xFFFFFFFF);
+ }
+
+protected:
+ SkString onShortName() override { return SkString("convex-lineonly-paths"); }
+ SkISize onISize() override { return SkISize::Make(kGMWidth, kGMHeight); }
+ bool runAsBench() const override { return true; }
+
+ static SkPath GetPath(int index, int offset, SkPath::Direction dir) {
+ // narrow rect
+ const SkPoint gPoints0[] = {
+ { -1.5f, -50.0f },
+ { 1.5f, -50.0f },
+ { 1.5f, 50.0f },
+ { -1.5f, 50.0f }
+ };
+ // narrow rect on an angle
+ const SkPoint gPoints1[] = {
+ { -50.0f, -49.0f },
+ { -49.0f, -50.0f },
+ { 50.0f, 49.0f },
+ { 49.0f, 50.0f }
+ };
+ // trap - narrow on top - wide on bottom
+ const SkPoint gPoints2[] = {
+ { -10.0f, -50.0f },
+ { 10.0f, -50.0f },
+ { 50.0f, 50.0f },
+ { -50.0f, 50.0f }
+ };
+ // wide skewed rect
+ const SkPoint gPoints3[] = {
+ { -50.0f, -50.0f },
+ { 0.0f, -50.0f },
+ { 50.0f, 50.0f },
+ { 0.0f, 50.0f }
+ };
+ // thin rect with colinear-ish lines
+ const SkPoint gPoints4[] = {
+ { -6.0f, -50.0f },
+ { 4.0f, -50.0f },
+ { 5.0f, -25.0f },
+ { 6.0f, 0.0f },
+ { 5.0f, 25.0f },
+ { 4.0f, 50.0f },
+ { -4.0f, 50.0f }
+ };
+ // degenerate
+ const SkPoint gPoints5[] = {
+ { -0.025f, -0.025f },
+ { 0.025f, -0.025f },
+ { 0.025f, 0.025f },
+ { -0.025f, 0.025f }
+ };
+ // Triangle in which the first point should fuse with last
+ const SkPoint gPoints6[] = {
+ { -20.0f, -13.0f },
+ { -20.0f, -13.05f },
+ { 20.0f, -13.0f },
+ { 20.0f, 27.0f }
+ };
+ // thin rect with colinear lines
+ const SkPoint gPoints7[] = {
+ { -10.0f, -50.0f },
+ { 10.0f, -50.0f },
+ { 10.0f, -25.0f },
+ { 10.0f, 0.0f },
+ { 10.0f, 25.0f },
+ { 10.0f, 50.0f },
+ { -10.0f, 50.0f }
+ };
+ // capped teardrop
+ const SkPoint gPoints8[] = {
+ { 50.00f, 50.00f },
+ { 0.00f, 50.00f },
+ { -15.45f, 47.55f },
+ { -29.39f, 40.45f },
+ { -40.45f, 29.39f },
+ { -47.55f, 15.45f },
+ { -50.00f, 0.00f },
+ { -47.55f, -15.45f },
+ { -40.45f, -29.39f },
+ { -29.39f, -40.45f },
+ { -15.45f, -47.55f },
+ { 0.00f, -50.00f },
+ { 50.00f, -50.00f }
+ };
+ // teardrop
+ const SkPoint gPoints9[] = {
+ { 4.39f, 40.45f },
+ { -9.55f, 47.55f },
+ { -25.00f, 50.00f },
+ { -40.45f, 47.55f },
+ { -54.39f, 40.45f },
+ { -65.45f, 29.39f },
+ { -72.55f, 15.45f },
+ { -75.00f, 0.00f },
+ { -72.55f, -15.45f },
+ { -65.45f, -29.39f },
+ { -54.39f, -40.45f },
+ { -40.45f, -47.55f },
+ { -25.0f, -50.0f },
+ { -9.55f, -47.55f },
+ { 4.39f, -40.45f },
+ { 75.00f, 0.00f }
+ };
+ // clipped triangle
+ const SkPoint gPoints10[] = {
+ { -10.0f, -50.0f },
+ { 10.0f, -50.0f },
+ { 50.0f, 31.0f },
+ { 40.0f, 50.0f },
+ { -40.0f, 50.0f },
+ { -50.0f, 31.0f },
+ };
+
+ const SkPoint* gPoints[] = {
+ gPoints0, gPoints1, gPoints2, gPoints3, gPoints4, gPoints5, gPoints6,
+ gPoints7, gPoints8, gPoints9, gPoints10,
+ };
+
+ const size_t gSizes[] = {
+ SK_ARRAY_COUNT(gPoints0),
+ SK_ARRAY_COUNT(gPoints1),
+ SK_ARRAY_COUNT(gPoints2),
+ SK_ARRAY_COUNT(gPoints3),
+ SK_ARRAY_COUNT(gPoints4),
+ SK_ARRAY_COUNT(gPoints5),
+ SK_ARRAY_COUNT(gPoints6),
+ SK_ARRAY_COUNT(gPoints7),
+ SK_ARRAY_COUNT(gPoints8),
+ SK_ARRAY_COUNT(gPoints9),
+ SK_ARRAY_COUNT(gPoints10),
+ };
+ SK_COMPILE_ASSERT(SK_ARRAY_COUNT(gSizes) == SK_ARRAY_COUNT(gPoints), array_mismatch);
+
+ SkAutoTDelete<SkPoint> data;
+ const SkPoint* points;
+ int numPts;
+ if (index < (int) SK_ARRAY_COUNT(gPoints)) {
+ // manually specified
+ points = gPoints[index];
+ numPts = (int) gSizes[index];
+ } else {
+ // procedurally generated
+ SkScalar width = kMaxPathHeight/2;
+ SkScalar height = kMaxPathHeight/2;
+ switch (index-SK_ARRAY_COUNT(gPoints)) {
+ case 0:
+ numPts = 3;
+ break;
+ case 1:
+ numPts = 4;
+ break;
+ case 2:
+ numPts = 5;
+ break;
+ case 3: // squashed pentagon
+ numPts = 5;
+ width = kMaxPathHeight/5;
+ break;
+ case 4:
+ numPts = 6;
+ break;
+ case 5:
+ numPts = 8;
+ break;
+ case 6: // squashed octogon
+ numPts = 8;
+ width = kMaxPathHeight/5;
+ break;
+ case 7:
+ numPts = 20;
+ break;
+ case 8:
+ numPts = 100;
+ break;
+ default:
+ numPts = 3;
+ break;
+ }
+
+ data.reset(SkNEW_ARRAY(SkPoint, numPts));
+
+ create_ngon(numPts, data.get(), width, height);
+ points = data.get();
+ }
+
+ SkPath path;
+
+ if (SkPath::kCW_Direction == dir) {
+ path.moveTo(points[0]);
+ for (int i = 1; i < numPts; ++i) {
+ path.lineTo(points[i]);
+ }
+ } else {
+ path.moveTo(points[numPts-1]);
+ for (int i = numPts-2; i >= 0; --i) {
+ path.lineTo(points[i]);
+ }
+ }
+
+ path.close();
+#ifdef SK_DEBUG
+ // Each path this method returns should be convex, only composed of
+ // lines, wound the right direction, and short enough to fit in one
+ // of the GMs rows.
+ SkASSERT(path.isConvex());
+ SkASSERT(SkPath::kLine_SegmentMask == path.getSegmentMasks());
+ SkPath::Direction actualDir;
+ SkASSERT(path.cheapComputeDirection(&actualDir));
+ SkASSERT(dir == actualDir);
+ SkRect bounds = path.getBounds();
+ SkASSERT(SkScalarNearlyEqual(bounds.centerX(), 0.0f));
+ SkASSERT(bounds.height() <= kMaxPathHeight);
+#endif
+ return path;
+ }
+
+ // Draw a single path several times, shrinking it, flipping its direction
+ // and changing its start vertex each time.
+ void drawPath(SkCanvas* canvas, int index) {
+
+ SkPoint center;
+ {
+ SkPath path = GetPath(index, 0, SkPath::kCW_Direction);
+ if (fOffset.fX+path.getBounds().width() > kGMWidth) {
+ fOffset.fX = 0;
+ fOffset.fY += kMaxPathHeight;
+ }
+ center = { fOffset.fX + SkScalarHalf(path.getBounds().width()), fOffset.fY};
+ fOffset.fX += path.getBounds().width();
+ }
+
+ const SkColor colors[2] = { SK_ColorBLACK, SK_ColorWHITE };
+ const SkPath::Direction dirs[2] = { SkPath::kCW_Direction, SkPath::kCCW_Direction };
+ const float scales[] = { 1.0f, 0.75f, 0.5f, 0.25f, 0.1f, 0.01f, 0.001f };
+
+ SkPaint paint;
+ paint.setAntiAlias(true);
+
+ for (size_t i = 0; i < SK_ARRAY_COUNT(scales); ++i) {
+ SkPath path = GetPath(index, (int) i, dirs[i%2]);
+
+ canvas->save();
+ canvas->translate(center.fX, center.fY);
+ canvas->scale(scales[i], scales[i]);
+ paint.setColor(colors[i%2]);
+ canvas->drawPath(path, paint);
+ canvas->restore();
+ }
+ }
+
+ void onDraw(SkCanvas* canvas) override {
+ for (int i = 0; i < kNumPaths; ++i) {
+ this->drawPath(canvas, i);
+ }
+
+ // Repro for crbug.com/472723 (Missing AA on portions of graphic with GPU rasterization)
+ {
+ canvas->translate(356.0f, 50.0f);
+
+ SkPaint p;
+ p.setAntiAlias(true);
+
+ SkPath p1;
+ p1.moveTo(60.8522949f, 364.671021f);
+ p1.lineTo(59.4380493f, 364.671021f);
+ p1.lineTo(385.414276f, 690.647217f);
+ p1.lineTo(386.121399f, 689.940125f);
+ canvas->drawPath(p1, p);
+ }
+ }
+
+private:
+ static const int kNumPaths = 20;
+ static const int kMaxPathHeight = 100;
+ static const int kGMWidth = 512;
+ static const int kGMHeight = 512;
+
+ SkPoint fOffset; // the right edge of the last drawn path
+
+ typedef GM INHERITED;
+};
+
+//////////////////////////////////////////////////////////////////////////////
+
+DEF_GM( return SkNEW(ConvexLineOnlyPathsGM); )
+
+}
« no previous file with comments | « no previous file | gyp/gmslides.gypi » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698