imgprocessing.cpp

直方图的相关操作

			if(temp>255) temp=255;
			buf=(BYTE)temp;
			img[i*imgwidth+j]=buf;
		}
}
/**********************************************/
/*  function for get symmetry of image region */
/*  img      : the  image                     */
/*  imgheight: height of image                */
/*  imgwidth : width of image                 */
/*  rect     : the rect                       */
/**********************************************/

double Img_GetSymmetry(CByteArray& img,int imgheight,int imgwidth,CRect &rect)
{
	int height=rect.Height();
	int width=rect.Width();
	int top=rect.top;
	int left=rect.left;
    int i,j;
	int time=0;
	double sym=0.0;
	for(i=0;i<height;i++)
		for(j=0;j<width/2;j++)
		{
			sym+=abs((img[(i+top)*imgwidth+left+j]-img[(i+top)*imgwidth+left+width-j-1]));
	        time++;
		}
	return sym/time;
 
}

bool Img_Seperate(CByteArray& oldimg,CByteArray& newimg,int imgheight,int imgwidth,CRect& rect)
{
	int height=rect.Height();   //刘 矩形区域的高度
	int width=rect.Width();     //刘 矩形区域的宽度
	int top=rect.top;           //刘 矩形区域左上角的坐标
	int left=rect.left;         //
	if ((top+height)>imgheight||(left+width)>imgwidth)
		return false;
 	newimg.RemoveAll();         
	newimg.SetSize(height*width);//设置？图像的大小为矩形的大小
	int i,j;
	for(i=0;i<height;i++)
		for(j=0;j<width;j++)
		{
			newimg[i*width+j]=oldimg[(top+i)*imgwidth+left+j];
		}
	return true;
}

int Img_Threshold(CByteArray& oldimg,int height,int width,int threshold)
{
	int num=0;
    int i,j;
	for(i=0;i<height;i++)
		for(j=0;j<width;j++)
		{
			if(oldimg[i*width+j]<threshold)
			{
				oldimg[i*width+j]=0;
                num++;
			}
			else 
			oldimg[i*width+j]=255;
		}
    return num;
}
void Img_Convert(CByteArray& oldimg,int height,int width)
{
	int i,j;
	for(i=0;i<height;i++)
		for(j=0;j<width;j++)
		{
			oldimg[i*width+j]=255-oldimg[i*width+j];
		}
}
void Img_Copy(CByteArray& oldimg,CByteArray& newimg)
{
	newimg.RemoveAll();
	int i,size=oldimg.GetSize();
	newimg.SetSize(size);
	for(i=0;i<size;i++)
	{
		newimg[i]=oldimg[i];
	}
}
double Img_MHausdorff(CImage& imga,CImage& imgb,int Nsize,int penalty,int delta)
{	
	int i,j,I,k,l;
	int awidth=imga.GetWidth();
	int bwidth=imgb.GetWidth();
	int aheight=imga.GetHeight();
	int bheight=imgb.GetHeight();
	double dis,disaB,disAB,disab;
    BYTE value;
	disAB=0.0;
	for(i=0;i<aheight;i++)
		for(j=0;j<awidth;j++)
		{
			value=imga.m_ImageBody[i*awidth+j];
	        I=0;			
			for(k=0;k<=Nsize;k++)
			{
				for(l=-k;l<=k;l++)
				{
					if((j+l>=0)&&(j+l<bwidth)&&(i+k>=0)&&(i+k<bheight)) 
					{
						if((value-imgb.m_ImageBody[(i+k)*bwidth+j+l])>-delta&&
							(value-imgb.m_ImageBody[(i+k)*bwidth+j+l])<delta)
						{
						    I=1;
						    disab=sqrt((double)k*k+l*l);
						    break;
						}
					}
					if((i+l>=0)&&(i+l<bheight)&&(j+k>=0)&&(j+k<bwidth))
					{
						if((value-imgb.m_ImageBody[(i+l)*bwidth+j+k])>-delta&&
							(value-imgb.m_ImageBody[(i+l)*bwidth+j+k])<delta)
						{
							I=1;
							disab=sqrt((double)k*k+l*l);
							break;
						}
					}
					if((i-k>=0)&&(i-k<bheight)&&(j+l>=0)&&(j+l<bwidth))
						if((value-imgb.m_ImageBody[(i-k)*bwidth+j+l])>-delta&&
							(value-imgb.m_ImageBody[(i-k)*bwidth+j+l])<delta)
						{
							I=1;
							disab=sqrt((double)k*k+l*l);
							break;
						}
					if((i+l>=0)&&(i+l<bheight)&&(j-k>=0)&&(j-k<bwidth))
						if((value-imgb.m_ImageBody[(i+l)*bwidth+j-k])>-delta&&
							(value-imgb.m_ImageBody[(i+l)*bwidth+j-k])<delta)
						{
							I=1;
							disab=sqrt((double)k*k+l*l);
							break;
						}
				}//for l
				if(I==1) break;
			}//for k
			if(I==0) 
			    disaB=penalty;
            else
				disaB=disab;
		   disAB+=disaB;
		}//for outer
		dis=disAB/(awidth*aheight);
		return dis;

}
double Img_Hausdorff(CImage& imga,CImage& imgb,int Nsize,int penalty)
{
	int i,j,I,k,l;
	int awidth=imga.GetWidth();
	int bwidth=imgb.GetWidth();
	int aheight=imga.GetHeight();
	int bheight=imgb.GetHeight();
	double dis,disaB,disAB,disab;
    BYTE value;
	disAB=0.0;
	for(i=0;i<aheight;i++)
		for(j=0;j<awidth;j++)
		{
			value=imga.m_ImageBody[i*awidth+j];
	        I=0;			
			for(k=0;k<=Nsize;k++)
			{
				for(l=-k;l<=k;l++)
				{
					if((j+l>=0)&&(j+l<bwidth)&&(i+k>=0)&&(i+k<bheight)) 
					{
						if(value==imgb.m_ImageBody[(i+k)*bwidth+j+l])
						{
						    I=1;
						    disab=sqrt((double)k*k+l*l);
						    break;
						}
					}
					if((i+l>=0)&&(i+l<bheight)&&(j+k>=0)&&(j+k<bwidth))
					{
						if(value==imgb.m_ImageBody[(i+l)*bwidth+j+k])
						{
							I=1;
							disab=sqrt((double)k*k+l*l);
							break;
						}
					}
					if((i-k>=0)&&(i-k<bheight)&&(j+l>=0)&&(j+l<bwidth))
						if(value==imgb.m_ImageBody[(i-k)*bwidth+j+l])
						{
							I=1;
							disab=sqrt((double)k*k+l*l);
							break;
						}
					if((i+l>=0)&&(i+l<bheight)&&(j-k>=0)&&(j-k<bwidth))
						if(value==imgb.m_ImageBody[(i+l)*bwidth+j-k])
						{
							I=1;
							disab=sqrt((double)k*k+l*l);
							break;
						}
				}//for l
				if(I==1) break;
			}//for k
			if(I==0) 
			    disaB=penalty;
            else
				disaB=disab;
		   disAB+=disaB;
		}//for outer
		dis=disAB/(awidth*aheight);
		return dis;
}
void Img_Laplace(CByteArray& oldimg,CByteArray& newimg,int height,int width)
{
	int i,j,c;
	newimg.SetSize(oldimg.GetSize());
	for(i=1;i<height-1;i++)
		for(j=1;j<width-1;j++)
		{
			c=-4*(int)(oldimg[i*width+j])+(int)(oldimg[(i-1)*width+j])+
				(int)(oldimg[(i+1)*width+j]);
			c+=((int)(oldimg[i*width+j-1])+(int)(oldimg[i*width+j+1]));
			if(c<0){
				c=0;
			}
			else if(c>255){
				c=255;
			}
			newimg[i*width+j]=(unsigned char)c;
		}
}
/*****************************************************************/
/* Name: Grass_label()			                                 */
/* Function: Subroutine Counting objects in a binary image.      */
/* Parameters:imga,imgb:input and output buffer.                 */
/*          N:number of regions                                  */
/*          h:buffers to store object areas.                     */
/*         NS:maximal allowable number of objects(less than 255).*/
/*****************************************************************/
int Grass_label(CByteArray& imga,CByteArray& imgb,
				int& N,DoubleArray& h,int& NS,CRect& rect,int Width)
{
	int i,j,number;
	imgb.SetSize(imga.GetSize());
	h.SetSize(NS);
	number=0;
	for(i=rect.top;i<rect.bottom&&number<NS;i++)
		for(j=rect.left;j<rect.right&&number<NS;j++)
			if(imga[i*Width+j]==0)
			{
				Grass(imga,imgb,i,j,number+1,h[number],rect,Width);
				number++;
			}

    N=number;
    return (0);
}
/*******************************************/
/*           Name: grass()                 */
/*Function:Subroutine to clear a binary    */
/*         object that starts at (row,col) */
/*Parameters:imga,imgb:input/output buffer */
/*           row,col:pixel coordinates.    */
/*           number:current object number  */
/*           *area:object area(in pixels)  */
/*           rect: region                  */
/*******************************************/
int Grass(CByteArray& imga,CByteArray& imgb,int row,int col,
		  int number,double& area,CRect& rect,int width)
{
	int i,j;
	imga[row*width+col]=255;
	imgb[row*width+col]=number;
	area++;
	for(i=-1;i<=1;i++)
		for(j=-1;j<=1;j++)
		  if((row+i)>+rect.top&&(row+i)<rect.bottom
			&&(col+j)>+rect.left&&(col+j)<rect.right)
			if(imga[(row+i)*width+col+j]==0)
				Grass(imga,imgb,row+i,col+j,number,area,rect,width);
    return (0);
}
void Img_Grow(CByteArray& imga,CPoint& point,int place)
{
}

/******************************************/
void Img_Uniform(CByteArray& img,int height,int width,CRect& rect)
{
	int center=width/2,i,j,left,right;
    for(i=rect.top;i<rect.bottom;i++)
		for(j=rect.left;j<rect.Width()/2;j++)
		{
			left=img[i*width+j];
			right=img[i*width+width-1-j];
			if(abs(left-right)>100)
			img[i*width+j]=img[i*width+width-j-1]
				=(UINT)((left+right)/2.0);
//			if(left<right)
//				img[i*width+j]=img[i*width+width-j-1]=left;
//			else 
//				img[i*width+j]=img[i*width+width-j-1]=right;
		}
}
double Img_GetCos(CByteArray& imga,CByteArray& imgb)
{
	double u=0.0,v=0.0,mul=0.0;
	int i;
	for(i=0;i<imga.GetSize();i++)
	{
		u+=(imga[i]*imga[i]);
		v+=(imgb[i]*imgb[i]);
		mul+=(imga[i]*imgb[i]);
	}
	u=sqrt(u);
	v=sqrt(v);
    return(mul/(u*v));
}
double Img_GetCos(DoubleArray& imga,DoubleArray& imgb)
{
	double u=0.0,v=0.0,mul=0.0;
	int i;
	for(i=0;i<imga.GetSize();i++)
	{
		double temp=imga[i];
		u+=((double)imga[i]*(double)imga[i]);
		v+=((double)imgb[i]*(double)imgb[i]);
		mul+=((double)imga[i]*(double)imgb[i]);
	}
	u=sqrt(u);
	v=sqrt(v);
    return(mul/(u*v));
}
double Img_GetCos(DoubleArray& imga,DoubleArray& imgb,int Num)
{
	double u=0.0,v=0.0,mul=0.0;
	int i;
	for(i=0;i<Num;i++)
	{
		double temp=imga[i];
		u+=((double)imga[i]*(double)imga[i]);
		v+=((double)imgb[i]*(double)imgb[i]);
		mul+=((double)imga[i]*(double)imgb[i]);
	}
	u=sqrt(u);
	v=sqrt(v);
    return(mul/(u*v));
}
double Img_GetCos(CByteArray& imga,CByteArray& imgb,int height,int width,CRect& rect)
{
	double u=0.0,v=0.0,mul=0.0;
	int i,j;
	int l=rect.left;
	int t=rect.top;
	int b=rect.bottom;
	int r=rect.right;
	for(i=t;i<b;i++)
		for(j=l;j<r;j++)
	{
		u+=(imga[i*width+j]*imga[i*width+j]);
		v+=(imgb[(i-t)*rect.Width()+j-l]*imgb[(i-t)*rect.Width()+j-l]);
		mul+=(imga[i*width+j]*imgb[(i-t)*rect.Width()+j-l]);
	}
	u=sqrt(u);
	v=sqrt(v);
    return(mul/(u*v));
}

void Img_UpDown(CByteArray& imga,CByteArray& imgb,int height,int width,int newheight,int y0,double theta)
{
	double x1,y1;
	int i,j,a,b;
	int newwidth;
	double costh=cos(theta);
	//newheight=height*costh;
	newwidth=width;
	int y00=(int)(y0*cos(theta));
	imgb.SetSize(newheight*newwidth);
	for(i=0;i<newheight;i++)
		for(j=0;j<newwidth;j++)
		{
			x1=j;
			y1=y00+(double)(i-y00)/costh;
	        a=(int)y1,b=a+1;
			if(a<0) a=0;
			if(b>=height) b=height-1;
			imgb[i*newwidth+j]=(int)(imga[a*newwidth+j]*(b-y1)+imga[b*newwidth+j]*(y1-a));
		}
}
void Img_Projection(DoubleArray& data,DoubleArray& pm,int dim,int Num,DoubleArray& cf)
{
	int i,j;
	double buf;
	cf.SetSize(Num);
	for(i=0;i<Num;i++)
	{
		buf=0.0;
		for(j=0;j<dim;j++)
		{
			buf+=(data[j]*pm[j*240+i]);//150--yale,240--orl
		}
		cf[i]=buf;
	}

}
void Img_Denoise(CByteArray& imga,CByteArray& imgb,int height,int width)
{
	int i,j,m,n;
    imgb.RemoveAll();
	imgb.SetSize(height*width);
/* 	for(i=0;i<height;i++)
		for(j=0;j<width;j++)
		{
			if(i==0||j==0||i=height-1||j=width-1)
			{
			    imgb[i*width+j]=imga[i*width+j];
				continue;
			}
			cc=+(int)imga[(i-1)*width+(j-1)]
				+1*(int)imga[(i)*width+(j-1)]
				+(int)imga[(i+1)*width+(j-1)];
			cc+=(int)imga[(i-1)*width+(j+1)]
				+1*(int)imga[(i)*width+(j+1)]
				+(int)imga[(i+1)*width+(j+1)];
			cc+=1*(int)imga[(i-1)*width+j]
				+2*(int)imga[(i)*width+j]
				+1*(int)imga[(i+1)*width+j];
			c=cc/10;
			imgb[i*width+j]=(BYTE)c;
		}
		*/
	int block=2;
	for(i=0;i<height;i++)
		for(j=0;j<width;j++)
		{
			for(m=i;m<i+block;m++)
				for(n=j;n<j+block;n++)
				{
				}
		}
}
bool WriteArcFile(CString& str,DoubleArray& cf)
{
    CFile file;
	if(file.Open(str,CFile::modeCreate|CFile::modeWrite)==NULL)
	{
		AfxMessageBox("写向量错误");
		return false;
	}
	CArchive ar(&file,CArchive::store);
	cf.Serialize(ar);
	return true;
}
bool ReadArcFile(CString& str,DoubleArray& cf)
{
    CFile file;
	if(file.Open(str,CFile::modeRead)==NULL)
	{
		AfxMessageBox("读向量错误");
		return false;
	}
	CArchive ar(&file,CArchive::load);
	cf.Serialize(ar);
	return true;
}
bool ReadArcFile(CString& str,CByteArray& cf)
{
    CFile file;