本文將詳細介紹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,得到最後的分類結果。

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.         }