image.cpp

车牌识别(改定位)武汉理工大学

				for(k=0; k<m_iPixelNum; k++)
					m_pR[k]=(unsigned char)piData[k];
				
				
				if(piData!=NULL)
				{
					delete[] piData;
					piData=NULL;
				}
				
				return index;
}
void CImage::Crop(CRect CropRect)
{
	//Save original data
	int iOriginalHeight=m_nHeight;
	int iOriginalWidth=m_nWidth;
	
	int m_iPixelNum = m_nWidth*m_nHeight;
	unsigned char* pcTemp = new unsigned char[m_iPixelNum];
	memcpy(pcTemp,m_pR,m_iPixelNum);
	if( m_nHeight<=0 || m_nWidth<=0 )
	{
		return ;
	}
	if (!Create(CSize(CropRect.Width(),CropRect.Height()),FALSE))
	{
		return ;
	}
	int i,j;
	int index=0;
	for(i=CropRect.top;i<CropRect.bottom;i++)
	{
		for(j=CropRect.left;j<CropRect.right;j++)
		{
			if(i<0||i>=iOriginalHeight||j<0||j>=iOriginalWidth)
				m_pR[index]=0;		
			else
				m_pR[index]=pcTemp[i*iOriginalWidth+j];
			index++;
		}
	}
	if(pcTemp!=NULL)
	{
		delete [] pcTemp;
		pcTemp=NULL;
	}
}

void CImage::Stretch(CSize Size,int nStretchType)
{
	int iTargetHeight=Size.cy;
	int iTargetWidth=Size.cx;
	int m_iPixelNum=iTargetHeight*iTargetWidth;
	double* pdTemp;
	pdTemp=new double[m_iPixelNum];
	double HorStretch, VerStretch;
	HorStretch=((double)m_nWidth)/((double)iTargetWidth);
	VerStretch=((double)m_nHeight)/((double)iTargetHeight);
	
	int j;
	int index=0;
	for(int i=0;i<iTargetHeight;i++)
	{
		for(j=0;j<iTargetWidth;j++)
		{
			pdTemp[index]=GetSubPixel(HorStretch*((double)j), VerStretch*((double)i),nStretchType);
			index++;
		}
	}
	if (!Create(CSize(iTargetWidth,iTargetHeight),FALSE))
	{
		return ;
	}
	for(i=0; i<m_iPixelNum; i++)
		m_pR[i]=(unsigned char)pdTemp[i];
	
	if(pdTemp)
		delete [](double*)pdTemp;
}

double CImage::GetSubPixel(double x, double y, int Method)
{
	if(x<0||x>=m_nWidth)
		return 0;
	if(y<0||y>=m_nHeight)
		return 0;
	
	switch(Method)
	{
	case	NEAREST:
		{
			return m_pR[int(x)+m_nWidth*int(y)];
		}
		break;
		
	case	BILINEAR:
		{
			int x0,x1,y0,y1;
			x0=int(floor(x));
			y0=int(floor(y));
			x1=x0+1;
			y1=y0+1;
			
			if(x0<0||x1>=m_nWidth|| y0<0||y1>=m_nHeight)
				return 0;
			else
			{
				//移至单元格
				x-=double(x0);
				y-=double(y0);
				
				double f00,f10,f01,f11;
				f00= m_pR[y0*m_nWidth+x0];
				f10= m_pR[y0*m_nWidth+x1];
				f01= m_pR[y1*m_nWidth+x0];
				f11= m_pR[y1*m_nWidth+x1];
				
				double a,b,c,d;
				double xy=x*y;					
				a=f10-f00;
				b=f01-f00;
				c=f11+f00-f01-f10;
				d=f00;
				return a*x+b*y+c*xy+d;
			}
		}
		break;
		
	case	BICUBIC:
		{
			return 0;
		}
		break;
		
	default:
		{
			return 0;
		}
		break;
		
	}//End of switch
}
//已经改为八连通
BOOL CImage::GetLiantong(CList<int,int> &ListNum,CList<CRect,CRect> &ListRect,CImage &ImgOut, BYTE byVal)
{
	ListNum.RemoveAll();
	ListRect.RemoveAll();
	//底下为四连通代码
/*
		if (!ImgOut.Create(CSize(m_nWidth,m_nHeight),FALSE))
		{
			return FALSE;
		}
		int nPix = m_nWidth*m_nHeight;
		for (int i=0;i<nPix;i++)
		{
			ImgOut.m_pR[i]=BYTE(0);
		}
		int k=1;
		for (i=0;i<m_nHeight;i++)
		{
			for (int j=0;j<m_nWidth;j++)
			{
				if (i==0)
				{
					if (m_pR[i*m_nWidth+j]==byVal)
					{
						if (j>0)
						{
							if (ImgOut.m_pR[i*m_nWidth+j-1]>0)
							{
								ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[i*m_nWidth+j-1];
							}
							else
							{
								ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
								k++;
							}
						}
						else
						{
							ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
							k++;
						}
					}
				}
				else if (i>0)
				{
					if (m_pR[i*m_nWidth+j]==byVal)
					{
						if (j==0)
						{
							if (ImgOut.m_pR[(i-1)*m_nWidth+j]>0)
							{
								ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[(i-1)*m_nWidth+j];
							}
							else
							{
								ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
								k++;
							}
						}
						else
						{
							if (ImgOut.m_pR[i*m_nWidth+j-1]>0)
							{
								ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[i*m_nWidth+j-1];
								if (ImgOut.m_pR[(i-1)*m_nWidth+j]>0)
								{
									BYTE temp1=ImgOut.m_pR[(i-1)*m_nWidth+j];
									for (int ii=0;ii<=i;ii++)
									{
										for (int jj=0;jj<m_nWidth;jj++)
										{
											if (ImgOut.m_pR[ii*m_nWidth+jj]==temp1)
											{
												ImgOut.m_pR[ii*m_nWidth+jj]=ImgOut.m_pR[i*m_nWidth+j];
											}
										}
									}
								}
							}
							else
							{
								if (ImgOut.m_pR[(i-1)*m_nWidth+j]>0)
								{
									ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[(i-1)*m_nWidth+j];
								}
								else
								{
									ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
									k++;
								}
							}
						}
					}
				}
			}
		}*/
	
	if (!ImgOut.Create(CSize(m_nWidth,m_nHeight),FALSE))
	{
		return FALSE;
	}
	int nPix = m_nWidth*m_nHeight;
	for (int i=0;i<nPix;i++)
	{
		ImgOut.m_pR[i]=BYTE(0);
	}
	int k=1;
	for (i=0;i<m_nHeight;i++)
	{
		for (int j=0;j<m_nWidth;j++)
		{
			if (i==0)
			{
				if (m_pR[i*m_nWidth+j]==byVal)
				{
					if (j>0)
					{
						if (ImgOut.m_pR[i*m_nWidth+j-1]>0)
						{
							ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[i*m_nWidth+j-1];
						}
						else
						{
							ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
							k++;
						}
					}
					else
					{
						ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
						k++;
					}
				}
			}
			else if (i>0)
			{
				if (m_pR[i*m_nWidth+j]==byVal)
				{
					if (j==0)
					{
						if (ImgOut.m_pR[(i-1)*m_nWidth+j]>0)
						{
							ImgOut.m_pR[i*m_nWidth+j] = ImgOut.m_pR[(i-1)*m_nWidth+j];
						}
						
						else if(ImgOut.m_pR[(i-1)*m_nWidth+j+1]>0)
						{
							ImgOut.m_pR[i*m_nWidth+j] = ImgOut.m_pR[(i-1)*m_nWidth+j+1]; 
						}
						
						else
						{
							ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
							k++;
						}
					}
					else
					{
                        //斜上角
				     	if(ImgOut.m_pR[(i-1)*m_nWidth+j-1]>0)
						{
					       ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[(i-1)*m_nWidth+j-1];
						   if (j<m_nWidth-1)
						   {
							   if(ImgOut.m_pR[(i-1)*m_nWidth+j+1]>0)
							   {
								   BYTE temp1=ImgOut.m_pR[(i-1)*m_nWidth+j+1];
								   for (int ii=0;ii<=i;ii++)
								   {
									   for (int jj=0;jj<m_nWidth;jj++)
									   {
										   if (ImgOut.m_pR[ii*m_nWidth+jj]==temp1)
										   {
											   ImgOut.m_pR[ii*m_nWidth+jj]=ImgOut.m_pR[i*m_nWidth+j];
										   }
									   }
								   }
							   }
						   }
						  
						}
						//左边
						else if (ImgOut.m_pR[i*m_nWidth+j-1]>0)
						{
							ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[i*m_nWidth+j-1];
							if (ImgOut.m_pR[(i-1)*m_nWidth+j]>0)
							{
								BYTE temp1=ImgOut.m_pR[(i-1)*m_nWidth+j];
								for (int ii=0;ii<=i;ii++)
								{
									for (int jj=0;jj<m_nWidth;jj++)
									{
										if (ImgOut.m_pR[ii*m_nWidth+jj]==temp1)
										{
											ImgOut.m_pR[ii*m_nWidth+jj]=ImgOut.m_pR[i*m_nWidth+j];
										}
									}
								}
							}
						}
						//上边
						else if(ImgOut.m_pR[(i-1)*m_nWidth+j]>0)
						{	
							ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[(i-1)*m_nWidth+j];	
						}
						//斜上角（右边）
						else
						{
							if (j<m_nWidth-1)
							{
								if(ImgOut.m_pR[(i-1)*m_nWidth+j+1]>0)
								{
                                    ImgOut.m_pR[i*m_nWidth+j]=ImgOut.m_pR[(i-1)*m_nWidth+j+1];
								}
								else
								{
									ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
									k++;
								}
							}
							else
							{
								ImgOut.m_pR[i*m_nWidth+j]=BYTE(k);
								k++;
							}
						
						}
					}
				}
			}
		}
	}
	int * pL = new int[k];
	CRect * pRect = new CRect[k];	
	memset(pL,0,sizeof(int)*k);
	for(i=0;i<k;i++)
	{
		pRect[i] = CRect(9999,9999,-1,-1);
	}
	int nTemp;
	for(i=0;i<m_nHeight;i++)
	{
		for(int j=0;j<m_nWidth;j++)
		{
			nTemp = ImgOut.m_pR[i*m_nWidth+j];
			pL[nTemp]++;
			pRect[nTemp].left = min(j,pRect[nTemp].left);
			pRect[nTemp].right = max(j,pRect[nTemp].right);
			pRect[nTemp].top = min(i,pRect[nTemp].top);
			pRect[nTemp].bottom = max(i,pRect[nTemp].bottom);
		}
	}
	int Lt=0;
	for(i=0;i<k;i++)
	{
		
		if(pL[i]>0)
		{
			ListNum.AddTail(pL[i]);	
			ListRect.AddTail(pRect[i]);
			for (int j=0;j<m_nHeight*m_nWidth;j++)
			{
				if (ImgOut.m_pR[j]==i)
				{
					ImgOut.m_pR[j]-=Lt;
				}
			}
		}
		else
		{
			Lt++;
		}
		
		
		
	}
	delete []pL;
	delete []pRect;
	return TRUE;
}
int Max(int a, int b, int c)
{
	a = max(a,b);
	a = max(a,c);
	return a;
}
int Min(int a, int b, int c)
{
	a = min(a,b);
	a = min(a,c);
	return a;
}
BOOL CImage::CalCulate(BYTE pHist[][256], BYTE pMean[], double pS[],CRect * pRect)
{
	CRect rcCal;
	if (pRect==NULL)
	{
		rcCal.left = 0;
		rcCal.top = 0;
		rcCal.right = m_nWidth;
		rcCal.bottom = m_nHeight;
	}
	else
	{
		rcCal = *pRect;
	}
	memset(pHist[0],0,256);
	memset(pHist[1],0,256);
	memset(pHist[2],0,256);
	int nPix = rcCal.Width()*rcCal.Height();
	int i,j;
	for(i=rcCal.top;i<rcCal.bottom;i++)
	{
		for(j=rcCal.left;j<rcCal.right;j++)
		{
			pHist[0][m_pR[i*m_nWidth+j]]++;
			if (m_bRGB)
			{
				pHist[1][m_pG[i*m_nWidth+j]]++;
				pHist[2][m_pB[i*m_nWidth+j]]++;
			}
		}
	}
	double dSum[3];
	dSum[0] = 0;
	dSum[1] = 0;
	dSum[2] = 0;
	for(i=0;i<256;i++)
	{
		dSum[0] += pHist[0][i]*i;
		if (m_bRGB)
		{
			dSum[1] += pHist[1][i]*i;
			dSum[2] += pHist[2][i]*i;
		}		
	}
	for(i=0;i<3;i++)
	{
		dSum[i] = dSum[i]/nPix;
		pMean[i] = BYTE(dSum[i]);
	}
	
	dSum[0] = 0;
	dSum[1] = 0;
	dSum[2] = 0;
	for(i=0;i<256;i++)
	{
		dSum[0] += (i-pMean[0])*(i-pMean[0])*pHist[0][i];
		if (m_bRGB)
		{
			dSum[0] += (i-pMean[1])*(i-pMean[1])*pHist[1][i];
			dSum[0] += (i-pMean[2])*(i-pMean[2])*pHist[2][i];
		}		
	}
	for(i=0;i<3;i++)
	{
		pS[i] = sqrt(dSum[i]/nPix);
	}
	return TRUE;
}

CString GetIntToString(int *pIn, int Num)
{
	CString strRes;
	CString strTemp;
	for(int i=0;i<Num;i++)
	{
		strTemp.Format("%d ",pIn[i]);
		strRes += strTemp;
	}
	strRes += "\r\n";
	return strRes;
}
void CImage::Erosion(int nVal)
{
	int m_iPixelNum = m_nHeight*m_nWidth;
	unsigned char* pcTemp=new unsigned char[m_iPixelNum];
	int i,j,l;
	
	for(l=0;l<m_iPixelNum;l++)
		pcTemp[l]=0;
	
	for(i=1;i<m_nHeight-1;i++)
	{
		for(j=1;j<m_nWidth-1;j++)
		{
			if(m_pR[i*m_nWidth+j]>=1)
			{
				if ((m_pR[i*m_nWidth+j+1]>=1&&m_pR[i*m_nWidth+j-1]>=1)
					||(m_pR[i*m_nWidth+j+m_nWidth]>=1&&m_pR[i*m_nWidth+j-m_nWidth]>=1)) 
				{
					pcTemp[i*m_nWidth+j]=255;
				}
				else
				{
					pcTemp[i*m_nWidth+j]=0;
				}
			}
		}
	}
	for(l=0;l<m_iPixelNum;l++)
		m_pR[l]=pcTemp[l];
				
	delete [] pcTemp;
}
void CImage::Dilation()
{
	int m_iPixelNum=m_nHeight*m_nWidth;
	unsigned char* pcTemp=new unsigned char[m_iPixelNum];
	int i,j,l;
	for(l=0;l<m_iPixelNum;l++)
		pcTemp[l]=0;	
	for(i=1;i<m_nHeight-1;i++)
	{
		for(j=1;j<m_nWidth-1;j++)
		{
			if(m_pR[i*m_nWidth+j]>=1||m_pR[i*m_nWidth+j+1]>=1||m_pR[i*m_nWidth+j-1]>=1||m_pR[i*m_nWidth+j+m_nWidth]>=1||m_pR[i*m_nWidth+j-m_nWidth]>=1)
				pcTemp[i*m_nWidth+j]=255;
			else
				pcTemp[i*m_nWidth+j]=0;
		}
	}
	for(l=0;l<m_iPixelNum;l++)
		m_pR[l]=pcTemp[l];
	
	delete [] pcTemp;
}
void CImage::GetHistogram(int* piHistogram)
{
	for(int i=0;i<256;i++)
		piHistogram[i]=0;
	
	int m_iPixelNum=m_nHeight*m_nWidth;
	for(i=0;i<m_iPixelNum;i++)
		piHistogram[ m_pR[i] ]++;
}
void CImage::HistogramEqualization()
{		
	int i,j,k;
	int hist[256];
	for(k=0;k<256;k++) 
		hist[k]=0;
	for(i=0;i<m_nWidth;i++)
	{
		for(j=0;j<m_nHeight;j++)
		{
			k=m_pR[j*m_nWidth+i];
			hist[k]++;
		}
	}
	for(k=1;k<256;k++) 
		hist[k]+=hist[k-1];
	for(k=0;k<256;k++)
	{
		hist[k]=(int)(hist[k]*255.0/((double)m_nWidth*(double)m_nHeight)+0.5);
		if(hist[k]==255)
			hist[k]=254;
	}
	for(i=0;i<m_nWidth;i++)
	{
		for(j=0;j<m_nHeight;j++)
		{
			k = m_pR[i+j*m_nWidth];
			m_pR[i+j*m_nWidth]=(unsigned char)hist[k];
		}
	}
}

BOOL CImage::Edg