featureselection.cpp

线形判别分析算法和knn最近邻算法的实现

// FeatureSelection.cpp: implementation of the FeatureSelection class.
// Huscar's Feature Extraction Class
//////////////////////////////////////////////////////////////////////
#include "FeatureSelection.h"
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

FeatureSelection::FeatureSelection()
{

}

FeatureSelection::~FeatureSelection()
{

}

int FeatureSelection::OpenSampleFile(string file)
{
   in_stream.open(file.c_str());
   if(in_stream.fail())
   {
      cout << "Can't open this file" <<endl;
	  exit (1);
   }
   in_stream >> samp_num;
   trainingGroup.clear();
   testGroup.clear();
   return 0;
}

//Read the bitgraph from file
int FeatureSelection::PreOperation()
{
  char temp;
  int j;
  characVector.push_back(1);
  for(int i=0;i < ROWDIMENSION; i++ )
  {
	  bitMap.push_back(vector < int >());
      for(j=0;j < COLUMNDIMENSION; j++ )
	  {
	    in_stream >> temp;
        bitMap[i].push_back(temp-'0');  
	  }

  }
  return 0;
}
//Extract overlap features
int FeatureSelection::OverlapFeatureSelection()
{
   //Operate to 25 subfields
   ofstream out;
   int subFieldStartRow =0 ;
   int subFieldStartColumn =0;
   int abscissa;
   int ordinate;
   int value;
   //out.open("out.txt");
   while((subFieldStartRow) <= ROWDIMENSION - SUBFIELDIMENSION)
   {
	 subFieldStartColumn = 0;
	 while((subFieldStartColumn) <= COLUMNDIMENSION - SUBFIELDIMENSION)
     {
		value = 0;
        for(int i=0;i<SUBFIELDIMENSION; i++)
		{
           abscissa = subFieldStartRow+i;
	       for (int j=0; j<SUBFIELDIMENSION; j++)
		   {
		      ordinate = subFieldStartColumn+j;
			 // out << bitMap[abscissa][ordinate];
			  if(bitMap[abscissa][ordinate])
				 value ++;
		   }
		   out <<endl;
		}
		characVector.push_back((double) value);
		out <<value<<'\n'<<'\n';
	    subFieldStartColumn += SUBFIELDIMENSION - OVERLAPLEN ;
	 }
	 subFieldStartRow +=SUBFIELDIMENSION - OVERLAPLEN;
   }
//   for(int i=0; i<(int)characVector.size();i++)
//   {
//      cout <<characVector[i]<<"  ";
//   }
   return 0;
}

double FeatureSelection::LengthWidthFeatureSelection()
{
    //Extract length&&width feature
	int i;
	int j;
    for(i=0; i<ROWDIMENSION ;i++)
	{
		for(j=0;j<COLUMNDIMENSION; j++)
		{
		   if(bitMap[i][j])
		   {
               startRow = i;
			   break;
		   }
		}
		if(j == ROWDIMENSION) continue;
		if(bitMap[i][j])
		{
		   break;
		}
	}
	for(i =ROWDIMENSION-1;i>=0 ; i-- )
	{
		for(j=0;j<COLUMNDIMENSION; j++)
		{
		   if(bitMap[i][j])
		   {
               destRow = i;
			   break;
		   }
		}
		if(j == ROWDIMENSION) continue;
		if(bitMap[i][j])
		{
		    break;
		}
	}
    for(i = 0; i<COLUMNDIMENSION ;i++)
	{
		for(j=0;j<ROWDIMENSION; j++)
		{
		   if(bitMap[j][i])
		   {
               startColumn = i;
			   break;
		   }
		}
		if(j == ROWDIMENSION) continue;
		if(bitMap[j][i])
		{
		   break;
		}
	}
	for(i =COLUMNDIMENSION-1;i>=0 ; i-- )
	{
		for(j=0;j<ROWDIMENSION; j++)
		{
		   if(bitMap[j][i])
		   {
               destColumn = i;
			   break;
		   }
		}
		if(j == ROWDIMENSION) continue;
		if(bitMap[j][i])
		{
		    break;
		}
	}
    double result_feature 
		   =double(destRow - startRow+1)/double(destColumn - startColumn+1);
//	cout << result_feature << " ";
    characVector.push_back(result_feature);
	return result_feature;
}

double FeatureSelection::PixRatioFeatureSelection()
{
   int i,j,value=0;
   for(i = startRow; i <=destRow ;i++ )
   {
	   for(j = startColumn; j<= destColumn; j++ )
		   if (bitMap[i][j])
			   value++;
   }
   double result_feature 
	      =double(value)/double((destRow - startRow+1)*(destColumn - startColumn+1));
//   cout << result_feature ;
   characVector.push_back(result_feature);
   return result_feature;
}

int FeatureSelection::CharacVectorGeneration()
{
   int i = 0;
   //Generate training samples' feature
   for(i=0;i<TRAININGNUM;i++)
	{
       PreOperation();
       OverlapFeatureSelection();
       LengthWidthFeatureSelection();
       PixRatioFeatureSelection();
       bitMap.clear();
       trainingGroup.push_back(characVector);
       characVector.clear();
	}
	//Generate testing samples' feature
    for(i=0;i<TESTNUM;i++)
	{
       PreOperation();
       OverlapFeatureSelection();
       LengthWidthFeatureSelection();
       PixRatioFeatureSelection();
       bitMap.clear();
       testGroup.push_back(characVector);
       characVector.clear();
	}
    in_stream.close();
	return 0;
}