storage.cpp

使用LDA实现三维模型相关反馈的算法注：1、使用本系统必须在本地计算机上安装matlab 2、算法使用的三维模型特征向量是从PSB模型库中自动提取的DESIRE三维模型特征向量 3、本系统自带评测机制

#include "StdAfx.h"
#include ".\storage.h"
#include <string>
#include <math.h>

extern int round;
extern double originfeaturesmatrix[OBJECTNUMBER][FEATHERLENTH];
extern double newfeaturesmatrix[OBJECTNUMBER][MAXCLASSNUM];
extern int allclassobjectmembers[MAXCLASSNUM][MAXOBJECTNUM];
extern int numofoneclass[MAXCLASSNUM];
extern int positiveobjects[OBJECTNUMBER];
extern int negativeobjects[OBJECTNUMBER];
extern int pandnobjects[OBJECTNUMBER];
extern int pandnnum;
extern int positivenum;
extern int negativenum;
extern double trans[MAXCLASSNUM][FEATHERLENTH];
//double Sb[FEATHERLENTH][FEATHERLENTH];
//double Sw[FEATHERLENTH][FEATHERLENTH];



CStorage::CStorage(void)
//: totalclassnumber(0)
//, totalmodelnumber(0)
//, originfeaturesmatrix(NULL)
//, newfeaturesmatrix(NULL)
//, origindistancevector(NULL)
//, newdistancevector(NULL)
//, currentmodel(0)
//, labelnumber(0)
{
	//modelinclassnumber.clear();
	//allclassvector.clear();
	//oneclassvector.clear();
	//distancemap.clear();
	//labelvectorpositive.clear();
	//labelvectornegative.clear();
	//labelvector.clear();
	outfile0.open("result0.txt");
	outfile1.open("result1.txt");
	outfile2.open("result2.txt");
	outfile3.open("result3.txt");
	outfile4.open("result4.txt");
	outfile5.open("result5.txt");
	outfile6.open("result6.txt");
	outfile7.open("result7.txt");
	outfile8.open("result8.txt");
	outfile9.open("result9.txt");

}

CStorage::~CStorage(void)
{
	//delete[] originfeaturesmatrix;
	//delete[] newfeaturesmatrix;
	outfile0.close();
	outfile1.close();
	outfile2.close();
	outfile3.close();
	outfile4.close();
	outfile5.close();
	outfile6.close();
	outfile7.close();
	outfile8.close();
	outfile9.close();
}

bool CStorage::readalllabelsfromfile(CString infilepath)
{
	using namespace std;
	ifstream listfile(infilepath);
	string tempstr;
	CString ctempstr;
	int serial = 0;
	int classnum = 0;
	int postion = 0;

	getline(listfile,tempstr);
	while (getline(listfile,tempstr))
	{
		ctempstr = tempstr.c_str();
		if (ctempstr.Find(" ") > 0)
		{
			numofoneclass[classnum] = postion;
			classnum++;
			postion = 0;
			continue;
		}
		allclassobjectmembers[classnum][postion] = serial;
		postion++;
		serial++;

	}
	numofoneclass[classnum] = postion;
	listfile.close();

	//ofstream tempfile("test.txt");
	//int i,j;
	//int sum = 0;
	//for (i=0;i<90;i++)
	//{
	//	tempfile<<" begin"<<numofoneclass[i]<<endl;
	//       sum += numofoneclass[i];
	//	for (j=0;j<numofoneclass[i];j++)
	//	{
	//		tempfile<<allclassobjectmembers[i][j]<<endl;

	//	}
	//}
	//tempfile<<sum<<endl;
	//tempfile.close();

	//using namespace std;
	//ifstream listfile(infilepath);
	//string tempstr;
	//CString ctempstr;
	//int serial = 0;
	////int temptag;
	//getline(listfile,tempstr);
	//while (getline(listfile,tempstr))
	//{
	//	ctempstr = tempstr.c_str();
	//	if (ctempstr.Find(" ") > 0)
	//	{
	//		modelinclassnumber.push_back(int(oneclassvector.size()));
	//		allclassvector.push_back(oneclassvector);
	//		oneclassvector.clear();
	//		continue;
	//	}
	//	oneclassvector.push_back(serial);
	//	serial++;

	//}
	//modelinclassnumber.push_back(int(oneclassvector.size()));
	//allclassvector.push_back(oneclassvector);
	//oneclassvector.clear();
	//listfile.close();

	//totalmodelnumber = serial;
	//totalclassnumber = int(allclassvector.size());

	//ofstream tempfile("test.txt");
	//int i,j;
	//for (i=0;i<90;i++)
	//{
	//	for (j=0;j<modelinclassnumber[i];j++)
	//	{
	//		tempfile<<allclassvector[i][j]<<" ";
	//	}
 //       tempfile<<endl;
	//	//int j = modelinclassnumber[i];
	//}

	return true;
}

bool CStorage::readallfeaturesfromfile(CString infilepath)
{
	using namespace std;
	ifstream listfile(infilepath);
	string tempstr;
	CString Ctempstr,tfeature;
	int serial,pos,i;
	for(serial=0;serial<OBJECTNUMBER;serial++)
	{
		getline(listfile,tempstr);
		Ctempstr = tempstr.c_str();
		for (i = 0; i < FEATHERLENTH; i++)
		{
			pos = Ctempstr.Find(" ");
			tfeature = Ctempstr.Left(pos);
			originfeaturesmatrix[serial][i] = atof(tfeature);
			Ctempstr.Delete(0,pos+1);

		}

	}
	listfile.close();

	//using namespace std;
	//ifstream listfile(infilepath);
	//string tempstr;
	//CString Ctempstr,tfeature;
	//int serial,pos,i;
	//for(serial=0;serial<totalmodelnumber;serial++)
	//{
	//	getline(listfile,tempstr);
	//	Ctempstr = tempstr.c_str();
	//	for (i = 0; i < FEATHERLENTH; i++)
	//	{
	//		pos = Ctempstr.Find(" ");
	//		tfeature = Ctempstr.Left(pos);
	//		originfeaturesmatrix[serial][i] = atof(tfeature);
	//		Ctempstr.Delete(0,pos+1);

	//	}

	//}
	//listfile.close();

	//ofstream tempfile("test.txt");
	//for (serial=0;serial<totalmodelnumber;serial++)
	//{
	//	for (i=0;i<FEATHERLENTH;i++)
	//	{
	//		tempfile<<originfeaturesmatrix[serial][i]<<" ";
	//	}
	//	tempfile<<endl;
	//}

	return true;
}

bool CStorage::initvariables(void)
{
	//origindistancevector = new double[totalmodelnumber];
	//newdistancevector = new double[totalmodelnumber];

	//originfeaturesmatrix = new double*[totalmodelnumber];
	//newfeaturesmatrix = new double*[totalmodelnumber];

	//int i;

	//for (i=0;i<totalmodelnumber;i++)
	//{
	//	originfeaturesmatrix[i] = new double[FEATHERLENTH];
	//}
	//for (i=0;i<totalmodelnumber;i++)
	//{
	//	newfeaturesmatrix[i] = new double[90];
	//}

	return true;
}

bool CStorage::computedistance(int modelnumber)
{
	using namespace std;
	int i,j;
	double distancetemp;
	for (i=0;i<OBJECTNUMBER;i++)
	{
		distancetemp = 0;
		for (j=0;j<FEATHERLENTH;j++)
		{
			distancetemp += (originfeaturesmatrix[i][j] - originfeaturesmatrix[modelnumber][j])*(originfeaturesmatrix[i][j] - originfeaturesmatrix[modelnumber][j]);
		}
		distancetrans[i] = distancetemp;
	}

	//ofstream tempfile("test.txt");
	//for (i=0;i<OBJECTNUMBER;i++)
	//{
	//	tempfile<<distancetrans[i]<<endl;
	//}

	//distancemap.clear();
	//int i,j;
	//double distance;
	//std::vector<int> templabelvector;
	//for (i=0;i<totalmodelnumber;i++)
	//{
	//	distance = 0;
	//	for (j=0;j<FEATHERLENTH;j++)
	//	{
	//		//distance += fabs(originfeaturesmatrix[i][j] - originfeaturesmatrix[modelnumber][j]);
	//		distance += (originfeaturesmatrix[i][j] - originfeaturesmatrix[modelnumber][j])*(originfeaturesmatrix[i][j] - originfeaturesmatrix[modelnumber][j]);

	//	}

	//		outfile0<<distance<<std::endl;
	//		//写入文件
 //           //////////////////////////////////////////////////////////////////////////
	//		//////////////////////////////////////////////////////////////////////////

 //       if (( iterdistance = distancemap.find(distance) ) == distancemap.end())
 //       {
	//		templabelvector.clear();
	//		templabelvector.push_back(i);
	//		distancemap.insert(std::pair<double,std::vector<int> >(distance,templabelvector));
 //       }
	//	else
	//	{
	//		iterdistance->second.push_back(i);
	//	}

	//}

	//std::ofstream tempfile("test.txt");
	//iterdistance = distancemap.begin();
	//for (i=0;i<899;i++)
	//{
	//	if ( iterdistance->second.size() > 1)
	//	{
	//		tempfile<<i<<" "<<iterdistance->second.size()<<std::endl;
	//	}
	//	iterdistance++;

	//}
	//int sizetemp = distancemap.size();

	return true;
}

bool CStorage::labelretrieval(int currentclass)
{
	int i,j;
	int tempmin;
	double tempdistance;
	for (i=0;i<RETURNBACKNUM;i++)
	{
		tempdistance = 9999999999;
		for (j=0;j<OBJECTNUMBER;j++)
		{
			//if (distancetrans[j] < 0)continue;
			if (distancetrans[j] < tempdistance)
			{
				tempdistance = distancetrans[j];
				tempmin = j;
			}

		}
		distancetrans[tempmin] = 9999999999;
		nearestobjects[i] = tempmin;

	}

	for (i=0;i<RETURNBACKNUM;i++)
	{
		//判断是否被标注过
		for (j=0;j<pandnnum;j++)
		{
			if(pandnobjects[j] == nearestobjects[i])break;
		}
		if(j<pandnnum)continue;

		for (j=0;j<numofoneclass[currentclass];j++)
		{
			if (allclassobjectmembers[currentclass][j] == nearestobjects[i])break;

		}
		if (j<numofoneclass[currentclass])
		{
			positiveobjects[positivenum] = nearestobjects[i];
			positivenum++;
		}
		else
		{
			negativeobjects[negativenum] = nearestobjects[i];
			negativenum++;
		}
	}

	pandnnum = positivenum + negativenum;
	for (i=0;i<positivenum;i++)
	{
		pandnobjects[i] = positiveobjects[i];

	}
	j=0;
	for (;i<pandnnum;i++)
	{
		pandnobjects[i] = negativeobjects[j];
		j++;
	}

 //   iterdistance = distancemap.begin();
	//int i,j,k;
	//int rankmodel;
	////struct modellabel templabel;
	//for (i=0;i<labelnumber;)
	//{

	//	for (j=0; j < int(iterdistance->second.size());j++)//遍历最靠前的模型
	//	{
	//		rankmodel = iterdistance->second[j];
	//		//for (l=0;l<labelvector.size();l++)//判断是否标注过
	//		//{
	//		//	if (labelvector[l].modelnumber == rankmodel)break;
	//		//}

	//		//if(l<labelvector.size())
	//		//{
	//		//	i++;
	//		//	break;//已经被标注过
	//		//}
 //           if (labelvector.find(rankmodel) != labelvector.end())//已经标注
 //           {
	//			i++;
	//			break;
 //           }

	//		for (k=0;k<modelinclassnumber[currentclass];k++)//判断是否在类内
	//		{
	//			if(allclassvector[currentclass][k] == rankmodel)break;

	//		}
	//		if (k<modelinclassnumber[currentclass])//在类内
	//		{
 //      //            templabel.modelnumber = rankmodel;
	//			   //templabel.label = 1;
	//			labelvector.insert(std::pair<int,int>(rankmodel,1));
	//			   labelvectorpositive.push_back(rankmodel);
	//			   i++;
	//		}
	//		else//在类外
	//		{
	//			//templabel.modelnumber =rankmodel;
	//			//templabel.label = -1;
	//			labelvector.insert(std::pair<int,int>(rankmodel,-1));
	//			labelvectornegative.push_back(rankmodel);
	//			i++;

	//		}
	//		
	//	}
	//	iterdistance++;
	//}

	//std::ofstream tempfile("test.txt");
	//for (i=0;i<21;i++)
	//{
	//	tempfile<<labelvector[i].modelnumber<<" "<<labelvector[i].label<<std::endl;
	//}

	//int sizetemp = labelvector.size();
	//int sizetempi = labelvectorpositive.size();
	//int sizetempii = labelvectornegative.size();

	return true;
}

bool CStorage::computenewfeaturematrix()
{
	int i,j,k;
	double sumtemp;
	for (i=0;i<OBJECTNUMBER;i++)
	{
		for (j=0;j<90;j++)
		{
			sumtemp = 0;
			for (k=0;k<FEATHERLENTH;k++)
			{
				sumtemp += trans[j][k]*originfeaturesmatrix[i][k];

			}
			newfeaturesmatrix[i][j] = sumtemp;

		}
	}

	//std::ofstream tempfile("test.txt");
	//for (i=0;i<907;i++)
	//{
	//	for (j=0;j<300;j++)
	//	{
	//		tempfile<<j<<":"<<newfeaturesmatrix[i][j]<<" ";
	//	}
	//	tempfile<<std::endl;
	//}
	return true;
}

bool CStorage::computedistancenew(int modelnumber)
{
	//distancemap.clear();
	int i,j;
	double distance;
	//std::vector<int> templabelvector;
	for (i=0;i<OBJECTNUMBER;i++)
	{
		distance = 0;
		for (j=0;j<90;j++)
		{
			//distance += fabs(newfeaturesmatrix[i][j] - newfeaturesmatrix[modelnumber][j]);
			distance += (newfeaturesmatrix[i][j] - newfeaturesmatrix[modelnumber][j])*(newfeaturesmatrix[i][j] - newfeaturesmatrix[modelnumber][j]);

		}
        distancetrans[i] = distance;

		if (round == 0)
		{
			outfile0<<distance<<std::endl;
		}
		else if(round == 1)
		{
			outfile1<<distance<<std::endl;

		}
		else if(round == 2)
		{
			outfile2<<distance<<std::endl;

		}
		else if(round == 3)
		{
			outfile3<<distance<<std::endl;

		}
		else if(round == 4)
		{
			outfile4<<distance<<std::endl;

		}
		else if(round == 5)
		{
			outfile5<<distance<<std::endl;

		}
		else if(round == 6)
		{
			outfile6<<distance<<std::endl;

		}
		else if(round == 7)
		{
			outfile7<<distance<<std::endl;

		}
		else if(round == 8)
		{
			outfile8<<distance<<std::endl;

		}
		else if(round == 9)
		{
			outfile9<<distance<<std::endl;

		}

		//if (( iterdistance = distancemap.find(distance) ) == distancemap.end())
		//{
		//	templabelvector.clear();
		//	templabelvector.push_back(i);
		//	distancemap.insert(std::pair<double,std::vector<int> >(distance,templabelvector));
		//}
		//else
		//{
		//	iterdistance->second.push_back(i);
		//}

	}


	return true;
}