c - 高斯模糊在图像边缘的“不连续性”

我一直在尝试实现一个nxn图像的高斯模糊函数，其高斯核的特定半径为rs=（（int）2.75*sigma+0.5）。

for (x=0;x<n;x++){
    for (y=0;y<n;y++){

        sum=0.0,wsum=0.0;

        //Position correction at the edges

        if(x-rs<0){
            ix=0;
        }
        else ix=rs;

        if(y-rs<0){
            iy=0;
        }
        else iy=rs;

        if (x+rs>n-1){
            jx=n-1-x;
        }
        else jx=rs;

        if (y+rs>n-1){
            jy=n-1-y;
        }
        else jy=rs;
        //Kernel mean value correction at the edges

        if ( x-rs < 0 ){
            meanx=x+((int)rs/2);
        }
        else meanx=x;

        if(y-rs<0){
            meany=y+((int)rs/2);
        }
        else meany=y;

        if (x+rs>n-1){
            meanx=x-((int)rs/2);
        }
        else meanx=x;

        if (y+rs>n-1){
            meany=y-((int)rs/2);
        }
        else meany=y;


        for (i=x-ix;i<=x+jx;i++){
            for (j=y-iy;j<=y+jy;j++){

                weight=1/(2*M_PI*sigma*sigma)*exp(-((meanx-i)*(meanx-i)+(meany-j)*(meany-j))/(2*sigma*sigma));
                sum+=pic1.intenzity[i][j]*weight;
                wsum+=weight;
            }
        }

        pic2->intenzity[x][y]=((int)sum/wsum+0.5);

        fprintf(fw,"%d\n",pic2->intenzity[x][y]);
    }

当我不使用边缘的平均值校正时，结果如下所示：
without mean value correction
当我尝试移动内核的平均值时，它也在图像的下边缘和右边缘创建了一个不连续：
with shifting the mean value to rs/2
我必须修正边缘位置，因为总数会溢出。现在看来，高斯卷积在x和y都位于上边缘和左边缘的rs位置时，由于某种原因突然跳跃。我想使它的行为与在图像的“内部”中的行为相同，或者可能使强度随着位置接近边缘而衰减到0。
我可以用rs放大图像，但这会引起边缘位置的问题。
感谢您的任何有见地的帮助：）

最佳答案

让我们来看一个典型的过滤器内核，它被应用到一个图像中，使用伪代码。允许使用变量

# source[y][x]    Old image (read-only)
# target[y][x]    New image (write-only)
# image_height    Image height (y = 0 .. image_height-1)
# image_width     Image width (x = 0 .. image_width-1)
# filter[y][x]    Filter (weights) to be applied
# filter_height   Filter height (y = 0 .. filter_height-1)
# filter_width    Filter width (x = 0 .. filter_width-1)
# filter_y        Target pixel y coordinate in filter (filter_height/2)
# filter_x        Target pixel x coordinate in filter (filter_width/2)

其中filter_y = floor(filter_width / 2)和filter_x = floor(filter_height / 2)如果过滤器位于目标像素的中心（即对称）。伪代码大概是

For base_y = 0 to image_height - 1:

   # y range relative to base_y ...
   min_y = -filter_y
   max_y = filter_height - 1 - filter_y

   # ... must not exceed the image boundaries.
   If min_y + base_y < 0:
       min_y = -base_y
   End If

   If max_y + base_y < 0:
       max_y = -base_y
   End If

   If min_y + base_y >= image_height:
       min_y = image_height - 1 - base_y
   End If

   If max_y + base_y >= image_height:
       max_y = image_height - 1 - base_y
   End If

   For base_x = 0 to image_width - 1:

       # x range relative to base_x ...
       min_x = -filter_x
       max_x = filter_width - 1 - filter_x

       # ... must not exceed the image boundaries.
       If min_x + base_x < 0:
           min_x = -base_x
       End If

       If max_x + base_x < 0:
           max_x = -base_x
       End If

       If min_x + base_x >= image_width:
           min_x = image_width - 1 - base_x
       End If

       If max_x + base_x >= image_height:
           max_x = image_width - 1 - base_x
       End If

       ValueSum = 0
       WeightSum = 0

       For y = min_y to max_y:
           For x = min_x to max_x:
               Value = source[y + base_y][x + base_x]
               Weight = filter[y + filter_y][x + filter_x]
               ValueSum = ValueSum + Value * Weight
               WeightSum = WeightSum + Weight
           End For
        End For

        If WeightSum != 0:
            target[base_y][base_x] = ValueSum / WeightSum
        End If

    End For
End For

在最里面的循环中，[base_y][base_x]指的是目标像素，我们正在计算的像素；[y+base_y][x+base_x]指的是源像素，其权重为[y+filter_y][x+filter_x]。x和y是相对值，分别从-filter_x和-filter_y到filter_width-1-filter_x和filter_height-1-filter_y。
只要ValueSum和WeightSum有足够的范围，无论图像和过滤数据是整数还是浮点，都可以使用相同的代码。
最棘手的是如何正确计算min_y、max_y、min_x和max_x，这也是OP看到的造成艺术品的部分。
要进行调试，请删除最里面的两个循环，然后打印如下内容

printf("y = %d, ymin = %d (%d), ymax = %d (%d)\n",
       base_y, min_y, min_y + base_y, max_y, max_y + base_y);

在外环内（无需每次打印），和

printf("x = %d, xmin = %d (%d), xmax = %d (%d)\n",
       base_x, min_x, min_x + base_x, max_x, max_x + base_x);

一旦进入最里面的循环（不需要为每个base_x再次打印），例如base_y。这将输出if (y == 0) printf("...");行，并允许您验证定义的范围是否正确。
在OP的情况下，在图像边缘附近的范围是不正确的；即，它们的一些image_width + image_height子句对应于上述伪代码计算/分配不正确的if、min_x、max_x和min_y值。

关于c - 高斯模糊在图像边缘的“不连续性”，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/40423128/