gm/aaclip.cpp - platform/external/skia - Gitiles

 /*
  * 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 "SkPath.h"

 static void test_quadstroke(SkCanvas* canvas) {
     SkPath path;
     path.moveTo(6, 0);
     path.quadTo(150, 150, 0, 6);

     SkPaint paint;

     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kStroke_Style);
     canvas->translate(20, 20);

 #if 1
     canvas->drawPath(path, paint);
     canvas->translate(100, 0);
 #endif

     paint.setStrokeWidth(1.01f);
     canvas->drawPath(path, paint);
 }

 static void draw_conic(SkCanvas* canvas, SkScalar weight, const SkPaint& paint) {
     SkPath path;
     path.moveTo(100, 100);
     path.conicTo(300, 100, 300, 300, weight);
     canvas->drawPath(path, paint);
 }

 static void test_conic(SkCanvas* canvas) {
     SkPaint paint;
     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kStroke_Style);

     static const struct {
         SkScalar fWeight;
         SkColor  fColor;
     } gRec[] = {
         { 2   , SK_ColorRED },
         { 1   , SK_ColorGREEN },
         { 0.5f, SK_ColorBLUE },
     };

     for (SkScalar width = 0; width <= 20; width += 20) {
         canvas->save();
         paint.setStrokeWidth(width);
         for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
             paint.setColor(gRec[i].fColor);
             draw_conic(canvas, gRec[i].fWeight, paint);
             canvas->translate(-30, 30);
         }
         canvas->restore();
         canvas->translate(300, 0);
     }
 }

 #include "SkGradientShader.h"
 static void test_shallow_gradient(SkCanvas* canvas, SkScalar width, SkScalar height) {
     SkColor colors[] = { 0xFF7F7F7F, 0xFF7F7F7F, 0xFF000000 };
     SkScalar pos[] = { 0, 0.35f, SK_Scalar1 };
     SkPoint pts[] = { { 0, 0 }, { width, height } };
     SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos,
                                                  SK_ARRAY_COUNT(colors),
                                                  SkShader::kClamp_TileMode);
     SkPaint paint;
     paint.setShader(s)->unref();
     canvas->drawPaint(paint);
 }

 #include "SkDashPathEffect.h"
 static void test_giant_dash(SkCanvas* canvas) {
     SkPaint paint;
     const SkScalar intervals[] = { SK_Scalar1, SK_Scalar1 };

     paint.setStrokeWidth(2);
     paint.setPathEffect(new SkDashPathEffect(intervals, 2, 0))->unref();

     SkScalar big = 500 * 1000;

     canvas->drawLine(10, 10, big, 10, paint);
     canvas->drawLine(-big, 20, 500, 20, paint);
     canvas->drawLine(-big, 30, big, 30, paint);

     const SkScalar intervals2[] = { 20, 5, 10, 5 };
     paint.setPathEffect(new SkDashPathEffect(intervals2, 4, 17))->unref();

     canvas->translate(0, 40);
     SkScalar x = -500;
     SkScalar width = 3173;
     for (int i = 0; i < 40; ++i) {
         if (i > 10)
         canvas->drawLine(x, 0, x + width, 0, paint);
         x += 1;
         canvas->translate(0, 4);
     }
 }


 // Reproduces bug found here: http://jsfiddle.net/R8Cu5/1/
 //
 #include "SkGradientShader.h"
 static void test_grad(SkCanvas* canvas) {
     SkPoint pts[] = {
         { 478.544067f, -84.2041016f },
         { 602.455933f, 625.204102f },
     };
     SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, SK_ColorRED, SK_ColorRED };
     SkScalar pos[] = { 0, 0.3f, 0.3f, 1.0f };
     SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode);
     SkPaint p;
     p.setShader(s)->unref();
     canvas->drawPaint(p);
 }

 static SkCanvas* MakeCanvas(const SkIRect& bounds) {
     SkBitmap bm;
     bm.allocN32Pixels(bounds.width(), bounds.height());
     bm.eraseColor(SK_ColorTRANSPARENT);

     SkCanvas* canvas = new SkCanvas(bm);
     canvas->translate(-SkIntToScalar(bounds.fLeft), -SkIntToScalar(bounds.fTop));
     return canvas;
 }

 #ifdef SK_DEBUG
 static void GetBitmap(const SkCanvas* canvas, SkBitmap* bm) {
     *bm = canvas->getDevice()->accessBitmap(false);
 }
 #endif

 static void compare_canvas(const SkCanvas* a, const SkCanvas* b) {
 #ifdef SK_DEBUG
     SkBitmap bma, bmb;
     GetBitmap(a, &bma);
     GetBitmap(b, &bmb);

     SkASSERT(bma.width() == bmb.width());
     SkASSERT(bma.height() == bmb.height());

     bma.lockPixels();
     bmb.lockPixels();
     for (int y = 0; y < bma.height(); ++y) {
         const SkPMColor* rowa = bma.getAddr32(0, y);
         const SkPMColor* rowb = bmb.getAddr32(0, y);
         SkASSERT(!memcmp(rowa, rowb, bma.width() << 2));

         for (int x = 1; x < bma.width() - 1; ++x) {
             SkASSERT(0xFF000000 == rowa[x]);
             SkASSERT(0xFF000000 == rowb[x]);
         }
     }
 #endif
 }

 static void drawRectAsPath(SkCanvas* canvas, const SkRect& r, const SkPaint& p) {
     SkPath path;
     path.addRect(r);
     canvas->drawPath(path, p);
 }

 static void test_maskFromPath(const SkPath& path) {
     SkIRect bounds;
     path.getBounds().roundOut(&bounds);

     SkPaint paint;
     paint.setAntiAlias(true);

     SkAutoTUnref<SkCanvas> path_canvas(MakeCanvas(bounds));
     path_canvas->drawPath(path, paint);

     SkAutoTUnref<SkCanvas> rect_canvas(MakeCanvas(bounds));
     drawRectAsPath(rect_canvas, path.getBounds(), paint);

     compare_canvas(path_canvas, rect_canvas);
 }

 static void test_mask() {
     for (int i = 1; i <= 20; ++i) {
         const SkScalar dx = SK_Scalar1 / i;
         const SkRect constr = SkRect::MakeWH(dx, SkIntToScalar(2));
         for (int n = 2; n < 20; ++n) {
             SkPath path;
             path.setFillType(SkPath::kEvenOdd_FillType);
             SkRect r = constr;
             while (r.fRight < SkIntToScalar(4)) {
                 path.addRect(r);
                 r.offset(dx, 0);
             }
             test_maskFromPath(path);
         }
     }
 }

 /** Draw a 2px border around the target, then red behind the target;
     set the clip to match the target, then draw >> the target in blue.
 */

 static void draw (SkCanvas* canvas, SkRect& target, int x, int y) {
     SkPaint borderPaint;
     borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0));
     borderPaint.setAntiAlias(true);
     SkPaint backgroundPaint;
     backgroundPaint.setColor(SkColorSetRGB(0xDD, 0x0, 0x0));
     backgroundPaint.setAntiAlias(true);
     SkPaint foregroundPaint;
     foregroundPaint.setColor(SkColorSetRGB(0x0, 0x0, 0xDD));
     foregroundPaint.setAntiAlias(true);

     canvas->save();
     canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
     target.inset(SkIntToScalar(-2), SkIntToScalar(-2));
     canvas->drawRect(target, borderPaint);
     target.inset(SkIntToScalar(2), SkIntToScalar(2));
     canvas->drawRect(target, backgroundPaint);
     canvas->clipRect(target, SkRegion::kIntersect_Op, true);
     target.inset(SkIntToScalar(-4), SkIntToScalar(-4));
     canvas->drawRect(target, foregroundPaint);
     canvas->restore();
 }

 static void draw_square (SkCanvas* canvas, int x, int y) {
     SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 10 * SK_Scalar1));
     draw(canvas, target, x, y);
 }

 static void draw_column (SkCanvas* canvas, int x, int y) {
     SkRect target (SkRect::MakeWH(1 * SK_Scalar1, 10 * SK_Scalar1));
     draw(canvas, target, x, y);
 }

 static void draw_bar (SkCanvas* canvas, int x, int y) {
     SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 1 * SK_Scalar1));
     draw(canvas, target, x, y);
 }

 static void draw_rect_tests (SkCanvas* canvas) {
     draw_square(canvas, 10, 10);
     draw_column(canvas, 30, 10);
     draw_bar(canvas, 10, 30);
 }

 /**
    Test a set of clipping problems discovered while writing blitAntiRect,
    and test all the code paths through the clipping blitters.
    Each region should show as a blue center surrounded by a 2px green
    border, with no red.
 */

 class AAClipGM : public skiagm::GM {
 public:
     AAClipGM() {

     }

 protected:
     virtual SkString onShortName() SK_OVERRIDE {
         return SkString("aaclip");
     }

     virtual SkISize onISize() SK_OVERRIDE {
         return SkISize::Make(640, 480);
     }

     virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
         if (false) { test_quadstroke(canvas); return; }
         if (false) { test_conic(canvas); return; }
         if (false) {
             SkRect bounds;
             canvas->getClipBounds(&bounds);
             test_shallow_gradient(canvas, bounds.width(), bounds.height()); return;
         }
         if (false) {
             test_giant_dash(canvas); return;
         }
         if (false) {
             test_grad(canvas); return;
         }
         if (false) { // avoid bit rot, suppress warning
             test_mask();
         }

         // Initial pixel-boundary-aligned draw
         draw_rect_tests(canvas);

         // Repeat 4x with .2, .4, .6, .8 px offsets
         canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
         canvas->translate(SkIntToScalar(50), 0);
         draw_rect_tests(canvas);

         canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
         canvas->translate(SkIntToScalar(50), 0);
         draw_rect_tests(canvas);

         canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
         canvas->translate(SkIntToScalar(50), 0);
         draw_rect_tests(canvas);

         canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
         canvas->translate(SkIntToScalar(50), 0);
         draw_rect_tests(canvas);
     }

     virtual uint32_t onGetFlags() const { return kSkipPipe_Flag; }

 private:
     typedef skiagm::GM INHERITED;
 };

 DEF_GM( return SkNEW(AAClipGM); )
	/*
	* 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 "SkPath.h"

	static void test_quadstroke(SkCanvas* canvas) {
	SkPath path;
	path.moveTo(6, 0);
	path.quadTo(150, 150, 0, 6);

	SkPaint paint;

	paint.setAntiAlias(true);
	paint.setStyle(SkPaint::kStroke_Style);
	canvas->translate(20, 20);

	#if 1
	canvas->drawPath(path, paint);
	canvas->translate(100, 0);
	#endif

	paint.setStrokeWidth(1.01f);
	canvas->drawPath(path, paint);
	}

	static void draw_conic(SkCanvas* canvas, SkScalar weight, const SkPaint& paint) {
	SkPath path;
	path.moveTo(100, 100);
	path.conicTo(300, 100, 300, 300, weight);
	canvas->drawPath(path, paint);
	}

	static void test_conic(SkCanvas* canvas) {
	SkPaint paint;
	paint.setAntiAlias(true);
	paint.setStyle(SkPaint::kStroke_Style);

	static const struct {
	SkScalar fWeight;
	SkColor fColor;
	} gRec[] = {
	{ 2 , SK_ColorRED },
	{ 1 , SK_ColorGREEN },
	{ 0.5f, SK_ColorBLUE },
	};

	for (SkScalar width = 0; width <= 20; width += 20) {
	canvas->save();
	paint.setStrokeWidth(width);
	for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
	paint.setColor(gRec[i].fColor);
	draw_conic(canvas, gRec[i].fWeight, paint);
	canvas->translate(-30, 30);
	}
	canvas->restore();
	canvas->translate(300, 0);
	}
	}

	#include "SkGradientShader.h"
	static void test_shallow_gradient(SkCanvas* canvas, SkScalar width, SkScalar height) {
	SkColor colors[] = { 0xFF7F7F7F, 0xFF7F7F7F, 0xFF000000 };
	SkScalar pos[] = { 0, 0.35f, SK_Scalar1 };
	SkPoint pts[] = { { 0, 0 }, { width, height } };
	SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos,
	SK_ARRAY_COUNT(colors),
	SkShader::kClamp_TileMode);
	SkPaint paint;
	paint.setShader(s)->unref();
	canvas->drawPaint(paint);
	}

	#include "SkDashPathEffect.h"
	static void test_giant_dash(SkCanvas* canvas) {
	SkPaint paint;
	const SkScalar intervals[] = { SK_Scalar1, SK_Scalar1 };

	paint.setStrokeWidth(2);
	paint.setPathEffect(new SkDashPathEffect(intervals, 2, 0))->unref();

	SkScalar big = 500 * 1000;

	canvas->drawLine(10, 10, big, 10, paint);
	canvas->drawLine(-big, 20, 500, 20, paint);
	canvas->drawLine(-big, 30, big, 30, paint);

	const SkScalar intervals2[] = { 20, 5, 10, 5 };
	paint.setPathEffect(new SkDashPathEffect(intervals2, 4, 17))->unref();

	canvas->translate(0, 40);
	SkScalar x = -500;
	SkScalar width = 3173;
	for (int i = 0; i < 40; ++i) {
	if (i > 10)
	canvas->drawLine(x, 0, x + width, 0, paint);
	x += 1;
	canvas->translate(0, 4);
	}
	}



	// Reproduces bug found here: http://jsfiddle.net/R8Cu5/1/
	//
	#include "SkGradientShader.h"
	static void test_grad(SkCanvas* canvas) {
	SkPoint pts[] = {
	{ 478.544067f, -84.2041016f },
	{ 602.455933f, 625.204102f },
	};
	SkColor colors[] = { SK_ColorBLACK, SK_ColorBLACK, SK_ColorRED, SK_ColorRED };
	SkScalar pos[] = { 0, 0.3f, 0.3f, 1.0f };
	SkShader* s = SkGradientShader::CreateLinear(pts, colors, pos, 4, SkShader::kClamp_TileMode);
	SkPaint p;
	p.setShader(s)->unref();
	canvas->drawPaint(p);
	}

	static SkCanvas* MakeCanvas(const SkIRect& bounds) {
	SkBitmap bm;
	bm.allocN32Pixels(bounds.width(), bounds.height());
	bm.eraseColor(SK_ColorTRANSPARENT);

	SkCanvas* canvas = new SkCanvas(bm);
	canvas->translate(-SkIntToScalar(bounds.fLeft), -SkIntToScalar(bounds.fTop));
	return canvas;
	}

	#ifdef SK_DEBUG
	static void GetBitmap(const SkCanvas* canvas, SkBitmap* bm) {
	*bm = canvas->getDevice()->accessBitmap(false);
	}
	#endif

	static void compare_canvas(const SkCanvas* a, const SkCanvas* b) {
	#ifdef SK_DEBUG
	SkBitmap bma, bmb;
	GetBitmap(a, &bma);
	GetBitmap(b, &bmb);

	SkASSERT(bma.width() == bmb.width());
	SkASSERT(bma.height() == bmb.height());

	bma.lockPixels();
	bmb.lockPixels();
	for (int y = 0; y < bma.height(); ++y) {
	const SkPMColor* rowa = bma.getAddr32(0, y);
	const SkPMColor* rowb = bmb.getAddr32(0, y);
	SkASSERT(!memcmp(rowa, rowb, bma.width() << 2));

	for (int x = 1; x < bma.width() - 1; ++x) {
	SkASSERT(0xFF000000 == rowa[x]);
	SkASSERT(0xFF000000 == rowb[x]);
	}
	}
	#endif
	}

	static void drawRectAsPath(SkCanvas* canvas, const SkRect& r, const SkPaint& p) {
	SkPath path;
	path.addRect(r);
	canvas->drawPath(path, p);
	}

	static void test_maskFromPath(const SkPath& path) {
	SkIRect bounds;
	path.getBounds().roundOut(&bounds);

	SkPaint paint;
	paint.setAntiAlias(true);

	SkAutoTUnref<SkCanvas> path_canvas(MakeCanvas(bounds));
	path_canvas->drawPath(path, paint);

	SkAutoTUnref<SkCanvas> rect_canvas(MakeCanvas(bounds));
	drawRectAsPath(rect_canvas, path.getBounds(), paint);

	compare_canvas(path_canvas, rect_canvas);
	}

	static void test_mask() {
	for (int i = 1; i <= 20; ++i) {
	const SkScalar dx = SK_Scalar1 / i;
	const SkRect constr = SkRect::MakeWH(dx, SkIntToScalar(2));
	for (int n = 2; n < 20; ++n) {
	SkPath path;
	path.setFillType(SkPath::kEvenOdd_FillType);
	SkRect r = constr;
	while (r.fRight < SkIntToScalar(4)) {
	path.addRect(r);
	r.offset(dx, 0);
	}
	test_maskFromPath(path);
	}
	}
	}

	/** Draw a 2px border around the target, then red behind the target;
	set the clip to match the target, then draw >> the target in blue.
	*/

	static void draw (SkCanvas* canvas, SkRect& target, int x, int y) {
	SkPaint borderPaint;
	borderPaint.setColor(SkColorSetRGB(0x0, 0xDD, 0x0));
	borderPaint.setAntiAlias(true);
	SkPaint backgroundPaint;
	backgroundPaint.setColor(SkColorSetRGB(0xDD, 0x0, 0x0));
	backgroundPaint.setAntiAlias(true);
	SkPaint foregroundPaint;
	foregroundPaint.setColor(SkColorSetRGB(0x0, 0x0, 0xDD));
	foregroundPaint.setAntiAlias(true);

	canvas->save();
	canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
	target.inset(SkIntToScalar(-2), SkIntToScalar(-2));
	canvas->drawRect(target, borderPaint);
	target.inset(SkIntToScalar(2), SkIntToScalar(2));
	canvas->drawRect(target, backgroundPaint);
	canvas->clipRect(target, SkRegion::kIntersect_Op, true);
	target.inset(SkIntToScalar(-4), SkIntToScalar(-4));
	canvas->drawRect(target, foregroundPaint);
	canvas->restore();
	}

	static void draw_square (SkCanvas* canvas, int x, int y) {
	SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 10 * SK_Scalar1));
	draw(canvas, target, x, y);
	}

	static void draw_column (SkCanvas* canvas, int x, int y) {
	SkRect target (SkRect::MakeWH(1 * SK_Scalar1, 10 * SK_Scalar1));
	draw(canvas, target, x, y);
	}

	static void draw_bar (SkCanvas* canvas, int x, int y) {
	SkRect target (SkRect::MakeWH(10 * SK_Scalar1, 1 * SK_Scalar1));
	draw(canvas, target, x, y);
	}

	static void draw_rect_tests (SkCanvas* canvas) {
	draw_square(canvas, 10, 10);
	draw_column(canvas, 30, 10);
	draw_bar(canvas, 10, 30);
	}

	/**
	Test a set of clipping problems discovered while writing blitAntiRect,
	and test all the code paths through the clipping blitters.
	Each region should show as a blue center surrounded by a 2px green
	border, with no red.
	*/

	class AAClipGM : public skiagm::GM {
	public:
	AAClipGM() {

	}

	protected:
	virtual SkString onShortName() SK_OVERRIDE {
	return SkString("aaclip");
	}

	virtual SkISize onISize() SK_OVERRIDE {
	return SkISize::Make(640, 480);
	}

	virtual void onDraw(SkCanvas* canvas) SK_OVERRIDE {
	if (false) { test_quadstroke(canvas); return; }
	if (false) { test_conic(canvas); return; }
	if (false) {
	SkRect bounds;
	canvas->getClipBounds(&bounds);
	test_shallow_gradient(canvas, bounds.width(), bounds.height()); return;
	}
	if (false) {
	test_giant_dash(canvas); return;
	}
	if (false) {
	test_grad(canvas); return;
	}
	if (false) { // avoid bit rot, suppress warning
	test_mask();
	}

	// Initial pixel-boundary-aligned draw
	draw_rect_tests(canvas);

	// Repeat 4x with .2, .4, .6, .8 px offsets
	canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
	canvas->translate(SkIntToScalar(50), 0);
	draw_rect_tests(canvas);

	canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
	canvas->translate(SkIntToScalar(50), 0);
	draw_rect_tests(canvas);

	canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
	canvas->translate(SkIntToScalar(50), 0);
	draw_rect_tests(canvas);

	canvas->translate(SK_Scalar1 / 5, SK_Scalar1 / 5);
	canvas->translate(SkIntToScalar(50), 0);
	draw_rect_tests(canvas);
	}

	virtual uint32_t onGetFlags() const { return kSkipPipe_Flag; }

	private:
	typedef skiagm::GM INHERITED;
	};

	DEF_GM( return SkNEW(AAClipGM); )