Home | History | Annotate | Download | only in gm 
      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 "SkColor.h"
     10 #include "SkMatrixConvolutionImageFilter.h"
     11 #include "SkGradientShader.h"
     12 
     13 namespace skiagm {
     14 
     15 class MatrixConvolutionGM : public GM {
     16 public:
     17     MatrixConvolutionGM() : fInitialized(false) {
     18         this->setBGColor(0x00000000);
     19     }
     20 
     21 protected:
     22     virtual uint32_t onGetFlags() const SK_OVERRIDE {
     23         return kSkipTiled_Flag;
     24     }
     25 
     26     virtual SkString onShortName() {
     27         return SkString("matrixconvolution");
     28     }
     29 
     30     void make_bitmap() {
     31         fBitmap.allocN32Pixels(80, 80);
     32         SkCanvas canvas(fBitmap);
     33         canvas.clear(0x00000000);
     34         SkPaint paint;
     35         paint.setAntiAlias(true);
     36         paint.setColor(0xFFFFFFFF);
     37         paint.setTextSize(SkIntToScalar(180));
     38         SkPoint pts[2] = { SkPoint::Make(0, 0),
     39                            SkPoint::Make(0, SkIntToScalar(80)) };
     40         SkColor colors[2] = { 0xFFFFFFFF, 0x40404040 };
     41         SkScalar pos[2] = { 0, SkIntToScalar(80) };
     42         paint.setShader(SkGradientShader::CreateLinear(
     43             pts, colors, pos, 2, SkShader::kClamp_TileMode))->unref();
     44         const char* str = "e";
     45         canvas.drawText(str, strlen(str), SkIntToScalar(-10), SkIntToScalar(80), paint);
     46     }
     47 
     48     virtual SkISize onISize() {
     49         return SkISize::Make(500, 300);
     50     }
     51 
     52     void draw(SkCanvas* canvas, int x, int y, const SkIPoint& kernelOffset,
     53               SkMatrixConvolutionImageFilter::TileMode tileMode, bool convolveAlpha,
     54               const SkImageFilter::CropRect* cropRect = NULL) {
     55         SkScalar kernel[9] = {
     56             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     57             SkIntToScalar( 1), SkIntToScalar(-7), SkIntToScalar( 1),
     58             SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1),
     59         };
     60         SkISize kernelSize = SkISize::Make(3, 3);
     61         SkScalar gain = 0.3f, bias = SkIntToScalar(100);
     62         SkPaint paint;
     63         SkAutoTUnref<SkImageFilter> filter(
     64             SkMatrixConvolutionImageFilter::Create(kernelSize,
     65                                                    kernel,
     66                                                    gain,
     67                                                    bias,
     68                                                    kernelOffset,
     69                                                    tileMode,
     70                                                    convolveAlpha,
     71                                                    NULL,
     72                                                    cropRect));
     73         paint.setImageFilter(filter);
     74         canvas->save();
     75         canvas->translate(SkIntToScalar(x), SkIntToScalar(y));
     76         canvas->clipRect(SkRect::MakeWH(SkIntToScalar(fBitmap.width()),
     77                                         SkIntToScalar(fBitmap.height())));
     78         canvas->drawBitmap(fBitmap, 0, 0, &paint);
     79         canvas->restore();
     80     }
     81 
     82     typedef SkMatrixConvolutionImageFilter MCIF;
     83 
     84     virtual void onDraw(SkCanvas* canvas) {
     85         if (!fInitialized) {
     86             make_bitmap();
     87             fInitialized = true;
     88         }
     89         canvas->clear(0x00000000);
     90         SkIPoint kernelOffset = SkIPoint::Make(1, 0);
     91         for (int x = 10; x < 310; x += 100) {
     92             this->draw(canvas, x, 10, kernelOffset, MCIF::kClamp_TileMode, true);
     93             this->draw(canvas, x, 110, kernelOffset, MCIF::kClampToBlack_TileMode, true);
     94             this->draw(canvas, x, 210, kernelOffset, MCIF::kRepeat_TileMode, true);
     95             kernelOffset.fY++;
     96         }
     97         kernelOffset.fY = 1;
     98         SkImageFilter::CropRect rect(SkRect::MakeXYWH(10, 5, 60, 60));
     99         this->draw(canvas, 310, 10, kernelOffset, MCIF::kClamp_TileMode, true, &rect);
    100         this->draw(canvas, 310, 110, kernelOffset, MCIF::kClampToBlack_TileMode, true, &rect);
    101         this->draw(canvas, 310, 210, kernelOffset, MCIF::kRepeat_TileMode, true, &rect);
    102 
    103         this->draw(canvas, 410, 10, kernelOffset, MCIF::kClamp_TileMode, false);
    104         this->draw(canvas, 410, 110, kernelOffset, MCIF::kClampToBlack_TileMode, false);
    105         this->draw(canvas, 410, 210, kernelOffset, MCIF::kRepeat_TileMode, false);
    106     }
    107 
    108 private:
    109     typedef GM INHERITED;
    110     SkBitmap fBitmap;
    111     bool fInitialized;
    112 };
    113 
    114 //////////////////////////////////////////////////////////////////////////////
    115 
    116 static GM* MyFactory(void*) { return new MatrixConvolutionGM; }
    117 static GMRegistry reg(MyFactory);
    118 
    119 }
    120