SkMatrixConvolutionImageFilter.h revision 8b0e8ac5f582de80356019406e2975079bf0829d 
1/*
2 * Copyright 2012 The Android Open Source Project
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#ifndef SkMatrixConvolutionImageFilter_DEFINED
9#define SkMatrixConvolutionImageFilter_DEFINED
10
11#include "SkImageFilter.h"
12#include "SkScalar.h"
13#include "SkSize.h"
14#include "SkPoint.h"
15
16/*! \class SkMatrixConvolutionImageFilter
17    Matrix convolution image filter.  This filter applies an NxM image
18    processing kernel to a given input image.  This can be used to produce
19    effects such as sharpening, blurring, edge detection, etc.
20 */
21
22class SK_API SkMatrixConvolutionImageFilter : public SkImageFilter {
23public:
24    /*! \enum TileMode */
25    enum TileMode {
26      kClamp_TileMode,         /*!< Clamp to the image's edge pixels. */
27      kRepeat_TileMode,        /*!< Wrap around to the image's opposite edge. */
28      kClampToBlack_TileMode,  /*!< Fill with transparent black. */
29    };
30
31    /** Construct a matrix convolution image filter.
32        @param kernelSize  The kernel size in pixels, in each dimension (N by M).
33        @param kernel      The image processing kernel.  Must contain N * M
34                           elements, in row order.
35        @param gain        A scale factor applied to each pixel after
36                           convolution.  This can be used to normalize the
37                           kernel, if it does not sum to 1.
38        @param bias        A bias factor added to each pixel after convolution.
39        @param target      An offset applied to each pixel coordinate before
40                           convolution.  This can be used to center the kernel
41                           over the image (e.g., a 3x3 kernel should have a
42                           target of {1, 1}).
43        @param tileMode    How accesses outside the image are treated.  (@see
44                           TileMode).
45        @param convolveAlpha  If true, all channels are convolved.  If false,
46                           only the RGB channels are convolved, and
47                           alpha is copied from the source image.
48        @param input       The input image filter.  If NULL, the src bitmap
49                           passed to filterImage() is used instead.
50        @param cropRect    The rectangle to which the output processing will be limited.
51    */
52
53    SkMatrixConvolutionImageFilter(const SkISize& kernelSize,
54                                   const SkScalar* kernel,
55                                   SkScalar gain,
56                                   SkScalar bias,
57                                   const SkIPoint& target,
58                                   TileMode tileMode,
59                                   bool convolveAlpha,
60                                   SkImageFilter* input = NULL,
61                                   const CropRect* cropRect = NULL);
62    virtual ~SkMatrixConvolutionImageFilter();
63
64    SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkMatrixConvolutionImageFilter)
65
66protected:
67    SkMatrixConvolutionImageFilter(SkReadBuffer& buffer);
68    virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
69
70    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
71                               SkBitmap* result, SkIPoint* loc) SK_OVERRIDE;
72
73#if SK_SUPPORT_GPU
74    virtual bool asNewEffect(GrEffectRef** effect,
75                             GrTexture*,
76                             const SkMatrix& matrix,
77                             const SkIRect& bounds) const SK_OVERRIDE;
78#endif
79
80private:
81    SkISize   fKernelSize;
82    SkScalar* fKernel;
83    SkScalar  fGain;
84    SkScalar  fBias;
85    SkIPoint  fTarget;
86    TileMode  fTileMode;
87    bool      fConvolveAlpha;
88    typedef SkImageFilter INHERITED;
89
90    template <class PixelFetcher, bool convolveAlpha>
91    void filterPixels(const SkBitmap& src,
92                      SkBitmap* result,
93                      const SkIRect& rect,
94                      const SkIRect& bounds);
95    template <class PixelFetcher>
96    void filterPixels(const SkBitmap& src,
97                      SkBitmap* result,
98                      const SkIRect& rect,
99                      const SkIRect& bounds);
100    void filterInteriorPixels(const SkBitmap& src,
101                              SkBitmap* result,
102                              const SkIRect& rect,
103                              const SkIRect& bounds);
104    void filterBorderPixels(const SkBitmap& src,
105                            SkBitmap* result,
106                            const SkIRect& rect,
107                            const SkIRect& bounds);
108};
109
110#endif
111