rsipview.cpp

基于小波的SAR斑点处理

					CurOptr.Type = Optr[OptrStkNum-1].Type;
					CurOptr.Flag = Optr[OptrStkNum-1].Flag;
					OptrStkNum--;
					if(CurOptr.Type == FUNCTION)
					{
						//Pop an Operater Number;
						Opnd1 = Opnd[OpndStkNum-1];
						OpndStkNum--;
						if(Opnd1.Type == NUMBER)
						{
							float TmpNumber = Fuction(Opnd1.Number,CurOptr.Flag);
							Opnd[OpndStkNum].Number=TmpNumber;
							Opnd[OpndStkNum].Type=NUMBER;
							OpndStkNum++;
						}
						else if(Opnd1.Type == ISFILENAME)
						{
							Filehp1 = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width);
							if(Filehp1==NULL)
							{
								MessageBox("没有足够内存载入文件!");
								return;
							}
							BYTE *bp = (BYTE *)GlobalLock(Filehp1);

							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;	
							}	
							float *Resp = (float *)GlobalLock(Resfh);

							File.Open(Opnd1.FileName,CFile::modeRead);
							File.Read((void *)bp,(DWORD)Width*Height);
							File.Close();

							Fuction(Resp,bp,Height,Width,CurOptr.Flag);
	
							GlobalFree(Filehp1);
							GlobalUnlock(Resfh);

							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type == MEMHANDLE)
						{
							float *Thep = (float *)GlobalLock(Opnd1.Handle);

							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							Fuction(Resp,Thep,Height,Width,CurOptr.Flag);

							GlobalFree(Opnd1.Handle);
							GlobalUnlock(Resfh);

							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						continue;
					}
					else
					{
						//Pop Opnd Stack
						Opnd1 = Opnd[OpndStkNum-2];
						Opnd2 = Opnd[OpndStkNum-1];
						OpndStkNum-=2;
						if(Opnd1.Type==NUMBER && Opnd2.Type==NUMBER)
						{	
							float TmpNumber = Operate(Opnd1.Number,Opnd2.Number,CurOptr.Flag);
							Opnd[OpndStkNum].Type = NUMBER;
							Opnd[OpndStkNum].Number = TmpNumber;
							OpndStkNum++;
						}
						else if(Opnd1.Type==NUMBER && Opnd2.Type==ISFILENAME)
						{
							Filehp1 = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width);
							if(Filehp1==NULL)
							{
								MessageBox("没有足够内存载入文件!");
								return;
							}
							BYTE *bp = (BYTE *)GlobalLock(Filehp1);

							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							File.Open(Opnd2.FileName,CFile::modeRead);
							File.Read((void *)bp,(DWORD)Width*Height);
							File.Close();
							
							Operate(Resp,Opnd1.Number,bp,Height,Width,CurOptr.Flag);
							GlobalFree(Filehp1);
							GlobalUnlock(Resfh);

							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type==NUMBER && Opnd2.Type==MEMHANDLE)
						{
							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							float *Thep = (float *)GlobalLock(Opnd2.Handle);

							Operate(Resp,Opnd1.Number,Thep,Height,Width,CurOptr.Flag);
							GlobalFree(Opnd2.Handle);
							GlobalUnlock(Resfh);
							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type==ISFILENAME && Opnd2.Type==NUMBER)
						{
							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							Filehp1 = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width);
							if(Filehp1==NULL)
							{
								MessageBox("没有足够内存载入文件!");
								return;
							}
							BYTE *bp = (BYTE *)GlobalLock(Filehp1);

							File.Open(Opnd1.FileName,CFile::modeRead);
							File.Read((void *)bp,(DWORD)Width*Height);
							File.Close();
							
							Operate(Resp,bp,Opnd2.Number,Height,Width,CurOptr.Flag);

							GlobalFree(Filehp1);
							GlobalUnlock(Resfh);
							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type==ISFILENAME && Opnd2.Type==ISFILENAME)
						{
							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							Filehp1 = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width);
							if(Filehp1 == NULL)
							{
								MessageBox("没有足够内存载入文件!");
								return;
							}
							BYTE *bp1 = (BYTE *)GlobalLock(Filehp1);

							File.Open(Opnd1.FileName,CFile::modeRead);
							File.Read((void *)bp1,(DWORD)Width*Height);
							File.Close();
							
							Filehp2 = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width);
							if(Filehp2 == NULL)
							{
								MessageBox("没有足够内存载入文件!");
								return;
							}
							BYTE *bp2= (BYTE *)GlobalLock(Filehp2);

							File.Open(Opnd2.FileName,CFile::modeRead);
							File.Read((void *)bp2,(DWORD)Width*Height);
							File.Close();

							Operate(Resp,bp1,bp2,Height,Width,CurOptr.Flag);

							GlobalFree(Filehp1);
							GlobalFree(Filehp2);

							GlobalUnlock(Resfh);
							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type==ISFILENAME && Opnd2.Type==MEMHANDLE)
						{
							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							Filehp1 = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width);
							if(Filehp1==NULL)
							{
								MessageBox("没有足够内存载入文件!");
								return;
							}
							BYTE *bp1 = (BYTE *)GlobalLock(Filehp1);

							File.Open(Opnd1.FileName,CFile::modeRead);
							File.Read((void *)bp1,(DWORD)Width*Height);
							File.Close();
							
							float *Thep = (float *)GlobalLock(Opnd2.Handle);

							Operate(Resp,bp1,Thep,Height,Width,CurOptr.Flag);

							GlobalFree(Filehp1);
							GlobalFree(Opnd2.Handle);

							GlobalUnlock(Resfh);
							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type==MEMHANDLE && Opnd2.Type==NUMBER)
						{
							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							float *Thep = (float *)GlobalLock(Opnd1.Handle);

							Operate(Resp,Thep,Opnd2.Number,Height,Width,CurOptr.Flag);

							GlobalFree(Opnd1.Handle);

							GlobalUnlock(Resfh);
							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type==MEMHANDLE && Opnd2.Type==ISFILENAME)
						{
							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh == NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							float *Thep = (float *)GlobalLock(Opnd1.Handle);

							Filehp1 = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width);
							if(Filehp1 == NULL)
							{
								MessageBox("没有足够内存载入文件!");
								return;
							}
							BYTE *bp1 = (BYTE *)GlobalLock(Filehp1);

							File.Open(Opnd2.FileName,CFile::modeRead);
							File.Read((void *)bp1,(DWORD)Width*Height);
							File.Close();

							Operate(Resp,Thep,bp1,Height,Width,CurOptr.Flag);

							GlobalFree(Filehp1);
							GlobalFree(Opnd1.Handle);

							GlobalUnlock(Resfh);
							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						else if(Opnd1.Type==MEMHANDLE && Opnd2.Type==MEMHANDLE)
						{
							Resfh = GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE,(DWORD)Height*Width*sizeof(float));
							if(Resfh==NULL)
							{
								MessageBox("没有足够内存进行计算!");
								return;
							}
							float *Resp = (float *)GlobalLock(Resfh);

							float *Thep1 = (float *)GlobalLock(Opnd1.Handle);
							float *Thep2 = (float *)GlobalLock(Opnd2.Handle);

							Operate(Resp,Thep1,Thep2,Height,Width,CurOptr.Flag);

							GlobalFree(Opnd1.Handle);
							GlobalFree(Opnd2.Handle);

							GlobalUnlock(Resfh);
							Opnd[OpndStkNum].Handle=Resfh;
							Opnd[OpndStkNum].Type=MEMHANDLE;
							OpndStkNum++;
						}
						continue;
					}
				}
			}
		}
		//Calculate Ended
		int BmpCol = (Width+3)/4*4;
		BYTE *pNewData = (BYTE *)malloc(BmpCol*Height);
		BYTE TmRes;

		if(Opnd[OpndStkNum-1].Type == NUMBER)
		{
			if(Opnd[OpndStkNum-1].Number<0)
				TmRes = 0;
			else if(Opnd[OpndStkNum-1].Number>255)
				TmRes = 255;
			else TmRes = (BYTE)(Opnd[OpndStkNum-1].Number+0.5);
			int Process=0;
			int RPro;
			for(i=0; i<Height; i++)
			{
				RPro=(int)(100.0 * (i+1) / Height);
				if(RPro>Process)
				{
					for(int j=0; j<RPro-Process; j++)
						UpdateStatusBar();
					Process=RPro;
				}
				for(int j=0; j<Width; j++)
					pNewData[(DWORD)(Height-i-1)*BmpCol+j] = TmRes;
			}
		}
		else if(Opnd[OpndStkNum-1].Type == MEMHANDLE)
		{
			float *Thep = (float *)GlobalLock(Opnd[OpndStkNum-1].Handle);
			int Process=0;
			int RPro;
			for(i=0; i<Height; i++)
			{
				RPro=(int)(100.0 * (i+1) / Height);
				if(RPro>Process)
				{
					for(int j=0; j<RPro-Process; j++)
						UpdateStatusBar();
					Process=RPro;
				}
				for(int j=0; j<Width; j++)
				{
					if(Thep[(DWORD)i*Width+j]<0)
						TmRes = 0;
					else if(Thep[(DWORD)i*Width+j]>255)
						TmRes = 255;
					else 
						TmRes = (BYTE)(Thep[(DWORD)i*Width+j]+0.5);
					pNewData[(DWORD)(Height-i-1)*BmpCol+j] = TmRes;
				}
			}
	 		GlobalFree(Opnd[OpndStkNum-1].Handle);
		}
		delete []pTheToken;
		delete []Opnd;
		delete []Optr;
		CRSIPApp *theApp = (CRSIPApp *)AfxGetApp();

		CRSImage *pNewRSImage = new CRSImage();
					
		pNewRSImage->m_pImgData = pNewData;
		pNewRSImage->m_nImgHeight = Height;
		pNewRSImage->m_nImgWidth = Width;
		pNewRSImage->m_nImgType = nImgType;

		theApp->CreateNewImageDoc(pNewRSImage,"未命名图象");

		EndWaitCursor();
	}
}

void CRSIPView::OnImagePowerinfo() 
{
	CRSIPDoc * pDoc = (CRSIPDoc *)GetDocument();
	ASSERT(pDoc != NULL);

	if(pDoc->m_pRSImage!=NULL &&  
		pDoc->m_pRSImage->m_pImgData!=NULL)
	{
		if(pDoc->m_pRSImage->m_nImgType!=IMAGE_SINGLEBAND)
		{
			MessageBox("该功能只适用于单波段图象!");
			return;
		}

		int Size=pDoc->m_pRSImage->m_nImgWidth>pDoc->m_pRSImage->m_nImgHeight?
				pDoc->m_pRSImage->m_nImgWidth:pDoc->m_pRSImage->m_nImgHeight;

		if(Size > 1024)
		{
			MessageBox("做二维快速傅立叶变换的图象过大!");
			return;
		}

		int Time=powerof2(2,Size);
		//int Time=int(log(Size)/log(2))+1;
		Size=1;
		for(int i=0; i<Time; i++)
			Size*=2;
	
		BYTE *pbMap = (BYTE *)malloc(Size*Size);
		if(pbMap == NULL)
		{
			MessageBox("做二维快速傅立叶变换，内存不足!");
			return;
		}
	
		int BmpCol = (pDoc->m_pRSImage->m_nImgWidth+3)/4*4;
		for(i=0; i<pDoc->m_pRSImage->m_nImgHeight; i++)
			for(int j=0; j<pDoc->m_pRSImage->m_nImgWidth; j++)
				pbMap[(DWORD)i*Size+j] =
					pDoc->m_pRSImage->m_pImgData[(DWORD)(pDoc->m_pRSImage->m_nImgHeight-i-1)*BmpCol+j];


		float *lpreal = NULL;
		float *lpimag = NULL;
		lpreal = (float *)malloc(sizeof(float)*Size*Size);
		lpimag = (float *)malloc(sizeof(float)*Size*Size);
	
		if(lpimag==NULL || lpreal==NULL)
		{
			if(lpimag != NULL)
				free(lpimag);
			if(lpreal != NULL)	
				free(lpreal);
			free(pbMap);
			MessageBox("做二维快速傅立叶变换，内存不足!");
			return;
		}	

		BeginWaitCursor();

		float Temp;

		for ( i=0; i<Size; i++)
			for (int j=0; j<Size; j++)
			{
				Temp= (float)pbMap[(DWORD)i*Size+j];
				if ( (i+j) %2 != 0 )
					lpreal[(DWORD)i*Size+j] =  -Temp;
				else
					lpreal[(DWORD)i*Size+j] = Temp;
				lpimag[(DWORD)i*Size+j] = 0.0;
			}
		free(pbMap);

		FFT2D( lpreal, lpimag, Size, 0 ,Time);