Edge detection

Edge properties

The edges extracted from a two-dimensional image of a three-dimensional scene can be classified as either viewpoint dependent or viewpoint independent. A viewpoint independent edge typically reflects inherent properties of the three-dimensional objects, such as surface markings and surface shape. A viewpoint dependent edge may change as the viewpoint changes, and typically reflects the geometry of the scene, such as objects occluding one another.

A typical edge might for instance be the border between a block of red color and a block of yellow. In contrast a line (as can be extracted by a ridge detector) can be a small number of pixels of a different color on an otherwise unchanging background. For a line, there may therefore usually be one edge on each side of the line.

A simple edge model

Although certain literature has considered the detection of ideal step edges, the edges obtained from natural images are usually not at all ideal step edges. Instead they are normally affected by one or several of the following effects:

• focal blur caused by a finite depth-of-field and finite point spread function.
• penumbral blur caused by shadows created by light sources of non-zero radius.
• shading at a smooth object

A number of researchers have used a Gaussian smoothed step edge (an error function) as the simplest extension of the ideal step edge model for modeling the effects of edge blur in practical applications. Thus, a one-dimensional image ${\displaystyle f}$ that has exactly one edge placed at ${\displaystyle x=0}$ may be modeled as:

${\displaystyle f(x)=\frac{I_r-I_{\ell }}{2}\left(\mathrm{erf}\left(\frac{x}{\sqrt{2}\sigma }\right)+1\right)+I_{\ell }.}$

At the left side of the edge, the intensity is ${\displaystyle I_{\ell }=\underset{x\to -\mathrm{\infty }}{lim}f(x)}$, and right of the edge it is ${\displaystyle I_r=\underset{x\to \mathrm{\infty }}{lim}f(x)}$. The scale parameter ${\displaystyle \sigma }$ is called the blur scale of the edge. Ideally this scale parameter should be adjusted based on the quality of image to avoid destroying true edges of the image.

Difficulty

Outside of images with simple objects or featuring well-controlled lighting, edge detection is not a trivial task, since it can be difficult to determine what threshold should be used to define an edge between two pixels. For example, in the following one-dimensional signal, most would intuitively say there is an edge between the 4th and 5th pixels:

However, if the intensity difference between the 4th and the 5th pixels were smaller, it would not be as easy to say that there should be an edge in the corresponding region. Similarly, if the intensity differences between the adjacent neighboring pixels were higher, one could argue that more than one edge should be considered to exist, or even none at all.

Approaches

There are many methods for edge detection, but most of them can be grouped into two categories, search-based and zero-crossing based. The search-based methods detect edges by first computing a measure of edge strength, usually a first-order derivative expression such as the gradient magnitude, and then searching for local directional maxima of the gradient magnitude using a computed estimate of the local orientation of the edge, usually the gradient direction. The zero-crossing based methods search for zero crossings in a second-order derivative expression computed from the image in order to find edges, usually the zero-crossings of the Laplacian or the zero-crossings of a non-linear differential expression. As a pre-processing step to edge detection, a smoothing stage, typically Gaussian smoothing, is almost always applied (see also noise reduction).

The edge detection methods that have been published mainly differ in the types of smoothing filters that are applied and the way the measures of edge strength are computed. As many edge detection methods rely on the computation of image gradients, they also differ in the types of filters used for computing gradient estimates in the x- and y-directions.

A survey of a number of different edge detection methods can be found in (Ziou and Tabbone 1998); see also the encyclopedia articles on edge detection in Encyclopedia of Mathematics and Encyclopedia of Computer Science and Engineering.

Canny

John Canny considered the mathematical problem of deriving an optimal smoothing filter, given the criteria of detection, localization and minimizing multiple responses to a single edge. He showed that the optimal filter, given these assumptions, is a sum of four exponential terms. He also showed that this filter can be well approximated by first-order derivatives of Gaussians. Canny also introduced the notion of non-maximum suppression, which means that, given the presmoothing filters, edge points are defined as points where the gradient magnitude assumes a local maximum in the gradient direction. Looking for the zero crossing of the 2nd derivative along the gradient direction was first proposed by Haralick. It took less than two decades to find a modern geometric variational meaning for that operator, that links it to the Marr–Hildreth (zero crossing of the Laplacian) edge detector. That observation was presented by Ron Kimmel and Alfred Bruckstein.

Although his work was done in the early days of computer vision, the Canny edge detector (including its variations) is still a state-of-the-art edge detector. Edge detectors that perform better than the Canny usually require longer computation times or a greater number of parameters.

Kovalevsky

Vladimir A. Kovalevsky has suggested a quite different approach. He uses a preprocessing of the image with the Sigma filter and with a special filter for the dilution of the ramps. This method uses no brightness of the image but only the intensities of the color channels which is important for detecting an edge between two adjacent pixels of equal brightness but different colors. The method scans the image two times: first along the horizontal lines and second along the vertical columns. In each horizontal line six consequent adjacent pixels are considered and five color difference between each two adjacent pixels are calculated. Each color difference is the sum of absolute differences of the intensities of the color channels Red, Green, and Blue of the corresponding adjacent pixels. If this sum is greater than a given threshold, then the sign of the color difference is set equal to the sign of the difference of the green intensities. If the green difference is zero, then the sign of the color difference is set equal to the sign of the difference of the red intensities. If, however, both the green and the red differences are zero, then the sign of the color difference is set equal to the sign of the blue difference which in this case cannot be zero since the sum is greater than the threshold. Certain conditions for the values and signs of the five color differences are specified in such way that if the conditions are fulfilled, then a short vertical stroke is put between the third and the fourth of the six pixels as the label of the edge. Similar calculations are performed for the vertical columns. In this case a short horizontal stroke is put between the third and the fourth of the six subsequent pixels. The vertical and horizontal strokes (being the one-dimensional cells of an abstract cell complex corresponding to the image) mostly compose a connected sequence representing the edge. This method is robust and very fast and, what is more important, it can detect edges between adjacent pixels of equal brightness’s if the color difference between these pixels is greater than the threshold.

The Canny–Deriche detector was derived from similar mathematical criteria as the Canny edge detector, although starting from a discrete viewpoint and then leading to a set of recursive filters for image smoothing instead of exponential filters or Gaussian filters.

The differential edge detector described below can be seen as a reformulation of Canny's method from the viewpoint of differential invariants computed from a scale space representation leading to a number of advantages in terms of both theoretical analysis and sub-pixel implementation. In that aspect, Log Gabor filter have been shown to be a good choice to extract boundaries in natural scenes.

Other first-order methods

Different gradient operators can be applied to estimate image gradients from the input image or a smoothed version of it. The simplest approach is to use central differences:

${\displaystyle \begin{array}{cc}{L}_x(x,y)& =-\frac{1}{2}L(x-1,y)+0\cdot L(x,y)+\frac{1}{2}\cdot L(x+1,y)\\ L_y(x,y)& =-\frac{1}{2}L(x,y-1)+0\cdot L(x,y)+\frac{1}{2}\cdot L(x,y+1),\end{array}}$

corresponding to the application of the following filter masks to the image data:

${\displaystyle L_y=\left[\begin{array}{ccc}+1/2& 0& -1/2\end{array}\right]L\text{and}{L}_x=\left[\begin{array}{c}+1/2\\ 0\\ -1/2\end{array}\right]L.}$

The well-known and earlier Sobel operator is based on the following filters:

${\displaystyle L_y=\left[\begin{array}{ccc}+1& 0& -1\\ +2& 0& -2\\ +1& 0& -1\end{array}\right]L\text{and}{L}_x=\left[\begin{array}{ccc}+1& +2& +1\\ 0& 0& 0\\ -1& -2& -1\end{array}\right]L.}$

Given such estimates of first-order image derivatives, the gradient magnitude is then computed as:

${\displaystyle |\mathrm{\nabla }L|=\sqrt{L_x^2+L_y^2}}$

while the gradient orientation can be estimated as

${\displaystyle \theta =\mathrm{atan2}(L_y,L_x).}$

Other first-order difference operators for estimating image gradient have been proposed in the Prewitt operator, Roberts cross, Kayyali operator and Frei–Chen operator.

It is possible to extend filters dimension to avoid the issue of recognizing edge in low SNR image. The cost of this operation is loss in terms of resolution. Examples are Extended Prewitt 7×7.

Thresholding and linking

Once we have computed a measure of edge strength (typically the gradient magnitude), the next stage is to apply a threshold, to decide whether edges are present or not at an image point. The lower the threshold, the more edges will be detected, and the result will be increasingly susceptible to noise and detecting edges of irrelevant features in the image. Conversely a high threshold may miss subtle edges, or result in fragmented edges.

If the edge is applied to just the gradient magnitude image, the resulting edges will in general be thick and some type of edge thinning post-processing is necessary. For edges detected with non-maximum suppression however, the edge curves are thin by definition and the edge pixels can be linked into edge polygon by an edge linking (edge tracking) procedure. On a discrete grid, the non-maximum suppression stage can be implemented by estimating the gradient direction using first-order derivatives, then rounding off the gradient direction to multiples of 45 degrees, and finally comparing the values of the gradient magnitude in the estimated gradient direction.

A commonly used approach to handle the problem of appropriate thresholds for thresholding is by using thresholding with hysteresis. This method uses multiple thresholds to find edges. We begin by using the upper threshold to find the start of an edge. Once we have a start point, we then trace the path of the edge through the image pixel by pixel, marking an edge whenever we are above the lower threshold. We stop marking our edge only when the value falls below our lower threshold. This approach makes the assumption that edges are likely to be in continuous curves, and allows us to follow a faint section of an edge we have previously seen, without meaning that every noisy pixel in the image is marked down as an edge. Still, however, we have the problem of choosing appropriate thresholding parameters, and suitable thresholding values may vary over the image.

Connectivity of gradients without using (high) magnitude thresholds

This method finds connected set of pixels having a directional derivative magnitude larger than a fairly small threshold. It considers only presence of gradients instead of strength of gradients. After applying a dramatically small threshold (i.e. 5), a binary image is obtained. The morphological opening operation and the morphological closing operation are applied to the binary image to close gaps. Then, the distance transform operation is applied to the binary image to clear the pixels far from the background, so blob-like shapes or other false labeled regions are deleted from the edge map.

Edge thinning

Edge thinning is a technique used to remove the unwanted spurious points on the edges in an image. This technique is employed after the image has been filtered for noise (using median, Gaussian filter etc.), the edge operator has been applied (like the ones described above, Canny or Sobel) to detect the edges and after the edges have been smoothed using an appropriate threshold value. This removes all the unwanted points, and if applied carefully, results in one pixel thick edge elements.

Advantages:

1. Sharp and thin edges lead to greater efficiency in object recognition.
2. If Hough transforms are used to detect lines and ellipses, then thinning could give much better results.
3. If the edge happens to be the boundary of a region, then thinning could easily give the image parameters like perimeter without much algebra.

There are many popular algorithms used to do this, one such is described below:

1. Choose a type of connectivity, like 8, 6 or 4.
2. 8 connectivity is preferred, where all the immediate pixels surrounding a particular pixel are considered.
3. Remove points from North, south, east and west.
4. Do this in multiple passes, i.e. after the north pass, use the same semi processed image in the other passes and so on.
5. Remove a point if:
   The point has no neighbors in the North (if you are in the north pass, and respective directions for other passes).
   The point is not the end of a line.
   The point is isolated.
   Removing the points will not cause to disconnect its neighbors in any way.
6. Otherwise, keep the point.

The number of passes across direction should be chosen according to the level of accuracy desired.

Second-order approaches

Some edge-detection operators are instead based upon second-order derivatives of the intensity. This essentially captures the rate of change in the intensity gradient. Thus, in the ideal continuous case, detection of zero-crossings in the second derivative captures local maxima in the gradient.

The early Marr–Hildreth operator is based on the detection of zero-crossings of the Laplacian operator applied to a Gaussian-smoothed image. It can be shown, however, that this operator will also return false edges corresponding to local minima of the gradient magnitude. Moreover, this operator will give poor localization at curved edges. Hence, this operator is today mainly of historical interest.

Differential

A more refined second-order edge detection approach which automatically detects edges with sub-pixel accuracy, uses the following differential approach of detecting zero-crossings of the second-order directional derivative in the gradient direction:

Following the differential geometric way of expressing the requirement of non-maximum suppression proposed by Lindeberg, let us introduce at every image point a local coordinate system ${\displaystyle (u,v)}$, with the ${\displaystyle v}$-direction parallel to the gradient direction. Assuming that the image has been pre-smoothed by Gaussian smoothing and a scale space representation ${\displaystyle L(x,y;t)}$ at scale ${\displaystyle t}$ has been computed, we can require that the gradient magnitude of the scale space representation, which is equal to the first-order directional derivative in the ${\displaystyle v}$-direction ${\displaystyle L_v}$, should have its first order directional derivative in the ${\displaystyle v}$-direction equal to zero

${\displaystyle {\mathrm{\partial }}_v(L_v)=0}$

while the second-order directional derivative in the ${\displaystyle v}$-direction of ${\displaystyle L_v}$ should be negative, i.e.,

${\displaystyle {\mathrm{\partial }}_{vv}(L_v)\le 0.}$

Written out as an explicit expression in terms of local partial derivatives ${\displaystyle L_x,L_y,\dots ,L_{yyy}}$, this edge definition can be expressed as the zero-crossing curves of the differential invariant

${\displaystyle L_v^2{L}_{vv}=L_x^2{L}_{xx}+2L_x{L}_y{L}_{xy}+L_y^2{L}_{yy}=0,}$

that satisfies a sign-condition on the following differential invariant

${\displaystyle L_v^3{L}_{vvv}=L_x^3{L}_{xxx}+3L_x^2{L}_y{L}_{xxy}+3L_x{L}_y^2{L}_{xyy}+L_y^3{L}_{yyy}\le 0}$

where ${\displaystyle L_x,L_y,\dots ,L_{yyy}}$ denote partial derivatives computed from a scale space representation ${\displaystyle L}$ obtained by smoothing the original image with a Gaussian kernel. In this way, the edges will be automatically obtained as continuous curves with sub-pixel accuracy. Hysteresis thresholding can also be applied to these differential and subpixel edge segments.

In practice, first-order derivative approximations can be computed by central differences as described above, while second-order derivatives can be computed from the scale space representation ${\displaystyle L}$ according to:

${\displaystyle \begin{array}{cc}{L}_{xx}(x,y)& =L(x-1,y)-2L(x,y)+L(x+1,y),\\ L_{xy}(x,y)& =\frac{1}{4}(L(x-1,y-1)-L(x-1,y+1)-L(x+1,y-1)+L(x+1,y+1)),\\ L_{yy}(x,y)& =L(x,y-1)-2L(x,y)+L(x,y+1).\end{array}}$

corresponding to the following filter masks:

${\displaystyle L_{xx}=\left[\begin{array}{ccc}1& -2& 1\end{array}\right]L\text{and}{L}_{xy}=\left[\begin{array}{ccc}-1/4& 0& 1/4\\ 0& 0& 0\\ 1/4& 0& -1/4\end{array}\right]L\text{and}{L}_{yy}=\left[\begin{array}{c}1\\ -2\\ 1\end{array}\right]L.}$

Higher-order derivatives for the third-order sign condition can be obtained in an analogous fashion.

Phase congruency-based

A recent development in edge detection techniques takes a frequency domain approach to finding edge locations. Phase congruency (also known as phase coherence) methods attempt to find locations in an image where all sinusoids in the frequency domain are in phase. These locations will generally correspond to the location of a perceived edge, regardless of whether the edge is represented by a large change in intensity in the spatial domain. A key benefit of this technique is that it responds strongly to Mach bands, and avoids false positives typically found around roof edges. A roof edge, is a discontinuity in the first order derivative of a grey-level profile.

Phase Stretch Transform (PST)

The phase stretch transform or PST is a physics-inspired computational approach to signal and image processing. One of its utilities is for feature detection and classification. PST is a spin-off from research on the time stretch dispersive Fourier transform. PST transforms the image by emulating propagation through a diffractive medium with engineered 3D dispersive property (refractive index). The operation relies on symmetry of the dispersion profile and can be understood in terms of dispersive eigenfunctions or stretch modes. PST performs similar functionality as phase contrast microscopy but on digital images. PST is also applicable to digital images as well as temporal, time series, data.

Subpixel

To increase the precision of edge detection, several subpixel techniques had been proposed, including curve-fitting, moment-based, reconstructive, and partial area effect methods. These methods have different characteristics. Curve fitting methods are computationally simple but are easily affected by noise. Moment-based methods use an integral-based approach to reduce the effect of noise, but may require more computations in some cases. Reconstructive methods use horizontal gradients or vertical gradients to build a curve and find the peak of the curve as the sub-pixel edge. Partial area effect methods are based on the hypothesis that each pixel value depends on the area at both sides of the edge inside that pixel, producing accurate individual estimation for every edge pixel. Certain variants of the moment-based technique have been shown to be the most accurate for isolated edges.

The Marr-Hildreth Edge Detector

The Marr-Hildreth edge detector is distinguished by its use of the Laplacian of Gaussian (LoG) operator for edge detection in digital images. Unlike other edge detection methods, the LoG approach combines Gaussian smoothing with second derivative operations, allowing for simultaneous noise reduction and edge enhancement. The key advantage of this method lies in its ability to detect edges at various scales by adjusting the standard deviation of the Gaussian kernel, enabling detection of fine details as well as broader transitions. Moreover, the technique leverages zero-crossing detection on the LoG response to precisely locate edges, offering robustness against noise and maintaining edge continuity. This approach is particularly effective for detecting edges with clear boundaries in images while minimizing false positives due to noise, making it a valuable tool in computer vision applications where accurate edge localization is crucial.

Code for edge detection using Prewitt, Scharr and Sobel operator

Source:

Edge detection using Prewitt operator

<span id="mwAaQ"></span><span class="linenos" data-line="1" id="mwAaU"></span><span class="c" id="mwAaY">% MATLAB code for prewitt</span> <span class="linenos" data-line="2" id="mwAac"></span><span class="c" id="mwAag">% operator edge detection</span> <span class="linenos" data-line="3" id="mwAak"></span><span class="n" id="mwAao">k</span><span class="w" id="mwAas"> </span><span class="p" id="mwAaw">=</span><span class="w" id="mwAa0"> </span><span class="nb" id="mwAa4">imread</span><span class="p" id="mwAa8">(</span><span class="s" id="mwAbA">"logo.png"</span><span class="p" id="mwAbE">);</span> <span class="linenos" data-line="4" id="mwAbI"></span><span class="n" id="mwAbM">k</span><span class="w" id="mwAbQ"> </span><span class="p" id="mwAbU">=</span><span class="w" id="mwAbY"> </span><span class="nb" id="mwAbc">rgb2gray</span><span class="p" id="mwAbg">(</span><span class="n" id="mwAbk">k</span><span class="p" id="mwAbo">);</span> <span class="linenos" data-line="5" id="mwAbs"></span><span class="n" id="mwAbw">k1</span><span class="w" id="mwAb0"> </span><span class="p" id="mwAb4">=</span><span class="w" id="mwAb8"> </span><span class="nb" id="mwAcA">double</span><span class="p" id="mwAcE">(</span><span class="n" id="mwAcI">k</span><span class="p" id="mwAcM">);</span> <span class="linenos" data-line="6" id="mwAcQ"></span><span class="n" id="mwAcU">p_msk</span><span class="w" id="mwAcY"> </span><span class="p" id="mwAcc">=</span><span class="w" id="mwAcg"> </span><span class="p" id="mwAck">[</span><span class="o" id="mwAco">-</span><span class="mi" id="mwAcs">1</span><span class="w" id="mwAcw"> </span><span class="mi" id="mwAc0">0</span><span class="w" id="mwAc4"> </span><span class="mi" id="mwAc8">1</span><span class="p" id="mwAdA">;</span><span class="w" id="mwAdE"> </span><span class="o" id="mwAdI">-</span><span class="mi" id="mwAdM">1</span><span class="w" id="mwAdQ"> </span><span class="mi" id="mwAdU">0</span><span class="w" id="mwAdY"> </span><span class="mi" id="mwAdc">1</span><span class="p" id="mwAdg">;</span><span class="w" id="mwAdk"> </span><span class="o" id="mwAdo">-</span><span class="mi" id="mwAds">1</span><span class="w" id="mwAdw"> </span><span class="mi" id="mwAd0">0</span><span class="w" id="mwAd4"> </span><span class="mi" id="mwAd8">1</span><span class="p" id="mwAeA">];</span> <span class="linenos" data-line="7" id="mwAeE"></span><span class="n" id="mwAeI">kx</span><span class="w" id="mwAeM"> </span><span class="p" id="mwAeQ">=</span><span class="w" id="mwAeU"> </span><span class="nb" id="mwAeY">conv2</span><span class="p" id="mwAec">(</span><span class="n" id="mwAeg">k1</span><span class="p" id="mwAek">,</span><span class="w" id="mwAeo"> </span><span class="n" id="mwAes">p_msk</span><span class="p" id="mwAew">,</span><span class="w" id="mwAe0"> </span><span class="s" id="mwAe4">'same'</span><span class="p" id="mwAe8">);</span> <span class="linenos" data-line="8" id="mwAfA"></span><span class="n" id="mwAfE">ky</span><span class="w" id="mwAfI"> </span><span class="p" id="mwAfM">=</span><span class="w" id="mwAfQ"> </span><span class="nb" id="mwAfU">conv2</span><span class="p" id="mwAfY">(</span><span class="n" id="mwAfc">k1</span><span class="p" id="mwAfg">,</span><span class="w" id="mwAfk"> </span><span class="n" id="mwAfo">p_msk</span><span class="o" id="mwAfs">'</span><span class="p" id="mwAfw">,</span><span class="w" id="mwAf0"> </span><span class="s" id="mwAf4">'same'</span><span class="p" id="mwAf8">);</span> <span class="linenos" data-line="9" id="mwAgA"></span><span class="n" id="mwAgE">ked</span><span class="w" id="mwAgI"> </span><span class="p" id="mwAgM">=</span><span class="w" id="mwAgQ"> </span><span class="nb" id="mwAgU">sqrt</span><span class="p" id="mwAgY">(</span><span class="n" id="mwAgc">kx</span><span class="o" id="mwAgg">.^</span><span class="mi" id="mwAgk">2</span><span class="w" id="mwAgo"> </span><span class="o" id="mwAgs">+</span><span class="w" id="mwAgw"> </span><span class="n" id="mwAg0">ky</span><span class="o" id="mwAg4">.^</span><span class="mi" id="mwAg8">2</span><span class="p" id="mwAhA">);</span> <span class="linenos" data-line="10" id="mwAhE"></span> <span class="linenos" data-line="11" id="mwAhI"></span><span class="c" id="mwAhM">% display the images.</span> <span class="linenos" data-line="12" id="mwAhQ"></span><span class="n" id="mwAhU">imtool</span><span class="p" id="mwAhY">(</span><span class="n" id="mwAhc">k</span><span class="p" id="mwAhg">,[]);</span> <span class="linenos" data-line="13" id="mwAhk"></span> <span class="linenos" data-line="14" id="mwAho"></span><span class="c" id="mwAhs">% display the edge detection along x-axis.</span> <span class="linenos" data-line="15" id="mwAhw"></span><span class="n" id="mwAh0">imtool</span><span class="p" id="mwAh4">(</span><span class="nb" id="mwAh8">abs</span><span class="p" id="mwAiA">(</span><span class="n" id="mwAiE">kx</span><span class="p" id="mwAiI">),</span><span class="w" id="mwAiM"> </span><span class="p" id="mwAiQ">[]);</span> <span class="linenos" data-line="16" id="mwAiU"></span> <span class="linenos" data-line="17" id="mwAiY"></span><span class="c" id="mwAic">% display the edge detection along y-axis.</span> <span class="linenos" data-line="18" id="mwAig"></span><span class="n" id="mwAik">imtool</span><span class="p" id="mwAio">(</span><span class="nb" id="mwAis">abs</span><span class="p" id="mwAiw">(</span><span class="n" id="mwAi0">ky</span><span class="p" id="mwAi4">),[]);</span> <span class="linenos" data-line="19" id="mwAi8"></span> <span class="linenos" data-line="20" id="mwAjA"></span><span class="c" id="mwAjE">% display the full edge detection.</span> <span class="linenos" data-line="21" id="mwAjI"></span><span class="n" id="mwAjM">imtool</span><span class="p" id="mwAjQ">(</span><span class="nb" id="mwAjU">abs</span><span class="p" id="mwAjY">(</span><span class="n" id="mwAjc">ked</span><span class="p" id="mwAjg">),[]);</span>

Edge detection using Scharr operator

<span id="mwAjw"></span><span class="linenos" data-line="1" id="mwAj0"></span><span class="c" id="mwAj4">% Scharr operator -> edge detection</span> <span class="linenos" data-line="2" id="mwAj8"></span><span class="n" id="mwAkA">k</span><span class="w" id="mwAkE"> </span><span class="p" id="mwAkI">=</span><span class="w" id="mwAkM"> </span><span class="nb" id="mwAkQ">imread</span><span class="p" id="mwAkU">(</span><span class="s" id="mwAkY">"logo.png"</span><span class="p" id="mwAkc">);</span> <span class="linenos" data-line="3" id="mwAkg"></span><span class="n" id="mwAkk">k</span><span class="w" id="mwAko"> </span><span class="p" id="mwAks">=</span><span class="w" id="mwAkw"> </span><span class="nb" id="mwAk0">rgb2gray</span><span class="p" id="mwAk4">(</span><span class="n" id="mwAk8">k</span><span class="p" id="mwAlA">);</span> <span class="linenos" data-line="4" id="mwAlE"></span><span class="n" id="mwAlI">k1</span><span class="w" id="mwAlM"> </span><span class="p" id="mwAlQ">=</span><span class="w" id="mwAlU"> </span><span class="nb" id="mwAlY">double</span><span class="p" id="mwAlc">(</span><span class="n" id="mwAlg">k</span><span class="p" id="mwAlk">);</span> <span class="linenos" data-line="5" id="mwAlo"></span><span class="n" id="mwAls">s_msk</span><span class="w" id="mwAlw"> </span><span class="p" id="mwAl0">=</span><span class="w" id="mwAl4"> </span><span class="p" id="mwAl8">[</span><span class="o" id="mwAmA">-</span><span class="mi" id="mwAmE">3</span><span class="w" id="mwAmI"> </span><span class="mi" id="mwAmM">0</span><span class="w" id="mwAmQ"> </span><span class="mi" id="mwAmU">3</span><span class="p" id="mwAmY">;</span><span class="w" id="mwAmc"> </span><span class="o" id="mwAmg">-</span><span class="mi" id="mwAmk">10</span><span class="w" id="mwAmo"> </span><span class="mi" id="mwAms">0</span><span class="w" id="mwAmw"> </span><span class="mi" id="mwAm0">10</span><span class="p" id="mwAm4">;</span><span class="w" id="mwAm8"> </span><span class="o" id="mwAnA">-</span><span class="mi" id="mwAnE">3</span><span class="w" id="mwAnI"> </span><span class="mi" id="mwAnM">0</span><span class="w" id="mwAnQ"> </span><span class="mi" id="mwAnU">3</span><span class="p" id="mwAnY">];</span> <span class="linenos" data-line="6" id="mwAnc"></span><span class="n" id="mwAng">kx</span><span class="w" id="mwAnk"> </span><span class="p" id="mwAno">=</span><span class="w" id="mwAns"> </span><span class="nb" id="mwAnw">conv2</span><span class="p" id="mwAn0">(</span><span class="n" id="mwAn4">k1</span><span class="p" id="mwAn8">,</span><span class="w" id="mwAoA"> </span><span class="n" id="mwAoE">s_msk</span><span class="p" id="mwAoI">,</span><span class="w" id="mwAoM"> </span><span class="s" id="mwAoQ">'same'</span><span class="p" id="mwAoU">);</span> <span class="linenos" data-line="7" id="mwAoY"></span><span class="n" id="mwAoc">ky</span><span class="w" id="mwAog"> </span><span class="p" id="mwAok">=</span><span class="w" id="mwAoo"> </span><span class="nb" id="mwAos">conv2</span><span class="p" id="mwAow">(</span><span class="n" id="mwAo0">k1</span><span class="p" id="mwAo4">,</span><span class="w" id="mwAo8"> </span><span class="n" id="mwApA">s_msk</span><span class="o" id="mwApE">'</span><span class="p" id="mwApI">,</span><span class="w" id="mwApM"> </span><span class="s" id="mwApQ">'same'</span><span class="p" id="mwApU">);</span> <span class="linenos" data-line="8" id="mwApY"></span><span class="n" id="mwApc">ked</span><span class="w" id="mwApg"> </span><span class="p" id="mwApk">=</span><span class="w" id="mwApo"> </span><span class="nb" id="mwAps">sqrt</span><span class="p" id="mwApw">(</span><span class="n" id="mwAp0">kx</span><span class="o" id="mwAp4">.^</span><span class="mi" id="mwAp8">2</span><span class="w" id="mwAqA"> </span><span class="o" id="mwAqE">+</span><span class="w" id="mwAqI"> </span><span class="n" id="mwAqM">ky</span><span class="o" id="mwAqQ">.^</span><span class="mi" id="mwAqU">2</span><span class="p" id="mwAqY">);</span> <span class="linenos" data-line="9" id="mwAqc"></span><span class="c" id="mwAqg">% display the images.</span> <span class="linenos" data-line="10" id="mwAqk"></span><span class="n" id="mwAqo">imtool</span><span class="p" id="mwAqs">(</span><span class="n" id="mwAqw">k</span><span class="p" id="mwAq0">,[]);</span> <span class="linenos" data-line="11" id="mwAq4"></span><span class="c" id="mwAq8">% display the edge detection along x-axis.</span> <span class="linenos" data-line="12" id="mwArA"></span><span class="n" id="mwArE">imtool</span><span class="p" id="mwArI">(</span><span class="nb" id="mwArM">abs</span><span class="p" id="mwArQ">(</span><span class="n" id="mwArU">kx</span><span class="p" id="mwArY">),</span><span class="w" id="mwArc"> </span><span class="p" id="mwArg">[]);</span> <span class="linenos" data-line="13" id="mwArk"></span><span class="c" id="mwAro">% display the edge detection along y-axis.</span> <span class="linenos" data-line="14" id="mwArs"></span><span class="n" id="mwArw">imtool</span><span class="p" id="mwAr0">(</span><span class="nb" id="mwAr4">abs</span><span class="p" id="mwAr8">(</span><span class="n" id="mwAsA">ky</span><span class="p" id="mwAsE">),</span><span class="w" id="mwAsI"> </span><span class="p" id="mwAsM">[]);</span> <span class="linenos" data-line="15" id="mwAsQ"></span><span class="c" id="mwAsU">% display the full edge detection.</span> <span class="linenos" data-line="16" id="mwAsY"></span><span class="n" id="mwAsc">imtool</span><span class="p" id="mwAsg">(</span><span class="nb" id="mwAsk">abs</span><span class="p" id="mwAso">(</span><span class="n" id="mwAss">ked</span><span class="p" id="mwAsw">),</span><span class="w" id="mwAs0"> </span><span class="p" id="mwAs4">[]);</span>

Edge detection using Sobel operator

<span id="mwAtI"></span><span class="linenos" data-line="1" id="mwAtM"></span><span class="c" id="mwAtQ">% MATLAB code for Sobel operator</span> <span class="linenos" data-line="2" id="mwAtU"></span><span class="c" id="mwAtY">% edge detection</span> <span class="linenos" data-line="3" id="mwAtc"></span><span class="n" id="mwAtg">k</span><span class="w" id="mwAtk"> </span><span class="p" id="mwAto">=</span><span class="w" id="mwAts"> </span><span class="nb" id="mwAtw">imread</span><span class="p" id="mwAt0">(</span><span class="s" id="mwAt4">"logo.png"</span><span class="p" id="mwAt8">);</span> <span class="linenos" data-line="4" id="mwAuA"></span><span class="n" id="mwAuE">k</span><span class="w" id="mwAuI"> </span><span class="p" id="mwAuM">=</span><span class="w" id="mwAuQ"> </span><span class="nb" id="mwAuU">rgb2gray</span><span class="p" id="mwAuY">(</span><span class="n" id="mwAuc">k</span><span class="p" id="mwAug">);</span> <span class="linenos" data-line="5" id="mwAuk"></span><span class="n" id="mwAuo">k1</span><span class="w" id="mwAus"> </span><span class="p" id="mwAuw">=</span><span class="w" id="mwAu0"> </span><span class="nb" id="mwAu4">double</span><span class="p" id="mwAu8">(</span><span class="n" id="mwAvA">k</span><span class="p" id="mwAvE">);</span> <span class="linenos" data-line="6" id="mwAvI"></span><span class="n" id="mwAvM">s_msk</span><span class="w" id="mwAvQ"> </span><span class="p" id="mwAvU">=</span><span class="w" id="mwAvY"> </span><span class="p" id="mwAvc">[</span><span class="o" id="mwAvg">-</span><span class="mi" id="mwAvk">1</span><span class="w" id="mwAvo"> </span><span class="mi" id="mwAvs">0</span><span class="w" id="mwAvw"> </span><span class="mi" id="mwAv0">1</span><span class="p" id="mwAv4">;</span><span class="w" id="mwAv8"> </span><span class="o" id="mwAwA">-</span><span class="mi" id="mwAwE">2</span><span class="w" id="mwAwI"> </span><span class="mi" id="mwAwM">0</span><span class="w" id="mwAwQ"> </span><span class="mi" id="mwAwU">2</span><span class="p" id="mwAwY">;</span><span class="w" id="mwAwc"> </span><span class="o" id="mwAwg">-</span><span class="mi" id="mwAwk">1</span><span class="w" id="mwAwo"> </span><span class="mi" id="mwAws">0</span><span class="w" id="mwAww"> </span><span class="mi" id="mwAw0">1</span><span class="p" id="mwAw4">];</span> <span class="linenos" data-line="7" id="mwAw8"></span><span class="n" id="mwAxA">kx</span><span class="w" id="mwAxE"> </span><span class="p" id="mwAxI">=</span><span class="w" id="mwAxM"> </span><span class="nb" id="mwAxQ">conv2</span><span class="p" id="mwAxU">(</span><span class="n" id="mwAxY">k1</span><span class="p" id="mwAxc">,</span><span class="w" id="mwAxg"> </span><span class="n" id="mwAxk">s_msk</span><span class="p" id="mwAxo">,</span><span class="w" id="mwAxs"> </span><span class="s" id="mwAxw">'same'</span><span class="p" id="mwAx0">);</span> <span class="linenos" data-line="8" id="mwAx4"></span><span class="n" id="mwAx8">ky</span><span class="w" id="mwAyA"> </span><span class="p" id="mwAyE">=</span><span class="w" id="mwAyI"> </span><span class="nb" id="mwAyM">conv2</span><span class="p" id="mwAyQ">(</span><span class="n" id="mwAyU">k1</span><span class="p" id="mwAyY">,</span><span class="w" id="mwAyc"> </span><span class="n" id="mwAyg">s_msk</span><span class="o" id="mwAyk">'</span><span class="p" id="mwAyo">,</span><span class="w" id="mwAys"> </span><span class="s" id="mwAyw">'same'</span><span class="p" id="mwAy0">);</span> <span class="linenos" data-line="9" id="mwAy4"></span><span class="n" id="mwAy8">ked</span><span class="w" id="mwAzA"> </span><span class="p" id="mwAzE">=</span><span class="w" id="mwAzI"> </span><span class="nb" id="mwAzM">sqrt</span><span class="p" id="mwAzQ">(</span><span class="n" id="mwAzU">kx</span><span class="o" id="mwAzY">.^</span><span class="mi" id="mwAzc">2</span><span class="w" id="mwAzg"> </span><span class="o" id="mwAzk">+</span><span class="w" id="mwAzo"> </span><span class="n" id="mwAzs">ky</span><span class="o" id="mwAzw">.^</span><span class="mi" id="mwAz0">2</span><span class="p" id="mwAz4">);</span> <span class="linenos" data-line="10" id="mwAz8"></span> <span class="linenos" data-line="11" id="mwA0A"></span><span class="c" id="mwA0E">% display the images.</span> <span class="linenos" data-line="12" id="mwA0I"></span><span class="n" id="mwA0M">imtool</span><span class="p" id="mwA0Q">(</span><span class="n" id="mwA0U">k</span><span class="p" id="mwA0Y">,[]);</span> <span class="linenos" data-line="13" id="mwA0c"></span> <span class="linenos" data-line="14" id="mwA0g"></span><span class="c" id="mwA0k">% display the edge detection along x-axis.</span> <span class="linenos" data-line="15" id="mwA0o"></span><span class="n" id="mwA0s">imtool</span><span class="p" id="mwA0w">(</span><span class="nb" id="mwA00">abs</span><span class="p" id="mwA04">(</span><span class="n" id="mwA08">kx</span><span class="p" id="mwA1A">),</span><span class="w" id="mwA1E"> </span><span class="p" id="mwA1I">[]);</span> <span class="linenos" data-line="16" id="mwA1M"></span> <span class="linenos" data-line="17" id="mwA1Q"></span><span class="c" id="mwA1U">% display the edge detection along y-axis.</span> <span class="linenos" data-line="18" id="mwA1Y"></span><span class="n" id="mwA1c">imtool</span><span class="p" id="mwA1g">(</span><span class="nb" id="mwA1k">abs</span><span class="p" id="mwA1o">(</span><span class="n" id="mwA1s">ky</span><span class="p" id="mwA1w">),</span><span class="w" id="mwA10"> </span><span class="p" id="mwA14">[]);</span> <span class="linenos" data-line="19" id="mwA18"></span> <span class="linenos" data-line="20" id="mwA2A"></span><span class="c" id="mwA2E">% display the full edge detection.</span> <span class="linenos" data-line="21" id="mwA2I"></span><span class="n" id="mwA2M">imtool</span><span class="p" id="mwA2Q">(</span><span class="nb" id="mwA2U">abs</span><span class="p" id="mwA2Y">(</span><span class="n" id="mwA2c">ked</span><span class="p" id="mwA2g">),</span><span class="w" id="mwA2k"> </span><span class="p" id="mwA2o">[]);</span>