be63ce723f
updated links in cheatsheet renamed directory for Mat tutorial changed links from willow docs to opencv.itseez.com, from Trac to current Redmine
277 lines
8.7 KiB
ReStructuredText
277 lines
8.7 KiB
ReStructuredText
.. _sobel_derivatives:
|
|
|
|
Sobel Derivatives
|
|
******************
|
|
|
|
|
|
Goal
|
|
=====
|
|
|
|
In this tutorial you will learn how to:
|
|
|
|
.. container:: enumeratevisibleitemswithsquare
|
|
|
|
* Use the OpenCV function :sobel:`Sobel <>` to calculate the derivatives from an image.
|
|
* Use the OpenCV function :scharr:`Scharr <>` to calculate a more accurate derivative for a kernel of size :math:`3 \cdot 3`
|
|
|
|
Theory
|
|
========
|
|
|
|
.. note::
|
|
The explanation below belongs to the book **Learning OpenCV** by Bradski and Kaehler.
|
|
|
|
|
|
#. In the last two tutorials we have seen applicative examples of convolutions. One of the most important convolutions is the computation of derivatives in an image (or an approximation to them).
|
|
|
|
#. Why may be important the calculus of the derivatives in an image? Let's imagine we want to detect the *edges* present in the image. For instance:
|
|
|
|
|
|
.. image:: images/Sobel_Derivatives_Tutorial_Theory_0.jpg
|
|
:alt: How intensity changes in an edge
|
|
:align: center
|
|
|
|
You can easily notice that in an *edge*, the pixel intensity *changes* in a notorious way. A good way to express *changes* is by using *derivatives*. A high change in gradient indicates a major change in the image.
|
|
|
|
#. To be more graphical, let's assume we have a 1D-image. An edge is shown by the "jump" in intensity in the plot below:
|
|
|
|
.. image:: images/Sobel_Derivatives_Tutorial_Theory_Intensity_Function.jpg
|
|
:alt: Intensity Plot for an edge
|
|
:align: center
|
|
|
|
#. The edge "jump" can be seen more easily if we take the first derivative (actually, here appears as a maximum)
|
|
|
|
.. image:: images/Sobel_Derivatives_Tutorial_Theory_dIntensity_Function.jpg
|
|
:alt: First derivative of Intensity - Plot for an edge
|
|
:align: center
|
|
|
|
#. So, from the explanation above, we can deduce that a method to detect edges in an image can be performed by locating pixel locations where the gradient is higher than its neighbors (or to generalize, higher than a threshold).
|
|
|
|
#. More detailed explanation, please refer to **Learning OpenCV** by Bradski and Kaehler
|
|
|
|
Sobel Operator
|
|
---------------
|
|
|
|
#. The Sobel Operator is a discrete differentiation operator. It computes an approximation of the gradient of an image intensity function.
|
|
|
|
#. The Sobel Operator combines Gaussian smoothing and differentiation.
|
|
|
|
Formulation
|
|
^^^^^^^^^^^^
|
|
Assuming that the image to be operated is :math:`I`:
|
|
|
|
#. We calculate two derivatives:
|
|
|
|
a. **Horizontal changes**: This is computed by convolving :math:`I` with a kernel :math:`G_{x}` with odd size. For example for a kernel size of 3, :math:`G_{x}` would be computed as:
|
|
|
|
.. math::
|
|
|
|
G_{x} = \begin{bmatrix}
|
|
-1 & 0 & +1 \\
|
|
-2 & 0 & +2 \\
|
|
-1 & 0 & +1
|
|
\end{bmatrix} * I
|
|
|
|
b. **Vertical changes**: This is computed by convolving :math:`I` with a kernel :math:`G_{y}` with odd size. For example for a kernel size of 3, :math:`G_{y}` would be computed as:
|
|
|
|
.. math::
|
|
|
|
G_{y} = \begin{bmatrix}
|
|
-1 & -2 & -1 \\
|
|
0 & 0 & 0 \\
|
|
+1 & +2 & +1
|
|
\end{bmatrix} * I
|
|
|
|
#. At each point of the image we calculate an approximation of the *gradient* in that point by combining both results above:
|
|
|
|
.. math::
|
|
|
|
G = \sqrt{ G_{x}^{2} + G_{y}^{2} }
|
|
|
|
Although sometimes the following simpler equation is used:
|
|
|
|
.. math::
|
|
|
|
G = |G_{x}| + |G_{y}|
|
|
|
|
|
|
.. note::
|
|
|
|
When the size of the kernel is :math:`3`, the Sobel kernel shown above may produce noticeable inaccuracies (after all, Sobel is only an approximation of the derivative). OpenCV addresses this inaccuracy for kernels of size 3 by using the :scharr:`Scharr <>` function. This is as fast but more accurate than the standar Sobel function. It implements the following kernels:
|
|
|
|
.. math::
|
|
|
|
G_{x} = \begin{bmatrix}
|
|
-3 & 0 & +3 \\
|
|
-10 & 0 & +10 \\
|
|
-3 & 0 & +3
|
|
\end{bmatrix}
|
|
|
|
G_{y} = \begin{bmatrix}
|
|
-3 & -10 & -3 \\
|
|
0 & 0 & 0 \\
|
|
+3 & +10 & +3
|
|
\end{bmatrix}
|
|
|
|
You can check out more information of this function in the OpenCV reference (:scharr:`Scharr <>`). Also, in the sample code below, you will notice that above the code for :sobel:`Sobel <>` function there is also code for the :scharr:`Scharr <>` function commented. Uncommenting it (and obviously commenting the Sobel stuff) should give you an idea of how this function works.
|
|
|
|
Code
|
|
=====
|
|
|
|
#. **What does this program do?**
|
|
|
|
* Applies the *Sobel Operator* and generates as output an image with the detected *edges* bright on a darker background.
|
|
|
|
#. The tutorial code's is shown lines below. You can also download it from `here <http://code.opencv.org/svn/opencv/trunk/opencv/samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp>`_
|
|
|
|
.. code-block:: cpp
|
|
|
|
#include "opencv2/imgproc/imgproc.hpp"
|
|
#include "opencv2/highgui/highgui.hpp"
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
using namespace cv;
|
|
|
|
/** @function main */
|
|
int main( int argc, char** argv )
|
|
{
|
|
|
|
Mat src, src_gray;
|
|
Mat grad;
|
|
char* window_name = "Sobel Demo - Simple Edge Detector";
|
|
int scale = 1;
|
|
int delta = 0;
|
|
int ddepth = CV_16S;
|
|
|
|
int c;
|
|
|
|
/// Load an image
|
|
src = imread( argv[1] );
|
|
|
|
if( !src.data )
|
|
{ return -1; }
|
|
|
|
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
|
|
|
|
/// Convert it to gray
|
|
cvtColor( src, src_gray, CV_RGB2GRAY );
|
|
|
|
/// Create window
|
|
namedWindow( window_name, CV_WINDOW_AUTOSIZE );
|
|
|
|
/// Generate grad_x and grad_y
|
|
Mat grad_x, grad_y;
|
|
Mat abs_grad_x, abs_grad_y;
|
|
|
|
/// Gradient X
|
|
//Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
|
|
Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
|
|
convertScaleAbs( grad_x, abs_grad_x );
|
|
|
|
/// Gradient Y
|
|
//Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
|
|
Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
|
|
convertScaleAbs( grad_y, abs_grad_y );
|
|
|
|
/// Total Gradient (approximate)
|
|
addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );
|
|
|
|
imshow( window_name, grad );
|
|
|
|
waitKey(0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
Explanation
|
|
=============
|
|
|
|
#. First we declare the variables we are going to use:
|
|
|
|
.. code-block:: cpp
|
|
|
|
Mat src, src_gray;
|
|
Mat grad;
|
|
char* window_name = "Sobel Demo - Simple Edge Detector";
|
|
int scale = 1;
|
|
int delta = 0;
|
|
int ddepth = CV_16S;
|
|
|
|
#. As usual we load our source image *src*:
|
|
|
|
.. code-block:: cpp
|
|
|
|
src = imread( argv[1] );
|
|
|
|
if( !src.data )
|
|
{ return -1; }
|
|
|
|
#. First, we apply a :gaussian_blur:`GaussianBlur <>` to our image to reduce the noise ( kernel size = 3 )
|
|
|
|
.. code-block:: cpp
|
|
|
|
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
|
|
|
|
#. Now we convert our filtered image to grayscale:
|
|
|
|
.. code-block:: cpp
|
|
|
|
cvtColor( src, src_gray, CV_RGB2GRAY );
|
|
|
|
#. Second, we calculate the "*derivatives*" in *x* and *y* directions. For this, we use the function :sobel:`Sobel <>` as shown below:
|
|
|
|
.. code-block:: cpp
|
|
|
|
Mat grad_x, grad_y;
|
|
Mat abs_grad_x, abs_grad_y;
|
|
|
|
/// Gradient X
|
|
Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
|
|
/// Gradient Y
|
|
Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
|
|
|
|
The function takes the following arguments:
|
|
|
|
* *src_gray*: In our example, the input image. Here it is *CV_8U*
|
|
* *grad_x*/*grad_y*: The output image.
|
|
* *ddepth*: The depth of the output image. We set it to *CV_16S* to avoid overflow.
|
|
* *x_order*: The order of the derivative in **x** direction.
|
|
* *y_order*: The order of the derivative in **y** direction.
|
|
* *scale*, *delta* and *BORDER_DEFAULT*: We use default values.
|
|
|
|
Notice that to calculate the gradient in *x* direction we use: :math:`x_{order}= 1` and :math:`y_{order} = 0`. We do analogously for the *y* direction.
|
|
|
|
#. We convert our partial results back to *CV_8U*:
|
|
|
|
.. code-block:: cpp
|
|
|
|
convertScaleAbs( grad_x, abs_grad_x );
|
|
convertScaleAbs( grad_y, abs_grad_y );
|
|
|
|
|
|
#. Finally, we try to approximate the *gradient* by adding both directional gradients (note that this is not an exact calculation at all! but it is good for our purposes).
|
|
|
|
.. code-block:: cpp
|
|
|
|
addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );
|
|
|
|
#. Finally, we show our result:
|
|
|
|
.. code-block:: cpp
|
|
|
|
imshow( window_name, grad );
|
|
|
|
|
|
|
|
Results
|
|
========
|
|
|
|
#. Here is the output of applying our basic detector to *lena.jpg*:
|
|
|
|
|
|
.. image:: images/Sobel_Derivatives_Tutorial_Result.jpg
|
|
:alt: Result of applying Sobel operator to lena.jpg
|
|
:width: 300pt
|
|
:align: center
|