gm/matrixconvolution.cpp

   1 /*
   2  * Copyright 2012 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "gm.h"
   9 #include "sk_tool_utils.h"
  10 #include "SkColor.h"
  11 #include "SkGradientShader.h"
  12 #include "SkMatrixConvolutionImageFilter.h"
  13 #include "SkPixelRef.h"
  14
  15 namespace skiagm {
  16
  17 class MatrixConvolutionGM : public GM {
  18 public:
  19     MatrixConvolutionGM(SkColor colorOne, SkColor colorTwo, const char* nameSuffix)
  20             : fNameSuffix(nameSuffix) {
  21         this->setBGColor(0x00000000);
  22         fColors[0] = colorOne;
  23         fColors[1] = colorTwo;
  24     }
  25
  26 protected:
  27
  28     SkString onShortName() override {
  29         return SkStringPrintf("matrixconvolution%s", fNameSuffix);
  30     }
  31
  32     void makeBitmap() {
  33         // Draw our bitmap in N32, so legacy devices get "premul" values they understand
  34         SkBitmap n32Bitmap;
  35         n32Bitmap.allocN32Pixels(80, 80);
  36         SkCanvas canvas(n32Bitmap);
  37         canvas.clear(0x00000000);
  38         SkPaint paint;
  39         paint.setAntiAlias(true);
  40         sk_tool_utils::set_portable_typeface(&paint);
  41         paint.setColor(0xFFFFFFFF);
  42         paint.setTextSize(SkIntToScalar(180));
  43         SkPoint pts[2] = { SkPoint::Make(0, 0),
  44                            SkPoint::Make(0, SkIntToScalar(80)) };
  45         SkScalar pos[2] = { 0, SkIntToScalar(80) };
  46         paint.setShader(SkGradientShader::MakeLinear(
  47             pts, fColors, pos, 2, SkShader::kClamp_TileMode));
  48         const char* str = "e";
  49         canvas.drawString(str, SkIntToScalar(-10), SkIntToScalar(80), paint);
  50
  51         // ... tag the data as sRGB, so color-aware devices do gamut adjustment, etc...
  52         fBitmap.setInfo(SkImageInfo::MakeS32(80, 80, kPremul_SkAlphaType));
  53         fBitmap.setPixelRef(sk_ref_sp(n32Bitmap.pixelRef()), 0, 0);
  54     }
  55
  56     SkISize onISize() override {
  57         return SkISize::Make(500, 300);
  58     }
  59
  60     void draw(SkCanvas* canvas, int x, int y, const SkIPoint& kernelOffset,
  61               SkMatrixConvolutionImageFilter::TileMode tileMode, bool convolveAlpha,
  62               const SkImageFilter::CropRect* cropRect = nullptr) {
  63         SkScalar kernel[9] = {
  64             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
  65             SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
  66             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
  67         };
  68         SkISize kernelSize = SkISize::Make(3, 3);
  69         SkScalar gain = 0.3f, bias = SkIntToScalar(100);
  70         if (canvas->imageInfo().colorSpace()) {
  71             // TODO: Gain and bias are poorly specified (in the feConvolveMatrix SVG documentation,
  72             // there is obviously no mention of gamma or color spaces). Eventually, we need to
  73             // decide what to do with these (they generally have an extreme brightening effect).
  74             // For now, I'm modifying this GM to use values tuned to preserve luminance across the
  75             // range of input values (compared to the legacy math and values).
  76             //
  77             // It's impossible to match the results exactly, because legacy math produces a flat
  78             // response (when looking at sRGB encoded results), while gamma-correct math produces
  79             // a curve.
  80             gain = 0.25f;
  81             bias = 16.5f;
  82         }
  83         SkPaint paint;
  84         paint.setImageFilter(SkMatrixConvolutionImageFilter::Make(kernelSize,
  85                                                                   kernel,
  86                                                                   gain,
  87                                                                   bias,
  88                                                                   kernelOffset,
  89                                                                   tileMode,
  90                                                                   convolveAlpha,
  91                                                                   nullptr,
  92                                                                   cropRect));
  93         canvas->save();
  94         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
  95         canvas->clipRect(SkRect::MakeWH(SkIntToScalar(fBitmap.width()),
  96                                         SkIntToScalar(fBitmap.height())));
  97         canvas->drawBitmap(fBitmap, 0, 0, &paint);
  98         canvas->restore();
  99     }
 100
 101     typedef SkMatrixConvolutionImageFilter MCIF;
 102
 103     void onOnceBeforeDraw() override {
 104         this->makeBitmap();
 105     }
 106
 107     void onDraw(SkCanvas* canvas) override {
 108         canvas->clear(SK_ColorBLACK);
 109         SkIPoint kernelOffset = SkIPoint::Make(1, 0);
 110         SkImageFilter::CropRect rect(SkRect::Make(fBitmap.bounds()));
 111         for (int x = 10; x < 310; x += 100) {
 112             this->draw(canvas, x, 10, kernelOffset, MCIF::kClamp_TileMode, true, &rect);
 113             this->draw(canvas, x, 110, kernelOffset, MCIF::kClampToBlack_TileMode, true, &rect);
 114             this->draw(canvas, x, 210, kernelOffset, MCIF::kRepeat_TileMode, true, &rect);
 115             kernelOffset.fY++;
 116         }
 117         kernelOffset.fY = 1;
 118         SkImageFilter::CropRect smallRect(SkRect::MakeXYWH(10, 5, 60, 60));
 119         this->draw(canvas, 310, 10, kernelOffset, MCIF::kClamp_TileMode, true, &smallRect);
 120         this->draw(canvas, 310, 110, kernelOffset, MCIF::kClampToBlack_TileMode, true, &smallRect);
 121         this->draw(canvas, 310, 210, kernelOffset, MCIF::kRepeat_TileMode, true, &smallRect);
 122
 123         this->draw(canvas, 410, 10, kernelOffset, MCIF::kClamp_TileMode, false, &rect);
 124         this->draw(canvas, 410, 110, kernelOffset, MCIF::kClampToBlack_TileMode, false, &rect);
 125         this->draw(canvas, 410, 210, kernelOffset, MCIF::kRepeat_TileMode, false, &rect);
 126     }
 127
 128 private:
 129     SkBitmap fBitmap;
 130     SkColor fColors[2];
 131     const char* fNameSuffix;
 132
 133     typedef GM INHERITED;
 134 };
 135
 136 //////////////////////////////////////////////////////////////////////////////
 137
 138 DEF_GM(return new MatrixConvolutionGM(0xFFFFFFFF, 0x40404040, "");)
 139 DEF_GM(return new MatrixConvolutionGM(0xFFFF0000, 0xFF00FF00, "_color");)
 140
 141 }