Review on code from CS50x Problem Set 4 "Filter More" (Grayscale and Blur functions)

description of tasks: https://cs50.harvard.edu/x/2023/psets/4/filter/more/

There are two problems:

First one - I've made a function to GRAYSCALE a picture, but for some reason it doesn't round the value of average (3 color values divided by 3).
I have used the round() function in diferent places (when counting average and assigning the value of 'shade' to pixel), so I did with the ceil() function, it just doesn't work no matter what.

Second one - I've made a function to BOX-BLUR the image (making a 3x3 'box' around the pixel and counting the average amount of Red Green and Blue accordingly, then assigning the new values of color to the pixel in center of 3x3 'box') But the 'check50' tells me that I'm doing it all wrong.

Is there any critical mistakes in my code or is it just doesn't situated for this specific tests?

screenshots of 'test' included:

Grayscale: first, second, third

Blur: first, second, third

CODE for GRAYSCALE :

#include <math.h>

// Convert image to grayscale
void grayscale(int height, int width, RGBTRIPLE image[height][width])
{
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            int shade = 0;
            shade = ceil((image[i][j].rgbtRed + image[i][j].rgbtGreen + image[i][j].rgbtBlue) / 3);
            image[i][j].rgbtRed = shade; **//also tried round(shade) and ceil(shade)**
            image[i][j].rgbtGreen = shade;
            image[i][j].rgbtBlue = shade;
        }
    }
    return;
}

CODE for BLUR:

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE temp[height][width]; // temp array

    for (int i = 0; i < height; i++) // copy to temporary array
    {
        for (int j = 0; j < width; j++)
        {
            temp[i][j].rgbtRed = image[i][j].rgbtRed;
            temp[i][j].rgbtGreen = image[i][j].rgbtGreen;
            temp[i][j].rgbtBlue = image[i][j].rgbtBlue;
        }
    }

    for (int i = 0; i <= height; i++)
    {
        for (int j = 0; j <= width; j++) // going through array of pixels
        {
            unsigned int avgR = 0, avgG = 0, avgB = 0; // average color value = 0
            unsigned int count = 0;                    // to know how many pixels were used
            for (int k = (i - 1); k <= i + 1; k++)     // boundaries of blur (3x3)
            {
                for (int l = (j - 1); l < j + 1; l++) // boundaries
                {
                    if (k >= 0 && k <= (height - 1) && l >= 0 && l <= (width - 1)) // checking if pixel exists
                    {
                        avgR += round(temp[k][l].rgbtRed); // calculating average
                        avgG += round(temp[k][l].rgbtGreen);
                        avgB += round(temp[k][l].rgbtBlue);
                        count++; // pixels used count
                    }
                }
            }
            image[i][j].rgbtRed = round(avgR / count); // rewriting original color with average
            image[i][j].rgbtGreen = round(avgG / count);
            image[i][j].rgbtBlue = round(avgB / count);
        }
    }
    return;
}

I've tried to: change the position of round()and ceil() functions in **Grayscale **, tried to make 'shade' variable a float-type.

In Blur I didn't touch anything, because it's all wrong, so I dont know where to start

Maybe the problem is that I try to 'hardcode' as less as it is possible, so I make some mistakes while trying to automate all processes via loops

Wrong math

Code performs integer divisions avgR / count with its truncated integer quotient. It then passes the integer quotient to double round(double) for no useful effect.

// image[i][j].rgbtRed = round(avgR / count);

Instead perform rounding with integer math. Various rounding modes are possible to implement without using floating point math.

unsigned divide_round_half_way_up(unsigned a, unsigned b) {
  return = a/b + (a%b*2 >= b);
}

Note that the cost of a%b is often minute given the prior a/b. Good compilers render both the quotient and remainder for the time cost of one.

3 Off by one bugs

// for (int i = 0; i <= height; i++) {
//     for (int j = 0; j <= width; j++)pixels
//     ...
//        for (int l = (j - 1); l < j + 1; l++) // boundaries

for (int i = 0; i < height; i++) {
    for (int j = 0; j < width; j++)

        for (int l = (j - 1); l <= j + 1; l++)

Simplification

RGBTRIPLE temp[height][width]; // temp array

// for (int i = 0; i < height; i++) // copy to temporary array {
//    for (int j = 0; j < width; j++) {
//        temp[i][j].rgbtRed = image[i][j].rgbtRed;
//        temp[i][j].rgbtGreen = image[i][j].rgbtGreen;
//        temp[i][j].rgbtBlue = image[i][j].rgbtBlue;
//    }
// }

memcpy(temp, image, sizeof temp);

In the grayscale, you should try:

shade = round((image[i][j].rgbtRed + image[i][j].rgbtGreen + image[i][j].rgbtBlue) / 3.0);

Both ceil() and round() take floating point. Using 3.0 instead of 3 will force C calculate it as float.

No need to go beyond the very first example, where you get rgb = (27, 28, 28), and should produce (28,28,28), but get (27,27,27).

You are treating division as floating point division, given your use of round and ceil, but an int/int in C will perform integer division, i.e. truncating all decimals immediately.

You could fix that by e.g. dividing by 3., where the values will be promoted to a double, preserving the important decimals, then rounding off the numbers by whatever way you prefer.

int shade = ceil((image[i][j].rgbtRed + image[i][j].rgbtGreen + image[i][j].rgbtBlue) / 3.);

and

image[i][j].rgbtRed = round(avgR / (double)count);

respectively.

You have also messed up the bounds of in your blurring code.

for (int i = 0; i <= height; i++)

Your i goes to high here. Must be less than height.
And your inner loops

for (int k = (i - 1); k <= i + 1; k++)
{
    for (int l = (j - 1); l < j + 1; l++)

is clear to see that it's inconsistent with the upper bounds for k and l. Both should include the upper bound; l <= j + 1