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
10#include "SkArithmeticMode.h"
11#include "SkDevice.h"
12#include "SkBlurImageFilter.h"
13#include "SkColorFilter.h"
14#include "SkColorFilterImageFilter.h"
15#include "SkColorMatrixFilter.h"
16#include "SkImage.h"
17#include "SkImageSource.h"
18#include "SkMatrixConvolutionImageFilter.h"
19#include "SkReadBuffer.h"
20#include "SkWriteBuffer.h"
21#include "SkMergeImageFilter.h"
22#include "SkMorphologyImageFilter.h"
23#include "SkTestImageFilters.h"
24#include "SkXfermodeImageFilter.h"
25
26// More closely models how Blink's OffsetFilter works as of 10/23/13. SkOffsetImageFilter doesn't
27// perform a draw and this one does.
28class SimpleOffsetFilter : public SkImageFilter {
29public:
30    class Registrar {
31    public:
32        Registrar() {
33            SkFlattenable::Register("SimpleOffsetFilter",
34                                    SimpleOffsetFilter::CreateProc,
35                                    SimpleOffsetFilter::GetFlattenableType());
36        }
37    };
38    static SkImageFilter* Create(SkScalar dx, SkScalar dy, SkImageFilter* input) {
39        return new SimpleOffsetFilter(dx, dy, input);
40    }
41
42    bool onFilterImageDeprecated(Proxy* proxy, const SkBitmap& src, const Context& ctx,
43                                 SkBitmap* dst, SkIPoint* offset) const override {
44        SkBitmap source = src;
45        SkIPoint srcOffset = SkIPoint::Make(0, 0);
46        if (!this->filterInputDeprecated(0, proxy, src, ctx, &source, &srcOffset)) {
47            return false;
48        }
49
50        SkIRect bounds;
51        if (!this->applyCropRectDeprecated(ctx, proxy, source, &srcOffset, &bounds, &source)) {
52            return false;
53        }
54
55        SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
56        SkCanvas canvas(device);
57        SkPaint paint;
58        paint.setXfermodeMode(SkXfermode::kSrc_Mode);
59        canvas.drawBitmap(source, fDX - bounds.left(), fDY - bounds.top(), &paint);
60        *dst = device->accessBitmap(false);
61        offset->fX += bounds.left();
62        offset->fY += bounds.top();
63        return true;
64    }
65
66    SK_TO_STRING_OVERRIDE()
67    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SimpleOffsetFilter);
68
69protected:
70    void flatten(SkWriteBuffer& buffer) const override {
71        this->INHERITED::flatten(buffer);
72        buffer.writeScalar(fDX);
73        buffer.writeScalar(fDY);
74    }
75
76private:
77    SimpleOffsetFilter(SkScalar dx, SkScalar dy, SkImageFilter* input)
78        : SkImageFilter(1, &input), fDX(dx), fDY(dy) {}
79
80    SkScalar fDX, fDY;
81
82    typedef SkImageFilter INHERITED;
83};
84
85static SimpleOffsetFilter::Registrar gReg;
86
87SkFlattenable* SimpleOffsetFilter::CreateProc(SkReadBuffer& buffer) {
88    SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
89    SkScalar dx = buffer.readScalar();
90    SkScalar dy = buffer.readScalar();
91    return Create(dx, dy, common.getInput(0));
92}
93
94#ifndef SK_IGNORE_TO_STRING
95void SimpleOffsetFilter::toString(SkString* str) const {
96    str->appendf("SimpleOffsetFilter: (");
97    str->append(")");
98}
99#endif
100
101class ImageFiltersGraphGM : public skiagm::GM {
102public:
103    ImageFiltersGraphGM() {}
104
105protected:
106
107    SkString onShortName() override {
108        return SkString("imagefiltersgraph");
109    }
110
111    SkISize onISize() override { return SkISize::Make(600, 150); }
112
113    void onOnceBeforeDraw() override {
114        fImage.reset(SkImage::NewFromBitmap(
115            sk_tool_utils::create_string_bitmap(100, 100, SK_ColorWHITE, 20, 70, 96, "e")));
116    }
117
118    void onDraw(SkCanvas* canvas) override {
119        canvas->clear(SK_ColorBLACK);
120        {
121            SkAutoTUnref<SkImageFilter> bitmapSource(SkImageSource::Create(fImage));
122            SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
123                                                         SkXfermode::kSrcIn_Mode));
124            SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(4.0f, 4.0f, bitmapSource));
125            SkAutoTUnref<SkImageFilter> erode(SkErodeImageFilter::Create(4, 4, blur));
126            SkAutoTUnref<SkImageFilter> color(SkColorFilterImageFilter::Create(cf, erode));
127            SkAutoTUnref<SkImageFilter> merge(SkMergeImageFilter::Create(blur, color));
128
129            SkPaint paint;
130            paint.setImageFilter(merge);
131            canvas->drawPaint(paint);
132            canvas->translate(SkIntToScalar(100), 0);
133        }
134        {
135            SkAutoTUnref<SkImageFilter> morph(SkDilateImageFilter::Create(5, 5));
136
137            SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
138                                    0, SK_Scalar1, 0, 0, 0,
139                                    0, 0, SK_Scalar1, 0, 0,
140                                    0, 0, 0, 0.5f, 0 };
141
142            SkAutoTUnref<SkColorFilter> matrixFilter(SkColorMatrixFilter::Create(matrix));
143            SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter, morph));
144            SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
145            SkAutoTUnref<SkImageFilter> blendColor(SkXfermodeImageFilter::Create(mode, colorMorph));
146
147            SkPaint paint;
148            paint.setImageFilter(blendColor);
149            DrawClippedImage(canvas, fImage, paint);
150            canvas->translate(SkIntToScalar(100), 0);
151        }
152        {
153            SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
154                                    0, SK_Scalar1, 0, 0, 0,
155                                    0, 0, SK_Scalar1, 0, 0,
156                                    0, 0, 0, 0.5f, 0 };
157            SkAutoTUnref<SkColorFilter> matrixCF(SkColorMatrixFilter::Create(matrix));
158            SkAutoTUnref<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Create(matrixCF));
159            SkAutoTUnref<SkImageFilter> offsetFilter(
160                SimpleOffsetFilter::Create(10.0f, 10.f, matrixFilter));
161
162            SkAutoTUnref<SkXfermode> arith(SkArithmeticMode::Create(0, SK_Scalar1, SK_Scalar1, 0));
163            SkAutoTUnref<SkImageFilter> arithFilter(
164                SkXfermodeImageFilter::Create(arith, matrixFilter, offsetFilter));
165
166            SkPaint paint;
167            paint.setImageFilter(arithFilter);
168            DrawClippedImage(canvas, fImage, paint);
169            canvas->translate(SkIntToScalar(100), 0);
170        }
171        {
172            SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(
173              SkIntToScalar(10), SkIntToScalar(10)));
174
175            SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcIn_Mode));
176            SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
177            SkAutoTUnref<SkImageFilter> blend(
178                SkXfermodeImageFilter::Create(mode, blur, nullptr, &cropRect));
179
180            SkPaint paint;
181            paint.setImageFilter(blend);
182            DrawClippedImage(canvas, fImage, paint);
183            canvas->translate(SkIntToScalar(100), 0);
184        }
185        {
186            // Dilate -> matrix convolution.
187            // This tests that a filter using asFragmentProcessor (matrix
188            // convolution) correctly handles a non-zero source offset
189            // (supplied by the dilate).
190            SkAutoTUnref<SkImageFilter> dilate(SkDilateImageFilter::Create(5, 5));
191
192            SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcIn_Mode));
193
194            SkScalar kernel[9] = {
195                SkIntToScalar(-1), SkIntToScalar( -1 ), SkIntToScalar(-1),
196                SkIntToScalar(-1), SkIntToScalar(  7 ), SkIntToScalar(-1),
197                SkIntToScalar(-1), SkIntToScalar( -1 ), SkIntToScalar(-1),
198            };
199            SkISize kernelSize = SkISize::Make(3, 3);
200            SkScalar gain = 1.0f, bias = SkIntToScalar(0);
201            SkIPoint kernelOffset = SkIPoint::Make(1, 1);
202            auto tileMode = SkMatrixConvolutionImageFilter::kClamp_TileMode;
203            bool convolveAlpha = false;
204            SkAutoTUnref<SkImageFilter> convolve(
205                SkMatrixConvolutionImageFilter::Create(kernelSize,
206                                                       kernel,
207                                                       gain,
208                                                       bias,
209                                                       kernelOffset,
210                                                       tileMode,
211                                                       convolveAlpha,
212                                                       dilate));
213
214            SkPaint paint;
215            paint.setImageFilter(convolve);
216            DrawClippedImage(canvas, fImage, paint);
217            canvas->translate(SkIntToScalar(100), 0);
218        }
219        {
220            // Test that crop offsets are absolute, not relative to the parent's crop rect.
221            SkAutoTUnref<SkColorFilter> cf1(SkColorFilter::CreateModeFilter(SK_ColorBLUE,
222                                                                            SkXfermode::kSrcIn_Mode));
223            SkAutoTUnref<SkColorFilter> cf2(SkColorFilter::CreateModeFilter(SK_ColorGREEN,
224                                                                            SkXfermode::kSrcIn_Mode));
225            SkImageFilter::CropRect outerRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
226                                                               SkIntToScalar(80), SkIntToScalar(80)));
227            SkImageFilter::CropRect innerRect(SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
228                                                               SkIntToScalar(60), SkIntToScalar(60)));
229            SkAutoTUnref<SkImageFilter> color1(SkColorFilterImageFilter::Create(cf1, nullptr, &outerRect));
230            SkAutoTUnref<SkImageFilter> color2(SkColorFilterImageFilter::Create(cf2, color1, &innerRect));
231
232            SkPaint paint;
233            paint.setImageFilter(color2);
234            paint.setColor(SK_ColorRED);
235            canvas->drawRect(SkRect::MakeXYWH(0, 0, 100, 100), paint);
236            canvas->translate(SkIntToScalar(100), 0);
237        }
238    }
239
240private:
241    static void DrawClippedImage(SkCanvas* canvas, const SkImage* image, const SkPaint& paint) {
242        canvas->save();
243        canvas->clipRect(SkRect::MakeIWH(image->width(), image->height()));
244        canvas->drawImage(image, 0, 0, &paint);
245        canvas->restore();
246    }
247
248    SkAutoTUnref<SkImage> fImage;
249
250    typedef GM INHERITED;
251};
252
253///////////////////////////////////////////////////////////////////////////////
254
255DEF_GM(return new ImageFiltersGraphGM;)
256