CS50第4周Filter作业：边缘检测函数变量声明位置影响咨询

我在完成CS50 2023年第4周Filter作业的边缘检测函数时遇到问题，编写的代码仅能检测第一个像素的边缘，验证不通过。作业要求实现边缘检测功能，核心是使用Gx和Gy卷积核计算梯度。

无效代码 #

void edges(int height, int width, RGBTRIPLE image[height][width])
{
    // 创建图像副本
    RGBTRIPLE copy[height][width];

    // 将原始图像复制到副本
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            copy[i][j] = image[i][j];
        }
    }
    // 初始化x和y方向的卷积核
    int Gx[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
    int Gy[3][3] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};

    // 遍历图像的高度和宽度
    int sxr, sxb, sxg, syr, syb, syg;
    sxr = sxb = sxg = syr = syb = syg = 0;

    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            for (int k = 0; k < 3; k++)
            {
                for (int l = 0; l < 3; l++)
                {
                    // 跳过边界外的像素
                    if(i + k - 1 < 0 || i + k - 1 > height || j + l - 1 < 0 || j + l - 1 > width)
                    {
                        continue;
                    }

                    // 边界内的像素，累加梯度值
                    sxr += ((copy[i - 1 + k][j -  1 + l].rgbtRed) * (Gx[k][l]));
                    sxb += ((copy[i - 1 + k][j -  1 + l].rgbtBlue) * (Gx[k][l]));
                    sxg += ((copy[i - 1 + k][j -  1 + l].rgbtGreen) * (Gx[k][l]));

                    syr += ((copy[i - 1 + k][j -  1 + l].rgbtRed) * (Gy[k][l]));
                    syb += ((copy[i - 1 + k][j -  1 + l].rgbtBlue) * (Gy[k][l]));
                    syg += ((copy[i - 1 + k][j -  1 + l].rgbtGreen) * (Gy[k][l]));

                }
            }
            int srtR = round(sqrt(sxr * sxr + syr * syr));
            int srtB = round(sqrt(sxb * sxb + syb * syb));
            int srtG = round(sqrt(sxg * sxg + syg * syg));

            // 处理RGB值超过255的情况
            if (srtR > 255)
            {
                srtR = 255;
            }
            if (srtB > 255)
            {
                srtB = 255;
            }
            if (srtG > 255)
            {
                srtG = 255;
            }
            copy[i][j].rgbtRed =  srtR;
            copy[i][j].rgbtBlue = srtB;
            copy[i][j].rgbtGreen = srtG;
        }
    }
    // 将副本结果写回原图像
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j].rgbtRed = copy[i][j].rgbtRed;
            image[i][j].rgbtBlue = copy[i][j].rgbtBlue;
            image[i][j].rgbtGreen = copy[i][j].rgbtGreen;

        }
    }
}

可正常运行的代码 #

void edges(int height, int width, RGBTRIPLE image[height][width])
{
    // 创建图像副本
    RGBTRIPLE copy[height][width];

    // 将原始图像复制到副本
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            copy[i][j] = image[i][j];
        }
    }
    // 初始化x和y方向的卷积核
    int Gx[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
    int Gy[3][3] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};

    // 遍历图像的高度和宽度
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            float sxr, sxb, sxg, syr, syb, syg;
            sxr = sxb = sxg = syr = syb = syg = 0;

            for (int k = 0; k < 3; k++)
            {
                for (int l = 0; l < 3; l++)
                {
                    // 跳过边界外的像素
                    if(i + k - 1 < 0 || i + k - 1 >= height || j + l - 1 < 0 || j + l - 1 >= width)
                    {
                        continue;
                    }

                    // 边界内的像素，累加梯度值
                    sxr += ((copy[i - 1 + k][j -  1 + l].rgbtRed) * (Gx[k][l]));
                    sxb += ((copy[i - 1 + k][j -  1 + l].rgbtBlue) * (Gx[k][l]));
                    sxg += ((copy[i - 1 + k][j -  1 + l].rgbtGreen) * (Gx[k][l]));

                    syr += ((copy[i - 1 + k][j -  1 + l].rgbtRed) * (Gy[k][l]));
                    syb += ((copy[i - 1 + k][j -  1 + l].rgbtBlue) * (Gy[k][l]));
                    syg += ((copy[i - 1 + k][j -  1 + l].rgbtGreen) * (Gy[k][l]));

                }
            }
            int srtR = round(sqrt((sxr * sxr) + (syr * syr)));
            int srtB = round(sqrt(sxb * sxb + syb * syb));
            int srtG = round(sqrt(sxg * sxg + syg * syg));

            // 处理RGB值超过255的情况
            if (srtR > 255)
            {
                srtR = 255;
            }
            if (srtB > 255)
            {
                srtB = 255;
            }
            if (srtG > 255)
            {
                srtG = 255;
            }
            image[i][j].rgbtRed =  srtR;
            image[i][j].rgbtBlue = srtB;
            image[i][j].rgbtGreen = srtG;
        }
    }
}

两个代码的差异主要在于sxr等变量的声明位置（外层循环外vs每个像素循环内）、变量类型（int vs float）、边界判断条件及结果写入目标。请问为何变量声明位置会对代码运行结果产生如此大的影响？

问题根源：变量的生命周期与累加逻辑 #

在无效代码中，sxr、sxb等累加变量被声明在所有像素循环的外部，并且只初始化了一次。这会导致：

• 处理第一个像素时，变量从0开始累加，能计算出正确的梯度值；
• 处理第二个及后续像素时，变量不会被重置为0，而是在前一个像素的计算结果基础上继续累加。随着处理的像素增多，这些累加值会迅速膨胀，经过平方根计算和截断后几乎都变成255，最终只有第一个像素的边缘检测结果正常，后续像素全部失效。

而在有效代码中，这些累加变量被声明在每个像素的循环内部，每次处理新像素时，变量都会被重新初始化（赋值为0）。这样每个像素的梯度计算都是独立的，完全基于原始图像的像素值重新累加，不会受到前一个像素计算结果的干扰，自然能得到正确的边缘检测效果。

补充：其他差异的影响 #

虽然你重点问变量声明位置，但其他差异也对结果有重要作用：

• 变量类型从int改为float：避免整数累加过程中的精度丢失，多次乘法和累加后，浮点数能保留更准确的中间结果，让最终的平方根计算更精确；
• 边界判断条件修正：把>改为>=，数组索引范围是0到height-1，当索引等于height时已经越界，修正后能正确跳过边界外的像素；
• 结果写入目标调整：从修改copy改为直接写入image，因为我们已经提前保存了原始图像到copy中，所有计算都基于copy的原始值，修改copy会导致后续像素计算使用被修改后的值，而直接写入image则不会影响原始拷贝的完整性。

内容的提问来源于stack exchange，提问作者Nikhil