OpenCV  4.4.0-dev
Open Source Computer Vision
Functions
Graph API: Image filters

Functions

GMat cv::gapi::bilateralFilter (const GMat &src, int d, double sigmaColor, double sigmaSpace, int borderType=BORDER_DEFAULT)
 Applies the bilateral filter to an image. More...
 
GMat cv::gapi::blur (const GMat &src, const Size &ksize, const Point &anchor=Point(-1,-1), int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
 Blurs an image using the normalized box filter. More...
 
GMat cv::gapi::boxFilter (const GMat &src, int dtype, const Size &ksize, const Point &anchor=Point(-1,-1), bool normalize=true, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
 Blurs an image using the box filter. More...
 
GMat cv::gapi::Canny (const GMat &image, double threshold1, double threshold2, int apertureSize=3, bool L2gradient=false)
 Finds edges in an image using the Canny algorithm. More...
 
GMat cv::gapi::dilate (const GMat &src, const Mat &kernel, const Point &anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
 Dilates an image by using a specific structuring element. More...
 
GMat cv::gapi::dilate3x3 (const GMat &src, int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
 Dilates an image by using 3 by 3 rectangular structuring element. More...
 
GMat cv::gapi::equalizeHist (const GMat &src)
 Equalizes the histogram of a grayscale image. More...
 
GMat cv::gapi::erode (const GMat &src, const Mat &kernel, const Point &anchor=Point(-1,-1), int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
 Erodes an image by using a specific structuring element. More...
 
GMat cv::gapi::erode3x3 (const GMat &src, int iterations=1, int borderType=BORDER_CONSTANT, const Scalar &borderValue=morphologyDefaultBorderValue())
 Erodes an image by using 3 by 3 rectangular structuring element. More...
 
GMat cv::gapi::filter2D (const GMat &src, int ddepth, const Mat &kernel, const Point &anchor=Point(-1,-1), const Scalar &delta=Scalar(0), int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
 Convolves an image with the kernel. More...
 
GMat cv::gapi::gaussianBlur (const GMat &src, const Size &ksize, double sigmaX, double sigmaY=0, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
 Blurs an image using a Gaussian filter. More...
 
GArray< Point2fcv::gapi::goodFeaturesToTrack (const GMat &image, int maxCorners, double qualityLevel, double minDistance, const Mat &mask=Mat(), int blockSize=3, bool useHarrisDetector=false, double k=0.04)
 Determines strong corners on an image. More...
 
GMat cv::gapi::Laplacian (const GMat &src, int ddepth, int ksize=1, double scale=1, double delta=0, int borderType=BORDER_DEFAULT)
 Calculates the Laplacian of an image. More...
 
GMat cv::gapi::medianBlur (const GMat &src, int ksize)
 Blurs an image using the median filter. More...
 
GMat cv::gapi::sepFilter (const GMat &src, int ddepth, const Mat &kernelX, const Mat &kernelY, const Point &anchor, const Scalar &delta, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
 Applies a separable linear filter to a matrix(image). More...
 
GMat cv::gapi::Sobel (const GMat &src, int ddepth, int dx, int dy, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. More...
 
std::tuple< GMat, GMatcv::gapi::SobelXY (const GMat &src, int ddepth, int order, int ksize=3, double scale=1, double delta=0, int borderType=BORDER_DEFAULT, const Scalar &borderValue=Scalar(0))
 Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator. More...
 

Detailed Description

Function Documentation

◆ bilateralFilter()

GMat cv::gapi::bilateralFilter ( const GMat src,
int  d,
double  sigmaColor,
double  sigmaSpace,
int  borderType = BORDER_DEFAULT 
)

#include <opencv2/gapi/imgproc.hpp>

Applies the bilateral filter to an image.

The function applies bilateral filtering to the input image, as described in http://www.dai.ed.ac.uk/CVonline/LOCAL_COPIES/MANDUCHI1/Bilateral_Filtering.html bilateralFilter can reduce unwanted noise very well while keeping edges fairly sharp. However, it is very slow compared to most filters.

Sigma values: For simplicity, you can set the 2 sigma values to be the same. If they are small (< 10), the filter will not have much effect, whereas if they are large (> 150), they will have a very strong effect, making the image look "cartoonish".

Filter size: Large filters (d > 5) are very slow, so it is recommended to use d=5 for real-time applications, and perhaps d=9 for offline applications that need heavy noise filtering.

This filter does not work inplace.

Note
Function textual ID is "org.opencv.imgproc.filters.bilateralfilter"
Parameters
srcSource 8-bit or floating-point, 1-channel or 3-channel image.
dDiameter of each pixel neighborhood that is used during filtering. If it is non-positive, it is computed from sigmaSpace.
sigmaColorFilter sigma in the color space. A larger value of the parameter means that farther colors within the pixel neighborhood (see sigmaSpace) will be mixed together, resulting in larger areas of semi-equal color.
sigmaSpaceFilter sigma in the coordinate space. A larger value of the parameter means that farther pixels will influence each other as long as their colors are close enough (see sigmaColor ). When d>0, it specifies the neighborhood size regardless of sigmaSpace. Otherwise, d is proportional to sigmaSpace.
borderTypeborder mode used to extrapolate pixels outside of the image, see BorderTypes
Returns
Destination image of the same size and type as src.

◆ blur()

GMat cv::gapi::blur ( const GMat src,
const Size ksize,
const Point anchor = Point(-1,-1),
int  borderType = BORDER_DEFAULT,
const Scalar borderValue = Scalar(0) 
)

#include <opencv2/gapi/imgproc.hpp>

Blurs an image using the normalized box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \frac{1}{\texttt{ksize.width*ksize.height}} \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \end{bmatrix}\]

The call blur(src, ksize, anchor, borderType) is equivalent to boxFilter(src, src.type(), ksize, anchor, true, borderType).

Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.blur"
Parameters
srcSource image.
ksizeblurring kernel size.
anchoranchor point; default value Point(-1,-1) means that the anchor is at the kernel center.
borderTypeborder mode used to extrapolate pixels outside of the image, see cv::BorderTypes
borderValueborder value in case of constant border type
See also
boxFilter, bilateralFilter, GaussianBlur, medianBlur

◆ boxFilter()

GMat cv::gapi::boxFilter ( const GMat src,
int  dtype,
const Size ksize,
const Point anchor = Point(-1,-1),
bool  normalize = true,
int  borderType = BORDER_DEFAULT,
const Scalar borderValue = Scalar(0) 
)

#include <opencv2/gapi/imgproc.hpp>

Blurs an image using the box filter.

The function smooths an image using the kernel:

\[\texttt{K} = \alpha \begin{bmatrix} 1 & 1 & 1 & \cdots & 1 & 1 \\ 1 & 1 & 1 & \cdots & 1 & 1 \\ \hdotsfor{6} \\ 1 & 1 & 1 & \cdots & 1 & 1 \end{bmatrix}\]

where

\[\alpha = \begin{cases} \frac{1}{\texttt{ksize.width*ksize.height}} & \texttt{when } \texttt{normalize=true} \\1 & \texttt{otherwise} \end{cases}\]

Unnormalized box filter is useful for computing various integral characteristics over each pixel neighborhood, such as covariance matrices of image derivatives (used in dense optical flow algorithms, and so on). If you need to compute pixel sums over variable-size windows, use cv::integral.

Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.boxfilter"
Parameters
srcSource image.
dtypethe output image depth (-1 to set the input image data type).
ksizeblurring kernel size.
anchorAnchor position within the kernel. The default value \((-1,-1)\) means that the anchor is at the kernel center.
normalizeflag, specifying whether the kernel is normalized by its area or not.
borderTypePixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of constant border type
See also
sepFilter, gaussianBlur, medianBlur, integral

◆ Canny()

GMat cv::gapi::Canny ( const GMat image,
double  threshold1,
double  threshold2,
int  apertureSize = 3,
bool  L2gradient = false 
)

#include <opencv2/gapi/imgproc.hpp>

Finds edges in an image using the Canny algorithm.

The function finds edges in the input image and marks them in the output map edges using the Canny algorithm. The smallest value between threshold1 and threshold2 is used for edge linking. The largest value is used to find initial segments of strong edges. See http://en.wikipedia.org/wiki/Canny_edge_detector

Note
Function textual ID is "org.opencv.imgproc.filters.canny"
Parameters
image8-bit input image.
threshold1first threshold for the hysteresis procedure.
threshold2second threshold for the hysteresis procedure.
apertureSizeaperture size for the Sobel operator.
L2gradienta flag, indicating whether a more accurate \(L_2\) norm \(=\sqrt{(dI/dx)^2 + (dI/dy)^2}\) should be used to calculate the image gradient magnitude ( L2gradient=true ), or whether the default \(L_1\) norm \(=|dI/dx|+|dI/dy|\) is enough ( L2gradient=false ).

◆ dilate()

GMat cv::gapi::dilate ( const GMat src,
const Mat kernel,
const Point anchor = Point(-1,-1),
int  iterations = 1,
int  borderType = BORDER_CONSTANT,
const Scalar borderValue = morphologyDefaultBorderValue() 
)

#include <opencv2/gapi/imgproc.hpp>

Dilates an image by using a specific structuring element.

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

Dilation can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, and CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.dilate"
Parameters
srcinput image.
kernelstructuring element used for dilation; if elemenat=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times dilation is applied.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of a constant border
See also
erode, morphologyEx, getStructuringElement

◆ dilate3x3()

GMat cv::gapi::dilate3x3 ( const GMat src,
int  iterations = 1,
int  borderType = BORDER_CONSTANT,
const Scalar borderValue = morphologyDefaultBorderValue() 
)

#include <opencv2/gapi/imgproc.hpp>

Dilates an image by using 3 by 3 rectangular structuring element.

The function dilates the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the maximum is taken:

\[\texttt{dst} (x,y) = \max _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

Dilation can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, and CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.dilate"
Parameters
srcinput image.
iterationsnumber of times dilation is applied.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of a constant border
See also
dilate, erode3x3

◆ equalizeHist()

GMat cv::gapi::equalizeHist ( const GMat src)

#include <opencv2/gapi/imgproc.hpp>

Equalizes the histogram of a grayscale image.

The function equalizes the histogram of the input image using the following algorithm:

  • Calculate the histogram \(H\) for src .
  • Normalize the histogram so that the sum of histogram bins is 255.
  • Compute the integral of the histogram:

    \[H'_i = \sum _{0 \le j < i} H(j)\]

  • Transform the image using \(H'\) as a look-up table: \(\texttt{dst}(x,y) = H'(\texttt{src}(x,y))\)

The algorithm normalizes the brightness and increases the contrast of the image.

Note
The returned image is of the same size and type as input.
Function textual ID is "org.opencv.imgproc.equalizeHist"
Parameters
srcSource 8-bit single channel image.

◆ erode()

GMat cv::gapi::erode ( const GMat src,
const Mat kernel,
const Point anchor = Point(-1,-1),
int  iterations = 1,
int  borderType = BORDER_CONSTANT,
const Scalar borderValue = morphologyDefaultBorderValue() 
)

#include <opencv2/gapi/imgproc.hpp>

Erodes an image by using a specific structuring element.

The function erodes the source image using the specified structuring element that determines the shape of a pixel neighborhood over which the minimum is taken:

\[\texttt{dst} (x,y) = \min _{(x',y'): \, \texttt{element} (x',y') \ne0 } \texttt{src} (x+x',y+y')\]

Erosion can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, and CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.erode"
Parameters
srcinput image
kernelstructuring element used for erosion; if element=Mat(), a 3 x 3 rectangular structuring element is used. Kernel can be created using getStructuringElement.
anchorposition of the anchor within the element; default value (-1, -1) means that the anchor is at the element center.
iterationsnumber of times erosion is applied.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of a constant border
See also
dilate

◆ erode3x3()

GMat cv::gapi::erode3x3 ( const GMat src,
int  iterations = 1,
int  borderType = BORDER_CONSTANT,
const Scalar borderValue = morphologyDefaultBorderValue() 
)

#include <opencv2/gapi/imgproc.hpp>

Erodes an image by using 3 by 3 rectangular structuring element.

The function erodes the source image using the rectangular structuring element with rectangle center as an anchor. Erosion can be applied several (iterations) times. In case of multi-channel images, each channel is processed independently. Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, and CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Parameters
srcinput image
iterationsnumber of times erosion is applied.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of a constant border
See also
erode, dilate3x3

◆ filter2D()

GMat cv::gapi::filter2D ( const GMat src,
int  ddepth,
const Mat kernel,
const Point anchor = Point(-1,-1),
const Scalar delta = Scalar(0),
int  borderType = BORDER_DEFAULT,
const Scalar borderValue = Scalar(0) 
)

#include <opencv2/gapi/imgproc.hpp>

Convolves an image with the kernel.

The function applies an arbitrary linear filter to an image. When the aperture is partially outside the image, the function interpolates outlier pixel values according to the specified border mode.

The function does actually compute correlation, not the convolution:

\[\texttt{dst} (x,y) = \sum _{ \substack{0\leq x' < \texttt{kernel.cols}\\{0\leq y' < \texttt{kernel.rows}}}} \texttt{kernel} (x',y')* \texttt{src} (x+x'- \texttt{anchor.x} ,y+y'- \texttt{anchor.y} )\]

That is, the kernel is not mirrored around the anchor point. If you need a real convolution, flip the kernel using flip and set the new anchor to (kernel.cols - anchor.x - 1, kernel.rows - anchor.y - 1).

Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1. Output image must have the same size and number of channels an input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.filter2D"
Parameters
srcinput image.
ddepthdesired depth of the destination image
kernelconvolution kernel (or rather a correlation kernel), a single-channel floating point matrix; if you want to apply different kernels to different channels, split the image into separate color planes using split and process them individually.
anchoranchor of the kernel that indicates the relative position of a filtered point within the kernel; the anchor should lie within the kernel; default value (-1,-1) means that the anchor is at the kernel center.
deltaoptional value added to the filtered pixels before storing them in dst.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of constant border type
See also
sepFilter

◆ gaussianBlur()

GMat cv::gapi::gaussianBlur ( const GMat src,
const Size ksize,
double  sigmaX,
double  sigmaY = 0,
int  borderType = BORDER_DEFAULT,
const Scalar borderValue = Scalar(0) 
)

#include <opencv2/gapi/imgproc.hpp>

Blurs an image using a Gaussian filter.

The function filter2Ds the source image with the specified Gaussian kernel. Output image must have the same type and number of channels an input image.

Supported input matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.gaussianBlur"
Parameters
srcinput image;
ksizeGaussian kernel size. ksize.width and ksize.height can differ but they both must be positive and odd. Or, they can be zero's and then they are computed from sigma.
sigmaXGaussian kernel standard deviation in X direction.
sigmaYGaussian kernel standard deviation in Y direction; if sigmaY is zero, it is set to be equal to sigmaX, if both sigmas are zeros, they are computed from ksize.width and ksize.height, respectively (see cv::getGaussianKernel for details); to fully control the result regardless of possible future modifications of all this semantics, it is recommended to specify all of ksize, sigmaX, and sigmaY.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of constant border type
See also
sepFilter, boxFilter, medianBlur

◆ goodFeaturesToTrack()

GArray<Point2f> cv::gapi::goodFeaturesToTrack ( const GMat image,
int  maxCorners,
double  qualityLevel,
double  minDistance,
const Mat mask = Mat(),
int  blockSize = 3,
bool  useHarrisDetector = false,
double  k = 0.04 
)

#include <opencv2/gapi/imgproc.hpp>

Determines strong corners on an image.

The function finds the most prominent corners in the image or in the specified image region, as described in [212]

  • Function calculates the corner quality measure at every source image pixel using the cornerMinEigenVal or cornerHarris .
  • Function performs a non-maximum suppression (the local maximums in 3 x 3 neighborhood are retained).
  • The corners with the minimal eigenvalue less than \(\texttt{qualityLevel} \cdot \max_{x,y} qualityMeasureMap(x,y)\) are rejected.
  • The remaining corners are sorted by the quality measure in the descending order.
  • Function throws away each corner for which there is a stronger corner at a distance less than maxDistance.

The function can be used to initialize a point-based tracker of an object.

Note
If the function is called with different values A and B of the parameter qualityLevel , and A > B, the vector of returned corners with qualityLevel=A will be the prefix of the output vector with qualityLevel=B .
Function textual ID is "org.opencv.imgproc.goodFeaturesToTrack"
Parameters
imageInput 8-bit or floating-point 32-bit, single-channel image.
maxCornersMaximum number of corners to return. If there are more corners than are found, the strongest of them is returned. maxCorners <= 0 implies that no limit on the maximum is set and all detected corners are returned.
qualityLevelParameter characterizing the minimal accepted quality of image corners. The parameter value is multiplied by the best corner quality measure, which is the minimal eigenvalue (see cornerMinEigenVal ) or the Harris function response (see cornerHarris ). The corners with the quality measure less than the product are rejected. For example, if the best corner has the quality measure = 1500, and the qualityLevel=0.01 , then all the corners with the quality measure less than 15 are rejected.
minDistanceMinimum possible Euclidean distance between the returned corners.
maskOptional region of interest. If the image is not empty (it needs to have the type CV_8UC1 and the same size as image ), it specifies the region in which the corners are detected.
blockSizeSize of an average block for computing a derivative covariation matrix over each pixel neighborhood. See cornerEigenValsAndVecs .
useHarrisDetectorParameter indicating whether to use a Harris detector (see cornerHarris) or cornerMinEigenVal.
kFree parameter of the Harris detector.
Returns
vector of detected corners.

◆ Laplacian()

GMat cv::gapi::Laplacian ( const GMat src,
int  ddepth,
int  ksize = 1,
double  scale = 1,
double  delta = 0,
int  borderType = BORDER_DEFAULT 
)

#include <opencv2/gapi/imgproc.hpp>

Calculates the Laplacian of an image.

The function calculates the Laplacian of the source image by adding up the second x and y derivatives calculated using the Sobel operator:

\[\texttt{dst} = \Delta \texttt{src} = \frac{\partial^2 \texttt{src}}{\partial x^2} + \frac{\partial^2 \texttt{src}}{\partial y^2}\]

This is done when ksize > 1. When ksize == 1, the Laplacian is computed by filtering the image with the following \(3 \times 3\) aperture:

\[\vecthreethree {0}{1}{0}{1}{-4}{1}{0}{1}{0}\]

Note
Function textual ID is "org.opencv.imgproc.filters.laplacian"
Parameters
srcSource image.
ddepthDesired depth of the destination image.
ksizeAperture size used to compute the second-derivative filters. See getDerivKernels for details. The size must be positive and odd.
scaleOptional scale factor for the computed Laplacian values. By default, no scaling is applied. See getDerivKernels for details.
deltaOptional delta value that is added to the results prior to storing them in dst .
borderTypePixel extrapolation method, see BorderTypes. BORDER_WRAP is not supported.
Returns
Destination image of the same size and the same number of channels as src.
See also
Sobel, Scharr

◆ medianBlur()

GMat cv::gapi::medianBlur ( const GMat src,
int  ksize 
)

#include <opencv2/gapi/imgproc.hpp>

Blurs an image using the median filter.

The function smoothes an image using the median filter with the \(\texttt{ksize} \times \texttt{ksize}\) aperture. Each channel of a multi-channel image is processed independently. Output image must have the same type, size, and number of channels as the input image.

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest. The median filter uses cv::BORDER_REPLICATE internally to cope with border pixels, see cv::BorderTypes
Function textual ID is "org.opencv.imgproc.filters.medianBlur"
Parameters
srcinput matrix (image)
ksizeaperture linear size; it must be odd and greater than 1, for example: 3, 5, 7 ...
See also
boxFilter, gaussianBlur

◆ sepFilter()

GMat cv::gapi::sepFilter ( const GMat src,
int  ddepth,
const Mat kernelX,
const Mat kernelY,
const Point anchor,
const Scalar delta,
int  borderType = BORDER_DEFAULT,
const Scalar borderValue = Scalar(0) 
)

#include <opencv2/gapi/imgproc.hpp>

Applies a separable linear filter to a matrix(image).

The function applies a separable linear filter to the matrix. That is, first, every row of src is filtered with the 1D kernel kernelX. Then, every column of the result is filtered with the 1D kernel kernelY. The final result is returned.

Supported matrix data types are CV_8UC1, CV_8UC3, CV_16UC1, CV_16SC1, CV_32FC1. Output image must have the same type, size, and number of channels as the input image.

Note
In case of floating-point computation, rounding to nearest even is procedeed if hardware supports it (if not - to nearest value).
Function textual ID is "org.opencv.imgproc.filters.sepfilter"
Parameters
srcSource image.
ddepthdesired depth of the destination image (the following combinations of src.depth() and ddepth are supported:
    src.depth() = CV_8U, ddepth = -1/CV_16S/CV_32F/CV_64F
    src.depth() = CV_16U/CV_16S, ddepth = -1/CV_32F/CV_64F
    src.depth() = CV_32F, ddepth = -1/CV_32F/CV_64F
    src.depth() = CV_64F, ddepth = -1/CV_64F

when ddepth=-1, the output image will have the same depth as the source)

Parameters
kernelXCoefficients for filtering each row.
kernelYCoefficients for filtering each column.
anchorAnchor position within the kernel. The default value \((-1,-1)\) means that the anchor is at the kernel center.
deltaValue added to the filtered results before storing them.
borderTypePixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of constant border type
See also
boxFilter, gaussianBlur, medianBlur

◆ Sobel()

GMat cv::gapi::Sobel ( const GMat src,
int  ddepth,
int  dx,
int  dy,
int  ksize = 3,
double  scale = 1,
double  delta = 0,
int  borderType = BORDER_DEFAULT,
const Scalar borderValue = Scalar(0) 
)

#include <opencv2/gapi/imgproc.hpp>

Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.

In all cases except one, the \(\texttt{ksize} \times \texttt{ksize}\) separable kernel is used to calculate the derivative. When \(\texttt{ksize = 1}\), the \(3 \times 1\) or \(1 \times 3\) kernel is used (that is, no Gaussian smoothing is done). ksize = 1 can only be used for the first or the second x- or y- derivatives.

There is also the special value ksize = FILTER_SCHARR (-1) that corresponds to the \(3\times3\) Scharr filter that may give more accurate results than the \(3\times3\) Sobel. The Scharr aperture is

\[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\]

for the x-derivative, or transposed for the y-derivative.

The function calculates an image derivative by convolving the image with the appropriate kernel:

\[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\]

The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3) or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first case corresponds to a kernel of:

\[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\]

The second case corresponds to a kernel of:

\[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\]

Note
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.sobel"
Parameters
srcinput image.
ddepthoutput image depth, see combinations; in the case of 8-bit input images it will result in truncated derivatives.
dxorder of the derivative x.
dyorder of the derivative y.
ksizesize of the extended Sobel kernel; it must be odd.
scaleoptional scale factor for the computed derivative values; by default, no scaling is applied (see cv::getDerivKernels for details).
deltaoptional delta value that is added to the results prior to storing them in dst.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of constant border type
See also
filter2D, gaussianBlur, cartToPolar

◆ SobelXY()

std::tuple<GMat, GMat> cv::gapi::SobelXY ( const GMat src,
int  ddepth,
int  order,
int  ksize = 3,
double  scale = 1,
double  delta = 0,
int  borderType = BORDER_DEFAULT,
const Scalar borderValue = Scalar(0) 
)

#include <opencv2/gapi/imgproc.hpp>

Calculates the first, second, third, or mixed image derivatives using an extended Sobel operator.

In all cases except one, the \(\texttt{ksize} \times \texttt{ksize}\) separable kernel is used to calculate the derivative. When \(\texttt{ksize = 1}\), the \(3 \times 1\) or \(1 \times 3\) kernel is used (that is, no Gaussian smoothing is done). ksize = 1 can only be used for the first or the second x- or y- derivatives.

There is also the special value ksize = FILTER_SCHARR (-1) that corresponds to the \(3\times3\) Scharr filter that may give more accurate results than the \(3\times3\) Sobel. The Scharr aperture is

\[\vecthreethree{-3}{0}{3}{-10}{0}{10}{-3}{0}{3}\]

for the x-derivative, or transposed for the y-derivative.

The function calculates an image derivative by convolving the image with the appropriate kernel:

\[\texttt{dst} = \frac{\partial^{xorder+yorder} \texttt{src}}{\partial x^{xorder} \partial y^{yorder}}\]

The Sobel operators combine Gaussian smoothing and differentiation, so the result is more or less resistant to the noise. Most often, the function is called with ( xorder = 1, yorder = 0, ksize = 3) or ( xorder = 0, yorder = 1, ksize = 3) to calculate the first x- or y- image derivative. The first case corresponds to a kernel of:

\[\vecthreethree{-1}{0}{1}{-2}{0}{2}{-1}{0}{1}\]

The second case corresponds to a kernel of:

\[\vecthreethree{-1}{-2}{-1}{0}{0}{0}{1}{2}{1}\]

Note
First returned matrix correspons to dx derivative while the second one to dy.
Rounding to nearest even is procedeed if hardware supports it, if not - to nearest.
Function textual ID is "org.opencv.imgproc.filters.sobelxy"
Parameters
srcinput image.
ddepthoutput image depth, see combinations; in the case of 8-bit input images it will result in truncated derivatives.
orderorder of the derivatives.
ksizesize of the extended Sobel kernel; it must be odd.
scaleoptional scale factor for the computed derivative values; by default, no scaling is applied (see cv::getDerivKernels for details).
deltaoptional delta value that is added to the results prior to storing them in dst.
borderTypepixel extrapolation method, see cv::BorderTypes
borderValueborder value in case of constant border type
See also
filter2D, gaussianBlur, cartToPolar