implement laplacian 3x3

Im reading DIP 2nd edition by Gonzalez and Woods and try to my hands dirty with Laplacian mask (page 129&130) using wxImage.

float kernel [3][3]= {{1, 1, 1},{1,-8, 1},{1, 1, 1}};   

here is the processing loops:

unsigned char r,g,b;                    

float rtotal, gtotal, btotal; rtotal = gtotal = btotal = 0.0;   
//ignore the border pixel              

for(int i = 1; i<imgWidth-1; i++)
{

   for(int j = 1; j<imgHeight-1; j++) 
    {

     rtotal = gtotal=btotal =0.0;


       for(int y = -1; y<=1;y++)

       {

            for(int x = -1; x<=1;x++)

    开发者_JS百科        {

            // get each channel pixel value

            r = Image->GetRed(i+y,j+x);

            g = Image->GetGreen(i+y,j+x);

            b = Image->GetBlue(i+y,j+x);

            // calculate each channel surrouding neighbour pixel value base   

            rtotal += r* kernel[y+1][x+1];

            gtotal += g* kernel[y+1][x+1] ;

            btotal += b* kernel[y+1][x+1];

            }

    }
            //edit1: here is how to sharpen the image
            // original pixel - (0.2 * the sum of pixel neighbour)
            rtotal = loadedImage->GetRed(x,y) - 0.2*rtotal;

    gtotal = loadedImage->GetGreen(x,y) - 0.2*gtotal;

    btotal = loadedImage->GetBlue(x,y) - 0.2*btotal;
    // range checking

    if (rtotal >255) rtotal = 255;

       else if (rtotal <0) rtotal = 0;

    if(btotal>255) btotal = 255;

       else if(btotal < 0) btotal = 0;

    if(gtotal > 255) gtotal = 255;

       else if (gtotal < 0 ) gtotal =0;

    // commit new pixel value

    Image->SetRGB(i,j, rtotal, gtotal, btotal);

I applied that to the North Pole picture (grey image) and all I get is a blob of black and white pixels!

Any ideas where may I have missed something in the for loops?

Edit1: Finally get the answer after looking around on google. This dsp stuff is definitely tricky! I added to the code above, it will sharpen the image.

Cheers

---

First, the result of convolving with a Laplacian can have negative values. Consider a pixel with a value of 1 surrounded by 0's. The result of the convolution at that pixel will be -8.

Second, the range of the result will be between [-8 * 255, 8 * 255], which definitely does not fit into 8 bits. Essentially, when you do your range checking, you are losing most of the information, and most of your resulting pixels will end up either being 0 or 255.

What you have to do is store the result in an array of a type that is signed and wide enough to handle the range. Then, if you wish to output an 8-bit image, you would need to rescale the values so that -8 * 255 maps to 0, and 8 * 255 maps to 255. Or you can rescale it so that the least value maps to 0 and the greatest value maps to 255.

Edit: in this specific case, you can do the following:

rtotal = (rtotal + 8 * 255) / (16 * 255) * 255;

which simplifies to

rtotal = (rtotal + 8 * 255) / 16;

This would map rtotal into a range between 0 and 255 without truncation. You should do the same for gtotal and btotal.

---

I think your problem is that r, g and b are type unsigned int and that, depending on which compiler you are using and how it is optimising, you are implicitly casting them to floats in the lines rtotal += r* kernel[y+1][x+1]; etc. But if the compiler casts differently to your expectations then computing the middle value will not work because unsigned int can't be negative.

Solution: change r, g and b to float.

It won't make any difference but there is a tiny error in the lines r = Image->GetRed(i+y,j+x); because i is looping over the horizontal and j is looping to vertical.

---

Are you not supposed to divide by the number of pixels in the mask after computing the weighted sum, thus producing a weighted average? Without this, the sum of nine pixel values (even when multiplied with not-too-bright mask values) will easily exceed 255.