CODEWITHSUNDEEP
algorithmimage-processinggaussianedge-detection
metsburg
metsburg

Reputation: 2021

Scaling Laplacian of Gaussian Edge Detection

I am using Laplacian of Gaussian for edge detection using a combination of what is described in http://homepages.inf.ed.ac.uk/rbf/HIPR2/log.htm and http://wwwmath.tau.ac.il/~turkel/notes/Maini.pdf

Simply put, I'm using this equation : 

for(int i = -(kernelSize/2); i<=(kernelSize/2); i++)
    {

        for(int j = -(kernelSize/2); j<=(kernelSize/2); j++)
        {

            double L_xy = -1/(Math.PI * Math.pow(sigma,4))*(1 - ((Math.pow(i,2) + Math.pow(j,2))/(2*Math.pow(sigma,2))))*Math.exp(-((Math.pow(i,2) + Math.pow(j,2))/(2*Math.pow(sigma,2))));
            L_xy*=426.3;
        }

    }

and using up the L_xy variable to build the LoG kernel.

The problem is, when the image size is larger, application of the same kernel is making the filter more sensitive to noise. The edge sharpness is also not the same.

Let me put an example here...

Suppose we've got this image:Original image

Using a value of sigma = 0.9 and a kernel size of 5 x 5 matrix on a 480 × 264 pixel version of this image, we get the following output:

Small Image

However, if we use the same values on a 1920 × 1080 pixels version of this image (same sigma value and kernel size), we get something like this:enter image description here

[Both the images are scaled down version of an even larger image. The scaling down was done using a photo editor, which means the data contained in the images are not exactly similar. But, at least, they should be very near.]

Given that the larger image is roughly 4 times the smaller one... I also tried scaling the sigma by factor of 4 (sigma*=4) and the output was... you guessed it right, a black canvas.

Could you please help me realize how to implement a LoG edge detector that finds the same features from an input signal, even if the incoming signal is scaled up or down (scaling factor will be given).

Upvotes: 0

Views: 4573

Answers (1)

Vaaksiainen
Vaaksiainen

Reputation: 238

Looking at your images, I suppose you are working in 24-bit RGB. When you increase your sigma, the response of your filter weakens accordingly, thus what you get in the larger image with a larger kernel are values close to zero, which are either truncated or so close to zero that your display cannot distinguish.

To make differentials across different scales comparable, you should use the scale-space differential operator (Lindeberg et al.):

Scale-space differential

Essentially, differential operators are applied to the Gaussian kernel function (G_{\sigma}) and the result (or alternatively the convolution kernel; it is just a scalar multiplier anyways) is scaled by \sigma^{\gamma}. Here L is the input image and LoG is Laplacian of Gaussian -image.

When the order of differential is 2, \gammais typically set to 2.

Then you should get quite similar magnitude in both images.

Sources:

[1] Lindeberg: "Scale-space theory in computer vision" 1993

[2] Frangi et al. "Multiscale vessel enhancement filtering" 1998

Upvotes: 2

Related Questions