CS50 PSET4 Sobel过滤器-边缘（边界像素）

我已经为边缘（Sobel过滤器）的CS50 Pset4编写了以下代码

以下是CS50 Pset4问题描述的链接（仅限边缘部分）：

我写的代码显示了一个sobel过滤器图像，但我的问题只是边界像素

这是我的密码：

// Detect edges
void edges(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE imgCopy[height][width];

    float gxRed;
    float gxGreen;
    float gxBlue;

    float gyRed;
    float gyGreen;
    float gyBlue;

    float gRed;
    float gGreen;
    float gBlue;



    for (int h = 0; h < height; h++)
    {
        for (int w = 0; w < width; w++)
        {
            imgCopy[h][w].rgbtRed = image[h][w].rgbtRed;
            imgCopy[h][w].rgbtGreen = image[h][w].rgbtGreen;
            imgCopy[h][w].rgbtBlue = image[h][w].rgbtBlue;
        }
    }

    for (int h = 0; h < height; h++)
    {
        for (int w = 0; w < width; w++)
        {


            // Top left Corner
            if (h == 0 && w == 0)
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = 2 * imgCopy[h][w + 1].rgbtRed + imgCopy[h + 1][w + 1].rgbtRed;
                gxGreen = 2 * imgCopy[h][w + 1].rgbtGreen + imgCopy[h + 1][w + 1].rgbtGreen;
                gxBlue = 2 * imgCopy[h][w + 1].rgbtBlue + imgCopy[h + 1][w + 1].rgbtBlue;

                gyRed = 2 * imgCopy[h + 1][w].rgbtRed + imgCopy[h + 1][w + 1].rgbtRed ;
                gyGreen = 2 * imgCopy[h + 1][w].rgbtGreen + imgCopy[h + 1][w + 1].rgbtGreen;
                gyBlue = 2 * imgCopy[h + 1][w].rgbtBlue + imgCopy[h + 1][w + 1].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
                }

            // Top-right corner
            else if ( h == 0 && w == width - 1 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = -2 * imgCopy[h][w - 1].rgbtRed + -1 * imgCopy[h + 1][w - 1].rgbtRed;
                gxGreen = -2 * imgCopy[h][w - 1].rgbtGreen + -1 * imgCopy[h + 1][w - 1].rgbtGreen;
                gxBlue = -2 * imgCopy[h][w - 1].rgbtBlue + -1 * imgCopy[h + 1][w - 1].rgbtBlue;

                gyRed = 2 * imgCopy[h + 1][w].rgbtRed + imgCopy[h + 1][w - 1].rgbtRed;
                gyGreen = 2 * imgCopy[h + 1][w].rgbtGreen + imgCopy[h + 1][w - 1].rgbtGreen;
                gyBlue = 2 * imgCopy[h + 1][w].rgbtBlue + imgCopy[h + 1][w - 1].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Bottom left corner
            else if (h == height - 1 && w == 0 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = 1 * imgCopy[h - 1][w + 1].rgbtRed + 2 * imgCopy[h][w + 1].rgbtRed;
                gxGreen = 1 * imgCopy[h - 1][w + 1].rgbtGreen + 2 * imgCopy[h][w + 1].rgbtGreen;
                gxBlue = 1 * imgCopy[h - 1][w + 1].rgbtBlue + 2 * imgCopy[h][w + 1].rgbtBlue;

                gyRed = -1 * imgCopy[h - 1][w + 1].rgbtRed + -2 * imgCopy[h - 1][w].rgbtRed;
                gyGreen = -1 * imgCopy[h - 1][w + 1].rgbtGreen + -2 * imgCopy[h - 1][w].rgbtGreen;
                gyBlue = -1 * imgCopy[h - 1][w + 1].rgbtBlue + -2 * imgCopy[h - 1][w].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Bottom-right corner
            else if ( h == height - 1 && w == width - 1 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = -1 * imgCopy[h - 1][w - 1].rgbtRed + -2 * imgCopy[h][w - 1].rgbtRed;
                gxGreen = -1 * imgCopy[h - 1][w - 1].rgbtGreen + -2 * imgCopy[h][w - 1].rgbtGreen;
                gxBlue = -1 * imgCopy[h - 1][w - 1].rgbtBlue + -2 * imgCopy[h][w - 1].rgbtBlue;

                gyRed = -1 * imgCopy[h - 1][w - 1].rgbtRed + -2 * imgCopy[h - 1][w].rgbtRed;
                gyGreen = -1 * imgCopy[h - 1][w - 1].rgbtGreen + -2 * imgCopy[h - 1][w].rgbtGreen;
                gyBlue = -1 * imgCopy[h - 1][w - 1].rgbtBlue + -2 * imgCopy[h - 1][w].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Top border pixels
            else if ( h == 0 && (w > 0 && w < width - 1) )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = -1 * imgCopy[h][w - 1].rgbtRed + 1 * imgCopy[h][w + 1].rgbtRed;
                gxGreen = -1 * imgCopy[h][w - 1].rgbtGreen + 1 * imgCopy[h][w + 1].rgbtGreen;
                gxBlue = -1 * imgCopy[h][w - 1].rgbtBlue + 1 * imgCopy[h][w + 1].rgbtBlue;

                gyRed = 1 * imgCopy[h][w - 1].rgbtRed + 2 * imgCopy[h][w].rgbtRed + 1 * imgCopy[h][w + 1].rgbtRed;
                gyGreen = 1 * imgCopy[h][w - 1].rgbtGreen + 2 * imgCopy[h][w].rgbtGreen + 1 * imgCopy[h][w + 1].rgbtGreen;
                gyBlue = 1 * imgCopy[h][w - 1].rgbtBlue + 2 * imgCopy[h][w].rgbtBlue + 1 * imgCopy[h][w + 1].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Bottom border pixels
            else if ( h == height - 1 && (w > 0 && w < width - 1) )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = -1 * imgCopy[h][w - 1].rgbtRed + 1 * imgCopy[h][w + 1].rgbtRed;
                gxGreen = -1 * imgCopy[h][w - 1].rgbtGreen + 1 * imgCopy[h][w + 1].rgbtGreen;
                gxBlue = -1 * imgCopy[h][w - 1].rgbtBlue + 1 * imgCopy[h][w + 1].rgbtBlue;

                gyRed = -1 * imgCopy[h][w - 1].rgbtRed + -2 * imgCopy[h][w].rgbtRed + -1 * imgCopy[h][w + 1].rgbtRed;
                gyGreen = -1 * imgCopy[h][w - 1].rgbtGreen + -2 * imgCopy[h][w].rgbtGreen + -1 * imgCopy[h][w + 1].rgbtGreen;
                gyBlue = -1 * imgCopy[h][w - 1].rgbtBlue + -2 * imgCopy[h][w].rgbtBlue + -1 * imgCopy[h][w + 1].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Left-side border pixels
            else if ( (h > 0 && h < height - 1) && w == 0 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = 1 * imgCopy[h - 1][w].rgbtRed + 2 * imgCopy[h][w].rgbtRed + 1 * imgCopy[h + 1][w].rgbtRed;
                gxGreen = 1 * imgCopy[h - 1][w].rgbtGreen + 2 * imgCopy[h][w].rgbtGreen + 1 * imgCopy[h + 1][w].rgbtGreen;
                gxBlue = 1 * imgCopy[h - 1][w].rgbtBlue + 2 * imgCopy[h][w].rgbtBlue + 1 * imgCopy[h + 1][w].rgbtBlue;

                gyRed = -1 * imgCopy[h - 1][w].rgbtRed + 1 * imgCopy[h + 1][w].rgbtRed;
                gyGreen = -1 * imgCopy[h - 1][w].rgbtGreen + 1 * imgCopy[h + 1][w].rgbtGreen;
                gyBlue = -1 * imgCopy[h - 1][w].rgbtBlue + 1 * imgCopy[h + 1][w].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Right-side border pixels
            else if ( (h > 0 && h < height - 1) && w == width - 1 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = -1 * imgCopy[h - 1][w].rgbtRed + -2 * imgCopy[h][w].rgbtRed + -1 * imgCopy[h + 1][w].rgbtRed;
                gxGreen = -1 * imgCopy[h - 1][w].rgbtGreen + -2 * imgCopy[h][w].rgbtGreen + -1 * imgCopy[h + 1][w].rgbtGreen;
                gxBlue = -1 * imgCopy[h - 1][w].rgbtBlue + -2 * imgCopy[h][w].rgbtBlue + -1 * imgCopy[h + 1][w].rgbtBlue;

                gyRed = -1 * imgCopy[h - 1][w].rgbtRed + 1 * imgCopy[h + 1][w].rgbtRed;
                gyGreen = -1 * imgCopy[h - 1][w].rgbtGreen + 1 * imgCopy[h + 1][w].rgbtGreen;
                gyBlue = -1 * imgCopy[h - 1][w].rgbtBlue + 1 * imgCopy[h + 1][w].rgbtBlue;

                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if(gRed > 255)
                {
                    gRed = 255;
                }
                if(gGreen > 255)
                {
                    gGreen = 255;
                }
                if(gBlue > 255)
                {
                    gBlue = 255;
                }
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Middle 3x3 pixels
            else
            {
            gxRed =   (float)((-1 * imgCopy[h - 1][w - 1].rgbtRed) + (0 * imgCopy[h - 1][w].rgbtRed) + (1 * imgCopy[h - 1][w + 1].rgbtRed) +
                              (-2 * imgCopy[h][w - 1].rgbtRed)     + (0 * imgCopy[h][w].rgbtRed)     + (2 * imgCopy[h][w + 1].rgbtRed) +
                              (-1 * imgCopy[h + 1][w - 1].rgbtRed) + (0 * imgCopy[h + 1][w].rgbtRed) + (1 * imgCopy[h + 1][w + 1].rgbtRed));

            gxGreen = (float)((-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (0 * imgCopy[h - 1][w].rgbtGreen) + (1 * imgCopy[h - 1][w + 1].rgbtGreen) +
                              (-2 * imgCopy[h][w - 1].rgbtGreen)     + (0 * imgCopy[h][w].rgbtGreen)     + (2 * imgCopy[h][w + 1].rgbtGreen) +
                              (-1 * imgCopy[h + 1][w - 1].rgbtGreen) + (0 * imgCopy[h + 1][w].rgbtGreen) + (1 * imgCopy[h + 1][w + 1].rgbtGreen));

            gxBlue =  (float)((-1 * imgCopy[h - 1][w - 1].rgbtBlue) + (0 * imgCopy[h - 1][w].rgbtBlue) + (1 * imgCopy[h - 1][w + 1].rgbtBlue) +
                              (-2 * imgCopy[h][w - 1].rgbtBlue)     + (0 * imgCopy[h][w].rgbtBlue)     + (2 * imgCopy[h][w + 1].rgbtBlue) +
                              (-1 * imgCopy[h + 1][w - 1].rgbtBlue) + (0 * imgCopy[h + 1][w].rgbtBlue) + (1 * imgCopy[h + 1][w + 1].rgbtBlue));

            gyRed =   (float)((-1 * imgCopy[h - 1][w - 1].rgbtRed) + (-2 * imgCopy[h - 1][w].rgbtRed) + (-1 * imgCopy[h - 1][w + 1].rgbtRed) +
                              (0 * imgCopy[h][w - 1].rgbtRed)      + (0 * imgCopy[h][w].rgbtRed)      + (0 * imgCopy[h][w + 1].rgbtRed) +
                              (1 * imgCopy[h + 1][w - 1].rgbtRed)  + (2 * imgCopy[h + 1][w].rgbtRed)  + (1 * imgCopy[h + 1][w + 1].rgbtRed));

            gyGreen = (float)((-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (-2 * imgCopy[h - 1][w].rgbtGreen)  + (-1 * imgCopy[h - 1][w + 1].rgbtGreen) +
                              (0 * imgCopy[h][w - 1].rgbtGreen)      + (0 * imgCopy[h][w].rgbtGreen)       + (0 * imgCopy[h][w + 1].rgbtGreen) +
                              (1 * imgCopy[h + 1][w - 1].rgbtGreen)  + (2 * imgCopy[h + 1][w].rgbtGreen)   + (1 * imgCopy[h + 1][w + 1].rgbtGreen));

            gyBlue =  (float)((-1 * imgCopy[h - 1][w - 1].rgbtBlue) + (-2 * imgCopy[h - 1][w].rgbtBlue)  + (-1 * imgCopy[h - 1][w + 1].rgbtBlue) +
                              (0 * imgCopy[h][w - 1].rgbtBlue)      + (0 * imgCopy[h][w].rgbtBlue)       + (0 * imgCopy[h][w + 1].rgbtBlue) +
                              (1 * imgCopy[h + 1][w - 1].rgbtBlue)  + (2 * imgCopy[h + 1][w].rgbtBlue)   + (1 * imgCopy[h + 1][w + 1].rgbtBlue));

            gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
            gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
            gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

            gRed = round(gRed);
            gGreen = round(gGreen);
            gBlue = round(gBlue);

            if(gRed > 255)
            {
                gRed = 255;
            }
            if(gGreen > 255)
            {
                gGreen = 255;
            }
            if(gBlue > 255)
            {
                gBlue = 255;
            }
            image[h][w].rgbtRed = gRed;
            image[h][w].rgbtGreen = gGreen;
            image[h][w].rgbtBlue = gBlue;
            }

        }
    }
    return;
}

//检测边缘
空边（整数高度、整数宽度、RGB三重图像[高度][宽度]）
{
RGB三倍图像复制[高度][宽度]；
浮动gxRed；
绿色浮动；
浮动gxBlue；
浮子旋转；
浮绿；
浮蓝；
浮动格雷德；
漂浮绿色；
浮蓝；
对于（int h=0；h255）
{
gRed=255；
}
如果（绿色>255）
{
gGreen=255；
}
如果（gBlue>255）
{
gBlue=255；
}
图像[h][w].rgbtRed=gRed；
图像[h][w].rgbtGreen=gGreen；
图像[h][w].rgbtBlue=gBlue；
}
//右上角
else如果（h==0&&w==width-1）
{
//对于Gx和Gy值，假设角点处有一个3x3矩阵，角点外的任何像素都被视为等于零
//（角点像素不等于0，将角点像素视为与中间像素相同的3x3矩阵，并获取它们的Gx和Gy值）
gxRed=-2*imgCopy[h][w-1].rgbtRed+-1*imgCopy[h+1][w-1].rgbtRed；
gxGreen=-2*imgCopy[h][w-1].rgbtGreen+-1*imgCopy[h+1][w-1].rgbtGreen；
gxBlue=-2*imgCopy[h][w-1].rgbtBlue+-1*imgCopy[h+1][w-1].rgbtBlue；
gyRed=2*imgCopy[h+1][w].rgbtRed+imgCopy[h+1][w-1].rgbtRed；
gyGreen=2*imgCopy[h+1][w].rgbtGreen+imgCopy[h+1][w-1].rgbtGreen；
gyBlue=2*imgCopy[h+1][w].rgbtBlue+imgCopy[h+1][w-1].rgbtBlue；
gRed=sqrt（（gxRed*gxRed）+（gyRed*gyRed））；
gGreen=sqrt（（gxGreen*gxGreen）+（gyGreen*gyGreen））；
gBlue=sqrt（（gxBlue*gxBlue）+（gyBlue*gyBlue））；
gRed=圆形（gRed）；
g绿色=圆形（g绿色）；
gBlue=圆形（gBlue）；
如果（灰色>255）
{
gRed=255；
}
如果（绿色>255）
{
gGreen=255；
}
如果（gBlue>255）
{
gBlue=255；
}
图像[h][w].rgbtRed=gRed；
图像[h][w].rgbtGreen=gGreen；
图像[h][w].rgbtBlue=gBlue；
}
//左下角
else if（h==高度-1&&w==0）
{
//对于Gx和Gy值，假设角点处有一个3x3矩阵，角点外的任何像素都被视为等于零
//（角点像素不等于0，将角点像素视为与中间像素相同的3x3矩阵，并获取它们的Gx和Gy值）
gxRed=1*imgCopy[h-1][w+1]。rgbtRed+2*imgCopy[h][w+1]。rgbtRed；
gxGreen=1*imgCopy[h-1][w+1]。rgbtGreen+2*imgCopy[h][w+1]。rgbtGreen；
gxBlue=1*imgCopy[h-1][w+1].rgbtBlue+2*imgCopy[h][w+1].rgbtBlue；
gyRed=-1*imgCopy[h-1][w+1]。rgbtRed+-2*imgCopy[h-1][w]。rgbtRed；
gyGreen=-1*imgCopy[h-1][w+1]。rgbtGreen+-2*imgCopy[h-1][w]。rgbtGreen；
gyBlue=-1*imgCopy[h-1][w+1].rgbtBlue+-2*imgCopy[h-1][w].rgbtBlue；
gRed=sqrt（（gxRed*gxRed）+（gyRed*gyRed））；
gGreen=sqrt（（gxGreen*gxGreen）+（gyGreen*gyGreen））；
gBlue=sqrt（（gxBlue*gxBlue）+（gyBlue*gyBlue））；
gRed=圆形（gRed）；
g绿色=圆形（g绿色）；
gBlue=圆形（gBlue）；
如果（灰色>255）
{
gRed=255；
}
如果（绿色>255）
{
gGreen=255；
}
如果（gBlue>255）
{
void findG();

float gxRed, gxGreen, gxBlue;
float gyRed, gyGreen, gyBlue;
float gRed, gGreen, gBlue;

// Detect edges
void edges(int height, int width, RGBTRIPLE image[height][width])
{
    RGBTRIPLE imgCopy[height][width];

    // Making a copy of image
    for (int h = 0; h < height; h++)
    {
        for (int w = 0; w < width; w++)
        {
            imgCopy[h][w].rgbtRed = image[h][w].rgbtRed;
            imgCopy[h][w].rgbtGreen = image[h][w].rgbtGreen;
            imgCopy[h][w].rgbtBlue = image[h][w].rgbtBlue;
        }
    }

    for (int h = 0; h < height; h++)
    {
        for (int w = 0; w < width; w++)
        {

            // Top left Corner
            if (h == 0 && w == 0)
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = 2 * imgCopy[h][w + 1].rgbtRed + imgCopy[h + 1][w + 1].rgbtRed;
                gxGreen = 2 * imgCopy[h][w + 1].rgbtGreen + imgCopy[h + 1][w + 1].rgbtGreen;
                gxBlue = 2 * imgCopy[h][w + 1].rgbtBlue + imgCopy[h + 1][w + 1].rgbtBlue;

                gyRed = 2 * imgCopy[h + 1][w].rgbtRed + imgCopy[h + 1][w + 1].rgbtRed ;
                gyGreen = 2 * imgCopy[h + 1][w].rgbtGreen + imgCopy[h + 1][w + 1].rgbtGreen;
                gyBlue = 2 * imgCopy[h + 1][w].rgbtBlue + imgCopy[h + 1][w + 1].rgbtBlue;

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
                }

            // Top-right corner
            else if ( h == 0 && w == width - 1 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = -2 * imgCopy[h][w - 1].rgbtRed + -1 * imgCopy[h + 1][w - 1].rgbtRed;
                gxGreen = -2 * imgCopy[h][w - 1].rgbtGreen + -1 * imgCopy[h + 1][w - 1].rgbtGreen;
                gxBlue = -2 * imgCopy[h][w - 1].rgbtBlue + -1 * imgCopy[h + 1][w - 1].rgbtBlue;

                gyRed = 2 * imgCopy[h + 1][w].rgbtRed + imgCopy[h + 1][w - 1].rgbtRed;
                gyGreen = 2 * imgCopy[h + 1][w].rgbtGreen + imgCopy[h + 1][w - 1].rgbtGreen;
                gyBlue = 2 * imgCopy[h + 1][w].rgbtBlue + imgCopy[h + 1][w - 1].rgbtBlue;

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Bottom left corner
            else if (h == height - 1 && w == 0 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = 1 * imgCopy[h - 1][w + 1].rgbtRed + 2 * imgCopy[h][w + 1].rgbtRed;
                gxGreen = 1 * imgCopy[h - 1][w + 1].rgbtGreen + 2 * imgCopy[h][w + 1].rgbtGreen;
                gxBlue = 1 * imgCopy[h - 1][w + 1].rgbtBlue + 2 * imgCopy[h][w + 1].rgbtBlue;

                gyRed = -1 * imgCopy[h - 1][w + 1].rgbtRed + -2 * imgCopy[h - 1][w].rgbtRed;
                gyGreen = -1 * imgCopy[h - 1][w + 1].rgbtGreen + -2 * imgCopy[h - 1][w].rgbtGreen;
                gyBlue = -1 * imgCopy[h - 1][w + 1].rgbtBlue + -2 * imgCopy[h - 1][w].rgbtBlue;

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Bottom-right corner
            else if ( h == height - 1 && w == width - 1 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the corner and any pixel outside the corner is considered to be equal zero
                //(The corner pixels does not equal 0 you treat the corner pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = -1 * imgCopy[h - 1][w - 1].rgbtRed + -2 * imgCopy[h][w - 1].rgbtRed;
                gxGreen = -1 * imgCopy[h - 1][w - 1].rgbtGreen + -2 * imgCopy[h][w - 1].rgbtGreen;
                gxBlue = -1 * imgCopy[h - 1][w - 1].rgbtBlue + -2 * imgCopy[h][w - 1].rgbtBlue;

                gyRed = -1 * imgCopy[h - 1][w - 1].rgbtRed + -2 * imgCopy[h - 1][w].rgbtRed;
                gyGreen = -1 * imgCopy[h - 1][w - 1].rgbtGreen + -2 * imgCopy[h - 1][w].rgbtGreen;
                gyBlue = -1 * imgCopy[h - 1][w - 1].rgbtBlue + -2 * imgCopy[h - 1][w].rgbtBlue;

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Top border pixels
            else if ( h == 0 && (w > 0 && w < width - 1) )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero.
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = (-2 * imgCopy[h][w - 1].rgbtRed) + (2 * imgCopy[h][w + 1].rgbtRed) + (-1 * imgCopy[h + 1][w - 1].rgbtRed) + (1 * imgCopy[h + 1][w + 1].rgbtRed) ;
                gxGreen = (-2 * imgCopy[h][w - 1].rgbtGreen) + (2 * imgCopy[h][w + 1].rgbtGreen) + (-1 * imgCopy[h + 1][w - 1].rgbtGreen) + (1 * imgCopy[h + 1][w + 1].rgbtGreen) ;
                gxBlue = (-2 * imgCopy[h][w - 1].rgbtBlue) + (2 * imgCopy[h][w + 1].rgbtBlue) + (-1 * imgCopy[h + 1][w - 1].rgbtBlue) + (1 * imgCopy[h + 1][w + 1].rgbtBlue) ;

                gyRed = (1 * imgCopy[h + 1][w - 1].rgbtRed) + (2 * imgCopy[h + 1][w].rgbtRed) + (1 * imgCopy[h + 1][w + 1].rgbtRed);
                gyGreen = (1 * imgCopy[h + 1][w - 1].rgbtGreen) + (2 * imgCopy[h + 1][w].rgbtGreen) + (1 * imgCopy[h + 1][w + 1].rgbtGreen);
                gyBlue = (1 * imgCopy[h + 1][w - 1].rgbtBlue) + (2 * imgCopy[h + 1][w].rgbtBlue) + (1 * imgCopy[h + 1][w + 1].rgbtBlue);

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Bottom border pixels
            else if ( h == height - 1 && (w > 0 && w < width - 1) )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = (-2 * imgCopy[h][w - 1].rgbtRed) + (2 * imgCopy[h][w + 1].rgbtRed) + (-1 * imgCopy[h - 1][w - 1].rgbtRed) + (1 * imgCopy[h - 1][w + 1].rgbtRed) ;
                gxGreen = (-2 * imgCopy[h][w - 1].rgbtGreen) + (2 * imgCopy[h][w + 1].rgbtGreen) + (-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (1 * imgCopy[h - 1][w + 1].rgbtGreen) ;
                gxBlue = (-2 * imgCopy[h][w - 1].rgbtBlue) + (2 * imgCopy[h][w + 1].rgbtBlue) + (-1 * imgCopy[h - 1][w - 1].rgbtBlue) + (1 * imgCopy[h - 1][w + 1].rgbtBlue) ;

                gyRed = (-1 * imgCopy[h - 1][w - 1].rgbtRed) + (-2 * imgCopy[h - 1][w].rgbtRed) + (-1 * imgCopy[h - 1][w + 1].rgbtRed);
                gyGreen = (-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (-2 * imgCopy[h - 1][w].rgbtGreen) + (-1 * imgCopy[h - 1][w + 1].rgbtGreen);
                gyBlue = (-1 * imgCopy[h - 1][w - 1].rgbtBlue) + (-2 * imgCopy[h - 1][w].rgbtBlue) + (-1 * imgCopy[h - 1][w + 1].rgbtBlue);

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Left-side border pixels
            else if ( (h > 0 && h < height - 1) && w == 0 )
            {
                // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = (1 * imgCopy[h - 1][w + 1].rgbtRed) + (2 * imgCopy[h][w + 1].rgbtRed) + (1 * imgCopy[h + 1][w + 1].rgbtRed);
                gxGreen = (1 * imgCopy[h - 1][w + 1].rgbtGreen) + (2 * imgCopy[h][w + 1].rgbtGreen) + (1 * imgCopy[h + 1][w + 1].rgbtGreen);
                gxBlue = (1 * imgCopy[h - 1][w + 1].rgbtBlue) + (2 * imgCopy[h][w + 1].rgbtBlue) + (1 * imgCopy[h + 1][w + 1].rgbtBlue);

                gyRed = (-2 * imgCopy[h - 1][w].rgbtRed) + (2 * imgCopy[h + 1][w].rgbtRed) + (-1 * imgCopy[h - 1][w + 1].rgbtRed) + (1 * imgCopy[h + 1][w + 1].rgbtRed);
                gyGreen = (-2 * imgCopy[h - 1][w].rgbtGreen) + (2 * imgCopy[h + 1][w].rgbtGreen) + (-1 * imgCopy[h - 1][w + 1].rgbtGreen) + (1 * imgCopy[h + 1][w + 1].rgbtGreen);
                gyBlue = (-2 * imgCopy[h - 1][w].rgbtBlue) + (2 * imgCopy[h + 1][w].rgbtBlue) + (-1 * imgCopy[h - 1][w + 1].rgbtBlue) + (1 * imgCopy[h + 1][w + 1].rgbtBlue);

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Right-side border pixels
            else if ( (h > 0 && h < height - 1) && w == width - 1 )
            {
               // For Gx and Gy values imagine a 3x3 matrix at the border and any pixel outside the border is considered to be equal zero
                //(The border pixels does not equal 0 you treat the border pixel as a 3x3 matrix same as the middle pixels and get the Gx and Gy values for them)
                gxRed = (-1 * imgCopy[h - 1][w - 1].rgbtRed) + (-2 * imgCopy[h][w - 1].rgbtRed) + (-1 * imgCopy[h + 1][w - 1].rgbtRed);
                gxGreen = (-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (-2 * imgCopy[h][w - 1].rgbtGreen) + (-1 * imgCopy[h + 1][w - 1].rgbtGreen);
                gxBlue = (-1 * imgCopy[h - 1][w - 1].rgbtBlue) + (-2 * imgCopy[h][w - 1].rgbtBlue) + (-1 * imgCopy[h + 1][w - 1].rgbtBlue);

                gyRed = (-1 * imgCopy[h - 1][w - 1].rgbtRed) + (-2 * imgCopy[h - 1][w].rgbtRed) + (1 * imgCopy[h + 1][w - 1].rgbtRed) + (2 * imgCopy[h + 1][w].rgbtRed);
                gyGreen = (-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (-2 * imgCopy[h - 1][w].rgbtGreen) + (1 * imgCopy[h + 1][w - 1].rgbtGreen) + (2 * imgCopy[h + 1][w].rgbtGreen);
                gyBlue = (-1 * imgCopy[h - 1][w - 1].rgbtBlue) + (-2 * imgCopy[h - 1][w].rgbtBlue) + (1 * imgCopy[h + 1][w - 1].rgbtBlue) + (2 * imgCopy[h + 1][w].rgbtBlue);

                findG(h,w);
                
                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

            // Middle 3x3 pixels
            else
            {
                gxRed =   (float)((-1 * imgCopy[h - 1][w - 1].rgbtRed) + (1 * imgCopy[h - 1][w + 1].rgbtRed) +
                                  (-2 * imgCopy[h][w - 1].rgbtRed)     + (2 * imgCopy[h][w + 1].rgbtRed) +
                                  (-1 * imgCopy[h + 1][w - 1].rgbtRed) + (1 * imgCopy[h + 1][w + 1].rgbtRed));

                gxGreen = (float)((-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (1 * imgCopy[h - 1][w + 1].rgbtGreen) +
                                  (-2 * imgCopy[h][w - 1].rgbtGreen)     + (2 * imgCopy[h][w + 1].rgbtGreen) +
                                  (-1 * imgCopy[h + 1][w - 1].rgbtGreen) + (1 * imgCopy[h + 1][w + 1].rgbtGreen));

                gxBlue =  (float)((-1 * imgCopy[h - 1][w - 1].rgbtBlue)  + (1 * imgCopy[h - 1][w + 1].rgbtBlue) +
                                  (-2 * imgCopy[h][w - 1].rgbtBlue)      + (2 * imgCopy[h][w + 1].rgbtBlue) +
                                  (-1 * imgCopy[h + 1][w - 1].rgbtBlue)  + (1 * imgCopy[h + 1][w + 1].rgbtBlue));

                gyRed =   (float)((-1 * imgCopy[h - 1][w - 1].rgbtRed) + (-2 * imgCopy[h - 1][w].rgbtRed) + (-1 * imgCopy[h - 1][w + 1].rgbtRed) +
                                  (1 * imgCopy[h + 1][w - 1].rgbtRed)  + (2 * imgCopy[h + 1][w].rgbtRed)  + (1 * imgCopy[h + 1][w + 1].rgbtRed));

                gyGreen = (float)((-1 * imgCopy[h - 1][w - 1].rgbtGreen) + (-2 * imgCopy[h - 1][w].rgbtGreen)  + (-1 * imgCopy[h - 1][w + 1].rgbtGreen) +
                                  (1 * imgCopy[h + 1][w - 1].rgbtGreen)  + (2 * imgCopy[h + 1][w].rgbtGreen)   + (1 * imgCopy[h + 1][w + 1].rgbtGreen));

                gyBlue =  (float)((-1 * imgCopy[h - 1][w - 1].rgbtBlue) + (-2 * imgCopy[h - 1][w].rgbtBlue)  + (-1 * imgCopy[h - 1][w + 1].rgbtBlue) +
                                  (1 * imgCopy[h + 1][w - 1].rgbtBlue)  + (2 * imgCopy[h + 1][w].rgbtBlue)   + (1 * imgCopy[h + 1][w + 1].rgbtBlue));
                                  
                findG(h,w);

                image[h][w].rgbtRed = gRed;
                image[h][w].rgbtGreen = gGreen;
                image[h][w].rgbtBlue = gBlue;
            }

        }
    }
    return;
}

void findG(int h ,int w)
{
                gRed = sqrt((gxRed * gxRed) + (gyRed * gyRed));
                gGreen = sqrt((gxGreen * gxGreen) + (gyGreen * gyGreen));
                gBlue = sqrt((gxBlue * gxBlue) + (gyBlue * gyBlue));

                gRed = round(gRed);
                gGreen = round(gGreen);
                gBlue = round(gBlue);

                if (gRed > 255)
                {
                    gRed = 255;
                }
                if (gGreen > 255)
                {
                    gGreen = 255;
                }
                if (gBlue > 255)
                {
                    gBlue = 255;
                }
return;
}