• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2015 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 "SkBlurImageFilter.h"
10 #include "SkColorMatrixFilter.h"
11 #include "SkImage.h"
12 #include "SkImageFilter.h"
13 #include "SkSurface.h"
14 
15 /**
16  *  Test drawing a primitive w/ an imagefilter (in this case, just matrix w/ identity) to see
17  *  that we apply the xfermode *after* the image has been created and filtered, and not during
18  *  the creation step (i.e. before it is filtered).
19  *
20  *  see https://bug.skia.org/3741
21  */
do_draw(SkCanvas * canvas,SkXfermode::Mode mode,SkImageFilter * imf)22 static void do_draw(SkCanvas* canvas, SkXfermode::Mode mode, SkImageFilter* imf) {
23         SkAutoCanvasRestore acr(canvas, true);
24         canvas->clipRect(SkRect::MakeWH(220, 220));
25 
26         // want to force a layer, so modes like DstIn can combine meaningfully, but the final
27         // image can still be shown against our default (opaque) background. non-opaque GMs
28         // are a lot more trouble to compare/triage.
29         canvas->saveLayer(nullptr, nullptr);
30         canvas->drawColor(SK_ColorGREEN);
31 
32         SkPaint paint;
33         paint.setAntiAlias(true);
34 
35         SkRect r0 = SkRect::MakeXYWH(10, 60, 200, 100);
36         SkRect r1 = SkRect::MakeXYWH(60, 10, 100, 200);
37 
38         paint.setColor(SK_ColorRED);
39         canvas->drawOval(r0, paint);
40 
41         paint.setColor(0x660000FF);
42         paint.setImageFilter(imf);
43         paint.setXfermodeMode(mode);
44         canvas->drawOval(r1, paint);
45 }
46 
47 DEF_SIMPLE_GM(imagefilters_xfermodes, canvas, 480, 480) {
48         canvas->translate(10, 10);
49 
50         // just need an imagefilter to trigger the code-path (which creates a tmp layer)
51         SkAutoTUnref<SkImageFilter> imf(SkImageFilter::CreateMatrixFilter(SkMatrix::I(),
52                                                                           kNone_SkFilterQuality));
53 
54         const SkXfermode::Mode modes[] = {
55             SkXfermode::kSrcATop_Mode, SkXfermode::kDstIn_Mode
56         };
57 
58         for (size_t i = 0; i < SK_ARRAY_COUNT(modes); ++i) {
59             canvas->save();
60             do_draw(canvas, modes[i], nullptr);
61             canvas->translate(240, 0);
62             do_draw(canvas, modes[i], imf);
63             canvas->restore();
64 
65             canvas->translate(0, 240);
66         }
67 }
68 
make_image(SkCanvas * canvas)69 static SkImage* make_image(SkCanvas* canvas) {
70     const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
71     SkAutoTUnref<SkSurface> surface(canvas->newSurface(info));
72     if (!surface) {
73         surface.reset(SkSurface::NewRaster(info));
74     }
75     surface->getCanvas()->drawRect(SkRect::MakeXYWH(25, 25, 50, 50), SkPaint());
76     return surface->newImageSnapshot();
77 }
78 
79 // Compare blurs when we're tightly clipped (fast) and not as tightly (slower)
80 //
81 // Expect the two to draw the same (modulo the extra border of pixels when the clip is larger)
82 //
83 DEF_SIMPLE_GM(fast_slow_blurimagefilter, canvas, 620, 260) {
84     SkAutoTUnref<SkImage> image(make_image(canvas));
85     const SkRect r = SkRect::MakeIWH(image->width(), image->height());
86 
87     canvas->translate(10, 10);
88     for (SkScalar sigma = 8; sigma <= 128; sigma *= 2) {
89         SkPaint paint;
90         SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(sigma, sigma));
91         paint.setImageFilter(blur);
92 
93         canvas->save();
94         // we outset the clip by 1, to fall out of the fast-case in drawImage
95         // i.e. the clip is larger than the image
96         for (SkScalar outset = 0; outset <= 1; ++outset) {
97             canvas->save();
98             canvas->clipRect(r.makeOutset(outset, outset));
99             canvas->drawImage(image, 0, 0, &paint);
100             canvas->restore();
101             canvas->translate(0, r.height() + 20);
102         }
103         canvas->restore();
104         canvas->translate(r.width() + 20, 0);
105     }
106 }
107 
108 ///////////////////////////////////////////////////////////////////////////////////////////////////
109 #include "Resources.h"
110 #include "SkBlurImageFilter.h"
111 #include "SkMatrixConvolutionImageFilter.h"
112 #include "SkMorphologyImageFilter.h"
113 #include "SkColorMatrixFilter.h"
114 #include "SkColorFilterImageFilter.h"
115 #include "SkRRect.h"
116 
draw_set(SkCanvas * canvas,SkImageFilter * filters[],int count)117 static void draw_set(SkCanvas* canvas, SkImageFilter* filters[], int count) {
118     const SkRect r = SkRect::MakeXYWH(30, 30, 200, 200);
119     const SkScalar offset = 250;
120     SkScalar dx = 0, dy = 0;
121 
122     for (int i = 0; i < count; ++i) {
123         canvas->save();
124         SkRRect rr = SkRRect::MakeRectXY(r.makeOffset(dx, dy), 20, 20);
125         canvas->clipRRect(rr, SkRegion::kIntersect_Op, true);
126         canvas->saveLayer({ &rr.getBounds(), nullptr, filters[i], 0 });
127         canvas->drawColor(0x40FFFFFF);
128         canvas->restore();
129         canvas->restore();
130 
131         if (0 == dx) {
132             dx = offset;
133         } else {
134             dx = 0;
135             dy = offset;
136         }
137     }
138 }
139 
140 DEF_SIMPLE_GM(savelayer_with_backdrop, canvas, 830, 550) {
141     SkColorMatrix cm;
142     cm.setSaturation(10);
143     SkAutoTUnref<SkColorFilter> cf(SkColorMatrixFilter::Create(cm));
144     const SkScalar kernel[] = { 4, 0, 4, 0, -15, 0, 4, 0, 4 };
145     SkImageFilter* filters[] = {
146         SkBlurImageFilter::Create(10, 10),
147         SkDilateImageFilter::Create(8, 8),
148         SkMatrixConvolutionImageFilter::Create({ 3, 3 }, kernel, 1, 0, { 0, 0 },
149                                            SkMatrixConvolutionImageFilter::kClampToBlack_TileMode,
150                                                true),
151         SkColorFilterImageFilter::Create(cf),
152     };
153 
154     const struct {
155         SkScalar    fSx, fSy, fTx, fTy;
156     } xforms[] = {
157         { 1, 1, 0, 0 },
158         { 0.5f, 0.5f, 530, 0 },
159         { 0.25f, 0.25f, 530, 275 },
160         { 0.125f, 0.125f, 530, 420 },
161     };
162 
163     SkPaint paint;
164     paint.setFilterQuality(kMedium_SkFilterQuality);
165     SkAutoTUnref<SkImage> image(GetResourceAsImage("mandrill_512.png"));
166 
167     canvas->translate(20, 20);
168     for (const auto& xform : xforms) {
169         canvas->save();
170         canvas->translate(xform.fTx, xform.fTy);
171         canvas->scale(xform.fSx, xform.fSy);
172         canvas->drawImage(image, 0, 0, &paint);
173         draw_set(canvas, filters, SK_ARRAY_COUNT(filters));
174         canvas->restore();
175     }
176 
177     for (auto& filter : filters) {
178         filter->unref();
179     }
180 }
181