Home | History | Annotate | Download | only in effects 
      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 
     22 class SK_API SkMatrixConvolutionImageFilter : public SkImageFilter {
     23 public:
     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 
     66 protected:
     67     SkMatrixConvolutionImageFilter(SkFlattenableReadBuffer& buffer);
     68     virtual void flatten(SkFlattenableWriteBuffer&) 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 
     80 private:
     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