Question

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

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扩大图像，但这会导致边缘位置出现问题。

感谢您提供任何有见地的帮助：）

Answer 1

让我们看一下以伪代码应用于图像的典型滤波器内核。让我们使用变量

# 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具有足够的范围，无论图像和过滤器数据是整数还是浮点数，相同的代码都能正常工作。

棘手的部分，以及导致OP看到的人工制品的部分，是如何正确计算min_y，max_y，min_x和max_x。

要进行调试，请删除最内层的两个循环，然后打印类似

的内容

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

外部循环内部的

（不需要为每个base_x打印它！）和

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_y再次打印），例如， if (y == 0) printf("...");。这会输出image_width + image_height行，并让您验证您定义的范围是否正确。

在OP的情况下，图像边缘附近的范围不正确;即，与上述伪代码对应的某些if子句计算/分配不正确的min_x，max_x，min_y和max_y值。

＆＃34;间断＆＃34;高斯模糊图像边缘的研究

1 个答案: