图像基本变换---KMeans聚类算法

本文将详细介绍K-Means均值聚类的算法及实现。

   聚类是一个将数据集中在某些方面相似的数据成员进行分类组织的过程。K均值聚类是最著名的划分聚类算法，由于简洁和效率使得他成为所有聚类算法中最广泛使用的。给定一个数据点集合和需要的聚类数目k，k由用户指定，k均值算法根据某个距离函数反复把数据分入k个聚类中。

  算法过程：

  1,初始化聚类数目K，并任意选择K个初始化均值ui。

  2,迭代图像中每个像素f(x,y)，判断其距离哪一个聚类均值最近，即|f(x,y)-ui|最小，则将该像素划分归属为对应的聚类i。

  3,完成一次迭代后，计算每一个聚类的新的均值ui，均值公式不在重复。

  4,重复步骤2-3，直到相邻两次迭代中每一个聚类的ui不在发生变化，则迭代结束。

  5,得到最后的分类结果。

   注：本文代码中采用的是对灰度图像进行 KMeans 聚类，然后还原彩色信息。

   下面 我们给出一份Win8 C#代码，另附一份Winform C#代码DEMO，在文章末尾链接 中。

1. ///   
2.         /// KMeans Cluster process.  
3.         ///   
4.         /// The source image.  
5.         /// Cluster threshould, from 2 to 255.  
6.         ///   
7.         public static WriteableBitmap KMeansCluster(WriteableBitmap src,int k)////KMeansCluster  
8.         {  
9.             if (src != null)  
10.             {  
11.                 int w = src.PixelWidth;  
12.                 int h = src.PixelHeight;  
13.                 WriteableBitmap dstImage = new WriteableBitmap(w, h);  
14.                 byte[] temp = src.PixelBuffer.ToArray();  
15.                 byte[] tempMask = (byte[])temp.Clone();  
16.                 int b = 0, g = 0, r = 0;  
17.                 //定义灰度图像信息存储变量  
18.                 byte[] imageData = new byte[w * h];  
19.                 //定义聚类均值存储变量(存储每一个聚类的均值)  
20.                 double[] meanCluster = new double[k];  
21.                 //定义聚类标记变量(标记当前像素属于哪一类)  
22.                 int[] markCluster = new int[w * h];  
23.                 //定义聚类像素和存储变量(存储每一类像素值之和)  
24.                 double[] sumCluster = new double[k];  
25.                 //定义聚类像素统计变量(存储每一类像素的数目)  
26.                 int []countCluster = new int[k];  
27.                 //定义聚类RGB分量存储变量(存储每一类的RGB三分量大小)  
28.                 int[] sumR = new int[k];  
29.                 int[] sumG = new int[k];  
30.                 int[] sumB = new int[k];  
31.                 //临时变量  
32.                 int sum = 0;  
33.                 //循环控制变量  
34.                 bool s = true;  
35.                 double[] mJduge = new double[k];  
36.                 double tempV = 0;  
37.                 int cou = 0;  
38.                 //获取灰度图像信息   
39.                 for (int j = 0; j < h; j++)  
40.                 {  
41.                     for (int i = 0; i < w; i++)  
42.                     {  
43.                         b = tempMask[i * 4 + j * w * 4];  
44.                         g = tempMask[i * 4 + 1 + j * w * 4];  
45.                         r = tempMask[i * 4 + 2 + j * w * 4];  
46.                         imageData[i + j * w] = (byte)(b * 0.114 + g * 0.587 + r * 0.299);  
47.                     }  
48.                 }  
49.                 while (s)  
50.                 {  
51.                     sum = 0;  
52.                     //初始化聚类均值  
53.                     for (int i = 0; i < k; i++)  
54.                     {  
55.                         meanCluster[i] = i * 255.0 / (k - 1);  
56.                     }  
57.                     //计算聚类归属  
58.                     for (int i = 0; i < imageData.Length; i++)  
59.                     {  
60.                         tempV = Math.Abs((double)imageData[i] - meanCluster[0]);  
61.                         cou = 0;  
62.                         for (int j = 1; j < k; j++)  
63.                         {  
64.                             double t = Math.Abs((double)imageData[i] - meanCluster[j]);  
65.                             if (tempV > t)  
66.                             {  
67.                                 tempV = t;  
68.                                 cou = j;  
69.                             }  
70.                         }  
71.                         countCluster[cou]++;  
72.                         sumCluster[cou] += (double)imageData[i];  
73.                         markCluster[i] = cou;  
74.                     }  
75.                     //更新聚类均值  
76.                     for (int i = 0; i < k; i++)  
77.                     {  
78.                         meanCluster[i] = sumCluster[i] / (double)countCluster[i];  
79.                         sum += (int)(meanCluster[i] - mJduge[i]);  
80.                         mJduge[i] = meanCluster[i];  
81.                     }  
82.                     if (sum == 0)  
83.                     {  
84.                         s = false;  
85.                     }  
86.                 }  
87.                 //计算聚类RGB分量  
88.                 for (int j = 0; j < h; j++)  
89.                 {  
90.                     for (int i = 0; i < w; i++)  
91.                     {  
92.                         sumB[markCluster[i + j * w]] += tempMask[i * 4 + j * w * 4];  
93.                         sumG[markCluster[i + j * w]] += tempMask[i * 4 + 1 + j * w * 4];  
94.                         sumR[markCluster[i + j * w]] += tempMask[i * 4 + 2 + j * w * 4];  
95.                     }  
96.                 }  
97.                 for (int j = 0; j < h; j++)  
98.                 {  
99.                     for (int i = 0; i < w; i++)  
100.                     {  
101.                         temp[i * 4 + j * 4 * w] = (byte)(sumB[markCluster[i + j * w]] / countCluster[markCluster[i + j * w]]);  
102.                         temp[i * 4 + 1 + j * 4 * w] = (byte)(sumG[markCluster[i + j * w]] / countCluster[markCluster[i + j * w]]);  
103.                         temp[i * 4 + 2 + j * 4 * w] = (byte)(sumR[markCluster[i + j * w]] / countCluster[markCluster[i + j * w]]);  
104.                     }  
105.                 }                  
106.                 Stream sTemp = dstImage.PixelBuffer.AsStream();  
107.                 sTemp.Seek(0, SeekOrigin.Begin);  
108.                 sTemp.Write(temp, 0, w * 4 * h);  
109.                 return dstImage;  
110.             }  
111.             else  
112.             {  
113.                 return null;  
114.             }  
115.         }  

    

demo下载： http://www.zealfilter.com/forum.php?mod=viewthread&tid=29&extra=page%3D1