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

 /*
  * Copyright 2017 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 "SkAutoPixmapStorage.h"
 #include "SkColorPriv.h"
 #include "SkImage.h"
 #include "SkPath.h"
 #include "SkSurface.h"

 namespace skiagm {

 skiagm::DrawResult draw_diff(SkCanvas* canvas, SkImage* imgA, SkImage* imgB, SkString* errorMsg) {
     SkASSERT(imgA->dimensions() == imgB->dimensions());

     int w = imgA->width(), h = imgA->height();

     // First, draw the two images faintly overlaid
     SkPaint paint;
     paint.setAlpha(64);
     paint.setBlendMode(SkBlendMode::kPlus);
     canvas->drawImage(imgA, 0, 0, &paint);
     canvas->drawImage(imgB, 0, 0, &paint);

     // Next, read the pixels back, figure out if there are any differences
     SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
     SkAutoPixmapStorage pmapA;
     SkAutoPixmapStorage pmapB;
     pmapA.alloc(info);
     pmapB.alloc(info);
     if (!imgA->readPixels(pmapA, 0, 0) || !imgB->readPixels(pmapB, 0, 0)) {
         *errorMsg = "Failed to read pixels.";
         return skiagm::DrawResult::kFail;
     }

     int maxDiffX = 0, maxDiffY = 0, maxDiff = 0;
     SkBitmap highlight;
     highlight.allocN32Pixels(w, h);
     highlight.eraseColor(SK_ColorTRANSPARENT);

     for (int y = 0; y < h; ++y) {
         for (int x = 0; x < w; ++x) {
             uint32_t pixelA = *pmapA.addr32(x, y);
             uint32_t pixelB = *pmapB.addr32(x, y);
             if (pixelA != pixelB) {
                 int diff =
                     SkTAbs((int)(SkColorGetR(pixelA) - SkColorGetR(pixelB))) +
                     SkTAbs((int)(SkColorGetG(pixelA) - SkColorGetG(pixelB))) +
                     SkTAbs((int)(SkColorGetB(pixelA) - SkColorGetB(pixelB))) +
                     SkTAbs((int)(SkColorGetA(pixelA) - SkColorGetA(pixelB)));
                 if (diff > maxDiff) {
                     maxDiffX = x;
                     maxDiffY = y;
                     maxDiff = diff;
                 }
                 *highlight.getAddr32(x, y) = SkPackARGB32(0xA0, 0xA0, 0x00, 0x00);
             }
         }
     }

     SkPaint outline;
     outline.setStyle(SkPaint::kStroke_Style);
     outline.setColor(maxDiff == 0 ? 0xFF007F00 : 0xFF7F0000);

     if (maxDiff > 0) {
         // Call extra attention to the region we're going to zoom
         SkPMColor yellow = SkPackARGB32(0xFF, 0xFF, 0xFF, 0x00);
         *highlight.getAddr32(maxDiffX, maxDiffY) = yellow;
         *highlight.getAddr32(SkTMax(maxDiffX - 1, 0), maxDiffY) = yellow;
         *highlight.getAddr32(maxDiffX, SkTMax(maxDiffY - 1, 0)) = yellow;
         *highlight.getAddr32(SkTMin(maxDiffX + 1, w - 1), maxDiffY) = yellow;
         *highlight.getAddr32(maxDiffX, SkTMin(maxDiffY + 1, h - 1)) = yellow;

         // Draw the overlay
         canvas->drawBitmap(highlight, 0, 0);

         // Draw zoom of largest pixel diff
         SkBitmap bmpA, bmpB;
         SkAssertResult(bmpA.installPixels(pmapA));
         SkAssertResult(bmpB.installPixels(pmapB));
         canvas->drawBitmapRect(bmpA, SkRect::MakeXYWH(maxDiffX - 5, maxDiffY - 5, 10, 10),
                                SkRect::MakeXYWH(w, 0, w, h), nullptr);
         canvas->drawBitmapRect(bmpB, SkRect::MakeXYWH(maxDiffX - 5, maxDiffY - 5, 10, 10),
                                SkRect::MakeXYWH(2 * w, 0, w, h), nullptr);

         // Add lines to separate zoom boxes
         canvas->drawLine(w, 0, w, h, outline);
         canvas->drawLine(2 * w, 0, 2 * w, h, outline);
     }

     // Draw outline of whole test region
     canvas->drawRect(SkRect::MakeWH(3 * w, h), outline);
     return skiagm::DrawResult::kOk;
 }

 namespace {
 typedef std::function<void(SkCanvas*, const SkRect&, const SkPaint&)> ShapeDrawFunc;
 }

 /**
  *  Iterates over a variety of rect shapes, paint parameters, and matrices, calling two different
  *  user-supplied draw callbacks. Produces a grid clearly showing if the two callbacks produce the
  *  same visual results in all cases.
  */
 static skiagm::DrawResult draw_rect_geom_diff_grid(SkCanvas* canvas, ShapeDrawFunc f1,
                                                    ShapeDrawFunc f2, SkString* errorMsg) {
     // Variables:
     // - Fill, hairline, wide stroke
     // - Axis aligned, rotated, scaled, scaled negative, perspective
     // - Source geometry (normal, collapsed, inverted)
     //
     // Things not (yet?) tested:
     // - AntiAlias on/off
     // - StrokeAndFill
     // - Cap/join
     // - Anything even more elaborate...

     const SkRect kRects[] = {
         SkRect::MakeXYWH(10, 10, 30, 30),  // Normal
         SkRect::MakeXYWH(10, 25, 30, 0),   // Collapsed
         SkRect::MakeXYWH(10, 40, 30, -30), // Inverted
     };

     const struct { SkPaint::Style fStyle; SkScalar fStrokeWidth; } kStyles[] = {
         { SkPaint::kFill_Style, 0 },   // Filled
         { SkPaint::kStroke_Style, 0 }, // Hairline
         { SkPaint::kStroke_Style, 5 }, // Wide stroke
     };

     SkMatrix mI = SkMatrix::I();
     SkMatrix mRot;
     mRot.setRotate(30, 25, 25);
     SkMatrix mScale;
     mScale.setScaleTranslate(0.5f, 1, 12.5f, 0);
     SkMatrix mFlipX;
     mFlipX.setScaleTranslate(-1, 1, 50, 0);
     SkMatrix mFlipY;
     mFlipY.setScaleTranslate(1, -1, 0, 50);
     SkMatrix mFlipXY;
     mFlipXY.setScaleTranslate(-1, -1, 50, 50);
     SkMatrix mPersp;
     mPersp.setIdentity();
     mPersp.setPerspY(0.002f);

     const SkMatrix* kMatrices[] = { &mI, &mRot, &mScale, &mFlipX, &mFlipY, &mFlipXY, &mPersp, };

     canvas->translate(10, 10);

     SkImageInfo info = canvas->imageInfo().makeWH(50, 50);
     auto surface = canvas->makeSurface(info);
     if (!surface) {
         surface = SkSurface::MakeRasterN32Premul(50, 50);
     }

     for (const SkRect& rect : kRects) {
         for (const auto& style : kStyles) {
             canvas->save();

             for (const SkMatrix* mat : kMatrices) {
                 SkPaint paint;
                 paint.setColor(SK_ColorWHITE);
                 paint.setAntiAlias(true);
                 paint.setStyle(style.fStyle);
                 paint.setStrokeWidth(style.fStrokeWidth);

                 // Do first draw
                 surface->getCanvas()->clear(SK_ColorBLACK);
                 surface->getCanvas()->save();
                 surface->getCanvas()->concat(*mat);
                 f1(surface->getCanvas(), rect, paint);
                 surface->getCanvas()->restore();
                 auto imgA = surface->makeImageSnapshot();

                 // Do second draw
                 surface->getCanvas()->clear(SK_ColorBLACK);
                 surface->getCanvas()->save();
                 surface->getCanvas()->concat(*mat);
                 f2(surface->getCanvas(), rect, paint);
                 surface->getCanvas()->restore();
                 auto imgB = surface->makeImageSnapshot();

                 skiagm::DrawResult drawResult = draw_diff(canvas, imgA.get(), imgB.get(), errorMsg);
                 if (skiagm::DrawResult::kOk != drawResult) {
                     return drawResult;
                 }
                 canvas->translate(160, 0);
             }
             canvas->restore();
             canvas->translate(0, 60);
         }
     }
     return skiagm::DrawResult::kOk;
 }

 static const int kNumRows = 9;
 static const int kNumColumns = 7;
 static const int kTotalWidth = kNumColumns * 160 + 10;
 static const int kTotalHeight = kNumRows * 60 + 10;

 DEF_SIMPLE_GM_BG_CAN_FAIL(rects_as_paths, canvas, errorMsg, kTotalWidth, kTotalHeight,
                           SK_ColorBLACK) {
     // Drawing a rect vs. adding it to a path and drawing the path, should produce same results.
     auto rectDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
         canvas->drawRect(rect, paint);
     };
     auto pathDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
         SkPath path;
         path.addRect(rect);
         canvas->drawPath(path, paint);
     };

     return draw_rect_geom_diff_grid(canvas, rectDrawFunc, pathDrawFunc, errorMsg);
 }

 DEF_SIMPLE_GM_BG_CAN_FAIL(ovals_as_paths, canvas, errorMsg, kTotalWidth, kTotalHeight,
                           SK_ColorBLACK) {
     // Drawing an oval vs. adding it to a path and drawing the path, should produce same results.
     auto ovalDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
         canvas->drawOval(rect, paint);
     };
     auto pathDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
         SkPath path;
         path.addOval(rect);
         canvas->drawPath(path, paint);
     };

     return draw_rect_geom_diff_grid(canvas, ovalDrawFunc, pathDrawFunc, errorMsg);
 }

 DEF_SIMPLE_GM_BG_CAN_FAIL(arcs_as_paths, canvas, errorMsg, kTotalWidth, kTotalHeight,
                           SK_ColorBLACK) {
     // Drawing an arc vs. adding it to a path and drawing the path, should produce same results.
     auto arcDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
         canvas->drawArc(rect, 10, 200, false, paint);
     };
     auto pathDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
         SkPath path;
         path.addArc(rect, 10, 200);
         canvas->drawPath(path, paint);
     };

     return draw_rect_geom_diff_grid(canvas, arcDrawFunc, pathDrawFunc, errorMsg);
 }

 }
	/*
	* Copyright 2017 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 "SkAutoPixmapStorage.h"
	#include "SkColorPriv.h"
	#include "SkImage.h"
	#include "SkPath.h"
	#include "SkSurface.h"

	namespace skiagm {

	skiagm::DrawResult draw_diff(SkCanvas* canvas, SkImage* imgA, SkImage* imgB, SkString* errorMsg) {
	SkASSERT(imgA->dimensions() == imgB->dimensions());

	int w = imgA->width(), h = imgA->height();

	// First, draw the two images faintly overlaid
	SkPaint paint;
	paint.setAlpha(64);
	paint.setBlendMode(SkBlendMode::kPlus);
	canvas->drawImage(imgA, 0, 0, &paint);
	canvas->drawImage(imgB, 0, 0, &paint);

	// Next, read the pixels back, figure out if there are any differences
	SkImageInfo info = SkImageInfo::MakeN32Premul(w, h);
	SkAutoPixmapStorage pmapA;
	SkAutoPixmapStorage pmapB;
	pmapA.alloc(info);
	pmapB.alloc(info);
	if (!imgA->readPixels(pmapA, 0, 0) \|\| !imgB->readPixels(pmapB, 0, 0)) {
	*errorMsg = "Failed to read pixels.";
	return skiagm::DrawResult::kFail;
	}

	int maxDiffX = 0, maxDiffY = 0, maxDiff = 0;
	SkBitmap highlight;
	highlight.allocN32Pixels(w, h);
	highlight.eraseColor(SK_ColorTRANSPARENT);

	for (int y = 0; y < h; ++y) {
	for (int x = 0; x < w; ++x) {
	uint32_t pixelA = *pmapA.addr32(x, y);
	uint32_t pixelB = *pmapB.addr32(x, y);
	if (pixelA != pixelB) {
	int diff =
	SkTAbs((int)(SkColorGetR(pixelA) - SkColorGetR(pixelB))) +
	SkTAbs((int)(SkColorGetG(pixelA) - SkColorGetG(pixelB))) +
	SkTAbs((int)(SkColorGetB(pixelA) - SkColorGetB(pixelB))) +
	SkTAbs((int)(SkColorGetA(pixelA) - SkColorGetA(pixelB)));
	if (diff > maxDiff) {
	maxDiffX = x;
	maxDiffY = y;
	maxDiff = diff;
	}
	*highlight.getAddr32(x, y) = SkPackARGB32(0xA0, 0xA0, 0x00, 0x00);
	}
	}
	}

	SkPaint outline;
	outline.setStyle(SkPaint::kStroke_Style);
	outline.setColor(maxDiff == 0 ? 0xFF007F00 : 0xFF7F0000);

	if (maxDiff > 0) {
	// Call extra attention to the region we're going to zoom
	SkPMColor yellow = SkPackARGB32(0xFF, 0xFF, 0xFF, 0x00);
	*highlight.getAddr32(maxDiffX, maxDiffY) = yellow;
	*highlight.getAddr32(SkTMax(maxDiffX - 1, 0), maxDiffY) = yellow;
	*highlight.getAddr32(maxDiffX, SkTMax(maxDiffY - 1, 0)) = yellow;
	*highlight.getAddr32(SkTMin(maxDiffX + 1, w - 1), maxDiffY) = yellow;
	*highlight.getAddr32(maxDiffX, SkTMin(maxDiffY + 1, h - 1)) = yellow;

	// Draw the overlay
	canvas->drawBitmap(highlight, 0, 0);

	// Draw zoom of largest pixel diff
	SkBitmap bmpA, bmpB;
	SkAssertResult(bmpA.installPixels(pmapA));
	SkAssertResult(bmpB.installPixels(pmapB));
	canvas->drawBitmapRect(bmpA, SkRect::MakeXYWH(maxDiffX - 5, maxDiffY - 5, 10, 10),
	SkRect::MakeXYWH(w, 0, w, h), nullptr);
	canvas->drawBitmapRect(bmpB, SkRect::MakeXYWH(maxDiffX - 5, maxDiffY - 5, 10, 10),
	SkRect::MakeXYWH(2 * w, 0, w, h), nullptr);

	// Add lines to separate zoom boxes
	canvas->drawLine(w, 0, w, h, outline);
	canvas->drawLine(2 * w, 0, 2 * w, h, outline);
	}

	// Draw outline of whole test region
	canvas->drawRect(SkRect::MakeWH(3 * w, h), outline);
	return skiagm::DrawResult::kOk;
	}

	namespace {
	typedef std::function<void(SkCanvas*, const SkRect&, const SkPaint&)> ShapeDrawFunc;
	}

	/**
	* Iterates over a variety of rect shapes, paint parameters, and matrices, calling two different
	* user-supplied draw callbacks. Produces a grid clearly showing if the two callbacks produce the
	* same visual results in all cases.
	*/
	static skiagm::DrawResult draw_rect_geom_diff_grid(SkCanvas* canvas, ShapeDrawFunc f1,
	ShapeDrawFunc f2, SkString* errorMsg) {
	// Variables:
	// - Fill, hairline, wide stroke
	// - Axis aligned, rotated, scaled, scaled negative, perspective
	// - Source geometry (normal, collapsed, inverted)
	//
	// Things not (yet?) tested:
	// - AntiAlias on/off
	// - StrokeAndFill
	// - Cap/join
	// - Anything even more elaborate...

	const SkRect kRects[] = {
	SkRect::MakeXYWH(10, 10, 30, 30), // Normal
	SkRect::MakeXYWH(10, 25, 30, 0), // Collapsed
	SkRect::MakeXYWH(10, 40, 30, -30), // Inverted
	};

	const struct { SkPaint::Style fStyle; SkScalar fStrokeWidth; } kStyles[] = {
	{ SkPaint::kFill_Style, 0 }, // Filled
	{ SkPaint::kStroke_Style, 0 }, // Hairline
	{ SkPaint::kStroke_Style, 5 }, // Wide stroke
	};

	SkMatrix mI = SkMatrix::I();
	SkMatrix mRot;
	mRot.setRotate(30, 25, 25);
	SkMatrix mScale;
	mScale.setScaleTranslate(0.5f, 1, 12.5f, 0);
	SkMatrix mFlipX;
	mFlipX.setScaleTranslate(-1, 1, 50, 0);
	SkMatrix mFlipY;
	mFlipY.setScaleTranslate(1, -1, 0, 50);
	SkMatrix mFlipXY;
	mFlipXY.setScaleTranslate(-1, -1, 50, 50);
	SkMatrix mPersp;
	mPersp.setIdentity();
	mPersp.setPerspY(0.002f);

	const SkMatrix* kMatrices[] = { &mI, &mRot, &mScale, &mFlipX, &mFlipY, &mFlipXY, &mPersp, };

	canvas->translate(10, 10);

	SkImageInfo info = canvas->imageInfo().makeWH(50, 50);
	auto surface = canvas->makeSurface(info);
	if (!surface) {
	surface = SkSurface::MakeRasterN32Premul(50, 50);
	}

	for (const SkRect& rect : kRects) {
	for (const auto& style : kStyles) {
	canvas->save();

	for (const SkMatrix* mat : kMatrices) {
	SkPaint paint;
	paint.setColor(SK_ColorWHITE);
	paint.setAntiAlias(true);
	paint.setStyle(style.fStyle);
	paint.setStrokeWidth(style.fStrokeWidth);

	// Do first draw
	surface->getCanvas()->clear(SK_ColorBLACK);
	surface->getCanvas()->save();
	surface->getCanvas()->concat(*mat);
	f1(surface->getCanvas(), rect, paint);
	surface->getCanvas()->restore();
	auto imgA = surface->makeImageSnapshot();

	// Do second draw
	surface->getCanvas()->clear(SK_ColorBLACK);
	surface->getCanvas()->save();
	surface->getCanvas()->concat(*mat);
	f2(surface->getCanvas(), rect, paint);
	surface->getCanvas()->restore();
	auto imgB = surface->makeImageSnapshot();

	skiagm::DrawResult drawResult = draw_diff(canvas, imgA.get(), imgB.get(), errorMsg);
	if (skiagm::DrawResult::kOk != drawResult) {
	return drawResult;
	}
	canvas->translate(160, 0);
	}
	canvas->restore();
	canvas->translate(0, 60);
	}
	}
	return skiagm::DrawResult::kOk;
	}

	static const int kNumRows = 9;
	static const int kNumColumns = 7;
	static const int kTotalWidth = kNumColumns * 160 + 10;
	static const int kTotalHeight = kNumRows * 60 + 10;

	DEF_SIMPLE_GM_BG_CAN_FAIL(rects_as_paths, canvas, errorMsg, kTotalWidth, kTotalHeight,
	SK_ColorBLACK) {
	// Drawing a rect vs. adding it to a path and drawing the path, should produce same results.
	auto rectDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
	canvas->drawRect(rect, paint);
	};
	auto pathDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
	SkPath path;
	path.addRect(rect);
	canvas->drawPath(path, paint);
	};

	return draw_rect_geom_diff_grid(canvas, rectDrawFunc, pathDrawFunc, errorMsg);
	}

	DEF_SIMPLE_GM_BG_CAN_FAIL(ovals_as_paths, canvas, errorMsg, kTotalWidth, kTotalHeight,
	SK_ColorBLACK) {
	// Drawing an oval vs. adding it to a path and drawing the path, should produce same results.
	auto ovalDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
	canvas->drawOval(rect, paint);
	};
	auto pathDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
	SkPath path;
	path.addOval(rect);
	canvas->drawPath(path, paint);
	};

	return draw_rect_geom_diff_grid(canvas, ovalDrawFunc, pathDrawFunc, errorMsg);
	}

	DEF_SIMPLE_GM_BG_CAN_FAIL(arcs_as_paths, canvas, errorMsg, kTotalWidth, kTotalHeight,
	SK_ColorBLACK) {
	// Drawing an arc vs. adding it to a path and drawing the path, should produce same results.
	auto arcDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
	canvas->drawArc(rect, 10, 200, false, paint);
	};
	auto pathDrawFunc = [](SkCanvas* canvas, const SkRect& rect, const SkPaint& paint) {
	SkPath path;
	path.addArc(rect, 10, 200);
	canvas->drawPath(path, paint);
	};

	return draw_rect_geom_diff_grid(canvas, arcDrawFunc, pathDrawFunc, errorMsg);
	}

	}