downhill.cpp

一些自己做的关于图象处理的程序（如傅立叶变换

// DownHill.cpp: implementation of the CDownHill class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "photostar.h"
#include "DownHill.h"
#include "Queue.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDownHill::CDownHill()
{
	
}

CDownHill::~CDownHill()
{
	
}



BOOL CDownHill::OnDownHill()
{
    if (m_pImageObject == NULL)
	{
		return FALSE;
	}
	
	
	int iWidth = m_pImageObject->GetWidth();
	int iHeight = m_pImageObject->GetHeight();
	int iNumbits=m_pImageObject->GetNumBits();
	/******************************the old image*****************************/
	unsigned char *pOldBuffer, *pNewBuffer, *pOldBits, *pNewBits;
	BITMAPFILEHEADER *pOldBFH, *pNewBFH;
	BITMAPINFOHEADER *pOldBIH, *pNewBIH;
	RGBQUAD *pOldPalette, *pNewPalette;
	int nWidthBytes, nNumColors;
	
	pOldBuffer = (unsigned char *) m_pImageObject->GetDIBPointer(&nWidthBytes, m_pImageObject->GetNumBits());
	if (pOldBuffer == NULL) 
	{
		return FALSE;
	}
	
	pOldBFH = (BITMAPFILEHEADER *) pOldBuffer;
	pOldBIH = (BITMAPINFOHEADER *) &pOldBuffer[sizeof(BITMAPFILEHEADER)];
	nNumColors = m_pImageObject->GetNumColors();
	pOldPalette = (RGBQUAD *)  &pOldBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
	pOldBits = (unsigned char *) &pOldBuffer[sizeof(BITMAPFILEHEADER)
		+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
	
	/*****************************the new image*****************************/
	DWORD dwNewSize;
	HGLOBAL hNewDib;
	
	//Allocate a global memory block for the new image
	dwNewSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) 
		+ nNumColors * sizeof(RGBQUAD)
		+ nWidthBytes * (m_pImageObject->GetHeight());
	hNewDib = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, dwNewSize);
	if (hNewDib == NULL)
	{
		m_pImageObject->m_nLastError = IMAGELIB_MEMORY_ALLOCATION_ERROR;
		::GlobalUnlock(m_pImageObject->GetDib());
		return FALSE;
	}
	
	//Get the pointer to the new memory block
	pNewBuffer = (unsigned char *) ::GlobalLock(hNewDib);
	if (pNewBuffer == NULL)
	{
		::GlobalFree( hNewDib );
		m_pImageObject->m_nLastError = IMAGELIB_MEMORY_LOCK_ERROR;
		::GlobalUnlock(m_pImageObject->GetDib());
		return FALSE;
	}
	
	pNewBFH = (BITMAPFILEHEADER *) pNewBuffer;
	pNewBIH = (BITMAPINFOHEADER *) &pNewBuffer[sizeof(BITMAPFILEHEADER)];
	pNewPalette = (RGBQUAD *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)];
	pNewBits = (unsigned char *) &pNewBuffer[sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+nNumColors*sizeof(RGBQUAD)];
	
	//Make a copy of the old image
	memcpy(pNewBuffer,pOldBuffer,dwNewSize);
	/*******************************Downhill Filter****************************/
	int i,j,m,n,u=0,ii,jj,q=0,p=0,iii,jjj;
	int media[400][8];
	int *mediaimage;
	mediaimage=new int [iHeight*iWidth];
	int *finaliseimage;
	finaliseimage=new int [iHeight*iWidth];
	int max=0,min=255;
	int test=0;
	CQueue queue;
	queue.InitQueue();
	for(j=0;j<iHeight;j++)
	{
		for(i=0;i<iWidth;i++)
		{
			finaliseimage[(iHeight-1-j)*nWidthBytes+i]=0;
			mediaimage[(iHeight-1-j)*nWidthBytes+i]=0;
			pNewBits[(iHeight-1-j)*nWidthBytes+i]=0/*pOldBits[(iHeight-1-j)*nWidthBytes+i]*/;
		}
	}
	if (m_nStartX>=m_nEndX)
	{
		m=m_nEndX;
	}
	else
	{
		m=m_nStartX;
	}
	if (m_nStartY>=m_nEndY)
	{
		n=m_nEndY;
	}
	else
	{
		n=m_nStartY;
	}	    
	if(m_nlable2==1)
	{
		for(i=1;i<(int)fabs(m_nStartX-m_nEndX);i+=2)//寻找区域最大值
		{
			for(j=1;j<(int)fabs(m_nStartY-m_nEndY);j+=2)
			{
				int w=pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i];
				if(pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i-1]==w &&
					pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i]==w &&
					pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i+1]==w &&
					pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i-1]==w &&
					pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i+1]==w &&
					pOldBits[(iHeight-1-n-j+1)*nWidthBytes+m+i-1]==w &&
					pOldBits[(iHeight-1-n-j+1)*nWidthBytes+m+i]==w &&
					pOldBits[(iHeight-1-n-j+1)*nWidthBytes+m+i+1]==w)
				{
					if(pOldBits[(iHeight-1-n-j-2)*nWidthBytes+m+i-2]<=w)
					{
						if(pOldBits[(iHeight-1-n-j-2)*nWidthBytes+m+i-1]<=w)
						{
							if(pOldBits[(iHeight-1-n-j-2)*nWidthBytes+m+i]<=w)
							{
								if(pOldBits[(iHeight-1-n-j-2)*nWidthBytes+m+i+1]<=w)
								{
									if(pOldBits[(iHeight-1-n-j-2)*nWidthBytes+m+i+2]<=w)
									{
										if(pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i-2]<=w)
										{
											if(pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i-2]<=w)
											{
												if(pOldBits[(iHeight-1-n-j+1)*nWidthBytes+m+i-2]<=w)
												{
													if(pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i+2]<=w)
													{
														if(pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i+2]<=w)
														{
															if(pOldBits[(iHeight-1-n-j+1)*nWidthBytes+m+i+2]<=w)
															{
																if(pOldBits[(iHeight-1-n-j+2)*nWidthBytes+m+i-2]<=w)
																{
																	if(pOldBits[(iHeight-1-n-j+2)*nWidthBytes+m+i-1]<=w)
																	{
																		if(pOldBits[(iHeight-1-n-j+2)*nWidthBytes+m+i]<=w)
																		{
																			if(pOldBits[(iHeight-1-n-j+2)*nWidthBytes+m+i+1]<=w)
																			{
																				if(pOldBits[(iHeight-1-n-j+2)*nWidthBytes+m+i+2]<=w)
																				{
																					for(jj=-1;jj<2;jj++)
																					{
																						for(ii=-1;ii<2;ii++)
																						{
																							media[u][q]=(iHeight-1-n-j-jj)*nWidthBytes+m+i+ii;
																							q++;
																						}
																					}
																					q=0;
																					u++;
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
		}
		
		for(i=1;i<(int)fabs(m_nStartX-m_nEndX);i+=2)//初始化标识图像
		{
			for(j=1;j<(int)fabs(m_nStartY-m_nEndY);j+=2)
			{
				for(ii=0;ii<u;ii++)
				{
					
					if(media[ii][4]==(iHeight-1-n-j)*nWidthBytes+m+i)
					{ 
						for(iii=-1;iii<2;iii++)
						{
							for(jjj=-1;jjj<2;jjj++)
							{
								mediaimage[(iHeight-1-n-j-jjj)*nWidthBytes+m+i+iii]=pOldBits[(iHeight-1-n-j-jjj)*nWidthBytes+m+i+iii];
								if(m_nlable==2)//对比算法一处始化
								{
									int a=(iHeight-1-n-j-jjj)*nWidthBytes+m+i+iii;
									if (a!=(iHeight-1-n-j)*nWidthBytes+m+i)
									{
										queue.EnQueue(a);
									}
									
								}
							}
						}
						ii=u;
					}
					
				}
				
			}
		}
		if(m_nlable==1)
		{
			for(i=0;i<(int)fabs(m_nStartX-m_nEndX);i++)//判断图像是否最终确定
			{
				for(j=0;j<(int)fabs(m_nStartY-m_nEndY);j++)
				{
					if(mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i]!=0)
					{
						finaliseimage[(iHeight-1-n-j)*nWidthBytes+m+i]=1;
					}
				}
			}
			for(i=0;i<=(int)fabs(m_nStartX-m_nEndX);i++)//找标识图像中的最大值
			{
				for(j=0;j<=(int)fabs(m_nStartY-m_nEndY);j++)
				{
					if (mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i]>max)
					{
						max=mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i];
					}
					/*
					if(mediaimage[(n-1+j)*nWidthBytes+m+i]<min)
					{
					min=mediaimage[(n-1+j)*nWidthBytes+m+i];
					}
					*/
				}
			}
			CList<int,int>* list;//定义max个线性链表
			list = new CList<int, int>[max+1];
			for(i=0;i<=(int)fabs(m_nStartX-m_nEndX);i++)//将标识图像中非零点位置附给相应的线性链表
			{
				for(j=0;j<=(int)fabs(m_nStartY-m_nEndY);j++)
				{
					ii=mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i];
					if(ii!=0)
					{
						list[ii].AddTail((iHeight-1-n-j)*nWidthBytes+m+i);
					}
				}
			}
			for(i=max;i>=1;i--)
			{	
				int height,width;
				if(!list[i].IsEmpty())//对原始图像进行下山滤波处理
				{
					POSITION pos=list[i].GetHeadPosition();
					
					while (pos != NULL)
					{
						p=list[i].GetNext(pos);
						
						width=p%nWidthBytes;
						height=iHeight-1-(p-width)/nWidthBytes;
						if(height<iHeight-1 && width<iWidth-1 && height>1 && width>1)
						{
							for(ii=-1;ii<2;ii++)
							{
								for(jj=-1;jj<2;jj++)
								{
									if(pOldBits[(iHeight-1-height-jj)*nWidthBytes+width+ii]>0 && finaliseimage[(iHeight-1-height-jj)*nWidthBytes+width+ii]==0)
									{
										if(i>=pOldBits[(iHeight-1-height-jj)*nWidthBytes+width+ii])
										{
											list[pOldBits[(iHeight-1-height-jj)*nWidthBytes+width+ii]].AddTail((iHeight-1-height-jj)*nWidthBytes+width+ii);
										}
										else
										{
											list[i].AddTail((iHeight-1-height-jj)*nWidthBytes+width+ii);
										}
										finaliseimage[(iHeight-1-height-jj)*nWidthBytes+width+ii]=1;
									}
								}
							}
							
						}
					}
					
				}
				if(!list[i].IsEmpty())//附值给新图像
				{
					POSITION pos=list[i].GetHeadPosition();
					
					for(j=0;j<list[i].GetCount();j++)
					{
						p=list[i].GetNext(pos);	
						
						pNewBits[p]=i;
					}
				}
				
				
			}
		}
		if(m_nlable==2)//对比算法一滤波过程
		{
			int p;
			int height,width;
			while (queue.DeQueue(p)!=NULL)
			{
				width=p%nWidthBytes;
				height=iHeight-1-(p-width)/nWidthBytes;
				if(height<iHeight-1 && width<iWidth-1 && height>1 && width>1)
				{
					for(i=-1;i<2;i++)
					{
						for(j=-1;j<2;j++)
						{
							int a=(iHeight-1-height-j)*nWidthBytes+width+i;
							if (a!=(iHeight-1-height)*nWidthBytes+width)
							{
								if(mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i]<mediaimage[p] &&
									pOldBits[(iHeight-1-height-j)*nWidthBytes+width+i]!=mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i])
								{
									if(mediaimage[p]>=pOldBits[(iHeight-1-height-j)*nWidthBytes+width+i])
									{
										mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i]=pOldBits[(iHeight-1-height-j)*nWidthBytes+width+i];
									}
									else
									{
										mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i]=mediaimage[p];
									}
									queue.EnQueue((iHeight-1-height-j)*nWidthBytes+width+i);
								}
							}
						}
					}
				}
			}
			for(j=0;j<iHeight;j++)
			{
				for(i=0;i<iWidth;i++)
				{
						pNewBits[(iHeight-1-j)*nWidthBytes+i]=mediaimage[(iHeight-1-j)*nWidthBytes+i];
				}
			}
			queue.DestroyQueue();
		}
	}
	if(m_nlable2==2)
	{
		if (m_nlable==3)//对比算法二
		{
			for(i=1;i<fabs(m_nStartX-m_nEndX);i++)
			{
				for(j=1;j<=fabs(m_nStartY-m_nEndY);j++)
				{
					for(ii=-1;ii<2;ii++)
					{
						if(pOldBits[(iHeight-1-n-j+1)*nWidthBytes+m+i+ii]>max)
						{
							max=pOldBits[(iHeight-1-n-j+1)*nWidthBytes+m+i+ii];
						}
					}
					for(ii=-1;ii<1;ii++)
					{
						if(pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i+ii]>max)
						{
							max=pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i+ii];
						}
					}
					if(max>=pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i])
					{
						mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i]=pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i];
					}
					else
					{
						mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i]=max;
					}
				}
			}
			int vary;
			for(i=1;i<fabs(m_nStartX-m_nEndX);i++)
			{
				for(j=fabs(m_nStartY-m_nEndY)-1;j>=0;j--)
				{
					for(ii=-1;ii<2;ii++)
					{
						if(pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i+ii]>max)
						{
							max=pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i+ii];
						}
					}
					for(ii=0;ii<2;ii++)
					{
						if(pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i+ii]>max)
						{
							max=pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i+ii];
						}
					}
					if(max>=pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i])
					{
						mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i]=pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i];
					}
					else
					{
						mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i]=max;
					}
					vary=0;
					for(ii=-1;ii<2;ii++)
					{
						if(mediaimage[(iHeight-1-n-j-1)*nWidthBytes+m+i+ii]<pOldBits[(iHeight-1-n-j-1)*nWidthBytes+m+i+ii]
							&& mediaimage[(iHeight-1-n-j-1)*nWidthBytes+m+i+ii]<mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i])
						{
							queue.EnQueue((iHeight-1-n-j)*nWidthBytes+m+i);
							vary++;
							ii=2;
						}
					}
					if(vary==0)
					{
						if(mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i+1]<pOldBits[(iHeight-1-n-j)*nWidthBytes+m+i+1]
							&& mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i+1]<mediaimage[(iHeight-1-n-j)*nWidthBytes+m+i])
						{
							queue.EnQueue((iHeight-1-n-j)*nWidthBytes+m+i);
							ii=2;
						}
					}
						
				}
				int p;
				int height,width;
				while (queue.DeQueue(p)!=NULL)
				{
					width=p%nWidthBytes;
					height=iHeight-1-(p-width)/nWidthBytes;
					if(height<iHeight-1 && width<iWidth-1 && height>1 && width>1)
					{
						for(j=-1;j<2;j++)
						{
							for(i=-1;i<2;i++)
							{
								int a=(iHeight-1-height-j)*nWidthBytes+width+i;
								if (a!=(iHeight-1-height)*nWidthBytes+width)
								{
									if(mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i]<mediaimage[p] &&
										pOldBits[(iHeight-1-height-j)*nWidthBytes+width+i]!=mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i])
									{
										if(mediaimage[p]>=pOldBits[(iHeight-1-height-j)*nWidthBytes+width+i])
										{
											mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i]=pOldBits[(iHeight-1-height-j)*nWidthBytes+width+i];
										}
										else
										{
											mediaimage[(iHeight-1-height-j)*nWidthBytes+width+i]=mediaimage[p];
										}
										queue.EnQueue((iHeight-1-height-j)*nWidthBytes+width+i);
									}
								}
							}
						}
					}
				}
				for(j=0;j<iHeight;j++)
				{
					for(i=0;i<iWidth;i++)
					{
							pNewBits[(iHeight-1-j)*nWidthBytes+i]=mediaimage[(iHeight-1-j)*nWidthBytes+i];
					}
				}
				queue.DestroyQueue();
			
			}
}	
	}
	//Free the memory for the old image
	::GlobalUnlock(m_pImageObject->GetDib());
	::GlobalFree(m_pImageObject->GetDib());
	
	//Update the DIB in the object pointed by m_pImaeObject
	::GlobalUnlock(hNewDib);
	m_pImageObject->SetDib(hNewDib);
	
	return TRUE;
	
	
}