simplega.cpp

遗传算法(图像处理)

// SimpleGA.cpp: implementation of the CSimpleGA class.
//
//////////////////////////////////////////////////////////////////////

#include "SimpleGA.h"
#include "ProjectHead.h"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CSimpleGA::CSimpleGA()
{
	m_lMutationTimes=0;	m_lMatingTimes=0;
	m_dSumFitness=0.0;m_dMaxFitness=0.0;m_iMaxLocation=0;
	m_count=0;
	m_nowp=0;
	m_position=0;
	last_maxfitness=0.0;

}

/********************************************************/
/*                MATING POOL INITIAL                   */
/*                交配池初始化函数                      */
/*********************************************************/
void CSimpleGA::Initial(int pop_size,double mutation_p,double crossing_p)
{
  int  i;
  m_iPopuSize=pop_size;
  m_dMutationP=mutation_p;m_dCrossingP=crossing_p;
  m_lpParents=(CGAUnite *)malloc(sizeof(CGAUnite)*m_iPopuSize);
  if(m_lpParents==NULL) 
  {
	  cout<<"内存空间分配失败！"<<endl;
	  exit(0);
  }
  m_lpFilials=(CGAUnite *)malloc(sizeof(CGAUnite)*m_iPopuSize);
  if(m_lpFilials==NULL)
  {
	  cout<<"内存空间分配失败！"<<endl;
	  free(m_lpParents);
	  exit(0);
  }
  for(i=0;i<m_iPopuSize;i++)
  {
	  m_lpParents[i].Initial();
	  m_lpParents[i].FitnessFunction();
	  m_lpFilials[i]=m_lpParents[i];
  }
  return;
}

/********************************************************/
/*                STATISTIC FUNCTION                   */
/*                交配池统计函数                        */
/*********************************************************/
CSimpleGA::Statistic()
{
 int i,max_l;
 double sum1,max_f;
 sum1=0.0;max_f=0.0;max_l=0;
 for(i=0;i<m_iPopuSize;i++)
 {
 	 sum1=sum1+m_lpParents[i].m_dFitness;
	 if(m_lpParents[i].m_dFitness>max_f) 
	 {

		 max_f=m_lpParents[i].m_dFitness;
		 max_l=i;
	 } 
 }
 m_dSumFitness=sum1;m_dMaxFitness=max_f;m_iMaxLocation=max_l;
 m_dAverageFitness=sum1/(double)m_iPopuSize;
 return 1;
}

/********************************************************/
/*                SELECTION FUNCTION                   */
/*                  个体选择函数                        */
/*********************************************************/
int CSimpleGA::Selection()
{ 
  double rand1,partsum;
  int j;
  partsum=0.0;j=0;
  rand1=(double)rand()/(double)RAND_MAX;
  rand1=rand1*fabs(m_dSumFitness);
  while((partsum<rand1)&&(j<m_iPopuSize))
	{ partsum=partsum+fabs(m_lpParents[j].m_dFitness);j++;}
  return(j);
}
///////////////////////////////////////////////////////
//               FLIP FUNCTION                      //
//               FLIP 实验函数                       //
///////////////////////////////////////////////////////

int CSimpleGA::Flip(double probability)
{   
	double probability_f;     
    // srand((unsigned)time(NULL));
	 probability_f=(double)rand()/(double)(RAND_MAX);
	 if ( probability_f<=probability) return(1);
	 else return(0);
}
///////////////////////////////////////////////////////
//               MUTATION FUNCTION                  //
//                     变异函数                      //
///////////////////////////////////////////////////////
int CSimpleGA::Mutation(unsigned int loca)
{    
	 int mutate;
     mutate=Flip(m_dMutationP);
     if(mutate==1)
	 {   
		 m_lMutationTimes=m_lMutationTimes+1;
		 if(loca==1) loca=0;
		 else loca=1;
	 }
     if(loca==1) return(1);
	else return(0);
}
///////////////////////////////////////////////////////
//                 MATING FUNCTION                  //
//                     杂交函数                      //
///////////////////////////////////////////////////////
int CSimpleGA::Mating(unsigned int *parent1_chain1,unsigned int *parent1_chain2,
				  	  unsigned int *parent2_chain1,unsigned int *parent2_chain2,
					  int k5)
{  
	int j;
    if(Flip(m_dCrossingP)==1)
	 {  
		m_lMatingTimes=m_lMatingTimes+1;
	    for(j=0;j<GEN_LENGTH;j++)
	    {
		m_lpFilials[k5].m_uGenChainA[j]=Mutation(parent1_chain1[j]);
		m_lpFilials[k5].m_uGenChainB[j]=Mutation(parent2_chain2[j]);
		m_lpFilials[k5+1].m_uGenChainA[j]=Mutation(parent2_chain1[j]);
		m_lpFilials[k5+1].m_uGenChainB[j]=Mutation(parent1_chain2[j]);
	     }
	 }
	else
	{
		for(j=0;j<GEN_LENGTH;j++)
		{ 
		 m_lpFilials[k5].m_uGenChainA[j]=Mutation(parent1_chain1[j]);
	     m_lpFilials[k5].m_uGenChainA[j]=Mutation(parent1_chain2[j]);
	     m_lpFilials[k5+1].m_uGenChainA[j]=Mutation(parent2_chain1[j]);
	     m_lpFilials[k5+1].m_uGenChainA[j]=Mutation(parent2_chain2[j]);
		}
    }
   return(1);
}
/********************************************************/
/*                GENERATION FUNCTION                   */
/*                  子代产生函数                        */
/*********************************************************/
void CSimpleGA::Generation(void)
{  
   unsigned int mate1,mate2;
   int j;
   j=0;
   while(j<m_iPopuSize)
   {  
	 mate1=Selection();
	 mate2=Selection();
	 Mating(m_lpParents[mate1].m_uGenChainA,
		    m_lpParents[mate1].m_uGenChainB,
		    m_lpParents[mate2].m_uGenChainA,
			m_lpParents[mate2].m_uGenChainB,j);
	 m_lpFilials[j].FitnessFunction();
	 m_lpFilials[j+1].FitnessFunction();
	 j=j+2;
    }
   return;
}

/********************************************************/
/*                NEXT GENERATION                       */
/*      下一代子代产生的准备函数：父代、子代一致函数    */
/*********************************************************/
void CSimpleGA::NextGeneration()
{
	int i;
	for(i=0;i<m_iPopuSize;i++) 
		m_lpParents[i]=m_lpFilials[i];
 return;
 }


void CSimpleGA::ReportGeneration(void)
{
	int i;
	//cout<<endl;
	m_position++;
	if(m_dMaxFitness>last_maxfitness)
	{
		m_count=0;
		m_nowp=m_position;
		last_maxfitness=m_dMaxFitness;
	}
	else
		m_count++;
	cout<< "现在稳定在：";
	cout<< m_nowp;
	cout<<endl;
//	cout<<"gen   chain1:  ";
//	for(i=GEN_LENGTH-1;i>=0;i--)
//	cout<<m_lpParents[m_iMaxLocation].m_uGenChainA[i];
//	cout<<endl;

//	cout<<"gen   chain2:  ";
//	for(i=GEN_LENGTH-1;i>=0;i--)
//	cout<<m_lpParents[m_iMaxLocation].m_uGenChainB[i];
//	cout<<endl;
    
//	cout<<"decode chain:  ";
//	for(i=GEN_LENGTH-1;i>=0;i--)
//	cout<<m_lpParents[m_iMaxLocation].m_uDecodeChain[i];
//	cout<<endl;
//
//	cout<<"Parameters Are:"<<endl;
//	for(i=N_PARAMETER-1;i>=0;i--)
//	cout<<"x["<<i<<"]="<<m_lpParents[m_iMaxLocation].m_dDecValue[i]<<endl;
//	cout<<"Max Population Location Is:  "<<m_iMaxLocation<<endl;
  //  cout<<"Max Fitness="<<m_lpParents[m_iMaxLocation].m_dFitness<<endl;
	cout<<"Max Fitness="<<m_dMaxFitness<<endl;
//	cout<<"Average Fitness= "<<m_dAverageFitness<<endl;
//	cout<<"Population MutationTimes Is:  "<<m_lMutationTimes<<endl;
//	cout<<"Population MatingTimes Is:  "<<m_lMatingTimes<<endl;
//	cout<<"Population Affinity Is:   "<<m_dAffinity<<endl;
//	cout<<"m_dCrossingP="<<m_dCrossingP<<"; "<<"m_dMutationP="<<m_dMutationP<<endl;
	return;	
}

void CSimpleGA::FreeSpace()
{
		free(m_lpParents);
	    free(m_lpFilials);
		return;
}

CSimpleGA::~CSimpleGA()
{
}

void CSimpleGA::CalcuAffinity()
{
	double sum1,sum2;
	int i,j,k;
	sum2=0.0;
   for(i=0;i<m_iPopuSize;i++)
   {   sum1=0.0;
	   for(j=0;j<m_iPopuSize;j++)
		{
		   if(i!=j)
		   {
				for(k=0;k<GEN_LENGTH;k++)
				{
					if(m_lpParents[i].m_uDecodeChain[k]!=m_lpParents[j].m_uDecodeChain[k])
					sum1=sum1+1.0;
				}
		   }
	   }
	   sum2=sum2+sum1/(double)GEN_LENGTH/(double)m_iPopuSize;
   }
   m_dAffinity=sum2/(double)m_iPopuSize;
   return;
}

int CSimpleGA::SaveDate(LPCTSTR filename,char if_rewrite)
{
	FILE *fp;
	if(if_rewrite=='r')
		fp=fopen(filename,"w+b");
	else
	{
		fp=fopen(filename,"r+b");
		if(fp==NULL) fp=fopen(filename,"w+");
	}
	if(fp==NULL) return -1;
	fseek(fp,0,SEEK_END);
	fwrite(&m_dMaxFitness,sizeof(double),1,fp);
	fwrite(&m_dAverageFitness,sizeof(double),1,fp);
	fwrite(&m_dAffinity,sizeof(double),1,fp);
	fclose(fp);
	return 1;
}

int CSimpleGA::SaveCount(LPCTSTR filename,int count)
{
	FILE *fp;
	fp=fopen(filename,"w+b");
	if(fp==NULL) return -1;
	fwrite(&count,sizeof(int),1,fp);
	fclose(fp);
	return 1;
}