classification.cpp

<图像模式识别－vc＋＋技术实现>的配套光盘源代码

	//权值初值为0
	for(n=0;n<10;n++)
		for(i=0;i<26;i++)
			w[n][i]=0;
	do
	{
		flag=true;
		for(n=0;n<10;n++)
		{
			for(i=0;i<40;i++)//for(i=0;i<pattern[n].number;i++)
			{
				//取已知样品
				for(j=0;j<25;j++)
					x[j]=pattern[n].feature[i][j];
				x[25]=1;//最后一位置1
				//计算结果权矢量
				for(j=0;j<10;j++)
					d[j]=0;
				for(j=0;j<10;j++)
					for(k=0;k<26;k++)
						d[j]+=w[j][k]*x[k];
				bool f=true;
				//判断d[n]是否为最大值
				for(j=0;j<10;j++)
				{
					if(j!=n)
						f&=(d[n]>d[j])?true:false;
				}

				if(f)//若d[n]为最大值
					flag&=true;//通过检验
				else//否则，未通过检验需要修正权值
				{
					for(j=0;j<10;j++)
					{
						for(k=0;k<26;k++)
						{
							if(j==n)
								w[j][k]+=x[k];
							else if(d[j]>d[n])
								w[j][k]-=x[k];
							else;
						}
					}
					flag&=false;
				}
			}
		}
		if(++c>2000)break;
	}while(!flag);//到此为止得到线性判别函数权矢量

	double num[26];//未知样品
	for(i=0;i<25;i++)
		num[i]=testsample[i];
	num[25]=1;//末位置1
	for(n=0;n<10;n++)//计算判别函数
	{
		hx[n]=0;
		for(i=0;i<26;i++)
			hx[n]+=w[n][i]*num[i];
	}

	double maxval=hx[0];
	int number=0;
	for(n=1;n<10;n++)//取判别函数最大值
	{
		if(hx[n]>maxval)
		{
			maxval=hx[n];
			number=n;
		}
	}
	return number;
}

/******************************************************************
*   函数名称：LMSE()
*   函数类型：int 
*   函数功能：LMSE算法 ,返回手写数字的类别
******************************************************************/
int Classification::LMSE()
{
	double w[10][26];//权值
	double d[10];//迭代计算结果权矢量
	double x[26];//增1样品
	bool flag;
	int n,i,j,k;

	//权值初值为0
	for(n=0;n<10;n++)
		for(i=0;i<26;i++)
			w[n][i]=0;
	int c=0,cc=1;
	do
	{
		flag=true;
		for(n=0;n<10;n++)
		{
				for(i=0;i<40;i++)//for(i=0;i<pattern[n].number;i++)
			{
				//取已知样品
				for(j=0;j<25;j++)
					x[j]=pattern[n].feature[i][j];
				x[25]=1;//末位置1
				//计算结果权矢量
				for(j=0;j<10;j++)
					d[j]=0;
				for(j=0;j<10;j++)
					for(k=0;k<26;k++)
						d[j]+=w[j][k]*x[k];
				bool f=true;
				//d[n]是否最大值？
				for(j=0;j<10;j++)
				{
					if(j!=n)
						f&=(d[n]>d[j])?true:false;
				}

				if(f)//若d[n]为最大值
					flag&=true;
				else
					flag&=false;

				for(j=0;j<10;j++)//改变权值，10个
				{
					double rX;
					if(j==n)//是当前类别
						rX=1.0;//r[X(k)]=1
					else
						rX=0.0;//r[X(k)]=0
					
					for(k=0;k<26;k++)
					{
						w[j][k]+=x[k]*(rX-d[j])/cc;
					}
				}
				++cc;
			}
		}
		if(++c>2000)break;
	}while(!flag);//到此为止得到线性判别函数权矢量
	
	double hx[10];
	double num[26];
	//取未知样品
	for(i=0;i<25;i++)
		num[i]=testsample[i];
	num[25]=1;//末位置1
	//计算判别函数
	for(n=0;n<10;n++)
	{
		hx[n]=0;
		for(i=0;i<26;i++)
			hx[n]+=w[n][i]*num[i];
	}
	//判别函数最大值
	double maxval=hx[0];
	int number=0;
	for(n=1;n<10;n++)
	{
		if(hx[n]>maxval)
		{
			maxval=hx[n];
			number=n;
		}
	}
	return number;
}

/******************************************************************
*   函数名称：Zengliangjiaozheng()
*   函数类型：int 
*   函数功能：增量校正算法 ,返回手写数字的类别
******************************************************************/
int Classification::Zengliangjiaozheng()
{
	double w[10][26];//权值
	double d[10];//迭代计算结果权矢量
	double x[26];//增1样品
	bool flag;
	int n,i,j,k;

	//权值初值为0
	for(n=0;n<10;n++)
		for(i=0;i<26;i++)
			w[n][i]=0;
	int c=0,cc=1;
	do
	{
		flag=true;
		for(n=0;n<10;n++)
		{
			for(i=0;i<10;i++)//	for(i=0;i<pattern[n].number;i++)
			{
				//取已知样品
				for(j=0;j<25;j++)
					x[j]=pattern[n].feature[i][j];
				x[25]=1;//末位置1
				//计算结果权矢量
				for(j=0;j<10;j++)
					d[j]=0;
				for(j=0;j<10;j++)
					for(k=0;k<26;k++)
						d[j]+=w[j][k]*x[k];
				bool f=true;
				//d[n]是否最大值？
				for(j=0;j<10;j++)
				{
					if(j!=n)
						f&=(d[n]>d[j])?true:false;
				}

				if(f)//若d[n]为最大值
					flag&=true;
				else//否则
					flag&=false;

				for(j=0;j<10;j++)
				{
					double rX;
					if(j==n)//是当前类别
						rX=1.0;//r[X(k)]=1
					else
						rX=0.0;//r[X(k)]=0

					if(d[j]<rX)//W(k)X(k)<r[X(k)]
					{
						for(k=0;k<26;k++)
							w[j][k]+=x[k]/cc;
					}
					else//W(k)X(k)≥r[X(k)]
					{
						for(k=0;k<26;k++)
							w[j][k]-=x[k]/cc;
					}
				}
				++cc;
			}
		}
		if(++c>2000)break;
	}while(!flag);//到此为止得到线性判别函数权矢量
	
	double hx[10];
	double num[26];
	//取未知样品
	for(i=0;i<25;i++)
		num[i]=testsample[i];
	num[25]=1;//末位置1
	//求判别函数
	for(n=0;n<10;n++)
	{
		hx[n]=0;
		for(i=0;i<26;i++)
			hx[n]+=w[n][i]*num[i];
	}
	//判别函数最大值
	double maxval=hx[0];
	int number=0;
	for(n=1;n<10;n++)
	{
		if(hx[n]>maxval)
		{
			maxval=hx[n];
			number=n;
		}
	}
	return number;
}

/******************************************************************
*   函数名称：ifClassified(int Class0,int Class1)
*   函数类型：CString
*   参数说明：int Class0,int Class1:要验证的两个类别
*   函数功能：用LMSE方法验证两类的可分性,返回每次迭代的权值
******************************************************************/
CString Classification::ifClassified(int Class0,int Class1)
{
	double X[60][26];//增1样品矩阵
	double Xsharp[26][60];//X的规范逆矩阵X#
	double w[26];//权值向量
	double Xw[60];//X*W
	double b[60];//向量
	double e[60];//向量
	bool flag;
	int c=1;//迭代次数
	CString str;
	CString s;
	CStdioFile cf;//文件
	int i,j;
	
	//增1样品矩阵的前30个取Class0的样品
	for(i=0;i<30;i++)
	{
		for(j=0;j<25;j++)
		{
			X[i][j]=pattern[Class0].feature[i][j];
		}
		X[i][25]=1;//最后一位取1
	}
	//增1样品矩阵的后30个取Class1的样品（取负）
	for(i=30;i<59;i++)
	{
		for(j=0;j<25;j++)
		{
			X[i][j]=-pattern[Class1].feature[i-30][j];
		}
		X[i][25]=-1;
	}
	//求X的规范逆矩阵X#
	guifanni(X,Xsharp);
	//b赋初值，b(1)={1,1,1,...,1}
	for(i=0;i<40;i++)
		b[i]=1;
	do
	{
		s.Format("第%d次迭代：										",c);
		str.Insert(str.GetLength(),s);
		brmul(Xsharp,b,w);//w=x#*b
		brmul(X,w,Xw);//x*w
		flag=true;
		for(i=0;i<40;i++)
		{
			e[i]=Xw[i]-b[i];
			flag&=e[i]<0?true:false;//e的分量是否全负？
			s.Format("%d,\t",e[i]);
			str.Insert(str.GetLength(),s);
		}
		if(!flag)//e的分量不是全负，调整b
		{
			for(i=0;i<40;i++)
				b[i]+=2*e[i];
		}
		if(++c>300) break;//迭代超过300次，退出。
	}while(!flag);
	//存入文件“lmse.txt”
	if(cf.Open("lmse.txt",CFile::modeCreate|CFile::modeWrite))
	{
		cf.WriteString(str);
		cf.Close();
	}
	return str;	
}


/******************************************************************
*   函数名称：Shihanshu()
*   函数类型：int 
*   函数功能：势函数分类法 ,返回手写数字的类别
******************************************************************/
int Classification::Shihanshu()
{
	int r[10][2000];//系数
	int x[2000][2];//样品
	double hx[10];//判别函数
	int i,j,k,n,c=0;

	for(k=0;k<10;k++)//循环10次
	{
		for(n=0;n<10;n++)//10个类别
		{
			for(i=0;i<20;i++)//每类取20个样品
			{
				if(c==0)
				{
					for(j=0;j<10;j++)
						r[j][0]=1;
				}
				else
				{
					for(j=0;j<10;j++)
					{
						double t=0.0;
						for(int l=0;l<c;l++)
							t+=r[j][l]*K(pattern[n].feature[i],pattern[x[l][0]].feature[x[l][1]]);
						hx[j]=t;
					}
					for(j=0;j<10;j++)
					{
						if(j==n)
						{
							if(hx[j]>0)//分类正确
								r[n][c]=0;
							else//分类错误
								r[n][c]=1;
						}
						else
						{
							if(hx[j]<0)//分类正确
								r[n][c]=0;
							else//分类错误
								r[n][c]=-1;
						}
					}
				}
				x[c][0]=n;
				x[c][1]=i;	
				c++;
			}
		}
	}

	for(j=0;j<10;j++)
	{
		double t=0.0;
		for(int l=0;l<200;l++)
			t+=r[j][l]*K(testsample,pattern[x[l][0]].feature[x[l][1]]);
		hx[j]=t;
	}
	
	double maxval=hx[0];
	int number=0;
	for(n=1;n<10;n++)
	{
		if(hx[n]>maxval)
		{
			maxval=hx[n];
			number=n;
		}
	}
	return number;	
}

/****************************************************************
*   函数名称：K(double X[], double Xk[])
*   函数类型：double 
*   参数说明：X[], Xk[]:两个样品的特征
*   函数功能：计算两个样品的势函数 ,返回两各样品的势函数函数值。
****************************************************************/
double Classification::K(double X[], double Xk[])
{
	double d=0.0;
	for(int i=0;i<25;i++)
		d+=(X[i]-Xk[i])*(X[i]-Xk[i]);
	return exp(-d);
}

/****************************************************************
*   函数名称：pipei(double s1[], double s2[])
*   函数类型：double 
*   参数说明：double s1[], double s2[]:两个样品的特征
*   函数功能：计算两个样品的匹配程度 ,返回两各样品的的匹配程度。
****************************************************************/
double Classification::pipei(double s1[], double s2[])
{
	double count=0.0;
	for(int i=0;i<25;i++)
	{
		count+=(s1[i]-s2[i])*(s1[i]-s2[i]);
	}
	return count;
}