c_fuzzycluster.m

模糊算法

function[m_pattern]=C_FuzzyCluster(m_pattern,patternNum)
    disType=DisSelDlg();%获得距离计算类型
    dis=zeros(patternNum,patternNum); %模糊系数矩阵
    tempDis=zeros(patternNum,patternNum);
    %得到初始模糊距离
    for i=1:patternNum
        for j=1:patternNum
            dis(i,j)=GetFuzzyDistance(i,j,disType,m_pattern,patternNum);
        end
    end
    %构造等价类
    flag=ture;
    
    while(flag)
        flag=false;
        for i=1:patternNum
            for j=1:patternNum
                if(i==j)%对角线为1
                    tempDis(i,j)=1;
                else
                     tempDis(i,j)=GetFuzzyIntegral(dis,i,j,patternNum);
                end
            end
        end
        
        for i=1:patternNum
            for j=1:patternNum
                if((tempDis(i,j)-dis(i,j))^2>0.000001)
                    flag=ture;
                    break;
                end
            end
            if(flag)
                break;
            end
        
        dis=tempDis;
        end
        
        %显示模糊系数矩阵
        num=zeros(patternNum+1,patternNum+1);
        for i=1:patternNum+1
            for j=1:patternNum+1
                if(i==1&&j~=1)
                    num(i,j)=j-1;
                else if (i==1&&j==1)
                        num(i,j)=0;
                    else if(j==1)
                            num(i,j)=i-1;
                        else
                            num(i,j)=dis(i-1,j-1);
                        end
                    end
                end
                
                %当样品个数小于16时，显示模糊系数矩阵
                if(patternNum<16)
                    a=[(980-60*patternNum)/2,650-30*patternNum,65*patternNum,30*patternNum];
                    h=figure('Position',a,'Name','模糊系数矩阵');
                    figure(h);
                    axes('XTick',[],'YTick',[],'Units','pixels','XColor',[1,1,1],'Postion',[0,0,a(3),a(4)]);
                    for i=1:patternNum+1
                        for j=1:patternNum+1
                            if(i~=1||j~=1)
                                text(60*(j-1)+10,a(4)-20*i,num2str(num(i,j)),'Units','pixels');
                            else
                                text(60*(j-1)+10,a(4)-20*i,'行/列','Units','pixels');
                            end
                        end
                    end
                end
                pointer=1;
                xiShu=-ones(1,paternNum*paternNum);
                %记录模糊系数矩阵中不同的系数
                for i=1:patternNum
                    for j=i:patternNum
                        done=false;
                        for k=1:pointer
                            d=(xiShu(1,k)-dis(i,j))^2;
                            if(xiShu(1,k)-dis(i,j)^2<0.0000001)
                                done=true;
                                break;
                            end
                        end
                        if(~done)
                            xiShu(1,pinter)=dis(i,j);
                            pointer=pointer+1;
                        end
                    end
                end
                
                for i=1:pointer-1 %对阀值由小到大排序
                    for j=1:pointer-i-1
                        if(xiShu(1,j)>xiShu(1,j+1))
                            temp=xiShu(1,j);
                            xiShu(1,j)=xiShu(1,j+1);
                            xiShu(1,j+1)=temp;
                        end
                    end
                end
                str1=['当前阀值'];
                str3=['输入阀值(模糊系数大于该阀值的样品将被归为同类)'];
                str2='';
                for i=1:pointer-1
                    str2=[str2 num2str(xiShu(1,i)),';'];
                end
                show=char(str1 ,str2, str3);
                T=inputdlg(show,'输入阀值对话框');
                T=str2num(T{1,1});
                
                
                %根据阀值输出聚类结果
                result=zeros(patternNum,patternNum);
                for i=1:patternNum
                    m_pattern(i).category=0;
                    for j=1:patternNum
                        if(dis(i,j)>T)
                            result(i,j)=1;
                        else
                            result(i,j)=0;
                        end
                    end
                end
                centerNum=0;
                
                
                %显示模糊聚类结果
                for i=1:patternNum+1
                    for j=1:patternNum+1
                        if(i==1&&j~=1)
                            num(i,j)=j-1;
                        else if (i==1&&j==1)
                            num(i,j)=0;
                            else if(j==1)
                                    num(i,j)=i-1;
                                else
                                    num(i,j)=result(i-1,j-1);
                                end
                            end
                            
                    %当样品个数小于16时，显示模糊矩阵对照表
                    if(patternNum<16)
                        set(h,'Name','每行中“1”对应的列为同一类','Position',[a(1),a(2),a(3)/2,a(4)]);
                   axes('XTick',[],'YTick',[],'Units','pixels','XColor',[1,1,1],'YColor',[1,1,1],'Postion',[0,0,a(3)/2,a(4)]);
                   for i=1:patternNum+1
                       for j=1:patternNum+1
                           if(i~=1||j~=1)
                               text(30*(j-1)+10,a(4)-20*i,num2str(num(i,j)),'Units','pixels');
                           else
                               text(30*(j-1)+10,a(4)-20*i,'行/列','Units','pixels');
                           end
                       end
                   end
                       set(h,'WindowStyle','modal');
                    end
                    
                    %按照阀值分类
                    for i=1:patternNum
                        for j=i:patternNum
                            if(result(i,j)==1)
                                if(m_pattern(i).category~=0)
                                    m_pattern(j).categorym_pattern(i).category;
                                else if (m_pattern(j).category~=0)
                                    m_pattern(i).category=m_pattern(j).category;
                                    else
                                        centerNum=centerNum+1;
                                        m_pattern(i).category=centerNum;
                                        m_pattern(j).category=centerNum;
                                    end
                                end
                            end
                        end
                        
                        
      %计算样品1和样品2间的模糊距离，距离模式由参数disType给定
      function[result]=GetFuzzyDistance(p1,p2,disType,m_pattern,patternNum)
              result=0;
              global Nwidth;
              switch(disType)
                  case 1%欧氏距离
                      max=0;
                      for i=1:patternNum-1
                          for j=i+1:patternNum
                              tempDis=GetDistance(m_pattern(i),m_pattern(j),1);
                              if(max<tempDis)
                                  max=tempDis;
                                  result=(max-GetDistance(m_pattern(i),m_pattern(p2),1))/max;
                              end
                          end
                      end
                      
                  case 2%数量积
                      max=0;
                       for i=1:patternNum-1
                          for j=i+1:patternNum
                              temp=m_pattern(i).feature(:)'*m_pattern(j).feature(:);
                              if(max<temp)
                                  max=temp;
                              end
                          end
                       end
                       temp=m_pattern(p1).feature(:)'*m_pattern(p2).feature(:);
                       result=temp/max;
                       
                    case 3%相关系数
                        ap1=0;
                        ap2=0;
                        ap1=mean(mean(m_pattern(p1).feature));
                        ap2=mean(mean(m_pattern(p2).feature));
                        ap1=ap1*ones(Nwidth*Nwidth,1);
                        ap2=ap2*ones(Nwidth*Nwidth,1);
                        a=(m_pattern(p1).feature(:)-ap1)'*(m_pattern(p2).feature(:)-ap2);
                        b1=(m_pattern(p1).feature(:)-ap1)'*(m_pattern(p21).feature(:)-ap1);
                        b2=(m_pattern(p2).feature(:)-ap2)'*(m_pattern(p2).feature(:)-ap2);
                        if(b2*b1~=0)
                            result=a/sqrt(b1*b2);
                        end
                        
                      case 4 %最大最小法
                          min=0;
                          max=0;
                          for m=1:Nwidth
                              for n=1:Nwidth
                                  if(m_pattern(p1).feature(m,n)<m_pattern(p2).feature(m,n))
                                      min=min+m_pattern(p1).feature(m,n);
                                      max=max+m_pattern(p2).feature(m,n);
                                  else
                                      min=min+m_pattern(p2).feature(m,n);
                                      max=max+m_pattern(p1).feature(m,n);
                                  end
                              end
                          end
                          if(max~=0)
                              result=min/max;
                          end
                          
                          
                      case 5 %算数平均法
                          min=0;
                          max=0;
                          for m=1:Nwidth
                              for n=1;Nwidth
                                  if(m_pattern(p1).feature(m,n)<m_pattern(p2).feature(m,n))
                                      min=min+m_pattern(p1).feature(m,n);
                                  else
                                      min=min+m_pattern(p2).feature(m,n);
                                  end
                                   max=max+m_pattern(p1).feature(m,n)+m_pattern(p2).feature(m,n);
                              end
                          end
                          if(max~=0)
                              result=2*min/max;
                          end
                          
                          
                     case 6 %几何平均最小法
                          min=0;
                          max=0;
                          for m=1:Nwidth
                              for n=1;Nwidth
                                  if(m_pattern(p1).feature(m,n)<m_pattern(p2).feature(m,n))
                                      min=min+m_pattern(p1).feature(m,n);
                                  else
                                      min=min+m_pattern(p2).feature(m,n);
                                  end
                                   max=max+sqrt(m_pattern(p1).feature(m,n)*m_pattern(p2).feature(m,n);
                              end
                          end
                          if(max~=0)
                              result=min/max;
                          end    
              end
              
              
              
              %返回模糊矩阵数组中第i行第j列的模糊积
          function[result]=GetFuzzyIntegral(dis,i,j,patternNum)
              result=0;
              for t=1:patternNum
                  if(dis(i,t)<dis(t,j))
                      td=dis(i,t);
                  else
                      td=dis(t,j);
                  end
                  if(result<td)
                      result=td;
                  end
              end