algorithm.cpp

模式识别二维链表实现isodata算法 早期试验

}

int CAlgorithm::DisplayInfo()
{
	cout<<endl;
	cout<<endl;
	cout<<endl;
	cout<<endl;

	cout<<"未归类模式信息:"<<endl;
	DisplayPattern(pPattern);

	cout<<"类的信息:"<<endl;

	
	for(int i=1;i<=ClusNum;i++)
	{
		cout<<"类 no."<<i<<endl;
		DisplayCluster(GetClusPointer(i));
	}


	cout<<"类的个数:"<<ClusNum<<endl;
	
	cout<<"未归类模式个数"<<UnClusPatNum<<endl;
	cout<<"各个模式到其类中心的总体平均距离"<<TotalMeanDis<<endl;


	return 0;

}

void CAlgorithm::Test()
{
	int delay=0;
	int result=0;
	ParaSet();
		Step1();
		cout<<"step1"<<endl;

step2:	Step2();
		cout<<"step2"<<endl;
		DisplayInfo();
		Sleep(delay);
		if(Step3()==2)
		{
			cout<<"step3"<<endl;
			DisplayInfo();
			Sleep(delay);

			goto step2 ;
		}
		Step4();
		cout<<"step4"<<endl;
		DisplayInfo();
		result=Step5();
		Sleep(delay);

		cout<<"step5"<<endl;
		DisplayInfo();
		Sleep(delay);

		if(result==6)
			goto step6;
		if(result==9)
			goto step9;
		
step6: Step6_7();
	   cout<<"step6_7"<<endl;
		DisplayInfo();
		Sleep(delay);

	   if(Step8()==2)
	   {
		   cout<<"step8"<<endl;
		   DisplayInfo();
		Sleep(delay);

		   goto step2;
	   }
step9:	Step9_10();
		cout<<"step9"<<endl;
		DisplayInfo();
		Sleep(delay);

		if(Step11()==2)
		{
			cout<<"step11"<<endl;
			DisplayInfo();
		Sleep(delay);

			goto step2;
		}
		

}

int CAlgorithm::FreePatInClus(PATTERN_S *p)//释放已聚类的模式
{

	if(p==NULL)
		return 1;
	PATTERN_S *pTemp;
	pTemp=pPattern;
	UnClusPatNum+=CountPattern(p);
	if(pTemp==NULL)
	{
		pPattern=p;
		return 0;
	}

	while(pTemp->pNext!=NULL)
		pTemp=pTemp->pNext;
	pTemp->pNext=p;
	return 0;

}

int CAlgorithm::CountPattern(PATTERN_S *p)////返回模式结构链的长度
{
	int count=0;
	if(p==NULL)
		return 0;
	PATTERN_S *pTemp;
	pTemp=p;
	while(pTemp!=NULL)
	{
		count++;
		pTemp=pTemp->pNext;
	}

	return count;

}

int CAlgorithm::CombineCluster(int posc1, int posc2)//根据位置参数合并两个类
{	
	if(posc1==posc2||posc1<1||posc1>ClusNum||posc2<1||posc2>ClusNum)
		return 1;
	

	CLUSTER_S *pTempc1,*pTempc2;
	PATTERN_S *pTempp1,*pTempp2;
	pTempc1=GetClusPointer(posc1);
	pTempc2=GetClusPointer(posc2);
	if(pTempc1->CombineOrNot==1||pTempc2->CombineOrNot==1)
		return 1;
	pTempp1=pTempc1->pPat;
	pTempp2=pTempc2->pPat;
	if(pTempp1==NULL)
	{
		pTempp1=pTempp2;
		pTempc2->pPat=NULL;
		pTempc1->CombineOrNot=1;
		DeleteCluster(posc2);
	}
	else
	{
		while(pTempp1->pNext!=NULL)
			pTempp1=pTempp1->pNext;
		pTempp1->pNext=pTempp2;
		pTempc2->pPat=NULL;
		pTempc1->CombineOrNot=1;
		DeleteCluster(posc2);
	}
	
	return 0;

}

int CAlgorithm::AddNullCluster()
{
	CLUSTER_S *pTemp;
	pTemp=new CLUSTER_S;

	pTemp->pPat=NULL;
	pTemp->pNext=NULL;
	pTemp->pCenter=NULL;
	pTemp->MaxBiaozhuncha=0;
	pTemp->MaxBiaozhunchaPos=0;
	pTemp->PatCentMeanDis=0;
	pTemp->CombineOrNot=0;
	AddCluster(pTemp);

	return 0;

}

CLUSTER_S* CAlgorithm::GetClusPointer(int position)//根据位置参数返回类结构指针
{
	if(position<0||position>ClusNum)
		return NULL;
	CLUSTER_S *pTemp;
	pTemp=pCluster;
	if(position==1)
		return pTemp;
	for(int i=1;i<position;i++)
		pTemp=pTemp->pNext;
	return pTemp;


}

int CAlgorithm::Random(int max)
{
	
	return rand()%max+1;
	

}

double CAlgorithm::CalPatClusCentDis(PATTERN_S *p, CLUSTER_S *c)//计算模式与类心之间的距离
{	
	double *Pat,*Cent;
	double result=0;
	Pat=p->pat;
	if(Pat==NULL||c==NULL)
		return 0;
	Cent=c->pCenter;
	for(int i=0;i<PatDim;i++)
	{
		result+=pow((Pat[i]-Cent[i]),2);
	}
	result=sqrt(result);
	return result;

}


int CAlgorithm::CalPatCentMeanDis(CLUSTER_S *c)//计算更新各类中模式到类心的平均距离
{
	
	if(c==NULL)
		return 1;
	if(c->pCenter==NULL||c->pPat==NULL)
		return 1;
	double *Cent;
	Cent=c->pCenter;
	PATTERN_S *pTemp;
	pTemp=c->pPat;
	int i;
	double result;
	int length=CountPattern(c->pPat);
	double dis=0;

	do
		{
			result=0;
			for(i=0;i<PatDim;i++)
				result+=pow(pTemp->pat[i]-Cent[i],2);
			result=sqrt(result);
			dis+=result;
			pTemp=pTemp->pNext;
		}
	while(pTemp!=NULL);
	dis=dis/length;
	c->PatCentMeanDis=dis;
	return 0;
}



double CAlgorithm::CalTotalMeanDis()//计算各个模式到其类内中心的总体平均距离
{
	CLUSTER_S *pTemp;
	pTemp=pCluster;
	double Dis=0;
	if(pTemp==NULL)
		return 0;
	do
	{
		Dis+=CountPattern(pTemp->pPat)*pTemp->PatCentMeanDis;
		pTemp=pTemp->pNext;
	}
	while(pTemp!=NULL);
	Dis=Dis/PatNum;
	TotalMeanDis=Dis;
	return Dis;
}

int CAlgorithm::CalClusMaxBiaozhuncha(CLUSTER_S *c)//计算类内距离的标准差矢量的最大值
{
	double *pCha;
	PATTERN_S *pTemp;
	pTemp=c->pPat;
	if(pTemp==NULL||c==NULL)
		return 1;

	pCha=new double[PatDim];
	int i=0;
	for(i=0;i<PatDim;i++)
	{
		pCha[i]=0;
	}

	int length=CountPattern(pTemp);
	do
		{	
			for(i=0;i<PatDim;i++)
			{
				pCha[i]+=pow(c->pCenter[i]-pTemp->pat[i],2);
			}
			pTemp=pTemp->pNext;
		}
		while(pTemp!=NULL);
		for(i=0;i<PatDim;i++)
		{
			pCha[i]=sqrt(pCha[i]/length);
		}

	int maxpos=0;
	double temp1=0,temp2=0;
	for(i=0;i<PatDim;i++)
	{
		temp2=pCha[i];
		if(temp1<temp2)
		{
			temp1=temp2;
			maxpos=i;
		}
	}
	c->MaxBiaozhuncha=pCha[maxpos];
	c->MaxBiaozhunchaPos=maxpos;
	delete []pCha;
		
	return 0;
	


}


int CAlgorithm::SeperateCluster(CLUSTER_S *c)//将一个类分裂
{
	if(c==NULL)
		return 1;
	if(c->pPat==NULL||c->pCenter==NULL)
		return 1;
	CLUSTER_S *pAdd;
	pAdd=new CLUSTER_S;
	pAdd->pCenter=new double[PatDim];
	int i;
	for(i=0;i<PatDim;i++)
	{
		if(i==c->MaxBiaozhunchaPos)
			pAdd->pCenter[i]=c->pCenter[i]-k*c->MaxBiaozhuncha;
		else
			pAdd->pCenter[i]=c->pCenter[i];
	}
	pAdd->pPat=NULL;
	pAdd->CombineOrNot=0;
	pAdd->MaxBiaozhuncha=0;
	pAdd->pNext=NULL;
	pAdd->pPat=NULL;
	pAdd->MaxBiaozhunchaPos=0;
	pAdd->PatCentMeanDis=0;
	AddCluster(pAdd);
	c->pCenter[c->MaxBiaozhunchaPos]+=k*c->MaxBiaozhuncha;
	FreePatInClus(c->pPat);
	c->pPat=NULL;
	c->CombineOrNot=0;
	c->MaxBiaozhuncha=0;
	c->MaxBiaozhunchaPos=0;
	c->PatCentMeanDis=0;
	return 0;

}

double CAlgorithm::CalClusCentDis(int posc1,int posc2)//根据位置计算两个类心之间的距离
{
	if(posc1==posc2||posc1<1||posc1>ClusNum||posc2<1||posc2>ClusNum)
	return 1;
	
	CLUSTER_S *pTempc1,*pTempc2;
	pTempc1=GetClusPointer(posc1);
	pTempc2=GetClusPointer(posc2);
	if(pTempc1==NULL||pTempc2==NULL)
		return 1;

	double dis=0;
	for(int i=0;i<PatDim;i++)
	{
		dis+=pow(pTempc1->pCenter[i]-pTempc2->pCenter[i],2);
	}
	dis=sqrt(dis);
	return dis;
}



int CAlgorithm::PatternFromArray(double input[])//把数组转换为模式链结构
{

//	if(sizeof(input)!=PatNum*PatDim)
//		return 1;
	

		
	ClusNum=0;
	Ip=0;//实际迭代的次数

	pPattern=NULL;
	pCluster=NULL;

	PATTERN_S *pTemp;
	PATTERN_S *pEnd;
	int i,j;
	
	
	for(i=0;i<PatNum;i++)
	{
		pTemp=new PATTERN_S;
		
		for(j=0;j<PatDim;j++)
			
		{
			if(j==0)
				pTemp->pat=new double[PatDim];
			pTemp->pat [j]=input[i*PatDim+j];
		}

		cout<<endl;

		
		if(pPattern==NULL)
		{
			pPattern=pTemp;
			pEnd=pTemp;

		}
		else 
		{
			pEnd->pNext=pTemp;
		}
		pEnd=pTemp;

		
	}
	pEnd=pTemp;
	pEnd->pNext =NULL;
	UnClusPatNum=PatNum;
		

	
	return 0;
}


int CAlgorithm::MemoryFree()//释放内存
{
	PATTERN_S *pTempp,*pDelp;
	CLUSTER_S *pTempc,*pDelc;
	double *pDelCen;
	pTempc=pCluster;
	if(pTempc==NULL)
	{
		return 1;
	}
	do
	{
		pDelCen=pTempc->pCenter;
		delete []pDelCen;
		pTempp=pTempc->pPat;
		do
		{	
			if(pTempp==NULL)
				break;

			pDelp=pTempp;
			pTempp=pTempp->pNext;
			delete []pDelp->pat;
			delete pDelp;
		}
		while(pTempp!=NULL);
		pDelc=pTempc;
		pTempc=pTempc->pNext;
		delete pDelc;
	}
	while(pTempp!=NULL);

	return 0;

}
void CAlgorithm::Process()
{
	int delay=0;
	int result=0;
	//ParaSet();
		Step1();
	//	cout<<"step1"<<endl;

step2:	Step2();
	//	cout<<"step2"<<endl;
	//	DisplayInfo();
	//	Sleep(delay);
		if(Step3()==2)
		{
	//		cout<<"step3"<<endl;
	//		DisplayInfo();
	//		Sleep(delay);

			goto step2 ;
		}
		Step4();
	//	cout<<"step4"<<endl;
	//	DisplayInfo();
		result=Step5();
	//	Sleep(delay);

	//	cout<<"step5"<<endl;
	//	DisplayInfo();
	//	Sleep(delay);

		if(result==6)
			goto step6;
		if(result==9)
			goto step9;
		
step6: Step6_7();
	//   cout<<"step6_7"<<endl;
	//	DisplayInfo();
	//	Sleep(delay);

	   if(Step8()==2)
	   {
	//	   cout<<"step8"<<endl;
	//	   DisplayInfo();
	//	Sleep(delay);

		   goto step2;
	   }
step9:	Step9_10();
	//	cout<<"step9"<<endl;
	//	DisplayInfo();
	//	Sleep(delay);

		if(Step11()==2)
		{
	//		cout<<"step11"<<endl;
	//		DisplayInfo();
	//	Sleep(delay);

			goto step2;
		}
		return ;


}