@ -7,713 +7,328 @@ Functions and classes described in this section are used to perform various line
gpu::BaseRowFilter_GPU
----------------------
..ocv:class:: gpu::BaseRowFilter_GPU
Base class for linear or non-linear filters that processes rows of 2D arrays. Such filters are used for the "horizontal" filtering passes in separable filters. ::
..note:: This class does not allocate memory for a destination image. Usually this class is used inside :ocv:class:`gpu::FilterEngine_GPU`.
gpu::BaseColumnFilter_GPU
-------------------------
..ocv:class:: gpu::BaseColumnFilter_GPU
Base class for linear or non-linear filters that processes columns of 2D arrays. Such filters are used for the "vertical" filtering passes in separable filters. ::
Rect roi = Rect(0,0,-1,-1), Stream& stream = Stream::Null()) = 0;
};
The class can be used to apply an arbitrary filtering operation to an image. It contains all the necessary intermediate buffers. Pointers to the initialized ``FilterEngine_GPU`` instances are returned by various ``create*Filter_GPU`` functions (see below), and they are used inside high-level functions such as :ocv:func:`gpu::filter2D`, :ocv:func:`gpu::erode`, :ocv:func:`gpu::Sobel` , and others.
By using ``FilterEngine_GPU`` instead of functions you can avoid unnecessary memory allocation for intermediate buffers and get better performance: ::
while (...)
{
gpu::GpuMat src = getImg();
gpu::GpuMat dst;
// Allocate and release buffers at each iterations
``FilterEngine_GPU`` can process a rectangular sub-region of an image. By default, if ``roi == Rect(0,0,-1,-1)`` , ``FilterEngine_GPU`` processes the inner region of an image ( ``Rect(anchor.x, anchor.y, src_size.width - ksize.width, src_size.height - ksize.height)`` ) because some filters do not check whether indices are outside the image for better performance. See below to understand which filters support processing the whole image and which do not and identify image type limitations.
..note:: The GPU filters do not support the in-place mode.
Creates a non-separable filter engine with the specified filter.
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createFilter2D_GPU( const Ptr<BaseFilter_GPU>& filter2D, int srcType, int dstType)
:param filter2D:Non-separable 2D filter.
:param srcType:Input image type. It must be supported by ``filter2D`` .
:param dstType:Output image type. It must be supported by ``filter2D`` .
Usually this function is used inside such high-level functions as :ocv:func:`gpu::createLinearFilter_GPU`, :ocv:func:`gpu::createBoxFilter_GPU`.
gpu::createSeparableFilter_GPU
----------------------------------
Creates a separable filter engine with the specified filters.
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createSeparableFilter_GPU( const Ptr<BaseRowFilter_GPU>& rowFilter, const Ptr<BaseColumnFilter_GPU>& columnFilter, int srcType, int bufType, int dstType)
:param rowFilter:"Horizontal" 1D filter.
:param columnFilter:"Vertical" 1D filter.
:param srcType:Input image type. It must be supported by ``rowFilter`` .
:param bufType:Buffer image type. It must be supported by ``rowFilter`` and ``columnFilter`` .
:param dstType:Output image type. It must be supported by ``columnFilter`` .
Usually this function is used inside such high-level functions as :ocv:func:`gpu::createSeparableLinearFilter_GPU`.
gpu::getRowSumFilter_GPU
----------------------------
Creates a horizontal 1D box filter.
..ocv:function:: Ptr<BaseRowFilter_GPU> gpu::getRowSumFilter_GPU(int srcType, int sumType, int ksize, int anchor = -1)
:param srcType:Input image type. Only ``CV_8UC1`` type is supported for now.
:param sumType:Output image type. Only ``CV_32FC1`` type is supported for now.
:param ksize:Kernel size.
:param anchor:Anchor point. The default value (-1) means that the anchor is at the kernel center.
..note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
gpu::Filter::apply
------------------
Applies the specified filter to the image.
gpu::getColumnSumFilter_GPU
-------------------------------
Creates a vertical 1D box filter.
..ocv:function:: Ptr<BaseColumnFilter_GPU> gpu::getColumnSumFilter_GPU(int sumType, int dstType, int ksize, int anchor = -1)
:param sumType:Input image type. Only ``CV_8UC1`` type is supported for now.
:param dstType:Output image type. Only ``CV_32FC1`` type is supported for now.
:param src:Source image. ``CV_8UC1`` and ``CV_8UC4`` source types are supported.
:param dst:Destination image with the same size and type as ``src``.
:param kernel:Structuring element used for dilation. If ``kernel=Mat()``, a 3x3 rectangular structuring element is used.
gpu::createLinearFilter
-----------------------
Creates a non-separable linear 2D filter.
:param anchor:Position of an anchor within the element. The default value ``(-1, -1)`` means that the anchor is at the element center.
:param iterations:Number of times dilation to be applied.
:param stream:Stream for the asynchronous version.
..note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
..seealso:::ocv:func:`dilate`
gpu::morphologyEx
---------------------
Applies an advanced morphological operation to an image.
..ocv:function:: void gpu::morphologyEx( const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, Point anchor=Point(-1, -1), int iterations=1 )
..ocv:function:: void gpu::morphologyEx( const GpuMat& src, GpuMat& dst, int op, const Mat& kernel, GpuMat& buf1, GpuMat& buf2, Point anchor=Point(-1, -1), int iterations=1, Stream& stream=Stream::Null() )
:param src:Source image. ``CV_8UC1`` and ``CV_8UC4`` source types are supported.
:param dst:Destination image with the same size and type as ``src`` .
:param op:Type of morphological operation. The following types are possible:
* **MORPH_OPEN** opening
* **MORPH_CLOSE** closing
* **MORPH_GRADIENT** morphological gradient
* **MORPH_TOPHAT** "top hat"
* **MORPH_BLACKHAT** "black hat"
:param kernel:Structuring element.
:param anchor:Position of an anchor within the element. The default value ``Point(-1, -1)`` means that the anchor is at the element center.
:param iterations:Number of times erosion and dilation to be applied.
:param stream:Stream for the asynchronous version.
..note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
..seealso:::ocv:func:`morphologyEx`
gpu::createLinearFilter_GPU
-------------------------------
Creates a non-separable linear filter.
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createLinearFilter_GPU(int srcType, int dstType, const Mat& kernel, Point anchor = Point(-1,-1), int borderType = BORDER_DEFAULT)
..ocv:function:: Ptr<Filter> gpu::createLinearFilter(int srcType, int dstType, InputArray kernel, Point anchor = Point(-1,-1), int borderMode = BORDER_DEFAULT, Scalar borderVal = Scalar::all(0))
:param srcType:Input image type. Supports ``CV_8U`` , ``CV_16U`` and ``CV_32F`` one and four channel image.
:param dstType:Output image type. The same type as ``src`` is supported.
:param kernel:2D array of filter coefficients. Floating-point coefficients will be converted to fixed-point representation before the actual processing. Supports size up to 16. For larger kernels use :ocv:class:`gpu::Convolution`.
:param anchor:Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.
:param borderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
..seealso:::ocv:func:`createLinearFilter`
gpu::filter2D
-----------------
Applies the non-separable 2D linear filter to an image.
..ocv:function:: void gpu::filter2D(const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernel, Point anchor=Point(-1,-1), int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null())
:param src:Source image. Supports ``CV_8U`` , ``CV_16U`` and ``CV_32F`` one and four channel image.
:param dst:Destination image. The size and the number of channels is the same as ``src`` .
:param ddepth:Desired depth of the destination image. If it is negative, it is the same as ``src.depth()`` . It supports only the same depth as the source image depth.
:param dstType:Output image type. Only the same type as ``src`` is supported for now.
:param kernel:2D array of filter coefficients.
:param anchor:Anchor of the kernel that indicates the relative position of a filtered point within the kernel. The anchor resides within the kernel. The special default value (-1,-1) means that the anchor is at the kernel center.
:param anchor:Anchor point. The default value Point(-1, -1) means that the anchor is at the kernel center.
:param borderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
:param borderMode:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
:param stream:Stream for the asynchronous version.
..ocv:function::void gpu::Laplacian(const GpuMat& src, GpuMat& dst, int ddepth, int ksize = 1, double scale = 1, int borderType = BORDER_DEFAULT, Stream& stream = Stream::Null())
..ocv:function:: Ptr<Filter> gpu::createLaplacianFilter(int srcType, int dstType, int ksize = 1, double scale = 1, int borderMode = BORDER_DEFAULT, Scalar borderVal = Scalar::all(0))
:param src:Source image. ``CV_8UC1`` and ``CV_8UC4`` source types are supported.
:param dst:Destination image. The size and number of channels is the same as ``src`` .
:param srcType:Input image type. Supports ``CV_8U`` , ``CV_16U`` and ``CV_32F`` one and four channel image.
:param ddepth:Desired depth of the destination image. It supports only the same depth as the source image depth.
:param dstType:Output image type. Only the same type as ``src`` is supported for now.
:param ksize:Aperture size used to compute the second-derivative filters (see :ocv:func:`getDerivKernels`). It must be positive and odd. Only ``ksize`` = 1 and ``ksize`` = 3 are supported.
:param scale:Optional scale factor for the computed Laplacian values. By default, no scaling is applied (see :ocv:func:`getDerivKernels` ).
:param borderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
:param stream:Stream for the asynchronous version.
..note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
Creates a primitive row filter with the specified kernel.
..ocv:function:: Ptr<BaseRowFilter_GPU> gpu::getLinearRowFilter_GPU( int srcType, int bufType, const Mat& rowKernel, int anchor=-1, int borderType=BORDER_DEFAULT )
:param bufType:Intermediate buffer type with as many channels as ``srcType`` .
:param rowKernel:Filter coefficients. Support kernels with ``size <= 16`` .
:param anchor:Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
:param borderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate`. For details on limitations, see below.
There are two versions of the algorithm: NPP and OpenCV.
* NPP version is called when ``srcType == CV_8UC1`` or ``srcType == CV_8UC4`` and ``bufType == srcType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101`` , ``BORDER_REPLICATE`` , and ``BORDER_CONSTANT`` border types. It checks indices outside the image.
Creates a primitive column filter with the specified kernel.
:param borderMode:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
..ocv:function:: Ptr<BaseColumnFilter_GPU> gpu::getLinearColumnFilter_GPU( int bufType, int dstType, const Mat& columnKernel, int anchor=-1, int borderType=BORDER_DEFAULT )
:param borderVal:Default border value.
:param bufType:Intermediate buffer type with as many channels as ``dstType`` .
:param columnKernel:Filter coefficients. Support kernels with ``size <= 16`` .
:param anchor:Anchor position within the kernel. Negative values mean that the anchor is positioned at the aperture center.
gpu::createSeparableLinearFilter
--------------------------------
Creates a separable linear filter.
:param borderType:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` . For details on limitations, see below.
..ocv:function:: Ptr<Filter> gpu::createSeparableLinearFilter(int srcType, int dstType, InputArray rowKernel, InputArray columnKernel, Point anchor = Point(-1,-1), int rowBorderMode = BORDER_DEFAULT, int columnBorderMode = -1)
There are two versions of the algorithm: NPP and OpenCV.
:param srcType:Source array type.
* NPP version is called when ``dstType == CV_8UC1`` or ``dstType == CV_8UC4`` and ``bufType == dstType`` . Otherwise, the OpenCV version is called. NPP supports only ``BORDER_CONSTANT`` border type and does not check indices outside the image.
:param dstType:Destination array type.
* OpenCV version supports only ``CV_32F`` buffer depth and ``BORDER_REFLECT101`` , ``BORDER_REPLICATE`` , and ``BORDER_CONSTANT`` border types. It checks indices outside image.
:param rowKernel:Horizontal filter coefficients. Support kernels with ``size <= 32`` .
:param rowKernel:Horizontal filter coefficients. Support kernels with ``size <= 16`` .
:param columnKernel:Vertical filter coefficients. Support kernels with ``size <= 16`` .
:param columnKernel:Vertical filter coefficients. Support kernels with ``size <= 32`` .
:param anchor:Anchor position within the kernel. Negative values mean that anchor is positioned at the aperture center.
:param rowBorderType:Pixel extrapolation method in the vertical direction For details, see :ocv:func:`borderInterpolate`. For details on limitations, see :ocv:func:`gpu::getLinearRowFilter_GPU`, cpp:ocv:func:`gpu::getLinearColumnFilter_GPU`.
:param rowBorderMode:Pixel extrapolation method in the vertical direction For details, see :ocv:func:`borderInterpolate`.
:param columnBorderType:Pixel extrapolation method in the horizontal direction.
:param columnBorderMode:Pixel extrapolation method in the horizontal direction.
..ocv:function::void gpu::sepFilter2D( const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, Point anchor=Point(-1,-1), int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1 )
..ocv:function:: Ptr<Filter> gpu::createDerivFilter(int srcType, int dstType, int dx, int dy, int ksize, bool normalize = false, double scale = 1, int rowBorderMode = BORDER_DEFAULT, int columnBorderMode = -1)
..ocv:function:: void gpu::sepFilter2D( const GpuMat& src, GpuMat& dst, int ddepth, const Mat& kernelX, const Mat& kernelY, GpuMat& buf, Point anchor=Point(-1,-1), int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, Stream& stream=Stream::Null() )
:param dst:Destination image with the same size and number of channels as ``src`` .
:param dy:Derivative order in respect of y.
:param ddepth:Destination image depth. ``CV_8U`` , ``CV_16S`` , ``CV_32S`` , and ``CV_32F`` are supported.
:param ksize:Aperture size. See :ocv:func:`getDerivKernels` for details.
:param kernelX:Horizontal filter coefficients.
:param normalize:Flag indicating whether to normalize (scale down) the filter coefficients or not. See :ocv:func:`getDerivKernels` for details.
:param kernelY:Vertical filter coefficients.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :ocv:func:`getDerivKernels` .
:param anchor:Anchor position within the kernel. The default value ``(-1, 1)`` means that the anchor is at the kernel center.
:param rowBorderMode:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
:param rowBorderType:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
:param columnBorderMode:Pixel extrapolation method in the horizontal direction.
:param columnBorderType:Pixel extrapolation method in the horizontal direction.
:param stream:Stream for the asynchronous version.
..ocv:function:: Ptr<Filter> gpu::createSobelFilter(int srcType, int dstType, int dx, int dy, int ksize = 3, double scale = 1, int rowBorderMode = BORDER_DEFAULT, int columnBorderMode = -1)
:param srcType:Source image type.
gpu::createDerivFilter_GPU
------------------------------
Creates a filter engine for the generalized Sobel operator.
:param dstType:Destination array type.
..ocv:function:: Ptr<FilterEngine_GPU> gpu::createDerivFilter_GPU(int srcType, int dstType, int dx, int dy, int ksize, int rowBorderType = BORDER_DEFAULT, int columnBorderType = -1)
:param dstType:Destination image type with as many channels as ``srcType`` , ``CV_8U`` , ``CV_16S`` , ``CV_32S`` , and ``CV_32F`` depths are supported.
:param ksize:Size of the extended Sobel kernel. Possible values are 1, 3, 5 or 7.
:param dx:Derivative order in respect of x.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :ocv:func:`getDerivKernels` .
:param dy:Derivative order in respect of y.
:param rowBorderMode:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
:param ksize:Aperture size. See :ocv:func:`getDerivKernels` for details.
:param columnBorderMode:Pixel extrapolation method in the horizontal direction.
:param rowBorderType:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
..seealso:::ocv:func:`Sobel`
:param columnBorderType:Pixel extrapolation method in the horizontal direction.
..ocv:function:: Ptr<Filter> gpu::createScharrFilter(int srcType, int dstType, int dx, int dy, double scale = 1, int rowBorderMode = BORDER_DEFAULT, int columnBorderMode = -1)
gpu::Sobel
--------------
Applies the generalized Sobel operator to an image.
:param srcType:Source image type.
..ocv:function:: void gpu::Sobel( const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, int ksize=3, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1 )
:param dstType:Destination array type.
..ocv:function:: void gpu::Sobel( const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, int ksize=3, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, Stream& stream=Stream::Null() )
:param dst:Destination image with the same size and number of channels as source image.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. See :ocv:func:`getDerivKernels` for details.
:param ddepth:Destination image depth. ``CV_8U`` , ``CV_16S`` , ``CV_32S`` , and ``CV_32F`` are supported.
:param rowBorderMode:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
:param dx:Derivative order in respect of x.
:param columnBorderMode:Pixel extrapolation method in the horizontal direction.
:param dy:Derivative order in respect of y.
..seealso:::ocv:func:`Scharr`
:param ksize:Size of the extended Sobel kernel. Possible values are 1, 3, 5 or 7.
:param scale:Optional scale factor for the computed derivative values. By default, no scaling is applied. For details, see :ocv:func:`getDerivKernels` .
:param rowBorderType:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
gpu::createGaussianFilter
-------------------------
Creates a Gaussian filter.
:param columnBorderType:Pixel extrapolation method in the horizontal direction.
..ocv:function:: Ptr<Filter> gpu::createGaussianFilter(int srcType, int dstType, Size ksize, double sigma1, double sigma2 = 0, int rowBorderMode = BORDER_DEFAULT, int columnBorderMode = -1)
:param stream:Stream for the asynchronous version.
:param ksize:Aperture size. See :ocv:func:`getGaussianKernel` for details.
:param sigma1:Gaussian sigma in the horizontal direction. See :ocv:func:`getGaussianKernel` for details.
gpu::Scharr
---------------
Calculates the first x- or y- image derivative using the Scharr operator.
:param sigma2:Gaussian sigma in the vertical direction. If 0, then :math:`\texttt{sigma2}\leftarrow\texttt{sigma1}` .
..ocv:function:: void gpu::Scharr( const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1 )
:param rowBorderMode:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
..ocv:function:: void gpu::Scharr( const GpuMat& src, GpuMat& dst, int ddepth, int dx, int dy, GpuMat& buf, double scale=1, int rowBorderType=BORDER_DEFAULT, int columnBorderType=-1, Stream& stream=Stream::Null() )
:param columnBorderMode:Pixel extrapolation method in the horizontal direction.
:param dst:Destination image with the same size and type as ``src`` .
:param ksize:Gaussian kernel size. ``ksize.width`` and ``ksize.height`` can differ but they both must be positive and odd. If they are zeros, they are computed from ``sigma1`` and ``sigma2`` .
:param sigma1:Gaussian kernel standard deviation in X direction.
gpu::createBoxMinFilter
-----------------------
Creates the minimum filter.
:param sigma2:Gaussian kernel standard deviation in Y direction. If ``sigma2`` is zero, it is set to be equal to ``sigma1`` . If they are both zeros, they are computed from ``ksize.width`` and ``ksize.height``, respectively. See :ocv:func:`getGaussianKernel` for details. To fully control the result regardless of possible future modification of all this semantics, you are recommended to specify all of ``ksize`` , ``sigma1`` , and ``sigma2`` .
..ocv:function:: Ptr<Filter> gpu::createBoxMinFilter(int srcType, Size ksize, Point anchor = Point(-1, -1), int borderMode = BORDER_DEFAULT, Scalar borderVal = Scalar::all(0))
:param rowBorderType:Pixel extrapolation method in the vertical direction. For details, see :ocv:func:`borderInterpolate`.
:param srcType:Input/output image type. Only ``CV_8UC1`` and ``CV_8UC4`` are supported.
:param columnBorderType:Pixel extrapolation method in the horizontal direction.
:param ksize:Kernel size.
:param stream:Stream for the asynchronous version.
:param anchor:Anchor point. The default value (-1) means that the anchor is at the kernel center.
:param borderMode:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
:param borderVal:Default border value.
gpu::getMaxFilter_GPU
-------------------------
Creates the maximum filter.
..ocv:function:: Ptr<BaseFilter_GPU> gpu::getMaxFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
gpu::createRowSumFilter
-----------------------
Creates a horizontal 1D box filter.
..ocv:function:: Ptr<Filter> gpu::createRowSumFilter(int srcType, int dstType, int ksize, int anchor = -1, int borderMode = BORDER_DEFAULT, Scalar borderVal = Scalar::all(0))
:param srcType:Input image type. Only ``CV_8UC1`` and ``CV_8UC4`` are supported.
:param srcType:Input image type. Only ``CV_8UC1`` type is supported for now.
:param dstType:Output image type. It supports only the same type as the source type.
:param sumType:Output image type. Only ``CV_32FC1`` type is supported for now.
:param ksize:Kernel size.
:param anchor:Anchor point. The default value (-1) means that the anchor is at the kernel center.
..note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
:param borderMode:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
:param borderVal:Default border value.
gpu::getMinFilter_GPU
-------------------------
Creates the minimum filter.
..ocv:function:: Ptr<BaseFilter_GPU> gpu::getMinFilter_GPU(int srcType, int dstType, const Size& ksize, Point anchor = Point(-1,-1))
gpu::createColumnSumFilter
--------------------------
Creates a vertical 1D box filter.
:param srcType:Input image type. Only ``CV_8UC1`` and ``CV_8UC4`` are supported.
..ocv:function:: Ptr<Filter> gpu::createColumnSumFilter(int srcType, int dstType, int ksize, int anchor = -1, int borderMode = BORDER_DEFAULT, Scalar borderVal = Scalar::all(0))
:param dstType:Output image type. It supports only the same type as the source type.
:param srcType:Input image type. Only ``CV_8UC1`` type is supported for now.
:param sumType:Output image type. Only ``CV_32FC1`` type is supported for now.
:param ksize:Kernel size.
:param anchor:Anchor point. The default value (-1) means that the anchor is at the kernel center.
..note:: This filter does not check out-of-border accesses, so only a proper sub-matrix of a bigger matrix has to be passed to it.
:param borderMode:Pixel extrapolation method. For details, see :ocv:func:`borderInterpolate` .
Vladislav Vinogradov
12 years ago