Edge Detection in Images with Wavelet Transform

• Download demo project - 38.8 KB
• Download source - 47.3 KB

Introduction

Edge detection is used in computer vision applications for contours extraction of objects. The usual method is to use convolution operation of the image with complex filters like Sobel or Prewitt.

Sobel Filter

Real
1.0  0.0 -1.0
2.0  0.0 -2.0
1.0  0.0 -1.0
Imaginary
1.0  2.0  1.0
0.0  0.0  0.0
-1.0 -2.0 -1.0

Prewitt Filter

Real
0.5  0.0 -0.5
0.5  0.0 -0.5
0.5  0.0 -0.5
Imaginary
0.5  0.5  0.5
0.0  0.0  0.0
-0.5 -0.5 -0.5

You may extract the edges for example with my vec2D wrapper described in my article Vector Class Wrapper SSE Optimized for Math Operations.

However unless integer optimized, floating point operations might take quite a long time. With wavelet transform, you might achieve similar results with a few mathematical operations. For example, Haar transform of the image provides details of that image contained in the high frequency bands very similar in appearance if you used X and Y difference filters on the same image.

X Difference Filter

0.0  0.0  0.0
0.5  0.0 -0.5
0.0  0.0  0.0

Y Difference Filter

0.0  0.5  0.0
0.0  0.0  0.0
0.0 -0.5  0.0

If we keep the details of the image obtained with Haar transform, remove the coarse-grained low frequency component and perform image reconstruction, we obtain the edges of the objects present in the image.

Background

Image processing background for Edge Detection is needed. You might also consult my articles about wavelet analysis of image data: 2D Fast Wavelet Transform Library for Image Processing and Fast Dyadic Image Scaling with Haar Transform.

Using the Code

The code and the demo application are used from my article 2D Fast Wavelet Transform Library for Image Processing where you may find details on how to run the code and use the library. In this project, I added several edge specific operations so you may experiment with different wavelet filters, scales, and denoising thresholds to select the best combination. Below I demonstrate the daub1 filter application, which is the filter used in Haar transform.

Open the image and transform it to 1, 2 or 3 scales. You might add the threshold to remove the noise. Below, the daub1 filter is selected with 1 scale transform without denoising:

You will get this FWT spectrum:

Now click Transform->Denoise menu item to remove low frequency component:

You might find the corresponding function in the BaseFWT2D class:

void BaseFWT2D::remove_LLband()
{
        if (m_status <= 0)
                return;

        unsigned int width = m_width / 
            (unsigned int)(pow(2.0f, (float)getJ()));
        unsigned int height = m_height / 
            (unsigned int)(pow(2.0f, (float)getJ()));
        
        for (unsigned int y = 0; y < height; y++) 
                for (unsigned int x = 0; x < width; x++)                     
                        spec2d[y][x] = 0;                
}

Now you may reconstruct the image:

It does not seem like the edges yet. You need just subtract 128 from the image and compute the absolute value with Transform->Abs values menu item:

But the edges are rather vague. First I proceeded with contrast stretching, that is normalizing the image to 0 ... 255 range. But there might be several pixels at the upper limit of the range and it does not really improve the situation. The better choice would be non-linear normalization like logarithmic scale but I just multiply the pixel data by some value and obtain the more prominent edges. For 1 scale transform, the multiplication by 7 works well and does not overflow the 255 limit for the majority of pixels, but for 2 or 3 scales you might diminish the multiplication number.

Now click Transform->Contrast stretch to amplify your edges:

You may compare the same picture results I obtained with the Sobel filter. It looks smoother, but then you might proceed to morphological operations like erosion and dilation and get a thin skeleton of the contour so in the end, the results will be very close.

I've developed Haar transform MMX optimization and in future, plan to provide an update to the code as EdgeDetector class or something similar and compare the performance.

This article, along with any associated source code and files, is licensed under The GNU General Public License (GPLv3)