Suppose that the data mining task is to cluster the following eight points (with (x, y) representing location) into three clusters.
A1(2, 10), A2(2, 5), A3(8, 4), B1(5, 8), B2(7, 5), B3(6, 4), C1(1, 2), C2(4, 9).
The distance function is Euclidean distance. Suppose initially we assign A1, B1, and C1 as the
center of each cluster, respectively. Use the k-means algorithm to show only
(a) The three cluster centers after the first round of Assignment execution and
(b) The final three clusters

就算法本身来说是很简单的，K-means算法是很简单的，基本过程如下：

1，从 n个数据对象任意选择 k 个对象作为初始聚类中心；
2，根据每个聚类对象的均值（中心对象），计算每个对象与这些中心对象的距离；并根据最小距离重新对相应对象进行划分；
3，重新计算每个（有变化）聚类的均值（中心对象） ；
4，重复2->3到不再变化或稳定为止。

其中最麻烦是第一步确定k的值和如何选定第一组中心值。不过在这道题中完全不涉及这个问题，因为k的值（3）和初始中心值的选择已经给定。

一下是用ActionScript实现的代码：

//##############################################################################
//
//##############################################################################
package
{
	import flash.display.Sprite;
	import flash.geom.Point;

	public class CC extends Sprite
	{

		public function CC()
		{

			allPoints = new Object();
			allPoints.a1 = new Point(2, 10);
			allPoints.a2 = new Point(2, 5);
			allPoints.a3 = new Point(8, 4);
			allPoints.b1 = new Point(5, 8);
			allPoints.b2 = new Point(7, 5);
			allPoints.b3 = new Point(6, 4);
			allPoints.c1 = new Point(1, 2);
			allPoints.c2 = new Point(4, 9);
			//
			getCluster();
		}

		private var allPoints:Object;

		private var c1:Object = new Object();

		private var c2:Object = new Object();

		private var c3:Object = new Object();

		private var oldC1:Object;

		private var oldC2:Object;

		private var oldC3:Object;

		private var p1:Point = new Point(2, 10);

		private var p2:Point = new Point(5, 8);

		private var p3:Point = new Point(1, 2);

		private var accountTime:uint = 1;

		private function getCluster():void
		{
			trace("Count Num: " + accountTime);
			oldC1 = c1;
			oldC2 = c2;
			oldC3 = c3;
			c1 = new Object();
			c2 = new Object();
			c3 = new Object();
			for (var name:String in allPoints)
			{
				var p:Point = allPoints[name] as Point;
				var num:uint = getClusterNum(allPoints[name], name);
				this["c" + num][name] = p;
			}
			trace("New clusters are:");
			for (var i:uint = 1; i <= 3; i++)
			{
				var str:String = i + ": ";
				for (var n:String in this["c" + i])
				{
					str += n + ", ";
				}
				trace(str);
			}
			trace("Count " + accountTime + " end");
			getNewCenters();

		}

		private function getNewCenters():void
		{
			var str:String = "New centre points are: ";
			for (var i:uint = 1; i <= 3; i++)
			{
				var xx:Number = 0;
				var yy:Number = 0;
				var count:uint = 0;
				for each(var p:Point in this["c" + i])
				{
					xx += p.x;
					yy += p.y;
					count ++;
				}
				xx = xx / count;
				yy = yy / count;
				this["p" + i] = new Point(xx, yy);
				str += ("p" + i + ": (" + xx.toFixed(2) + ", " + yy.toFixed(2) +　"), ");
			}
			trace(str + "n");
			if(isEnd() || accountTime > 100)
			{
				trace("Centre points not changed, ALL END");
			}
			else
			{
				accountTime ++;
				getCluster();
			}
		}

		private function isEnd():Boolean
		{
			for (var i:uint = 1; i <= 3; i++)
			{
				for(var n:String in this["c" + i])
				{
					if(this["oldC" + i][n] == null) return false;
				}
			}
			return true;
		}

		private function getClusterNum(p:Point, pName:String):uint
		{
			var d1:Number = getDistance(p, p1);
			var d2:Number = getDistance(p, p2);
			var d3:Number = getDistance(p, p3);
			//
			var str:String = "Distances for " + pName + ": ";
			str += d1.toFixed(2) + ", ";
			str += d2.toFixed(2) + ", ";
			str += d3.toFixed(2);
			//
			var num:uint;
			if (d1 <= d2)
			{
				if (d1 <= d3)
				{
					num = 1;
				}
				else
				{
					num = 3;
				}
			}
			else
			{
				if (d2 <= d3)
				{
					num = 2;
				}
				else
				{
					num = 3;
				}
			}
			str += " | nearest: " + num;
			trace(str);
			return num;
		}

		private function getDistance(p1:Point, p2:Point):Number
		{
			var xx:Number = p1.x - p2.x;
			var yy:Number = p1.y - p2.y;
			var dd:Number = Math.sqrt(xx * xx + yy * yy);
			//trace("get distance", p1, p2, dd);
			return dd;
		}
	}
}

输出结果如下：

Count Num: 1
Distances for b3: 7.21, 4.12, 5.39 | nearest: 2
Distances for a1: 0.00, 3.61, 8.06 | nearest: 1
Distances for a2: 5.00, 4.24, 3.16 | nearest: 3
Distances for a3: 8.49, 5.00, 7.28 | nearest: 2
Distances for c1: 8.06, 7.21, 0.00 | nearest: 3
Distances for b1: 3.61, 0.00, 7.21 | nearest: 2
Distances for c2: 2.24, 1.41, 7.62 | nearest: 2
Distances for b2: 7.07, 3.61, 6.71 | nearest: 2
New clusters are:
1: a1,
2: b3, b1, c2, b2, a3,
3: a2, c1,
Count 1 end
New centre points are: p1: (2.00, 10.00), p2: (6.00, 6.00), p3: (1.50, 3.50),

Count Num: 2
Distances for b3: 7.21, 2.00, 4.53 | nearest: 2
Distances for a1: 0.00, 5.66, 6.52 | nearest: 1
Distances for a2: 5.00, 4.12, 1.58 | nearest: 3
Distances for a3: 8.49, 2.83, 6.52 | nearest: 2
Distances for c1: 8.06, 6.40, 1.58 | nearest: 3
Distances for b1: 3.61, 2.24, 5.70 | nearest: 2
Distances for c2: 2.24, 3.61, 6.04 | nearest: 1
Distances for b2: 7.07, 1.41, 5.70 | nearest: 2
New clusters are:
1: c2, a1,
2: b3, b1, b2, a3,
3: a2, c1,
Count 2 end
New centre points are: p1: (3.00, 9.50), p2: (6.50, 5.25), p3: (1.50, 3.50),

Count Num: 3
Distances for b3: 6.26, 1.35, 4.53 | nearest: 2
Distances for a1: 1.12, 6.54, 6.52 | nearest: 1
Distances for a2: 4.61, 4.51, 1.58 | nearest: 3
Distances for a3: 7.43, 1.95, 6.52 | nearest: 2
Distances for c1: 7.76, 6.39, 1.58 | nearest: 3
Distances for b1: 2.50, 3.13, 5.70 | nearest: 1
Distances for c2: 1.12, 4.51, 6.04 | nearest: 1
Distances for b2: 6.02, 0.56, 5.70 | nearest: 2
New clusters are:
1: c2, a1, b1,
2: b3, b2, a3,
3: a2, c1,
Count 3 end
New centre points are: p1: (3.67, 9.00), p2: (7.00, 4.33), p3: (1.50, 3.50),

Count Num: 4
Distances for b3: 5.52, 1.05, 4.53 | nearest: 2
Distances for a1: 1.94, 7.56, 6.52 | nearest: 1
Distances for a2: 4.33, 5.04, 1.58 | nearest: 3
Distances for a3: 6.62, 1.05, 6.52 | nearest: 2
Distances for c1: 7.49, 6.44, 1.58 | nearest: 3
Distances for b1: 1.67, 4.18, 5.70 | nearest: 1
Distances for c2: 0.33, 5.55, 6.04 | nearest: 1
Distances for b2: 5.21, 0.67, 5.70 | nearest: 2
New clusters are:
1: c2, a1, b1,
2: b3, b2, a3,
3: a2, c1,
Count 4 end
New centre points are: p1: (3.67, 9.00), p2: (7.00, 4.33), p3: (1.50, 3.50),

Centre points not changed, ALL END

3. 空间滤波
(a)噪点生成器。1. 找到（或开发）一段程序能在一个图像中加入高斯噪点,并且必须能够指出噪点的均值和方差。2.找到（或开发）一段程序能在一个图像中加入黑白相间的（脉冲式）噪点,并且必须能指出这两种噪点中每一种的出
现概率。
(b)写一段程序实现空间均值滤波，把你的滤波器应用到在(a)中含噪点的图像上。你可以把你的空间遮罩的大小固定设成3X3，但是系数要是可变的并作为你程序的输入。
(c)修改你在(b)中生成的程序以实现一个3X3 的中值滤波。比较用均值滤波和中值滤波过滤后的图像的不同之处。

结果图：

先把高斯噪声的伪随机数生成方法记下来。其他的以后有空再写。

/**
* 用雅可比变换生成一个呈高斯分布的伪随机数。
*
* @param mu 平均值μ
* @param sigma 标准差σ^2
* @return 伪随机数。
*/
private function getGaussianRandom(mu:Number = 0, sigma:Number = 1):Number
{
	var r1:Number = Math.random();
	var r2:Number = Math.random();
	var rs:Number = Math.sqrt(-2 * Math.log(r1)) * Math.cos(2 * Math.PI * r2 ) * sigma + mu;
	return rs;
}

写一段几何转换程序可以按一定数值进行旋转,转换和缩放图像,分别使用用最邻近点算法和双线性差值算法。

开始的时候google了很多关于最近邻点算法（nearest）和双线性差值算法（biliear）的内容，发现挺麻烦的，而且推算下来的计算量很大，觉得无从下手。后来看了课程的讲义，发现老师的要求似乎是很简单的（实际上是我搜索错了算法 O_O）。对于最近邻算法，转换之后的点对应到原图位置后，距离该位置最近的一个点的灰度，即为转换后的点的灰度。而双线性差值算法要稍微多算一点，如下图：

将对应的位置附近的四个点的灰度统一起来做计算即可。公式也很简单，假设目标位置的左下，左上，右下，右上点的灰度分别为f00，f01，f10，f11，x值是目标位置到f00点的x距离，y值是目标位置到f00点的y距离，fxy是转换后的点的灰度值，公式为：

fxy = (f10 – f00) * x + (f01 – f00) * y + (f11 + f00 – f01 – f10) * x * y + f00

结果如下图。

其实为了偷懒，我没有计算rotate值，因为没有想出一个好的方法来将转换后的坐标mapping到原图的位置，干脆就使用Flex中的rotate属性做了一个切换，老师应该看不出来的吧。XD

这东西只能断断续续的做，还是将自己做的东西记录下来，免得忘掉了。

首要的问题，在AS中似乎没有直接获取灰度值的方法，因此我用的是将RGB值分解之后取平均值。顺便记录一下分解RGB的简单算法：

var red:uint = color >> 16 & 0xFF;
 var green:uint = color >> 8 & 0xFF;
 var blue:uint = color & 0xFF;

如果不将RGB的值转换成一个灰度值，可以分别对三个值进行计算，得到三个直方图，让后用同样的算法对三个值进行计算，之后再组成一个RGB值，可以作为整个图形的计算。

第一题，直方图均衡化

• 写一段程序计算一个图像的直方图
• 实现直方图均衡化
• 你的程序必须大体上能允许所有的灰阶图像作为输入

至少，在你的报告中需要包括原始图像和它的直方图，一张直方图均衡化的图，转换函数，改进后的图像和他的直方图。

实现效果：

按照我自己的理解，直方图的算法如下。未必正确，仅供参考。

// 以下代码仅描述算法，不能直接运行。
// 第一步，获取该位图从0-255的每个灰度值的点的个数。
for(i = 1 ; i < 255 ; i++)
{
	for(j = 1 ; j < 255 ; j++)
	{
		// grays数组的index为灰度值，值为该灰度值的点的个数
		grays[getGrayAt(i, j)]++;
	}
}

// 第二步，获得归一化之后的直方图
for(pi = 0 ; pi < grays.length ; pi++)
{
	p[pi] = grayList[pi] / (imgWidth * imgHeight); // p数组中保存的是每个灰度的百分比
}
// 第三步，累计的归一化直方图
for(ci = 0 ; ci < p.length ; ci++)
{
	c[ci] = 0;
	for(cj = 0 ; cj < ci ; cj++)
	{
		c[ci] += p[cj]; // 数组c中保存的是归一化之后的直方图
	}
}
//
// 最后，转换成新的位图
for(ti = 1 ; ti < 255 ; ti++)
{
	for(tj = 1 ; tj < 255 ; tj++)
	{
		t[ti][tj] = c[getGray(originaImage.getGrayAt(ti, tj))] * (maxGray - minGray) + minGray;
	}
}
// maxGray是原图中最高的灰度值，minGray是最低的。
// 数组t即为新的图的像素矩阵。

补充几个AS的方法：

public static function splitColor(color:uint):Array
{
	var red:uint = color >> 16 & 0xFF;
	var green:uint = color >> 8 & 0xFF;
	var blue:uint = color & 0xFF;
	return [red, green, blue];
}

public static function getGray(color:uint):uint
{
	var RGB:Array = splitColor(color);
	return uint((RGB[0] + RGB[1] + RGB[2]) / 3);
}

public static function getColor(gray:uint):uint
{
	return gray * 65536 + gray * 256 + gray;
}

一共只有6天休息，可怜哎。

补充4张新的国庆放假表：

到了学校才发现连一个路牌都没有，绕着走了一大圈才找到办理手续的地方。过去一问，我照片、协议书、个人信息都没有。于是赶紧找了个打印店上网注册输入资料然后打印，找了个自助照相机照了一版1寸照，终于在11点半之前完成了所有的手续。

下午的开学典礼，讲话，讲话，讲话，然后回家~

呼~~~下周开始上课~~

昨天下午终于正式的拿到了交大工程硕士的录取通知书，确切一点的说应该算是“缴费通知书”吧。2月九要入学，两年半交3万，毕业只能拿学位证没有学历证。虽然拿到通知书，却没有丝毫兴奋的感觉，很奇怪。

昨天下午终于正式的拿到了交大工程硕士的录取通知书，确切一点的说应该算是“缴费通知书”吧。2月九要入学，两年半交3万，毕业只能拿学位证没有学历证。虽然拿到通知书，却没有丝毫兴奋的感觉，很奇怪。