Logic for reflect function in pset4 filter

Question

I'm working through pset4 filter and the code for the reflect function. I'm still getting errors so clearly there's some kind of issue with my logic. When I try to apply filter to an actual image, I get this error: runtime error: index 600 out of bounds for type 'RGBTRIPLE [width]'

My thinking was to iterate through the array of pixels in the bitmap with two loops, but only go halfway for the loop going horizontally. And then use a helper function to swap the RGB color values with each pixel with its opposite pixel (for the opposite pixel - the position with regards to height is the same but the width is the total width minus the width value for that pixel). What am I getting wrong here?

void swap(int *a, int *b);

void reflect(int height, int width, RGBTRIPLE image[height][width]) // TODO explore more with swap function and malloc from lesson
{
    for (int i = 0; i < height; i++)
    {
        for (int k = 0; k < (width / 2); k++)
        {
            int x = image[i][k].rgbtBlue;
            int y = image[i][width - k].rgbtBlue;
            int g = image[i][k].rgbtGreen;
            int h = image[i][width - k].rgbtGreen;
            int l = image[i][k].rgbtRed;
            int j = image[i][width - k].rgbtRed;
            swap(&x, &y);
            swap(&g, &h);
            swap(&l, &j);
        }
    }
    return;
}

void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

UPDATE:

I tried another solution here, where I adjusted the bounds of the array and also ditched the local variables, but it's still not working. What am I missing? Do I need to copy the entire image and not just pixel by pixel somehow?

 void reflect(int height, int width, RGBTRIPLE image[height][width]) =
    {
        for (int i = 0; i < height - 1; i++)
        {
            for (int k = 0; k < (width / 2) - 1; k++)
            {
                RGBTRIPLE temp = image[i][k];
                image[i][k] = image[i][width - k];
                image[i][width - k] = temp;
            }
        }
        return;
    }

Answer 1

There are two issues. First is the one that @Himanshi brought up - It's doing a great job of swapping x/y, g/h and i/j. But at what point is anything actually being changed in the image array? Did you notice that the output file contains the original image?

Second, have you looked carefully at the maximum indexes that you're using for the array? Is [width -k] a valid index when k = 0???

Programming tip: While all of the reassigning and swapping of individual struct elements rgbtRed, rgbtGreen and rgbtBlue are correct, the whole thing can be streamlined just by swapping the entire pixel struct. Instead of 9 lines plus an added swap function, the whole thing can be done in just 3 lines. Say that you had two pixels that you wanted to swap, pxl1 and pxl2.

        RGBTRIPLE temp = pxl1 ;
        pxl1 = pxl2;
        pxl2 = temp;

It's not necessary to copy each element of a struct when you want to copy an entire struct.

If this answers your question, please click on the check mark to accept. Let's keep up on forum maintenance. ;-)

Answer 2

when you are writing this 'int y = image[i][width - k].rgbtBlue;' think exactly what pixel is this thing swapping?..