Implement support for non-scale/translate CTM in image filters.

gm/imagefilterstransformed.cpp

 /*
- * Copyright 2014 Google Inc.
+ * 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 "sk_tool_utils.h"
 #include "SkBitmapSource.h"
 #include "SkBlurImageFilter.h"
 #include "SkColor.h"
 #include "SkDisplacementMapEffect.h"
 #include "SkDropShadowImageFilter.h"
 #include "SkGradientShader.h"
 #include "SkMorphologyImageFilter.h"
-#include "SkOffsetImageFilter.h"
-#include "SkPerlinNoiseShader.h"
-#include "SkRectShaderImageFilter.h"
 #include "SkScalar.h"
 #include "gm.h"
 
-#define RESIZE_FACTOR_X SkIntToScalar(2)
-#define RESIZE_FACTOR_Y SkIntToScalar(5)
-
 namespace skiagm {
 

[robertphillips, 2015/03/20 14:01:09]

// This GM checks that the scale portion of the applied matrices is correctly
extracted and applied to the image inputs separate from the non-scale portion

?

[Stephen White, 2015/03/20 14:19:08]

Done (with tweaks).

-class ImageFiltersClippedGM : public GM {
+class ImageFiltersTransformedGM : public GM {
 public:
-    ImageFiltersClippedGM() : fInitialized(false) {
-        this->setBGColor(0x00000000);
+    ImageFiltersTransformedGM() : fInitialized(false) {
+        this->setBGColor(SK_ColorBLACK);
     }
 
 protected:
 

[robertphillips, 2015/03/20 14:01:09]

one line ?

[Stephen White, 2015/03/20 14:19:08]

Done.

     SkString onShortName() SK_OVERRIDE {
-        return SkString("imagefiltersclipped");
+        return SkString("imagefilterstransformed");
     }
 

[robertphillips, 2015/03/20 14:01:09]

one line ?

[Stephen White, 2015/03/20 14:19:08]

Done.

     SkISize onISize() SK_OVERRIDE {
-        return SkISize::Make(860, 500);
+        return SkISize::Make(560, 300);
     }
 

[robertphillips, 2015/03/20 14:01:09]

makeGradientCircle ?

[Stephen White, 2015/03/20 14:19:08]

Done.

     void make_gradient_circle(int width, int height) {
         SkScalar x = SkIntToScalar(width / 2);
         SkScalar y = SkIntToScalar(height / 2);
         SkScalar radius = SkMinScalar(x, y) * 0.8f;
         fGradientCircle.allocN32Pixels(width, height);
         SkCanvas canvas(fGradientCircle);
         canvas.clear(0x00000000);
         SkColor colors[2];
         colors[0] = SK_ColorWHITE;
         colors[1] = SK_ColorBLACK;
         SkAutoTUnref<SkShader> shader(
             SkGradientShader::CreateRadial(SkPoint::Make(x, y), radius, colors, NULL, 2,
                                            SkShader::kClamp_TileMode)
         );
         SkPaint paint;
         paint.setShader(shader);
         canvas.drawCircle(x, y, radius, paint);
     }
 
     void onDraw(SkCanvas* canvas) SK_OVERRIDE {

[robertphillips, 2015/03/20 14:01:09]

Can we move this stuff to a onOnceBeforeDraw method and get rid of fInitialized
?

[Stephen White, 2015/03/20 14:19:08]

Done.

         if (!fInitialized) {
             fCheckerboard.allocN32Pixels(64, 64);
             SkCanvas checkerboardCanvas(fCheckerboard);
             sk_tool_utils::draw_checkerboard(&checkerboardCanvas, 0xFFA0A0A0, 0xFF404040, 8);
 
             this->make_gradient_circle(64, 64);
             fInitialized = true;
         }
-        canvas->clear(0x00000000);
+
+        canvas->clear(SK_ColorBLACK);
 
         SkAutoTUnref<SkImageFilter> gradient(SkBitmapSource::Create(fGradientCircle));
         SkAutoTUnref<SkImageFilter> checkerboard(SkBitmapSource::Create(fCheckerboard));
-        SkAutoTUnref<SkShader> noise(SkPerlinNoiseShader::CreateFractalNoise(
-            SkDoubleToScalar(0.1), SkDoubleToScalar(0.05), 1, 0));
-        SkMatrix resizeMatrix;
-        resizeMatrix.setScale(RESIZE_FACTOR_X, RESIZE_FACTOR_Y);
-
         SkImageFilter* filters[] = {
-            SkBlurImageFilter::Create(SkIntToScalar(12), SkIntToScalar(12)),
-            SkDropShadowImageFilter::Create(SkIntToScalar(10), SkIntToScalar(10),
-                SkIntToScalar(3), SkIntToScalar(3), SK_ColorGREEN,
+            SkBlurImageFilter::Create(12, 0),
+            SkDropShadowImageFilter::Create(0, 15, 8, 0, SK_ColorGREEN,
                 SkDropShadowImageFilter::kDrawShadowAndForeground_ShadowMode),
             SkDisplacementMapEffect::Create(SkDisplacementMapEffect::kR_ChannelSelectorType,
                                             SkDisplacementMapEffect::kR_ChannelSelectorType,
-                                            SkIntToScalar(12),
+                                            12,
                                             gradient.get(),
                                             checkerboard.get()),
             SkDilateImageFilter::Create(2, 2, checkerboard.get()),
             SkErodeImageFilter::Create(2, 2, checkerboard.get()),
-            SkOffsetImageFilter::Create(SkIntToScalar(-16), SkIntToScalar(32)),
-            SkImageFilter::CreateMatrixFilter(resizeMatrix, kNone_SkFilterQuality),
-            SkRectShaderImageFilter::Create(noise),
         };
 

[robertphillips, 2015/03/20 14:01:09]

Can we make these two guys const ?

[Stephen White, 2015/03/20 14:19:08]

Done.

-        SkRect r = SkRect::MakeWH(SkIntToScalar(64), SkIntToScalar(64));
-        SkScalar margin = SkIntToScalar(16);
-        SkRect bounds = r;
-        bounds.outset(margin, margin);
+        SkScalar margin = SkIntToScalar(40);
+        SkScalar size = SkIntToScalar(60);
 
-        for (int xOffset = 0; xOffset < 80; xOffset += 16) {
+        for (size_t j = 0; j < 3; j++) {
             canvas->save();
-            bounds.fLeft = SkIntToScalar(xOffset);
+            canvas->translate(margin, 0);
             for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
                 SkPaint paint;
                 paint.setColor(SK_ColorWHITE);
                 paint.setImageFilter(filters[i]);
                 paint.setAntiAlias(true);
                 canvas->save();
-                canvas->clipRect(bounds);
-                if (5 == i) {
-                    canvas->translate(SkIntToScalar(16), SkIntToScalar(-32));
-                } else if (6 == i) {
-                    canvas->scale(SkScalarInvert(RESIZE_FACTOR_X),
-                                  SkScalarInvert(RESIZE_FACTOR_Y));
+                canvas->translate(size * 0.5, size * 0.5);
+                if (j == 1) {
+                    canvas->rotate(SkIntToScalar(45));
+                } else if (j == 2) {
+                    canvas->skew(0.5, 0.2);
                 }
-                canvas->drawCircle(r.centerX(), r.centerY(),
-                                   SkScalarDiv(r.width()*2, SkIntToScalar(5)), paint);
+                canvas->translate(-size * 0.5, -size * 0.5);
+                canvas->drawOval(SkRect::MakeXYWH(0, size * 0.1, size, size * 0.6), paint);
                 canvas->restore();
-                canvas->translate(r.width() + margin, 0);
+                canvas->translate(size + margin, 0);
             }
             canvas->restore();
-            canvas->translate(0, r.height() + margin);
+            canvas->translate(0, size + margin);
         }
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) {
             SkSafeUnref(filters[i]);
         }
     }
 
 private:
     bool fInitialized;
     SkBitmap fCheckerboard;
     SkBitmap fGradientCircle;
     typedef GM INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 

[robertphillips, 2015/03/20 14:01:09]

Use DEF_GM macro ?

[Stephen White, 2015/03/20 14:19:08]

Done.

-static GM* MyFactory(void*) { return new ImageFiltersClippedGM; }
+static GM* MyFactory(void*) { return new ImageFiltersTransformedGM; }
 static GMRegistry reg(MyFactory);
 
 }