opencv笔记（三十二）——将模糊集合用于灰度变换和边缘检测

淡淡的烟草味﹌ 2022-05-09 00:58 150阅读 0赞

# **模糊集合原理** #

在计算机编程的时候，常常会使用一种“干脆的”集合。在判断某件事，或者某个变量的时候，常常使用的是布尔值（因为某件事，不是真就是假）。通过一个阈值，去判断这件事，而这样的一个阈值的设定，会产生一个问题。还是使用《Digital Image Processing》 Rafael C. Gonzalez / Richard E. Woods书中的例子，看以下两个图。

![20131029093646796][]

当一个人的年龄超过20岁，那么这个人就不再属于年轻人范畴。这样来说，未免有些太过“残忍”，毕竟，20多岁的人还是“比较”年轻的。这里就出现了一个模糊的定义，“比较”年轻，这个集合既不属于年轻，也不属于非年轻，也就是其实年轻与非年轻之间的过度不应该是干脆的，而应该是渐进的过度。

定义**Z为对象集**，其中，**z**表示**Z中的一类元素**（比如z表示年龄）。Z中的**一个模糊集合A**主要由一个**隶属度**(Degree of membership)![20131029094740859][]来表示。对此，模糊集合A是一个由z值和隶属度函数组成的集合，即

![20131029095105531][]

当![20131029095303000][]的时候，所有的z是模糊集合A的完全成员；当![20131029095403953][]的时候，所有的z都不是模糊集合A的成员，当![20131029094740859][]的值介于0和1之间，那么此时的z称为模糊集合A的不完全成员。

下面，还有几个重要的性质。

对于所有的![20131029100111000][]，模糊集合A的补集(NOT)，其隶属度函数如下所示。

![20131029095913953][]

对于所有的![20131029100111000][]，模糊集合A与模糊集合B的并集(OR)U，其隶属度函数如下所示。

![20131029100401812][]

对于所有的![20131029100111000][]，模糊集合A与模糊集合B的交集(AND)I，其隶属度函数如下所示。

![70][]

到这里，其实已经可以用模糊集合来做一些事情了。对于一个问题的处理，在使用模糊集合来解决的时候，我们可以参考以下步骤。首先，需要将输入量折算为隶属度，这个过程叫做“模糊化”。然后，使用得到的隶属度来进行计算，或者判断，或者其他更复杂的算法。最后，需要将隶属度再次折算为输出，这个过程称为“去模糊”或者“反模糊”。

模糊集合为处理不严密信息提供了一种形式。将模糊与模糊隶属度函数之间的关联变量称为fuzification；通常用IF-THEN规则描述有关问题的知识。下面我们寻找一种方法，使用输入和问题的先验知识建立模糊系统的输出。

通常应用实现步骤为：

（１）模糊输入：将IF-THEN规则描述的先验知识映射到\[0,1\]区间，找到每个标量对应的模糊值。

（２）执行任何需要的模糊逻辑操作（AND、OR、NOT）,将所有输出组合到一起；利用一种推断方法，每个规则得到单一输出。

（３）应用聚合方法将所有规则的输出组合到一起，得到单个的输出模糊集合。

（４）对最后的输出去模糊化，得到“干脆”标量输出。（可以求模糊集的重心）

## 一、使用模糊集合进行灰度变换 ##

使用模糊集合来进行灰度变换，从而增强图像。首先可以在常理下考虑一下，一般的对于动态范围较小的图像，我们一般的处理的方法是灰度拉升，或者直方图均衡。

这两种的方法的本质就是，让原图较暗的像素更加暗，让原图较亮的像素更加亮。那么，我们规定如下模糊规则

###                            R1：IF 一个像素是暗的，THEN 让这个像素更暗； ###

###                            R2：IF 一个像素是灰的，THEN 让他保持是灰的； ###

###                            R3：IF 一个像素是亮的，THEN 让这个像素更亮； ###

这个规则就代表了我们的处理方法。当然，**IF**条件中的像素是暗的(或者灰的，或者是亮的)，这个概念都是模糊的。同理**THEN**结论中的更暗(或者保持灰的，或者更亮)亦是模糊的。为此，我们需要确立一个隶属度函数，从而来判断一个像素对于三个条件的隶属度。

实际上，隶属度函数的确定是很复杂的，然而，这里我们则尽量想得简单一点。首先，一个像素是**暗的**(模糊)，那么其隶属度函数大致的形状是，

*   *  在低于某个值![20131029103004734][]的时候域隶属度为1，
     *  在灰度越过某一个值![20131029103019562][]之后，其隶属度为0，
     *  当然![20131029103052968][]。然后![20131029103004734][]与![20131029103019562][]之间进行线性插值，那么，我们就可以得到R1的隶属度函数了。同理，R2与R3也是一样的。

为了简单起见，我们将**THEN**结论中的**更暗**设置为较为简单的函数。

*   *  为了让这个像素更黑，其输出都为0。同理，
     *  为了使这个像素保持灰的，我们将其输出设为0.5，
     *  为了使得一个像素更亮，我们将其设置为1。

根据以上讨论，我们所决定的隶属度函数如下所示。

![20131029104244906][]

使用输入的隶属度函数，可以得到模糊化后的数据。

>         对于一个像素![20131029120301109][]，需要根据规则**R1，R2**与**R3**，计算出![20131029120301109][]所对应的隶属度![20131029120603625][]，![20131029120608000][]与![20131029120611546][]，这个过程，称之为**模糊化**。将一个输入量模糊化，所使用的函数(或者说是对应关系)，称之为知识库。

模糊化之后，得到一个像素所对应的三个隶属度![20131029120603625][]，![20131029120608000][]与![20131029120611546][]之后，就可以进行反模糊化了。反模糊化的算法很多，这里使用简单的重心法去进行计算。

![310015-20160724171733716-1350267051.png][]

其中***Vd，Vg，Vb***为输出的单一值，对于一个像素![20131029120301109][]，需要根据规则R1，R2与R3，计算出![20131029120301109][]所对应的隶属度![20131029120603625][]，![20131029120608000][]与![20131029120611546][]。得到一个权值衡量后的成熟度估计值，最为输出值。到此，就得到了输出![20131029121527312][]，整个算法的效果如下图所示。

**实例：**

[![310015-20160724173602779-1204198096.jpg][]][310015-20160724173602779-1204198096.jpg 1]

![310015-20160724173659622-1335480723.jpg][]

根据以上算法，所得到的结果还是比较理想的。从灰度直方图来看，处理后的图像的直方图的动态范围得到了扩展，所得的图像也比原图更加的明亮清晰，图片的一些细节处理的较为妥当。所使用的Matlab代码如下所示。

function [drak,gray,brig] = Fuzzy_Knowledge(Intensity)
     
      if(Intensity <= 0.27) drak = double(1); 
      elseif(Intensity >= 0.5) drak = double(0);
      else drak = (0.5 - double(Intensity))/(0.22);
      end    
        
      if(Intensity >= 0.72) brig = double(1); 
      elseif(Intensity <= 0.5) brig = double(0);   
      else brig = double((double(Intensity) - 0.5)/0.22);
      end
      
      if(Intensity >= 0.72) gray = double(0); 
      elseif(Intensity <= 0.27) gray = double(0);
      elseif(Intensity <= 0.5) gray = double((double(Intensity) - 0.27)/0.22);
      else gray = double((0.72 - double(Intensity))/0.22);
      end
      
    end
    close all;
    clear all;
    clc;
     
    %% ---------Using Fuzzy for intensity transfromations---------------
    f = imread('einstein_orig.tif');
    f = mat2gray(f,[0 255]);
     
    [M,N]=size(f);
    g = zeros (M,N);
     
     for x = 1:1:M
         for y = 1:1:N
             [drak,gray,brig] = Fuzzy_Knowledge(f(x,y));
             g(x,y) = ((drak * 0) + (gray * 0.5) + (brig * 1))/(drak + gray + brig); 
         end
     end
     
    figure();
    subplot(1,2,1);
    imshow(f,[0 1]);
    xlabel('a).Original Image');
     
    subplot(1,2,2);
    imshow(g,[0 1]);
    xlabel('b).Result of fuzzy');
     
    figure();
    subplot(1,2,1);
    h = imhist(f)/(M*N);
    bar(0:1/255:1,h);
    axis([0 1 0 .2]),grid;
    xlabel('c).The Histogram of a');
     
    subplot(1,2,2);
    h = imhist(g)/(M*N);
    bar(0:1/255:1,h);
    axis([0 1 0 .2]),grid;
    xlabel('d).The Histogram of b');
     
    %%
    test = 0:1/255:1;
     for x = 1:1:256
             [drak(x),gray(x),brig(x)] = Fuzzy_Knowledge(test(x));
     end
     
    figure();
    subplot(1,2,1);
    plot(test,drak,test,gray,test,brig); 
    axis([0,1,0,1]),grid;
    axis square;
    legend('drak','gray','brig');
    xlabel('a).Input memberchip functions for fuzzy');
     
     
    subplot(1,2,2);
    x1 = [0,0];y1 = [0,1];
    x2 = [0.5,0.5];y2 = [0,1];
    x3 = [1,1];y3 = [0,1];
    plot(x1,y1,x2,y2,x3,y3); 
    axis([-0.1,1.1,0,1.2]),grid;
    axis square;
    legend('drak','gray','brig');
    xlabel('b).Output memberchip functions for fuzzy');

> 将隶属度函数重叠起来看，理解的重点：
> 
>                                                                          ![310015-20160724173855372-551591384.png][]
> 
>                                          ![310015-20160724174517044-1921886594.png][]
> 
>  关键就在这里，自定义了一个标准，这就是精髓。

模糊集图像增强算法有很多。归纳主要为以下步骤：

*  第一步、设计隶属度函数将图像从空间域变换到模糊集域。
 *  第二步、设计模糊增强算子，在模糊集域对图像进行处理。
 *  第三步、根据第一步的隶属度函数重新将图像从模糊集域变换到空间域。

在此根据\[1\]所述的隶属度函数和模糊增强算子，进行图像增强实现，代码如下所示：

clear all;
    close all;
    clc;
     
    I = double(imread('test.jpg'));
    imshow(I);
    [m,n] = size(I);
     
    Fe =1;
    Fd =120;
     
    xmax=max(max(I));
    u =(1+(xmax-I)/Fd).^(-Fe);
     
    for i =1:m
        for j =1:n
            if u(i,j)<0.5
                u(i,j) =2*u(i,j)^2;
            else
                u(i,j) =1-2*(1-u(i,j))^2;
            end
        end
    end
     
    I = xmax-Fd.*(u.^(-1/Fe)-1);
     
    figure,imshow(uint8(I));

实验结果：

原始图像：                                                                                     模糊集图像增强实现效果图

![20140112174821281][]                    ![20140112174749953][]

## 二、使用模糊集合进行边缘检测 ##

为了更深刻的理解模糊集合的性质，可以将规则的难度加深一些。若想进行一幅图像的边缘检测，在空间域上的想法是：“如果一个像素是处在平滑区域的，那么使得这个像素为亮，否则，则使得这个像素为暗。”为了使得这个算法在模糊集合的概念可以用，我们可以考虑使用灰度差来表示像素的平滑程度。

![20131029122957406][]

如上图所示，我们将一个像素8个相邻的像素，各减去这个像素的值，即![20131029123241937][]。我们可以得到如上图右侧的结果。基与此，可以推出以下规则。

![20131029123758484][]

注意，上述的zero，white与black都是模糊的概念。同样的，根据这三个规则模糊化之后，用重心法去模糊。同时，我们还希望，当两个点的灰度很接近的时候，去模糊能给予一个很强的响应，将灰度拉至很高(很亮)。所以，我们的输入隶属度函数需要再0处有一个较大的隶属度，这里，我使用了高斯分布的一部分。其输出隶属度函数，也不是像上面的例子一样简单，我希望若是白色的隶属度很高，其输出的灰度值就越高(越亮)，反之则越低(越暗)。根据上述，我指定的输入输出隶属度函数如下所示。

![20131029125207453][]

以上规则还出现了几个比较需要注意的地方。我们制定规则的时候，使用了AND，将两个条件相连了。这里在模糊集合里面，就相当于两个模糊集合的交集。首先，应该依次算出两个条件所对应的隶属度的值，然后，取最小值即可，如下所示。

![20131029125447234][]

其次，这里还出现了ELSE语句，这里，可以视为以上四个条件的补集的交集(有点拗口)。其实看数学式的话，应该很好明白的。

![20131029125730125][]

到这里，我们就可以顺利的算出上述五个条件的隶属度，然后同样的，使用最简单的重心法，就可以得到结果了。结果如下所示。

![20131029125846359][]

从结果可以看出来，根据整定的规则，我们已经很好的得到了图像的边缘。在这幅图像上再次进行加工，二值化什么的，就比较容易了。所得到的结果图像还是比较清晰的。以下是Matlab代码。

function [W1,W2,W3,W4,B] = Fuzzy_Knowledge_Filters(Intensity)
     
    for x = 1:1:3
       for y = 1:1:3
           if((Intensity(x,y) <= 0.2) &&(Intensity(x,y) >= -0.2))
               Intensity(x,y) = exp(-20*Intensity(x,y).*Intensity(x,y));
           else Intensity(x,y) = 0;
           end
       end
    end
     
    W1 = min(Intensity(1,2),Intensity(2,3));
    W2 = min(Intensity(2,3),Intensity(3,2));
    W3 = min(Intensity(3,2),Intensity(2,1));
    W4 = min(Intensity(2,1),Intensity(1,2));
    B = min(min(1-W1,1-W2),min(1-W3,1-W4));
      
    end
    %% ---------Using Fuzzy for Spatial Filters---------------
    close all;
    clear all;
    clc;
     
    f = imread('headCT_Vandy.tif');
    f = mat2gray(f,[0 255]);
     
    [M,N]=size(f);
    f_Ex = zeros(M+2,N+2);
     
    for x = 1:1:M
        for y = 1:1:N
            f_Ex(x+1,y+1) = f(x,y);
        end
    end
     
    z = zeros (3,3);
    g = zeros (M+2,N+2);
    for x = 2:1:M+1
        for y = 2:1:N+1
            z(1,1) = f_Ex(x-1,y-1) - f_Ex(x,y);
            z(1,2) = f_Ex(x-1,y) - f_Ex(x,y);
            z(1,3) = f_Ex(x-1,y+1) - f_Ex(x,y);
            
            z(2,1) = f_Ex(x,y-1) - f_Ex(x,y);
            z(2,2) = f_Ex(x,y) - f_Ex(x,y);
            z(2,3) = f_Ex(x,y+1) - f_Ex(x,y);
            
            z(3,1) = f_Ex(x+1,y-1) - f_Ex(x,y);
            z(3,2) = f_Ex(x+1,y) - f_Ex(x,y);
            z(3,3) = f_Ex(x+1,y+1) - f_Ex(x,y);
            
            [W1,W2,W3,W4,B] = Fuzzy_Knowledge_Filters(z);
            
            V1 = 0.8 * W1 + 0.2;
            V2 = 0.8 * W2 + 0.2;
            V3 = 0.8 * W3 + 0.2;
            V4 = 0.8 * W4 + 0.2;
            V5 = 0.8 - (0.8 * B);
            
            g(x,y) = ((W1*V1) + (W2*V2) + (W3*V3) + (W4*V4) + (B*V5))/(W1+W2+W3+W4+B); 
            
        end
    end
     
    figure();
    subplot(1,2,1);
    imshow(f,[0 1]);
    xlabel('a).Original Image');
     
    subplot(1,2,2);
    imshow(g,[0 1]);
    xlabel('b).Result of fuzzy');
     
     
    %%
    figure();
    subplot(1,2,1);
    x=-0.2:1/255:0.2;
    y=1/sqrt(2*pi)*exp(-20*x.*x);
    y = y/max(y);
    x = -1:1/255:1;
    y = [zeros(1,204) y zeros(1,204)];
    plot(x,y); 
    axis([-1,1,0,1]),grid;
    axis square;
    xlabel('a).Input memberchip functions for fuzzy');
     
    subplot(1,2,2);
    x1 = [0,0.2,1];y1 = [0,0,1];
    x2 = [0,0.8,1];y2 = [1,0,0];
    plot(x1,y1,x2,y2); 
    axis([0,1,0,1]),grid;
    axis square;
    legend('WH','BL');
    xlabel('b).Output memberchip functions for fuzzy');

转自：

[https://blog.csdn.net/sysu\_stone/article/details/10514963][https_blog.csdn.net_sysu_stone_article_details_10514963]

[https://blog.csdn.net/songzitea/article/details/18186013][https_blog.csdn.net_songzitea_article_details_18186013]

[https://blog.csdn.net/zhoufan900428/article/details/13502329][https_blog.csdn.net_zhoufan900428_article_details_13502329]

[20131029093646796]: /images/20220509/bb5ce501092644358e740f2d39c89d84.png
[20131029094740859]: /images/20220509/ba9cbabd9fb34041bace79384732ceb9.png
[20131029095105531]: /images/20220509/765323b53d0a40e7b2184061b05c935d.png
[20131029095303000]: https://img-blog.csdn.net/20131029095303000
[20131029095403953]: https://img-blog.csdn.net/20131029095403953
[20131029100111000]: /images/20220509/df79ee5c90c941b99eddf2a5883346ad.png
[20131029095913953]: /images/20220509/5e3c66b17e4343c6b9967e09dab79302.png
[20131029100401812]: /images/20220509/57b70aaa2c734b6888768ec1cc9bbf28.png
[70]: /images/20220509/dda0e31db9dd4be7973d317e45e311db.png
[20131029103004734]: /images/20220509/cb8a9fb5b6e44ce4842ed20dd30dbdc6.png
[20131029103019562]: /images/20220509/5946a924312f42ccbcc375914f2b4017.png
[20131029103052968]: https://img-blog.csdn.net/20131029103052968
[20131029104244906]: /images/20220509/44caef2954c041d78fb4210405d47c56.png
[20131029120301109]: https://img-blog.csdn.net/20131029120301109
[20131029120603625]: https://img-blog.csdn.net/20131029120603625
[20131029120608000]: https://img-blog.csdn.net/20131029120608000
[20131029120611546]: /images/20220509/a90b15e6815f4c8eb5427bd65efb52d5.png
[310015-20160724171733716-1350267051.png]: /images/20220509/9601f35b4ba349598175e8d60be71bd8.png
[20131029121527312]: /images/20220509/87e47eaed7c343168c45922d800aa685.png
[310015-20160724173602779-1204198096.jpg]: /images/20220509/28f8709a7b6c455a925bf6d7aeee9a06.png
[310015-20160724173602779-1204198096.jpg 1]: http://blog.csdn.net/zhoufan900428/article/details/13502329
[310015-20160724173659622-1335480723.jpg]: /images/20220509/3efb19b4f63c4c65b02d9c3c47fd759c.png
[310015-20160724173855372-551591384.png]: /images/20220509/909a000c6ca54961b503d394624f927f.png
[310015-20160724174517044-1921886594.png]: /images/20220509/9ab93c6cb13f462cadf0125c92808b72.png
[20140112174821281]: https://img-blog.csdn.net/20140112174821281
[20140112174749953]: /images/20220509/eb86757ddca446298931e9b7c6c42089.png
[20131029122957406]: /images/20220509/1da6867a33ce4ed789234f452c96a053.png
[20131029123241937]: /images/20220509/9856a52caec240e6a22c27743a4588ad.png
[20131029123758484]: /images/20220509/c7020715b255425aa3f302cfe85ecb8f.png
[20131029125207453]: /images/20220509/ca1c9da39629487bab3b7de93d835a47.png
[20131029125447234]: /images/20220509/edca310e19db4cd9b6e8b1777c64480e.png
[20131029125730125]: /images/20220509/8c8be14e63194f7aab9f20b9daec8f3d.png
[20131029125846359]: /images/20220509/2c15e17ed3334c44a6f93df4cc25095c.png
[https_blog.csdn.net_sysu_stone_article_details_10514963]: https://blog.csdn.net/sysu_stone/article/details/10514963
[https_blog.csdn.net_songzitea_article_details_18186013]: https://blog.csdn.net/songzitea/article/details/18186013
[https_blog.csdn.net_zhoufan900428_article_details_13502329]: https://blog.csdn.net/zhoufan900428/article/details/13502329