CS50 week 4 无滤镜模糊 Function

Question

我花了几天时间试图找出这个 function 有什么问题。它实际上编译得很好，但它以错误的方式模糊了图像。 我相信也许我的数字或公式是错误的，但在反复检查几个小时后，我无法弄清楚哪里出了问题。

该练习希望您使用 3*3 模糊框模糊图像，因此将模糊框的 RGB 值相加并将它们除以有效模糊框像素（图像边界一侧的像素）。然后分配“模糊”图像的值。

在我模糊的图像中，模糊不允许区分图片中的任何图形。 我检查了其他 blur function 答案，并尝试使用不同的变体从头开始制作和重新制作代码，但似乎没有任何效果。 下面的代码在我看来它更接近正确的解决方案。 任何帮助将不胜感激。 抱歉我的英语有任何错误

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{    // create image copy for holding modifies RGB values
     RGBTRIPLE copy[height][width];
     for(int i = 0; i < height; i++)
     {
         for (int j = 0; j < width; j++)
         {
              copy[i][j] = image[i][j];
         }
     }
     // setting variable for holding sum of blur box RGB values
     float blurred = 0.0;
     float blurgreen = 0.0;
     float blurblue = 0.0;
     // setting counter for valid blur box pixels
     float validpixels = 0.0;
     // looping through image rows
     for( int i = 0; i < height; i++)
     {   // looping through image columns
         for(int j = 0; j < width; j++)
         {   // looping through blur box rows
             for(int r = -1; r < 2; r++)
             {   //looping through blur box columns
                 for(int c = -1; c < 2; c++)
                 {   // counting only valid blur-box pixels(inside image boundaries)
                     if(i + c >= 0 && j + r >= 0 && i + c < height && j + r < width)
                     {  // storing total of blur box RGB values
                        blurred += copy[i + c][j + r].rgbtRed;
                        blurgreen += copy[i + c][j + r].rgbtGreen;
                        blurblue += copy[i + c][j + r].rgbtBlue;
                        // counting valid pixels total
                        validpixels ++;
                     }
                 }
             }
               // calculate RGB  blurred values and assigning them to image copy
               copy[i][j].rgbtRed = round(blurred / validpixels);
               copy[i][j].rgbtGreen = round(blurgreen / validpixels);
               copy[i][j].rgbtBlue = round(blurblue / validpixels);
         }
     }
     //giving blur values back to image
     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].rgbtGreen = copy[i][j].rgbtGreen;
              image[i][j].rgbtBlue = copy[i][j].rgbtBlue;
         }
     }
    return;
}

Answer 1

你有两个主要问题：

• 您必须重新初始化blur*变量以及每个像素的计数器。 否则你会不断总结越来越多的像素。 当你到达终点时，这基本上会创建整个图像的平均值。
• 您将模糊值存储在读取要模糊的值的同一数组中。 这完全泄露了制作副本的全部目的。

不是问题，但可以改进：

• 不要在程序中使用float 。 除非您在 memory 或计算能力方面有一些非常严格的限制，否则您应该始终对浮点数使用double 。
• 计数器最好定义为整数，而不是浮点数。
• Chux 指出：由于您的目的地是 integer 值，您可以将round替换为lround 。 或者一直使用 integer 算术，如 Chux 的回答所示。

修复在代码中使用//####标记

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{    // create image copy for holding modifies RGB values
     RGBTRIPLE copy[height][width];
     for(int i = 0; i < height; i++)
     {
         for (int j = 0; j < width; j++)
         {
              copy[i][j] = image[i][j];
         }
     }

     // looping through image rows
     for( int i = 0; i < height; i++)
     {   // looping through image columns
         for(int j = 0; j < width; j++)
         {   // looping through blur box rows

             // setting variable for holding sum of blur box RGB values
             //#### Initialize your blurring variables for each pixel you are visiting.
             //#### Always use double instead of float except you have specific requirements.
             double blurred = 0.0;
             double blurgreen = 0.0;
             double blurblue = 0.0;

             // setting counter for valid blur box pixels
             //#### Also re-initialize counter for each pixel
             //#### Counters are normally integers, no floating point numbers
             size_t validpixels = 0;

             for(int r = -1; r < 2; r++)
             {   //looping through blur box columns
                 for(int c = -1; c < 2; c++)
                 {   // counting only valid blur-box pixels(inside image boundaries)
                     if(i + c >= 0 && j + r >= 0 && i + c < height && j + r < width)
                     {  // storing total of blur box RGB values
                        blurred += copy[i + c][j + r].rgbtRed;
                        blurgreen += copy[i + c][j + r].rgbtGreen;
                        blurblue += copy[i + c][j + r].rgbtBlue;
                        // counting valid pixels total
                        validpixels ++;
                     }
                 }
             }
               // calculate RGB  blurred values and assigning them to image copy
               //#### No! Don't store in the copy again. This will disturb
               //#### calculation of the other pixels. 
               image[i][j].rgbtRed = lround(blurred / validpixels);
               image[i][j].rgbtGreen = lround(blurgreen / validpixels);
               image[i][j].rgbtBlue = lround(blurblue / validpixels);
         }
     }
     //giving blur values back to image
     //#### No! Copying again is not required. Results were stored there already

    return;
}

Answer 2

任何帮助将不胜感激。

不是解决问题，而是简化。

 //for(int i = 0; i < height; i++) {
 //    for (int j = 0; j < width; j++) {
 //         copy[i][j] = image[i][j];
 //    }
 //}
 memcpy(copy, image, sizeof copy);

同样，最终副本返回image 。 然而，由于不需要复制，因此只需放弃这一步。

// memcpy(image, copy, sizeof copy);

不要使用sizeof image因为它不是图像的大小。

---

与其使用float数学，不如继续使用 integer 数学。

 // float blurred = 0.0;
 unsigned blurred = 0;
 // float validpixels = 0.0;
 unsigned validpixels = 0;
  
   ...
   // Leave as is.
   blurred += copy[i + c][j + r].rgbtRed;
   ... 
      // copy[i][j].rgbtRed = round(blurred / validpixels);
      // Put result in `image[]`
      image[i][j].rgbtRed = (blurred + validpixels/2) / validpixels;

---

而不是在最深的循环中测试r ：

             {   //looping through blur box columns
                 for(int c = -1; c < 2; c++)
                 {   // counting only valid blur-box pixels(inside image boundaries)
                     if(i + c >= 0 && j + r >= 0 && i + c < height && j + r < width)
                     {  // storing total of blur box RGB values
                        blurred += copy[i + c][j + r].rgbtRed;
                        blurgreen += copy[i + c][j + r].rgbtGreen;
                        blurblue += copy[i + c][j + r].rgbtBlue;
                        // counting valid pixels total
                        validpixels ++;
                     }
                 }
             }

移动测试并重置validpixels

             unsigned blurred = 0;
             unsigned blurgreen = 0;
             unsigned blurblue = 0;
             unsigned validpixels = 0;
             for(int r = -1; r < 2; r++) {
                 // Add 
                 if(!(j + r >= 0 && j + r < width)) continue;
                 for(int c = -1; c < 2; c++) {
                     // if(i + c >= 0 && j + r >= 0 && i + c < height && j + r < width)
                     if(i + c >= 0 && i + c < height) {
                        blurred += copy[i + c][j + r].rgbtRed;
                        blurgreen += copy[i + c][j + r].rgbtGreen;
                        blurblue += copy[i + c][j + r].rgbtBlue;
                        validpixels ++;
                     }
                 }
             }

---

先进的

除法在时间上可能很昂贵。 由于绝大多数除法是 9，请考虑：

      image[i][j].rgbtRed = validpixels == 9 ? 
          (blurred + 9/2) / 9 :
          (blurred + validpixels/2) / validpixels;

启用优化后，编译器肯定会创建具有固定除数 9 的更快代码，即使无意中听到validpixels == 9也是如此。