AI 助理
备案控制台
开发者社区 人工智能 文章 正文

图像处理之Fuzzy C Means的聚合算法

2024-06-07 111
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 图像处理之Fuzzy C Means的聚合算法

Fuzzy C-Means聚合算法在图像分割(segmentation)和图像视觉处理中常常被用到聚合算法之


一本文是完全基于JAVA语言实现Fuzzy C-Means聚合算法，并可以运用到图像处理中实现简


单的对象提取。




一：数学原理


在解释数学原理之前，请先看看这个链接算是热身吧


http://home.deib.polimi.it/matteucc/Clustering/tutorial_html/cmeans.html。


看不懂没关系。我的解释足够详细，小学毕业都可以学会，本人就是小学毕业。


Fuzzy C-means算法主要是比较RGB空间的每个像素值与Cluster中的每个中心点值，最终给


每个像素指派一个值(0~1之间)说明该像素更接近于哪里Cluster的中心点，模糊规则是该像


素对所有cluster的值之和为1。简单的举例：假设图像中有三个聚类cluster1，cluster2，cluster3，


像素A对三个聚类的值分别为a1, a2, a3, 根据模糊规则a1 + a2 + a3 = 1。更进一步，如果a1


最大，则该像素比较接近于Cluster1。计算总的对象值J：

1365927277_5974.png


二：算法流程


初始输入参数:


a.      指定的聚类个数numberOfClusters,


b.      指定的最大循环次数maxIteration


c.      指定的最小终止循环差值deltaValue


大致流程如下：


1.      初始化所有像素点值与随机选取每个Cluster的中心点，初始化每个像素点P[i]对应


Cluster的模糊值p[i][k]并计算cluster index。


2.      计算对象值J


3.      计算每个Cluster的颜色值，产生新的图像像素


4.      计算每个像素的对应每个cluster的模糊值，更新每个像素的Cluster Index


5.      再次计算对象值J，并与第二步的对象值相减，如果差值小于deltaValue或者达到最大


循环数，停止计算输出结果图像，否则继续2 ～ 4


三：关键代码解析


欧几里德距离计算方法如下：

private double calculateEuclideanDistance(ClusterPoint p, ClusterCentroid c) 
{
  // int pa = (p.getPixelColor() >> 24) & 0xff;
    int pr = (p.getPixelColor() >> 16) & 0xff;
    int pg = (p.getPixelColor() >> 8) & 0xff;
    int pb = p.getPixelColor() & 0xff;
    // int ca = (c.getPixelColor() >> 24) & 0xff;
    int cr = (c.getPixelColor() >> 16) & 0xff;
    int cg = (c.getPixelColor() >> 8) & 0xff;
    int cb = c.getPixelColor() & 0xff;
    
    return Math.sqrt(Math.pow((pr - cr), 2.0) + Math.pow((pg - cg), 2.0) + Math.pow((pb - cb), 2.0));
}

计算每个像素与每个Cluster的Fuzzy数值的代码如下：

public void stepFuzzy()
{
    for (int c = 0; c < this.clusters.size(); c++)
    {
        for (int h = 0; h < this.points.size(); h++)
        {
 
            double top;
            top = calculateEuclideanDistance(this.points.get(h), this.clusters.get(c));
            if (top < 1.0) top = Eps;
 
            // sumTerms is the sum of distances from this data point to all clusters.
            double sumTerms = 0.0;
 
            for (int ck = 0; ck < this.clusters.size(); ck++)
            {
                sumTerms += top / calculateEuclideanDistance(this.points.get(h), this.clusters.get(ck));
 
            }
            // Then the membership value can be calculated as...
            fuzzyForPixels[h][c] = (double)(1.0 / Math.pow(sumTerms, (2 / (this.fuzzy - 1)))); 
        }
    };
 
 
    this.recalculateClusterMembershipValues();
}

计算并更新每个像素的Cluster index的代码如下：

private void recalculateClusterMembershipValues() 
{
 
    for (int i = 0; i < this.points.size(); i++)
   {
       double max = 0.0;
       double min = 0.0;
       double sum = 0.0;
       double newmax = 0;
       ClusterPoint p = this.points.get(i);
       //Normalize the entries
       for (int j = 0; j < this.clusters.size(); j++)
       {
           max = fuzzyForPixels[i][j] > max ? fuzzyForPixels[i][j] : max;
           min = fuzzyForPixels[i][j] < min ? fuzzyForPixels[i][j] : min;
       }
       //Sets the values to the normalized values between 0 and 1
       for (int j = 0; j < this.clusters.size(); j++)
       {
         fuzzyForPixels[i][j] = (fuzzyForPixels[i][j] - min) / (max - min);
           sum += fuzzyForPixels[i][j];
       }
       //Makes it so that the sum of all values is 1 
       for (int j = 0; j < this.clusters.size(); j++)
       {
         fuzzyForPixels[i][j] = fuzzyForPixels[i][j] / sum;
           if (Double.isNaN(fuzzyForPixels[i][j]))
           {
             fuzzyForPixels[i][j] = 0.0;
           }
           newmax = fuzzyForPixels[i][j] > newmax ? fuzzyForPixels[i][j] : newmax;
       }
       // ClusterIndex is used to store the strongest membership value to a cluster, used for defuzzification
        p.setClusterIndex(newmax);
     };
}

四：运行效果

1365927873_9248.png

五：算法源代码

FuzzyCMeansProcessor - 算法类

package com.gloomyfish.segmentation.fuzzycmeans;
 
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
import com.gloomyfish.filter.study.AbstractBufferedImageOp;
 
public class FuzzyCMeansProcessor extends AbstractBufferedImageOp {
  
  private List<ClusterPoint> points;
  private List<ClusterCentroid> clusters;
  private BufferedImage originalImage;
  private BufferedImage processedImage;
  private double Eps = Math.pow(10, -5);
 
    private double[][] fuzzyForPixels;
    
    // Gets or sets objective function
    private double numObj;
    
    public void setObj(double j) {
      this.numObj = j;
    }
    
    public double getObj() {
      return this.numObj;
    }
  
  private float fuzzy; // default is 2
  private int numCluster; // number of clusters in image
  
  public BufferedImage getResultImage()
  {
    return this.processedImage;
  }
  
  public FuzzyCMeansProcessor(/*List<ClusterPoint> points, List<ClusterCentroid> clusters, */float fuzzy, BufferedImage myImage, int numCluster)
  {
        points = new ArrayList<ClusterPoint>();
 
        int width = myImage.getWidth();
        int height = myImage.getHeight();
        int index = 0;
        int[] inPixels = new int[width*height];
        myImage.getRGB( 0, 0, width, height, inPixels, 0, width );
        for (int row = 0; row < myImage.getHeight(); ++row)
        {
            for (int col = 0; col < myImage.getWidth(); ++col)
            {
              index = row * width + col;
              int color = inPixels[index];
                points.add(new ClusterPoint(row, col, color));
 
            }
        }
 
 
 
        clusters = new ArrayList<ClusterCentroid>();
       
        //Create random points to use a the cluster centroids
        Random random = new Random();
        for (int i = 0; i < numCluster; i++)
        {
            int randomNumber1 = random.nextInt(width);
            int randomNumber2 = random.nextInt(height);
            index = randomNumber2 * width + randomNumber1;
            clusters.add(new ClusterCentroid(randomNumber1, randomNumber2, inPixels[index])); 
        }
        
        this.originalImage = myImage;
        this.fuzzy = fuzzy;
        this.numCluster = numCluster;
        
        double diff;
 
        // Iterate through all points to create initial U matrix
        fuzzyForPixels = new double[this.points.size()][this.clusters.size()];
        for (int i = 0; i < this.points.size(); i++)
        {
            ClusterPoint p = points.get(i);
            double sum = 0.0;
 
            for (int j = 0; j < this.clusters.size(); j++)
            {
                ClusterCentroid c = this.clusters.get(j);
                diff = Math.sqrt(Math.pow(calculateEuclideanDistance(p, c), 2.0));
                fuzzyForPixels[i][j] = (diff == 0) ? Eps : diff;
                sum += fuzzyForPixels[i][j];
            }
         }
        
        // re-calculate the membership value for one point of all clusters, and make suer it's sum of value is 1
        recalculateClusterMembershipValues();
        
  }
  
    public void calculateClusterCentroids()
    {
        for (int j = 0; j < this.clusters.size(); j++)
        {
            ClusterCentroid clusterCentroid = this.clusters.get(j);
            
            double l = 0.0;
            clusterCentroid.setRedSum(0);
            clusterCentroid.setBlueSum(0);
            clusterCentroid.setGreenSum(0);
            clusterCentroid.setMemberShipSum(0);
            double redSum = 0;
            double greenSum = 0;
            double blueSum = 0;
            double memebershipSum = 0;
            double pixelCount = 1;
 
            for (int i = 0; i < this.points.size(); i++)
            {
            
                ClusterPoint p = this.points.get(i);
                l = Math.pow(fuzzyForPixels[i][j], this.fuzzy);
            int ta = (p.getPixelColor() >> 24) & 0xff;
                int tr = (p.getPixelColor() >> 16) & 0xff;
                int tg = (p.getPixelColor() >> 8) & 0xff;
                int tb = p.getPixelColor() & 0xff;
                redSum += l * tr;
                greenSum += l * tg;
                blueSum += l * tb;
                memebershipSum += l;
 
                if (fuzzyForPixels[i][j] == p.getClusterIndex())
                {
                  pixelCount += 1;
                }
            }
            
            int clusterColor = (255 << 24) | ((int)(redSum / memebershipSum) << 16) | ((int)(greenSum / memebershipSum) << 8) | (int)(blueSum / memebershipSum);
            clusterCentroid.setPixelColor(clusterColor);
         }
 
        //update the original image
        // Bitmap tempImage = new Bitmap(myImageWidth, myImageHeight, PixelFormat.Format32bppRgb);
        BufferedImage tempImage = createCompatibleDestImage( originalImage, null );
        int width = tempImage.getWidth();
        int height = tempImage.getHeight();
        int index = 0;
        int[] outPixels = new int[width*height];
        
        for (int j = 0; j < this.points.size(); j++)
        {
            for (int i = 0; i < this.clusters.size(); i++)
            {
                ClusterPoint p = this.points.get(j);
                if (fuzzyForPixels[j][i] == p.getClusterIndex())
                {
                  int row = (int)p.getX(); // row
                  int col = (int)p.getY(); // column
                  index = row * width + col;
                  outPixels[index] = this.clusters.get(i).getPixelColor();
                }
            }
        }
        
        // fill the pixel data
        setRGB( tempImage, 0, 0, width, height, outPixels );
        processedImage = tempImage;
    }
    
    /// <summary>
    /// Perform one step of the algorithm
    /// </summary>
    public void stepFuzzy()
    {
        for (int c = 0; c < this.clusters.size(); c++)
        {
            for (int h = 0; h < this.points.size(); h++)
            {
 
                double top;
                top = calculateEuclideanDistance(this.points.get(h), this.clusters.get(c));
                if (top < 1.0) top = Eps;
 
                // sumTerms is the sum of distances from this data point to all clusters.
                double sumTerms = 0.0;
 
                for (int ck = 0; ck < this.clusters.size(); ck++)
                {
                    sumTerms += top / calculateEuclideanDistance(this.points.get(h), this.clusters.get(ck));
 
                }
                // Then the membership value can be calculated as...
                fuzzyForPixels[h][c] = (double)(1.0 / Math.pow(sumTerms, (2 / (this.fuzzy - 1)))); 
            }
        };
 
 
        this.recalculateClusterMembershipValues();
    }
  
    public double calculateObjectiveFunction()
    {
        double Jk = 0.0;
 
        for (int i = 0; i < this.points.size();i++)
        {
            for (int j = 0; j < this.clusters.size(); j++)
            {
                Jk += Math.pow(fuzzyForPixels[i][j], this.fuzzy) * Math.pow(this.calculateEuclideanDistance(points.get(i), clusters.get(j)), 2);
            }
        }
        return Jk;
    }
    
  
  private void recalculateClusterMembershipValues() 
  {
  
      for (int i = 0; i < this.points.size(); i++)
     {
         double max = 0.0;
         double min = 0.0;
         double sum = 0.0;
         double newmax = 0;
         ClusterPoint p = this.points.get(i);
         //Normalize the entries
         for (int j = 0; j < this.clusters.size(); j++)
         {
             max = fuzzyForPixels[i][j] > max ? fuzzyForPixels[i][j] : max;
             min = fuzzyForPixels[i][j] < min ? fuzzyForPixels[i][j] : min;
         }
         //Sets the values to the normalized values between 0 and 1
         for (int j = 0; j < this.clusters.size(); j++)
         {
           fuzzyForPixels[i][j] = (fuzzyForPixels[i][j] - min) / (max - min);
             sum += fuzzyForPixels[i][j];
         }
         //Makes it so that the sum of all values is 1 
         for (int j = 0; j < this.clusters.size(); j++)
         {
           fuzzyForPixels[i][j] = fuzzyForPixels[i][j] / sum;
             if (Double.isNaN(fuzzyForPixels[i][j]))
             {
               fuzzyForPixels[i][j] = 0.0;
             }
             newmax = fuzzyForPixels[i][j] > newmax ? fuzzyForPixels[i][j] : newmax;
         }
         // ClusterIndex is used to store the strongest membership value to a cluster, used for defuzzification
          p.setClusterIndex(newmax);
       };
  }
 
  private double calculateEuclideanDistance(ClusterPoint p, ClusterCentroid c) 
  {
    // int pa = (p.getPixelColor() >> 24) & 0xff;
      int pr = (p.getPixelColor() >> 16) & 0xff;
      int pg = (p.getPixelColor() >> 8) & 0xff;
      int pb = p.getPixelColor() & 0xff;
      // int ca = (c.getPixelColor() >> 24) & 0xff;
      int cr = (c.getPixelColor() >> 16) & 0xff;
      int cg = (c.getPixelColor() >> 8) & 0xff;
      int cb = c.getPixelColor() & 0xff;
      
      return Math.sqrt(Math.pow((pr - cr), 2.0) + Math.pow((pg - cg), 2.0) + Math.pow((pb - cb), 2.0));
  }
 
  @Override
  public BufferedImage filter(BufferedImage src, BufferedImage dest) {
    return processedImage;
  }
 
}

ClusterPoint- 存储图像像素点对象

package com.gloomyfish.segmentation.fuzzycmeans;
 
public class ClusterPoint {
  private double x;
  private double y;
  private int pixelColor;
  private int originalPixelColor;
  private double clusterIndex;
  
    public ClusterPoint(double x, double y, int col)
  {
    this.x = x;
        this.y = y;
        this.pixelColor = col;
        this.originalPixelColor = col;
        this.clusterIndex = -1;
  }
    
  public double getX() {
    return x;
  }
 
  public void setX(double x) {
    this.x = x;
  }
 
  public double getY() {
    return y;
  }
 
  public void setY(double y) {
    this.y = y;
  }
 
  public int getPixelColor() {
    return pixelColor;
  }
 
  public void setPixelColor(int pixelColor) {
    this.pixelColor = pixelColor;
  }
 
  public int getOriginalPixelColor() {
    return originalPixelColor;
  }
 
  public void setOriginalPixelColor(int originalPixelColor) {
    this.originalPixelColor = originalPixelColor;
  }
 
  public double getClusterIndex() {
    return clusterIndex;
  }
 
  public void setClusterIndex(double clusterIndex) {
    this.clusterIndex = clusterIndex;
  }
 
}

ClusterCentroid - 存储Cluster信息对象

package com.gloomyfish.segmentation.fuzzycmeans;
 
public class ClusterCentroid {
 
  private double x;
  private double y;
  private int pixelColor;
  private double redSum;
  private double greenSum;
  private double blueSum;
  private double memberShipSum;
  private int originalPixelColor;
  
    public ClusterCentroid(double x, double y, int color)
    {
      this.x = x;
      this.y = y;
      this.originalPixelColor = color;
      this.pixelColor = color;
    }
    
  public double getX() {
    return x;
  }
 
  public void setX(double x) {
    this.x = x;
  }
 
  public double getY() {
    return y;
  }
 
  public void setY(double y) {
    this.y = y;
  }
 
  public int getPixelColor() {
    return pixelColor;
  }
 
  public void setPixelColor(int pixelColor) {
    this.pixelColor = pixelColor;
  }
 
  public double getRedSum() {
    return redSum;
  }
 
  public void setRedSum(double redSum) {
    this.redSum = redSum;
  }
 
  public double getGreenSum() {
    return greenSum;
  }
 
  public void setGreenSum(double greenSum) {
    this.greenSum = greenSum;
  }
 
  public double getBlueSum() {
    return blueSum;
  }
 
  public void setBlueSum(double blueSum) {
    this.blueSum = blueSum;
  }
 
  public double getMemberShipSum() {
    return memberShipSum;
  }
 
  public void setMemberShipSum(double memberShipSum) {
    this.memberShipSum = memberShipSum;
  }
 
  public int getOriginalPixelColor() {
    return originalPixelColor;
  }
 
  public void setOriginalPixelColor(int originalPixelColor) {
    this.originalPixelColor = originalPixelColor;
  }
 
}

算法调用：

  int numClusters = 2; // (int)numericUpDown2.Value;
  int maxIterations = 20; //(int)numericUpDown3.Value;
  double accuracy = 0.00001; // (double)numericUpDown4.Value;
  FuzzyCMeansProcessor alg = new FuzzyCMeansProcessor(numClusters, sourceImage, numClusters);
  int k = 0;
  do
  {
      k++;
      alg.setObj(alg.calculateObjectiveFunction());
      alg.calculateClusterCentroids();
      alg.stepFuzzy();
      double Jnew = alg.calculateObjectiveFunction();
      System.out.println("Run method accuracy of delta value = " + Math.abs(alg.getObj() - Jnew));
      if (Math.abs(alg.getObj() - Jnew) < accuracy) break;
  }
  while (maxIterations > k);
  resultImage = alg.getResultImage();
  this.repaint();
}

六：Fuzzy C-means不足之处

需要提供额外的参数，不能自动识别Cluster，运行时间比较长。

博客从本月开始更新，请关注！！谢谢谢！

文章标签：
云数据库 ClickHouse
算法
计算机视觉
数据挖掘
存储
Java
关键词：
算法图像处理
图像处理算法
聚合算法
算法fuzzy
fuzzy算法
opencv学堂
目录
相关文章
opencv学堂
|
6月前
|
算法 计算机视觉
图像处理之积分图应用四（基于局部均值的图像二值化算法）
图像处理之积分图应用四（基于局部均值的图像二值化算法）
opencv学堂
558 0
opencv学堂
|
6月前
|
监控 算法 图计算
图像处理之积分图应用三（基于NCC快速相似度匹配算法）
图像处理之积分图应用三（基于NCC快速相似度匹配算法）
opencv学堂
85 0
opencv学堂
|
6月前
|
文字识别 算法 计算机视觉
图像处理之Zhang Suen细化算法
图像处理之Zhang Suen细化算法
opencv学堂
119 0
opencv学堂
|
6月前
|
算法 Java 计算机视觉
图像处理之积分图算法
图像处理之积分图算法
opencv学堂
74 2
opencv学堂
|
6月前
|
资源调度 算法 计算机视觉
图像处理之积分图应用二(快速边缘保留滤波算法)
图像处理之积分图应用二(快速边缘保留滤波算法)
opencv学堂
41 0
opencv学堂
|
6月前
|
算法 BI 计算机视觉
图像处理之积分图应用一(半径无关的快速模糊算法)
图像处理之积分图应用一(半径无关的快速模糊算法)
opencv学堂
50 0
opencv学堂
|
6月前
|
算法 计算机视觉
图像处理之基于泛红算法的二值图像内部区域填充
图像处理之基于泛红算法的二值图像内部区域填充
opencv学堂
50 0
软件算法开发
|
23小时前
|
机器学习/深度学习 算法
基于改进遗传优化的BP神经网络金融序列预测算法matlab仿真
本项目基于改进遗传优化的BP神经网络进行金融序列预测，使用MATLAB2022A实现。通过对比BP神经网络、遗传优化BP神经网络及改进遗传优化BP神经网络，展示了三者的误差和预测曲线差异。核心程序结合遗传算法（GA）与BP神经网络，利用GA优化BP网络的初始权重和阈值，提高预测精度。GA通过选择、交叉、变异操作迭代优化，防止局部收敛，增强模型对金融市场复杂性和不确定性的适应能力。
软件算法开发
101 80
软件算法开发
|
20天前
|
算法
基于WOA算法的SVDD参数寻优matlab仿真
该程序利用鲸鱼优化算法(WOA)对支持向量数据描述(SVDD)模型的参数进行优化，以提高数据分类的准确性。通过MATLAB2022A实现，展示了不同信噪比(SNR)下模型的分类误差。WOA通过模拟鲸鱼捕食行为，动态调整SVDD参数，如惩罚因子C和核函数参数γ，以寻找最优参数组合，增强模型的鲁棒性和泛化能力。
软件算法开发
61 31
软件算法开发
|
5天前
|
供应链 算法 调度
排队算法的matlab仿真,带GUI界面
该程序使用MATLAB 2022A版本实现排队算法的仿真，并带有GUI界面。程序支持单队列单服务台、单队列多服务台和多队列多服务台三种排队方式。核心函数`func_mms2`通过模拟到达时间和服务时间，计算阻塞率和利用率。排队论研究系统中顾客和服务台的交互行为，广泛应用于通信网络、生产调度和服务行业等领域，旨在优化系统性能，减少等待时间，提高资源利用率。
软件算法开发
26 1

热门文章

最新文章

  • 1
    领域最全 | 计算机视觉算法在路面坑洼检测中的应用综述(基于2D图像/3D LiDAR/深度学习)（上）
  • 2
    openssl中算法的组织方式
  • 3
    【WSN定位】基于chan算法实现多基站目标定位附Matlab代码
  • 4
    OpenCV 1 图像分割--分水岭算法代码
  • 5
    回归算法全解析！一文读懂机器学习中的回归模型
  • 6
    Linux内核中的有关Page的算法
  • 7
    机器学习-特征选择：如何使用递归特征消除算法自动筛选出最优特征？
  • 8
    算法笔记之回溯法（2）
  • 9
    缓存、缓存算法(转)
  • 10
    Console-算法[for]-输出等腰三角形
  • 1
    BASE64的算法说明
    69
  • 2
    算法人生（1）：从“强化学习”看如何“战胜拖延”
    115
  • 3
    理解并应用机器学习算法：决策树
    145
  • 4
    【机器学习】在使用K-means聚类算法时，如何选择K的值？
    422
  • 5
    【机器学习】为什么K-means算法使用欧式距离度量？
    405
  • 6
    【机器学习】描述K-means算法的步骤
    153
  • 7
    【机器学习】K-means和KNN算法有什么区别？
    652
  • 8
    C语言易混淆、简单算法、结构体题目练习、常见关键字总结-2
    56
  • 9
    C语言易混淆、简单算法、结构体题目练习、常见关键字总结-1
    60
  • 10
    图搜索算法详解
    144

    • 相关课程

    更多
  • 智能运维赛（复赛）：利用数据和算法，快速定位系统异常并进行根因分析
  • 智能创作赛（复赛）：相册应用中的视频故事生成算法介绍
  • 智能创作赛（初赛）：相册应用中的故事生成算法介绍
  • 相册服务中的故事生成算法介绍
  • Go语言核心编程 - 数据结构和算法
  • 神经网络概览及算法详解

    • 相关电子书

    更多
  • 数据+算法定义新世界
  • 袋鼠云基于实时计算的反黄牛算法
  • Alink：基于Apache Flink的算法平台

    • 相关实验场景

    更多
  • 使用Swing算法实现商品推荐
  • RSA密码算法设计与实现
  • 欧拉图的构造性证明与算法实现
  • 推荐系统入门之使用ALS算法实现打分预测
    • 下一篇
    【案例实战】SpringBoot整合阿里云文件上传OSS