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