omlib.cpp

图像处理软件,功能比较基础

			}
		}
	
		
		{
			AfxMessageBox (" 输入图象格式不正确！");				
			return NULL;
		}
}

BOOL Fit_itself(Picture input,Picture output)
{
 int Sum=0;
 float D,R,C,Exp,Variances,Threshold,Temp=0;
 

 
//============计算期望E========== 
 for (int Row=0;Row<input.row;Row++)
	 for (int Col=0;Col<input.col;Col++)
		  {
	       Sum+=input.p[Row][Col];
		   }
   Exp=(float)Sum/(input.col*input.row);


//============计算方差Variances===========
   for (int iRow=0;iRow<input.row;iRow++)
	   for (int Col=0;Col<input.col;Col++)
	   {   
		   Temp+=((input.p[iRow][Col]-Exp)*(input.p[iRow][Col]-Exp));
	   }
   Variances=(float)sqrt(Temp/(input.col*input.row));
   
//======确定R========
if (Exp<13)
      R=(float)0.7;
else if (Exp<=22)
      R=(float)0.8;     
else  R=(float)1.0 ;    
//=======确定C==============   
   if (Variances<9)
	     C=4;

   else if (Variances>=9&&Variances<13.5)
	     C=1;

   else  C=-1;
//========计算梯度D===========
for (int i=1;i<input.row;i++)
 for (int j=1;j<input.col;j++)
 {
	 D=(float)((2*input.p[i][j]-input.p[i-1][j]-input.p[i][j-1])/2);
//========计算门限============
   Threshold=-C*D+R*Exp;
   if (input.p[i][j]>=Threshold)
	   output.p[i][j]=255;
    else output.p[i][j]=0;
 }
   return TRUE;
}

HistogramEqualization(Picture input,Picture output)
{
	float iGray[256];
	int gray[256];
	int sum=0;
	for(int i=0;i<256;i++)
	{
		gray[i]=0;
		iGray[i]=0;
	}
	for(i=0;i<input.row;i++)
       for(int j=0;j<input.col;j++)
           gray[input.p[i][j]]++;
	   sum=input.col*input.row;
  for(i=0;i<256;i++)
      iGray[i]=(float)gray[i]/(float)sum;        //求各灰度的比率
  for(i=0;i<255;i++)
      iGray[i+1]+=iGray[i];
  for(i=0;i<256;i++)
      iGray[i]=(float)(255*iGray[i]+0.5);
  for(i=0;i<input.row;i++)
       for(int j=0;j<input.col;j++)
           output.p[i][j]=(unsigned char)iGray[input.p[i][j]];
	   return TRUE;
}
BOOL Ostu(Picture oldpic,Picture dealpic)
{
 BYTE threshold;                                 //门限
 float u0=0,u1=0;                                //类内均值
 float w0=0,w1=0;                                //类概率
 float equ=0,max=0;                              //类间方差
 int sum=oldpic.col*oldpic.row;                         //总象素个数
 int gray[256];
 float percent[256];

 for(int i=0;i<256;i++)
 {
   gray[i]=0;percent[i]=0;
 }
 for(i=0;i<oldpic.row;i++)
	 for(int j=0;j<oldpic.col;j++)
		 gray[oldpic.p[i][j]]++;
	 for(i=0;i<256;i++)                       //计算各灰度级的比率
		 percent[i]=(float)gray[i]/(float)sum;
	 for(i=0;i<256;i++)
	 {
		 for(int j=0;j<i;j++)		   
		 {
		   u0+=percent[j]*j;w0+=percent[j];
		 }
		 for(j=i;j<256;j++)
		 {
			 u1+=percent[j]*j;w1+=percent[j];
		 }
		 if(w0!=0&&w1!=0)
			 equ=w0*w1*(u1/w1-u0/w0)*(u1/w1-u0/w0);
		 if(equ>max)
		 {
			 threshold=i;max=equ;
		 }
		 u0=u1=w0=w1=0;
	 }
	 for(i=0;i<oldpic.row;i++)
		 for(int j=0;j<oldpic.col;j++)
		 {
			 if(oldpic.p[i][j]<threshold) dealpic.p[i][j]=0;
			 else  dealpic.p[i][j]=255;
		 }
		 return FALSE;		 
}

BOOL Fourier(Picture input,complex **cData)
{	
	int iWidth,iHeight;
	iWidth=input.col;
	iHeight=input.row;
	complex *w=NULL;                          //变换核
 double arg,w_real,w_imag,wrecur_real,wrecur_imag,wtemp_real; //变换核用的临时变量序列
 complex *list;                                      //取一行序列用
 int length=0;                              //记录一行序列的长度
 complex *xi,*xip,*xj,*wptr;
 int le,step,trans;
 int rank;                                   //蝶形运算的次数
 complex temp,u,tm;
 complex **turn;

 length=iWidth;
 arg=log(iWidth)/log(2.0);
 rank=(int) arg;

 le=length/2;
 w=new complex[le-1];                                    //计算变换核,w0不记
 arg=4.0*atan(1.0)/le;
 wrecur_real=w_real=cos(arg);
 wrecur_imag=w_imag=-sin(arg);
 xj=w;
 for(int x=1;x<le;x++)
 {
     xj->real=(float) wrecur_real;
     xj->imag=(float) wrecur_imag;
     xj++;
     wtemp_real=wrecur_real*w_real-wrecur_imag*w_imag;
     wrecur_imag=wrecur_real*w_imag+wrecur_imag*w_real;
     wrecur_real=wtemp_real;
 }

 for(int i=0;i<iHeight;i++)
 {
     list=cData[i];                                           //读出第一行数据

     le=length;
     step=1;              //每一级蝶形运算所用变换核的间隔
     for(int j=0;j<rank;j++)                 //叠代运算的次数
     {
         le=le/2;
         for(int x=0;x<length;x=x+2*le)  //first iteration with no multiplies
         {
                xi=list+x;
                xip=xi+le;
                temp.real=xi->real+xip->real;
                temp.imag=xi->imag+xip->imag;
                xip->real=xi->real-xip->real;
                xip->imag=xi->imag-xip->imag;
                *xi=temp;
         }
         wptr=w+step-1;                    //找W
         for(x=1;x<le;x++)
         {
                u=*wptr;
                for(int y=x;y<length;y=y+2*le)
                {
                       xi=list+y;
                       xip=xi+le;
                       temp.real=xi->real+xip->real;
                       temp.imag=xi->imag+xip->imag;
                       tm.real=xi->real-xip->real;
                       tm.imag=xi->imag-xip->imag;
                       xip->real=tm.real*u.real-tm.imag*u.imag;
                       xip->imag=tm.real*u.imag+tm.imag*u.real;
                       *xi=temp;
                }
                wptr=wptr+step;
         }
         step=2*step;
     }
     for(int x=0;x<length;x++)
     {
        trans=0;
        for(int y=0;y<rank;++y)
            trans=(trans<<1)|(1&(x>>y));
        if(x<trans)
        {
           xi=list+x;
           xj=list+trans;
           temp=*xj;
           *xj=*xi;
           *xi=temp;
        }
     }
 }
 if(w!=NULL) delete [] w;
 w=NULL;
//----------------------------------------------------------------------------
//将矩阵翻转重新计算!
 turn=new complex*[iWidth];                            //初始化翻转矩阵 ,注意不是转置
 for(i=0;i<iWidth;i++)
     turn[i]=new complex[iHeight];

 for(i=0;i<iHeight;i++)
    for(int j=0;j<iWidth;j++)
        turn[j][i]=cData[i][j];

 length=iHeight;
 arg=log(iHeight)/log(2.0);
 rank=(int) arg;

 le=length/2;
 w=new complex[le-1];                 //计算变换核,w0不记
 arg=4.0*atan(1.0)/le;
 wrecur_real=w_real=cos(arg);
 wrecur_imag=w_imag=-sin(arg);
 xj=w;
 for(x=1;x<le;x++)
 {
     xj->real=(float) wrecur_real;
     xj->imag=(float) wrecur_imag;
     xj++;
     wtemp_real=wrecur_real*w_real-wrecur_imag*w_imag;
     wrecur_imag=wrecur_real*w_imag+wrecur_imag*w_real;
     wrecur_real=wtemp_real;
 }

 for(i=0;i<iWidth;i++)
 {
     list=turn[i];

     le=length;
     step=1;              //每一级蝶形运算所用变换核的间隔
     for(int j=0;j<rank;j++)
     {
         le=le/2;
         for(int x=0;x<length;x=x+2*le)  //first iteration with no multiplies
         {
                xi=list+x;
                xip=xi+le;
                temp.real=xi->real+xip->real;
                temp.imag=xi->imag+xip->imag;
                xip->real=xi->real-xip->real;
                xip->imag=xi->imag-xip->imag;
                *xi=temp;
         }
         wptr=w+step-1;                    //找W
         for(x=1;x<le;x++)
         {
                u=*wptr;
                for(int y=x;y<length;y=y+2*le)
                {
                       xi=list+y;
                       xip=xi+le;
                       temp.real=xi->real+xip->real;
                       temp.imag=xi->imag+xip->imag;
                       tm.real=xi->real-xip->real;
                       tm.imag=xi->imag-xip->imag;
                       xip->real=tm.real*u.real-tm.imag*u.imag;
                       xip->imag=tm.real*u.imag+tm.imag*u.real;
                       *xi=temp;
                }
                wptr=wptr+step;
         }
         step=2*step;
     }
     for(int x=0;x<length;x++)
     {
        trans=0;
        for(int y=0;y<rank;++y)
            trans=(trans<<1)|(1&(x>>y));
        if(x<trans)
        {
           xi=list+x;
           xj=list+trans;
           temp=*xj;
           *xj=*xi;
           *xi=temp;
        }
     }
 }
 if(w!=NULL) delete [] w;
 w=NULL;
//-----------------------------------------------------------------------------
//翻转回来!
 for(i=0;i<iHeight;i++)
    for(int j=0;j<iWidth;j++)
    {
       cData[i][j].real=turn[j][i].real;
       cData[i][j].imag=turn[j][i].imag;
    }
 if(turn!=NULL)
 {
     for(int i=0;i<iWidth;i++)
         delete [] turn[i];
     delete [] turn;
     turn=NULL;
 }

 return TRUE;
}
   


 
//反变换--------------------------------------------------------------------


BOOL IFFT(Picture oldpic,complex **cData)
{
	int iWidth,iHeight;
	iWidth=oldpic.col;
	iHeight=oldpic.row;
	complex *w=NULL;                          //变换核
 double arg,w_real,w_imag,wrecur_real,wrecur_imag,wtemp_real; //变换核用的临时变量序列
 complex *list;                                      //取一行序列用
 int length=0;                              //记录一行序列的长度
 complex *xi,*xip,*xj,*wptr;
 int le,step,trans;
 int rank;                                   //蝶形运算的次数
 complex temp,u,tm;
 complex **turn;

 length=iWidth;
 arg=log(iWidth)/log(2.0);
 rank=(int) arg;

 le=length/2;
 w=new complex[le-1];                                    //计算变换核,w0不记
 arg=4.0*atan(1.0)/le;
 wrecur_real=w_real=cos(arg);
 wrecur_imag=w_imag=sin(arg);
 xj=w;
 for(int x=1;x<le;x++)
 {
    xj->real=(float) wrecur_real;
    xj->imag=(float) wrecur_imag;
    xj++;
    wtemp_real=wrecur_real*w_real-wrecur_imag*w_imag;
    wrecur_imag=wrecur_real*w_imag+wrecur_imag*w_real;
    wrecur_real=wtemp_real;
 }

 for(int i=0;i<iHeight;i++)
 {
     list=cData[i];                                         //读出第一行数据
     le=length;
     step=1;              //每一级蝶形运算所用变换核的间隔
     for(int j=0;j<rank;j++)                 //叠代运算的次数
     {
         le=le/2;
         for(x=0;x<length;x=x+2*le)  //first iteration with no multiplies
         {
                xi=list+x;
                xip=xi+le;
                temp.real=xi->real+xip->real;
                temp.imag=xi->imag+xip->imag;
                xip->real=xi->real-xip->real;
                xip->imag=xi->imag-xip->imag;
                *xi=temp;
         }
         wptr=w+step-1;                    //找W
         for(x=1;x<le;x++)
         {
                u=*wptr;
                for(int y=x;y<length;y=y+2*le)
                {
                       xi=list+y;
                       xip=xi+le;
                       temp.real=xi->real+xip->real;
                       temp.imag=xi->imag+xip->imag;
                       tm.real=xi->real-xip->real;
                       tm.imag=xi->imag-xip->imag;
                       xip->real=tm.real*u.real-tm.imag*u.imag;
                       xip->imag=tm.real*u.imag+tm.imag*u.real;
                       *xi=temp;
                }
                wptr=wptr+step;
         }
         step=2*step;
     }
     for(x=0;x<length;x++)
     {
        trans=0;
        for(int y=0;y<rank;++y)
            trans=(trans<<1)|(1&(x>>y));
        if(x<trans)
        {
           xi=list+x;
           xj=list+trans;
           temp=*xj;
           *xj=*xi;
           *xi=temp;
        }
     }
 }
 if(w!=NULL) delete [] w;
 w=NULL;
//----------------------------------------------------------------------------
//将矩阵翻转重新计算!
 turn=new complex*[iWidth];                            //初始化翻转矩阵
 for(i=0;i<iWidth;i++)
     turn[i]=new complex[iHeight];

 for(i=0;i<iHeight;i++)
    for(int j=0;j<iWidth;j++)
        turn[j][i]=cData[i][j];

 length=iHeight;
 arg=log(iHeight)/log(2.0);
 rank=(int) arg;

 le=length/2;
 w=new complex[le-1];                 //计算变换核,w0不记
 arg=4.0*atan(1.0)/le;
 wrecur_real=w_real=cos(arg);
 wrecur_imag=w_imag=sin(arg);
 xj=w;
 for(x=1;x<le;x++)
 {
     xj->real=(float) wrecur_real;
     xj->imag=(float) wrecur_imag;
     xj++;
     wtemp_real=wrecur_real*w_real-wrecur_imag*w_imag;
     wrecur_imag=wrecur_real*w_imag+wrecur_imag*w_real;
     wrecur_real=wtemp_real;
 }

 for(i=0;i<iWidth;i++)
 {
     list=turn[i];
     le=length;
     step=1;              //每一级蝶形运算所用变换核的间隔
     for(int j=0;j<rank;j++)
     {
         le=le/2;
         for(int x=0;x<length;x=x+2*le)  //first iteration with no multiplies
         {
                xi=list+x;
                xip=xi+le;
                temp.real=xi->real+xip->real;
                temp.imag=xi->imag+xip->imag;
                xip->real=xi->real-xip->real;
                xip->imag=xi->imag-xip->imag;
                *xi=temp;
         }
         wptr=w+step-1;                    //找W
         for(x=1;x<le;x++)
         {
                u=*wptr;
                for(int y=x;y<length;y=y+2*le)
                {
                       xi=list+y;
                       xip=xi+le;
                       temp.real=xi->real+xip->real;
                       temp.imag=xi->imag+xip->imag;
                       tm.real=xi->real-xip->real;
                       tm.imag=xi->imag-xip->imag;
                       xip->real=tm.real*u.real-tm.imag*u.imag;
                       xip->imag=tm.real*u.imag+tm.imag*u.real;
                       *xi=temp;
                }
                wptr=wptr+step;
         }
         step=2*step;
     }
     for(x=0;x<length;x++)
     {
        trans=0;
        for(int y=0;y<rank;++y)
            trans=(trans<<1)|(1&(x>>y));
        if(x<trans)
        {
           xi=list+x;
           xj=list+trans;
           temp=*xj;
           *xj=*xi;
           *xi=temp;
        }
     }
 }
 delete [] w;
 w=NULL;
//-----------------------------------------------------------------------------
//翻转回来!
 for(i=0;i<iHeight;i++)
    for(int j=0;j<iWidth;j++)
    {
       cData[i][j].real=turn[j][i].real/(iWidth*iHeight);         //此处必须除iWidth *iHeight
       cData[i][j].imag=turn[j][i].imag/(iWidth*iHeight);
    }
 if(turn!=NULL)
 {
    for(i=0;i<iWidth;i++)
       delete [] turn[i];
    delete [] turn;
    turn=NULL;
 }
 return TRUE;
}


int *HistoGarm (Picture input)
{
	int *histo=NULL;
	histo = new int [256];
	for (int k=0;k<256;k++)
		histo[k]=0;
	for (int i=0;i<input.row;i++)
		for (int j=0;j<input.col;j++)
		{
			histo[(int)(input.p[i][j])]++;
		}
		return histo;
}

PartFliter(Picture input,KERNEL ker,int fenmu,Picture output)