classify.h

二维点集合聚类的图像化演示程序 用它可以很直观的看到聚类的整个过程

#include <iostream>
#include <iomanip>
#include <fstream>
#include <string>
#include <new>
#include <Math.h>
using namespace std;
class point
{
public:
	float _x;
	float _y;
	int _type;
	point()
	{
		this->_x=0;
		this->_y=0;
		this->_type=0;
	}

	virtual ~point(){};

	void setxy(float t_x, float t_y)
	{
		this->_x=t_x;
		this->_y=t_y;
	}

	void settype(int t_type)
	{
		this->_type=t_type;
	}
};

class c_type
{
public:
	//当前类型的权值
	float _type_distance;
	//当前类型的值
	int _type_sum;
	c_type()
	{
		this->_type_distance=0;
		this->_type_sum=0;
	}
	virtual ~c_type(){}
};

//文件扫描函数，返回文件里点（数据）的总数 
int num_scan(char *filename)
{
	//AfxMessageBox(filename);
	int sum=0;
	float temp;
	fstream temp_file;
	temp_file.open(filename);
	//AfxMessageBox("文件扫描中");
	if(temp_file.fail())
	{
		AfxMessageBox("文件扫描失败");
		return -1;
	}
	else
	{
		//AfxMessageBox(sum);
		while(!temp_file.eof())
		{
			temp_file>>temp;
			sum++;
		//AfxMessageBox(sum);	
		}
		temp_file.close();
		return (sum-1)/2;//必须记清在往文件里输入时 在文件最后加上几个 空格
	}
}


//从文件里读指定数目的点(数据）
int read(char * filename ,point * points ,int point_num)
{
	fstream temp_file;
	temp_file.open(filename);
	if(temp_file.fail())
	{
		return -1;
	}
	else
	{
		// 对目标文件中的数据的格式有一定要求
		int i=0;
		while(!temp_file.eof() && i<point_num)
		{
			temp_file>>points[i]._x;
			temp_file>>points[i]._y;
			i++;

		}
		temp_file.close();
		return 1;
	}
}

//聚类"主"函数
int classify( point * points ,int point_sum ,int max_type )
{
	
	//循环用数
	int i,j;
	//type_sum为目前类型总数，position用于各点距离排序，distance_sum为距离（不重复）总数
	int type_sum=1,position=0,distance_sum=0;
	float distance;
	//
	float **matrix_distance,*t_array_distance,*r_array_distance,*array_distance;
	//
	c_type *type_array;
	//
	array_distance=new(float [point_sum*point_sum]);
	r_array_distance=new(float [point_sum*point_sum]);
	t_array_distance=new(float [point_sum*point_sum]);
	matrix_distance=new( float *[point_sum] );
	type_array=new( c_type [point_sum] );

	for(i=0;i<point_sum;i++)
	{
		points[i]._type=0;
	}
	//cout<<"输出matrix_distance:"<<endl;
	for(i=0;i<point_sum;i++)
	{
		matrix_distance[i]=new( float[point_sum]);
		for(j=0;j<point_sum;j++)
		{
			float temp;
			matrix_distance[i][j]=(points[i]._x-points[j]._x)*(points[i]._x-points[j]._x)+(points[i]._y-points[j]._y)*(points[i]._y-points[j]._y);
			temp=matrix_distance[i][j];
			matrix_distance[i][j]=sqrt(temp);
			//cout<<setw(14)<<matrix_distance[i][j];
			t_array_distance[i*point_sum+j]=matrix_distance[i][j];
		}
		cout<<endl<<endl;
	}

	//输出t_array_distance
	//cout<<endl;
	//cout<<"输出t_array_distance:"<<endl;
	for(i=0;i<point_sum*point_sum;i++)
	{
		;
		//cout<<setw(14)<<t_array_distance[i]<<endl;
	}
	//cout<<endl;

	//压缩t_array_distance
	distance_sum=1;
	position=1;
	r_array_distance[0]=t_array_distance[0];
	for(i=1;i<point_sum*point_sum;i++)
	{
		int find;
		float temp;
		find=0;
		temp=t_array_distance[i];
		for(int tempi=0;tempi<point_sum*point_sum;tempi++)
		{
			if(r_array_distance[tempi]==temp)
				find=1;
		}
		if(find==0)
		{
			r_array_distance[position]=temp;
			distance_sum++;
			position++;
		}
	}
	//cout<<endl<<endl;
	//cout<<"压缩t_array_distance"<<"  distance_sum=:"<<distance_sum<<endl;
	//cout<<"压缩t_array_distance"<<"   position:="<<position<<endl;
	//cout<<endl<<endl;

	//距离排序，并计算总数；
	for(i=0;i<distance_sum;i++)
	{
		position=0;
		for(j=0;j<distance_sum;j++)
		{
			if(r_array_distance[i]>r_array_distance[j] )
			{
				position++;
			}
		}
		array_distance[position]=r_array_distance[i];
	}
	//cout<<"距离排序，并计算总数"<<distance_sum<<endl;


	//输出array_distance
	//cout<<endl;
	//cout<<"输出array_distance:"<<endl;
	for(i=0;i<point_sum*point_sum;i++)
	{
		;
		//cout<<setw(14)<<array_distance[i]<<endl;
	}
	//cout<<endl<<endl;

	//对点进行最后分类
	int end_loop;
	end_loop=0;
	for(i=distance_sum-1;i>=0 && end_loop==0;i--)
	{
		end_loop=0;
		type_sum=1;//目前类型数
		points[0]._type=1;
		for(int tempj=1;tempj<point_sum;tempj++)
		{
			points[tempj]._type=0;
		}
		int find;
		float t_distance=array_distance[i];
		//cout<<t_distance<<endl;//输出当前标准距离
		for(int tempi=1;tempi<point_sum;tempi++)
		{
			
			if(points[tempi]._type==0)
			{
				find=0;//表示是否发现同型点
				for(j=0;j<tempi;j++)
				{
					if(matrix_distance[tempi][j]<=t_distance)
					{
						//cout<<"find==1"<<endl;
						points[tempi]._type=points[j]._type;//若为同型则归为同类
						find=1;
					}
				}
				//若没有找到同类
				if(find==0)
				{
					type_sum++;
					//cout<<"find==0"<<endl;
					//cout<<"type_sum="<<type_sum<<endl;
					points[tempi]._type=type_sum;
				}
			}
		}
		if(type_sum==max_type)
		{
			//cout<<"max_type="<<max_type<<endl;
			end_loop=1;
			//cout<<"break"<<endl;
			break;
		}
		//cout<<"i="<<i<<endl;
	}
	if(end_loop==1)
		return 1;
	else
		return 0;
}

int auto_classify( point * points ,int point_sum )
{
	fstream log;
	log.open("F:\\学习\\谢树生\\TEST\\mfc毕业设计\\log.txt");
	//循环用数
	int i,j;
	//type_sum为目前类型总数，position用于各点距离排序，distance_sum为距离（不重复）总数
	int type_sum=1,position=0,distance_sum=0;
	//float distance;
	//
	float **matrix_distance,*t_array_distance,*r_array_distance,*array_distance;
	//
	c_type *type_array;
	//
	array_distance=new(float [point_sum*point_sum]);
	r_array_distance=new(float [point_sum*point_sum]);
	t_array_distance=new(float [point_sum*point_sum]);
	matrix_distance=new( float *[point_sum] );
	type_array=new( c_type [point_sum] );

	//cout<<"输出matrix_distance:"<<endl;
	for(i=0;i<point_sum;i++)
	{		
		matrix_distance[i]=new( float[point_sum]);
		for(j=0;j<point_sum;j++)
		{
			float temp;
			matrix_distance[i][j]=(points[i]._x-points[j]._x)*(points[i]._x-points[j]._x)+(points[i]._y-points[j]._y)*(points[i]._y-points[j]._y);
			temp=matrix_distance[i][j];
			matrix_distance[i][j]=sqrt(temp);
			//cout<<setw(14)<<temp<<endl;
			
			t_array_distance[i*point_sum+j]=matrix_distance[i][j];
		}
		//cout<<endl<<endl;
	}
    /*
	//输出t_array_distance
	cout<<endl;
	cout<<"输出t_array_distance:"<<endl;
	for(i=0;i<point_sum*point_sum;i++)
	{
		cout<<setw(14)<<t_array_distance[i]<<endl;
	}
	cout<<endl;
    */
	//压缩t_array_distance
	distance_sum=1;
	position=1;
	r_array_distance[0]=t_array_distance[0];
	for(i=1;i<point_sum*point_sum;i++)
	{
		int find;
		float temp;
		find=0;
		temp=t_array_distance[i];
		for(int tempi=0;tempi<point_sum*point_sum;tempi++)
		{
			if(r_array_distance[tempi]==temp)
				find=1;
		}
		if(find==0)
		{
			r_array_distance[position]=temp;
			distance_sum++;
			position++;
		}
	}

	/*
	cout<<endl<<endl;
	cout<<"压缩t_array_distance"<<"  distance_sum=:"<<distance_sum<<endl;
	cout<<"压缩t_array_distance"<<"   position:="<<position<<endl;
	cout<<endl<<endl;
    */

	//距离排序，并计算总数；
	for(i=0;i<distance_sum;i++)
	{
		position=0;
		for(j=0;j<distance_sum;j++)
		{
			if(r_array_distance[i]>r_array_distance[j] )
			{
				position++;
			}
		}
		array_distance[position]=r_array_distance[i];
		//cout<<r_array_distance[i]<<endl;

	}
	//cout<<"距离排序，并计算总数"<<distance_sum<<endl;


	/*
	//输出array_distance
	cout<<endl;
	cout<<"输出array_distance:"<<endl;
	for(i=0;i<point_sum*point_sum;i++)
	{
		//cout<<setw(14)<<array_distance[i]<<endl;
	}
	cout<<endl<<endl;

    */
	//对点进行最后分类
	
	position=0;
	int pre_type_sum = point_sum;

	int spe_type_sum = point_sum;

	for(i=0;i<distance_sum;i++)
	{
		type_sum=1;//目前类型数
		points[0]._type=1;
		for(int tempj=1;tempj<point_sum;tempj++)
		{
			points[tempj]._type=0;
		}
		int find;
		float t_distance=array_distance[i];
		//cout<<t_distance<<endl;//输出当前标准距离
		for(int tempi=1;tempi<point_sum;tempi++)
		{
			
			if(points[tempi]._type==0)
			{
				find=0;//表示是否发现同型点
				for(j=0;j<tempi;j++)
				{
					if(matrix_distance[tempi][j]<=t_distance)
					{
						//cout<<"find==1"<<endl;
						points[tempi]._type=points[j]._type;//若为同型则归为同类
						find=1;
					}
				}
				//若没有找到同类
				if(find==0)
				{
					type_sum++;
					//cout<<"find==0"<<endl;
					//cout<<"type_sum="<<type_sum<<endl;
					points[tempi]._type=type_sum;
				}
			}
		}
		if(type_sum !=pre_type_sum)
		{
			
			log<<endl;
			log<<"次数i="<<i<<endl;
			log<<"位置position="<<position<<endl;
			log<<"目前类型数"<<type_sum<<endl;
			
			type_array[position]._type_sum=type_sum;
			pre_type_sum=type_sum;
			type_array[position]._type_distance =(spe_type_sum-type_sum)/t_distance;
			log<<"目前类型权值为"<<type_array[position]._type_distance<<endl;
			log<<endl;
			position++;
		}
	}

	//cout<<"最后position="<<position<<endl;
	int max_type_sum=0;
	int max_type_distance=0;
	for(i=0;i<position;i++)
	{
		if(type_array[i]._type_distance>max_type_distance)
		{
			//cout<<"max_type_distance="<<max_type_distance<<endl;
			//cout<<"type_array[i]._type_distance="<<type_array[i]._type_distance<<endl;
			max_type_distance=type_array[i]._type_distance;
			max_type_sum=type_array[i]._type_sum;
			//cout<<"max_type_sum="<<max_type_sum<<endl;
		}
	}
	return max_type_sum;
}