CS50 pset4 模糊功能 - 无法弄清楚为什么在 3x3 和 4x4 图像上测试失败

Question

我一直在研究 CS50 pset4 模糊功能的代码。该函数假设计算所有相邻像素的平均 RGB 值，然后将其应用于 "middle" 像素（因为该像素可以位于角落、边缘或中间的任何位置）

我在编译或运行编译代码时没有遇到任何错误。输出图像都显得模糊，但是当我运行针对 check50 的代码时，它在两个测试中失败了：

:( blur correctly filters 3x3 image
    expected "70 85 95\n80 9...", not "70 85 95\n80 9..."
:( blur correctly filters 4x4 image
    expected "70 85 95\n80 9...", not "70 85 95\n80 9..."

其他测试通过（测试边缘、角和中间的像素），所以我很难理解我做错了什么。

这是我的代码：

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    // creating a blank copy
    RGBTRIPLE blured[height][width];

    // upper left corner (anchored)
    for (int i = 0; i < 1; i++)
    {
        for (int j = 0; j < 1; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i; k <= i + 1; k++)
            {
                for (int l = j; l <= j + 1; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 4);
            blured[i][j].rgbtGreen = round(trackerGreen / 4);
            blured[i][j].rgbtBlue = round(trackerBlue / 4);
        }
    }
    // top middle row
    for (int i = 0; i < 1; i++)
    {
        for (int j = 1; j < width - 1; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i; k <= i + 1; k++)
            {
                for (int l = j - 1; l <= j + 1; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 6);
            blured[i][j].rgbtGreen = round(trackerGreen / 6);
            blured[i][j].rgbtBlue = round(trackerBlue / 6);
        }
    }
    // upper right corner (anchored)
    for (int i = 0; i < 1; i++)
    {
        for (int j = width - 1; j < width; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i; k <= i + 1; k++)
            {
                for (int l = j - 1; l <= j; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 4);
            blured[i][j].rgbtGreen = round(trackerGreen / 4);
            blured[i][j].rgbtBlue = round(trackerBlue / 4);
        }
    }
    // left middle column
    for (int i = 1; i < height - 1; i++)
    {
        for (int j = 0; j < 1; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i - 1; k <= i + 1; k++)
            {
                for (int l = j; l <= j + 1; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 6);
            blured[i][j].rgbtGreen = round(trackerGreen / 6);
            blured[i][j].rgbtBlue = round(trackerBlue / 6);
        }
    }
    // center
    for (int i = 1; i < height - 1; i++)
    {
        for (int j = 1; j < width - 1; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i - 1; k <= i + 1; k++)
            {
                for (int l = j - 1; l <= j + 1; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 9);
            blured[i][j].rgbtGreen = round(trackerGreen / 9);
            blured[i][j].rgbtBlue = round(trackerBlue / 9);
        }
    }
    // right middle column
    for (int i = 1; i < height - 1; i++)
    {
        for (int j = width - 1; j < width; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i - 1; k <= i + 1; k++)
            {
                for (int l = j; l <= j; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 6);
            blured[i][j].rgbtGreen = round(trackerGreen / 6);
            blured[i][j].rgbtBlue = round(trackerBlue / 6);
        }
    }
    // lower left corner (anchored)
    for (int i = height - 1; i < height; i++)
    {
        for (int j = 0; j < height; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i - 1; k <= i; k++)
            {
                for (int l = j; l <= j + 1; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 4);
            blured[i][j].rgbtGreen = round(trackerGreen / 4);
            blured[i][j].rgbtBlue = round(trackerBlue / 4);
        }
    }
    // bottom middle row
    for (int i = height - 1; i < height; i++)
    {
        for (int j = 1; j < width - 1; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i - 1; k <= i; k++)
            {
                for (int l = j - 1; l <= j + 1; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 6);
            blured[i][j].rgbtGreen = round(trackerGreen / 6);
            blured[i][j].rgbtBlue = round(trackerBlue / 6);
        }
    }
    // lower right corner (anchored)
    for (int i = height - 1; i < height; i++)
    {
        for (int j = width - 1; j < width; j++)
        {
            float trackerRed = 0, trackerGreen = 0, trackerBlue = 0;
            for (int k = i - 1; k <= i; k++)
            {
                for (int l = j - 1; l <= j; l++)
                {
                    trackerRed += (float)image[k][l].rgbtRed;
                    trackerGreen += (float)image[k][l].rgbtGreen;
                    trackerBlue += (float)image[k][l].rgbtBlue;
                }
            }
            blured[i][j].rgbtRed = round(trackerRed / 4);
            blured[i][j].rgbtGreen = round(trackerGreen / 4);
            blured[i][j].rgbtBlue = round(trackerBlue / 4);
        }
    }

    // copy blured image data back to the original image
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j].rgbtRed = blured[i][j].rgbtRed;
            image[i][j].rgbtGreen = blured[i][j].rgbtGreen;
            image[i][j].rgbtBlue = blured[i][j].rgbtBlue;
        }
    }
    return;
}

非常感谢任何帮助

Answer 1

我也在 class 所以这可能是完全错误的，但这是我看到的：

// right middle column
for (int l = j; l <= j; l++)

你对 int l 的 for 循环似乎不正确。不应该有 2 列吗？

// lower left corner (anchored)
for (int j = 0; j < height; j++)

j 应该是宽度，但是根据你之前的代码，它是一个角，我认为它应该是 1

CS50 pset4 模糊功能 - 无法弄清楚为什么在 3x3 和 4x4 图像上测试失败

CS50 pset4 blur function - trouble figuring out why the tests fails on 3x3 and 4x4 images

c

cs50