Question

I’m having a problem with edge detection using Sobel operator: it produces too many false edges, effect is shown on pictures below.
I’m using a 3×3 sobel operator – first extracting vertical then horizontal, final output is magnitude of each filter output.
Edges on synthetic images are extracted properly but natural images produce have too many false edges or “noise” even if image is preprocessed by applying blur or median filter.
What might be cause of this? Is it implementation problem (then: why synthetic images are fine?) or I need to do some more preprocessing?

Original:

Output:

code:

void imageOp::filter(image8* image, int maskSize, int16_t *mask)
{
    if((image == NULL) || (maskSize/2 == 0) || maskSize < 1)
    {
        if(image == NULL)
        {
            printf("filter: image pointer == NULL \n");
        }
        else if(maskSize < 1)
        {
            printf("filter: maskSize must be greater than 1\n");
        }
        else
        {
            printf("filter: maskSize must be odd number\n");
        }
        return;
    }

    image8* fImage = new image8(image->getHeight(), image->getWidth());
    uint16_t sum = 0;
    int d = maskSize/2;
    int ty, tx;

    for(int x = 0; x < image->getHeight(); x++)         //
    {                                                   // loop over image
        for(int y = 0; y < image->getWidth(); y++)      // 
        {
            for(int xm = -d; xm <= d; xm++)
            {
                for(int ym = -d; ym <= d; ym++)
                {
                    ty = y + ym;
                    if(ty < 0)  // edge conditions
                    {
                        ty = (-1)*ym - 1;
                    }
                    else if(ty >= image->getWidth())
                    {
                        ty = image->getWidth() - ym;
                    }

                    tx = x + xm;
                    if(tx < 0)  // edge conditions
                    {
                        tx = (-1)*xm - 1;
                    }
                    else if(tx >= image->getHeight())
                    {
                        tx = image->getHeight() - xm;
                    }

                    sum += image->img[tx][ty] * mask[((xm+d)*maskSize) + ym + d];
                }
            }

            if(sum > 255)
            {
                fImage->img[x][y] = 255;
            }
            else if(sum < 0)
            {
                fImage->img[x][y] = 0;
            }
            else
            {
                fImage->img[x][y] = (uint8_t)sum;
            }
            sum = 0;
        }
    }


    for(int x = 0; x < image->getHeight(); x++)
    {
        for(int y = 0; y < image->getWidth(); y++)
        {
            image->img[x][y] = fImage->img[x][y];
        }
    }

    delete fImage;
}

Answer 1

This appears to be due to a math error somewhere in your code. To follow on my comment, this is what I get when I run your image through a Sobel operator here (edge strength is indicated by brightness of the output image):

I used a GLSL fragment shader to produce this:

 precision mediump float;

 varying vec2 textureCoordinate;
 varying vec2 leftTextureCoordinate;
 varying vec2 rightTextureCoordinate;

 varying vec2 topTextureCoordinate;
 varying vec2 topLeftTextureCoordinate;
 varying vec2 topRightTextureCoordinate;

 varying vec2 bottomTextureCoordinate;
 varying vec2 bottomLeftTextureCoordinate;
 varying vec2 bottomRightTextureCoordinate;

 uniform sampler2D inputImageTexture;

 void main()
 {
    float bottomLeftIntensity = texture2D(inputImageTexture, bottomLeftTextureCoordinate).r;
    float topRightIntensity = texture2D(inputImageTexture, topRightTextureCoordinate).r;
    float topLeftIntensity = texture2D(inputImageTexture, topLeftTextureCoordinate).r;
    float bottomRightIntensity = texture2D(inputImageTexture, bottomRightTextureCoordinate).r;
    float leftIntensity = texture2D(inputImageTexture, leftTextureCoordinate).r;
    float rightIntensity = texture2D(inputImageTexture, rightTextureCoordinate).r;
    float bottomIntensity = texture2D(inputImageTexture, bottomTextureCoordinate).r;
    float topIntensity = texture2D(inputImageTexture, topTextureCoordinate).r;
    float h = -topLeftIntensity - 2.0 * topIntensity - topRightIntensity + bottomLeftIntensity + 2.0 * bottomIntensity + bottomRightIntensity;
    float v = -bottomLeftIntensity - 2.0 * leftIntensity - topLeftIntensity + bottomRightIntensity + 2.0 * rightIntensity + topRightIntensity;

    float mag = length(vec2(h, v));

    gl_FragColor = vec4(vec3(mag), 1.0);

You don’t show your mask values, which I assume contain the Sobel kernel. In the above code, I’ve hardcoded the calculations performed against the red channel of each pixel in a 3×3 Sobel kernel. This is purely for performance on my platform.

One thing I don’t notice in your code (again, I may be missing it like I did the sum being set back to 0) is the determination of the magnitude of the vector for the two portions of the Sobel operator. I’d expect to see a square root operation in there somewhere, if that was present.