My blur function blurs every image, but fails every check50 check - please help!

Question

I'd really appreciate any help that can be offered here. My code seems to output a blurred image perfectly, but fails every check50 check and I can't work out why...

void blur(int height, int width, RGBTRIPLE image[height][width])
{
    
    //Copy image over to new RGBTRIPLE
    
    RGBTRIPLE image_copy[height][width];
    for (int a = 0; a < height; a++)
    {
        for (int b = 0; b < width; b++)
        {
            image_copy[a][b] = image[a][b];
        }
    }
    
    //Cycle through each pixel of image
    
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            //Define 3x3 pixel array
            RGBTRIPLE arr[3][3];
            
            int i_proxy = i - 1;
            int j_proxy = j - 1;
            
            int null_count = 0;
            
            //Populate 3x3 array 
        
            for (int k = 0; k < 3; k++)
                {
                    for (int l = 0; l < 3; l++)
                    {
                        if (i_proxy < 0 || i_proxy == height || j_proxy < 0 || j_proxy == width)
                        {
                            arr[k][l].rgbtBlue = 0;
                            arr[k][l].rgbtGreen = 0;
                            arr[k][l].rgbtRed = 0;
                            null_count++;
                            j_proxy++;
                        }
                        else
                        {
                            arr[k][l] = image_copy[i_proxy][j_proxy];
                            j_proxy++;
                        }
                    }
                    i_proxy++;
                }
            int sum_red = 0, sum_blue = 0, sum_green = 0;
            for (int m = 0; m < 3; m++)
            {
                for (int n = 0; n < 3; n++)
                {
                    sum_red += arr[m][n].rgbtRed;
                    sum_blue += arr[m][n].rgbtBlue;
                    sum_green += arr[m][n].rgbtGreen;
                }
            }
            int pixel_type = 9 - null_count;
            image[i][j].rgbtBlue = round((float) (sum_blue / pixel_type));
            image[i][j].rgbtGreen = round((float) (sum_green / pixel_type));
            image[i][j].rgbtRed = round((float) (sum_red / pixel_type));
        }
    }
    return;
}

Answer 1

Please note I haven't validated this with testing and have only glanced at your code, but one thing that stands out to me:

round((float) (sum_blue / pixel_type))

Remember operator precedence here: the division will be performed first (as it is inside parentheses). At this point both values are integers so integer division will be performed and the remainder will be discarded. The result will then be cast to a float, but now it's irrelevant. Effectively the result will be exactly the same as:

sum_blue / pixel_type

If you remove the parentheses and cast one of the values to float, you will get the desired floating point division, and a meaningful result to perform round() on:

round((float) sum_blue / pixel_type)