rsimage.cpp

基于小波的SAR斑点处理

		infFile->Write(pszTemp->GetBuffer(256),256);
	}

	// 写专题遥感影响的类别信息
	if(m_nImgType == IMAGE_THEMATIC)
	{
		infFile->Write(&m_nClassNumber,sizeof(int));
		CRsThematicInfo *pInfo;
		for(i=0; i<m_nClassNumber; i++)
		{
			pInfo = (CRsThematicInfo *)(m_aThemeInfoArray[i]);
			TRY
			{
				infFile->Write(&(pInfo->m_nValue),sizeof(int));
				infFile->Write(pInfo->m_szClassName.GetBuffer(256),256);

				infFile->Write(&(pInfo->m_clrColor),sizeof(COLORREF));
				infFile->Write(pInfo->m_pdCenter,sizeof(double)*m_nLinkedImage);
				infFile->Write(pInfo->m_pdCovariance,sizeof(double)*m_nLinkedImage*m_nLinkedImage);
			}
			CATCH( CFileException, e )		//Some error
			{
				AfxMessageBox("写文件时出错!");
				return FALSE;
			}
			END_CATCH
		}
	}
	
	return TRUE;
}

// 保存遥感影象
BOOL CRSImage::SaveImage(LPCTSTR lpszPathName)
{
	CFile datFile;
	if(0 == datFile.Open(lpszPathName,CFile::modeCreate|CFile::modeWrite))
	{
		AfxMessageBox("不能创建数据文件!");
		return FALSE;
	}

	char szInfFileName[256];
	CFile infFile;

	char szFileName[256];
	char drive[3];
	char dir[256];
	char ext[5];

	_splitpath( lpszPathName, drive, dir, szFileName, ext );
	strcpy( szInfFileName , drive );
	strcat( szInfFileName , dir);
	strcat( szInfFileName , szFileName);
	strcat( szInfFileName , ".inf");

	if(0 != infFile.Open(szInfFileName,CFile::modeCreate|CFile::modeWrite))
	{
		if(!SaveRsInfo(&infFile))
			return FALSE;
		
		/*
		DWORD dwFlag = HEADERFLAG;
		TRY
		{
			infFile.Write(&dwFlag,sizeof(DWORD));
			infFile.Write(&m_nImgHeight,((char *)&m_dWaveLength-(char *)&m_nImgHeight+sizeof(double)));
			infFile.Write(m_szImgName.GetBuffer(256),256);
			
			DWORD dwReserved = 0L;
			for(int i=0;i<10;i++)
			{
				infFile.Write(&dwReserved,sizeof(DWORD));
			}
			
			if(m_pdwHistogram==NULL)
			{
				CalHistogram();				
			}
			if(m_nImgType==IMAGE_COMBINE)
			{
				for(int i=0;i<3*256;i++)
					infFile.Write(&m_pdwHistogram[i],sizeof(DWORD));
			}
			else
			{
				for(int i=0;i<256;i++)
					infFile.Write(&m_pdwHistogram[i],sizeof(DWORD));
			}
		}
		
		CATCH( CFileException, e )		//Some error
		{
			File.Close();
			return FALSE;
		}
		END_CATCH
		*/
		infFile.Close();
	}
	else
	{
		AfxMessageBox("不能创建信息文件!");
		return FALSE;
	}

	if(!SaveRsImage(&datFile))
		return FALSE;
		
	datFile.Close();
	return TRUE;		
}

// 显示单波段和专题遥感图象
void CRSImage::ShowRsMap(CDC * pDC, int nBeginX, int nBeginY, double dRatio)
{
	// 申请内存
	BITMAPINFO  * bmpInfo;
	HLOCAL hbmpInfo = LocalAlloc(LHND,sizeof(BITMAPINFOHEADER)+MAX_COLOR*sizeof(RGBQUAD));
	bmpInfo = (BITMAPINFO *)LocalLock(hbmpInfo);

	// 设置相关控制信息
	BITMAPINFOHEADER   bmpHeader;
	bmpHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmpHeader.biWidth = m_nImgWidth;
	bmpHeader.biHeight = m_nImgHeight;
	bmpHeader.biPlanes = 1;
	bmpHeader.biBitCount = 8;
	bmpHeader.biCompression = BI_RGB;
	bmpHeader.biSizeImage = (long)(m_nImgWidth+3)/4*4*m_nImgHeight;
	bmpHeader.biXPelsPerMeter = 0L;
	bmpHeader.biYPelsPerMeter = 0L;
	bmpHeader.biClrUsed = 0L;
	bmpHeader.biClrImportant = 0L;

	// 设置调色板
	int i;
	if(m_pPal==NULL)
	{
		m_pPal = new COLORREF[256];
		if(m_nImgType == IMAGE_SINGLEBAND)		//单波段遥感影象
		{
			for(i=0; i<256; i++)
				m_pPal[i] = RGB(i,i,i); 
		}
		else									//专题遥感影象
		{
			CRsThematicInfo * pInfo;
			for(i=0; i<256; i++)				//清零
				m_pPal[i] = RGB(0,0,0); 
			for(i=0; i<m_nClassNumber; i++)		//读取类别信息
			{
				pInfo = m_aThemeInfoArray.GetAt(i);
				m_pPal[pInfo->m_nValue] = pInfo->m_clrColor;
			}
		}
	}
	
	// 设置重要颜色信息
	RGBQUAD  rgbPanel[MAX_COLOR];
	//if(!m_bPreview)
		for(i=0; i<MAX_COLOR; i++)
		{
			rgbPanel[i].rgbRed=GetRValue(m_pPal[i]);
			rgbPanel[i].rgbGreen=GetGValue(m_pPal[i]);
			rgbPanel[i].rgbBlue=GetBValue(m_pPal[i]);
			rgbPanel[i].rgbReserved=0;
		}
	//else
	//	for(i=0; i<MAX_COLOR; i++)
	//	{
	//		rgbPanel[i].rgbRed=GetRValue(m_pNewPal[i]);
	//		rgbPanel[i].rgbGreen=GetGValue(m_pNewPal[i]);
	//		rgbPanel[i].rgbBlue=GetBValue(m_pNewPal[i]);
	//		rgbPanel[i].rgbReserved=0;
	//	}

	//int nBmpColNum = (m_nImgWidth+3)/4*4;

	memcpy(bmpInfo->bmiColors,rgbPanel,MAX_COLOR*sizeof(RGBQUAD));
	bmpInfo->bmiHeader = bmpHeader;

	::StretchDIBits(pDC->GetSafeHdc(),nBeginX,nBeginY,(int)(m_nImgWidth*dRatio),
		(int)(m_nImgHeight*dRatio),0,0,m_nImgWidth,m_nImgHeight,
		m_pImgData,bmpInfo,DIB_RGB_COLORS,SRCCOPY);
}

// 显示真彩色合成遥感图象
void CRSImage::ShowRGBRsMap(CDC * pDC,int nBeginX,int nBeginY,double dRatio)
{
	// 申请内存
	BITMAPINFO  *bmpInfo;
	HLOCAL hBmpInfo = LocalAlloc(LHND,sizeof(BITMAPINFOHEADER));
	ASSERT(hBmpInfo != NULL);
	bmpInfo = (BITMAPINFO *)LocalLock(hBmpInfo);
    
	// 设置相关控制信息
	BITMAPINFOHEADER   bmpHeader;
	bmpHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmpHeader.biWidth = m_nImgWidth;
	bmpHeader.biHeight = m_nImgHeight;
	bmpHeader.biPlanes = 1;
	bmpHeader.biBitCount = 24;
	bmpHeader.biCompression = BI_RGB;
	bmpHeader.biSizeImage = (long)(m_nImgWidth*3+3)/4*4*m_nImgHeight;
	bmpHeader.biXPelsPerMeter = 0;
	bmpHeader.biYPelsPerMeter = 0;
	bmpHeader.biClrUsed = 0;
	bmpHeader.biClrImportant = 0;

	bmpInfo->bmiHeader = bmpHeader;

	::StretchDIBits(pDC->GetSafeHdc(),nBeginX,nBeginY,(int)(m_nImgWidth*dRatio),
		(int)(m_nImgHeight*dRatio),0,0,m_nImgWidth,m_nImgHeight,
		m_pImgData,bmpInfo,DIB_RGB_COLORS,SRCCOPY);
}

// 将图象存为BMP位图
BOOL CRSImage::SaveBmp(CFile *File)
{
	BITMAPFILEHEADER bmpfh;
	BITMAPINFOHEADER bmpheader;
	bmpfh.bfType = 19778;
	int nBmpCol;
	if(m_nImgType != IMAGE_COMBINE)
		nBmpCol = (m_nImgWidth+3)/4*4;
	else
		nBmpCol = (m_nImgWidth*3+3)/4*4;
	if(m_nImgType != IMAGE_COMBINE)
		bmpfh.bfSize = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+
						  256*sizeof(RGBQUAD)+(DWORD)m_nImgHeight*nBmpCol;
	else
		bmpfh.bfSize = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+
						  (DWORD)m_nImgHeight*nBmpCol;
	bmpfh.bfReserved1 = 0;
	bmpfh.bfReserved2 = 0;
	if(m_nImgType != IMAGE_COMBINE)
		bmpfh.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER)+
						  256*sizeof(RGBQUAD);
	else
		bmpfh.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
	bmpheader.biSize = sizeof(BITMAPINFOHEADER);
	bmpheader.biWidth = m_nImgWidth;
	bmpheader.biHeight = m_nImgHeight;
	bmpheader.biPlanes = 1;
	if(m_nImgType != IMAGE_COMBINE)
		bmpheader.biBitCount = 8;
	else
		bmpheader.biBitCount = 24;

	bmpheader.biCompression = BI_RGB;
	bmpheader.biSizeImage = (DWORD)m_nImgHeight*nBmpCol;
	bmpheader.biXPelsPerMeter = 0;
	bmpheader.biYPelsPerMeter = 0;
	bmpheader.biClrUsed = 0;
	bmpheader.biClrImportant = 0;

	TRY
	{
		File->Write(&bmpfh,sizeof(BITMAPFILEHEADER));
		File->Write(&bmpheader,sizeof(BITMAPINFOHEADER));
		if(m_nImgType != IMAGE_COMBINE)
		{
			RGBQUAD rgb[256];
			for(int i=0;i<MAX_COLOR;i++)
			{
				rgb[i].rgbRed=GetRValue(m_pPal[i]);
				rgb[i].rgbGreen=GetGValue(m_pPal[i]);
				rgb[i].rgbBlue=GetBValue(m_pPal[i]);
				rgb[i].rgbReserved=0;
			}
			File->Write(rgb,256*sizeof(RGBQUAD));
		}

		File->Write(m_pImgData,nBmpCol*m_nImgHeight);
	}
	CATCH( CFileException, e )		//Some error
	{
		return FALSE;
	}
	END_CATCH
	
	return TRUE;
}

// 计算直方图信息
void CRSImage::CalHistogram()
{
	int i,j;
	int nBmpColNum;

	// 清除原有直方图信息
	if(m_pdwHistogram != NULL)
	{
		delete []m_pdwHistogram;
		m_pdwHistogram = NULL;
	}

	// 申请内存，并清零
	if(m_nImgType == IMAGE_COMBINE)
	{
		m_pdwHistogram = new DWORD[3*MAX_COLOR];
		if(m_pdwHistogram == NULL)
		{
			AfxMessageBox("申请内存失败!");
			return;
		}
		for(i=0; i<3*MAX_COLOR; i++)
			m_pdwHistogram[i] = 0L;
		nBmpColNum = (m_nImgWidth*3+3)/4*4;
	}
	else
	{
		m_pdwHistogram = new DWORD[MAX_COLOR];
		if(m_pdwHistogram == NULL)
		{
			AfxMessageBox("申请内存失败!");
			return;
		}
		for(i=0;i<MAX_COLOR;i++)
			m_pdwHistogram[i]=0L;
		nBmpColNum = (m_nImgWidth+3)/4*4;
	}

	// 统计直方图各颜色值的象元数
	int nLineBegOrder = 0;
	for(i=0; i<m_nImgHeight; i++)			//行
	{
		for(j=0; j<m_nImgWidth; j++)		//列
		{
			if(m_nImgType == IMAGE_COMBINE)
			{
				m_pdwHistogram[m_pImgData[nLineBegOrder+3*j]]++;
				m_pdwHistogram[m_pImgData[nLineBegOrder+3*j+1]+MAX_COLOR]++;
				m_pdwHistogram[m_pImgData[nLineBegOrder+3*j+2]+MAX_COLOR*2]++;
			}
			else
			{
				m_pdwHistogram[m_pImgData[nLineBegOrder+j]]++;
			}	
		}
		nLineBegOrder += nBmpColNum;
	}
}

// 对单波段遥感影象做线性直方图变换
void CRSImage::AdjustUsingLUT(BYTE *pLUT)
{
	ASSERT(m_nImgType == IMAGE_SINGLEBAND);
	int Process=0;
	int RPro;
	int i,j;

	int nBmpColNum = (m_nImgWidth+3)/4*4;
	if(m_pUndoData != NULL)
	{
		delete []m_pUndoData;
	}
	m_pUndoData = m_pImgData;
	m_pImgData = NULL;
	m_pImgData = (LPBYTE)new BYTE[nBmpColNum*m_nImgHeight];
	if(m_pImgData == NULL)
	{
		AfxMessageBox("没有足够内存完成操作!");
		return;
	}

	//  变更图象数据块
	for(i=0; i<m_nImgHeight; i++)				//行
	{
		RPro=(int)(100.0 * (i+1) / m_nImgHeight);
		if(RPro>Process)
		{
			for(j=0; j<RPro-Process; j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(j=0; j<m_nImgWidth; j++)			//列
			m_pImgData[i*nBmpColNum+j] = pLUT[m_pUndoData[i*nBmpColNum+j]];
	}
	UpdateStatusBar();
}

// 对真彩色合成遥感影象做线性直方图变换
void CRSImage::AdjustUsingLUT(BYTE *pLUTRed,BYTE *pLUTGreen,BYTE *pLUTBlue)
{
	ASSERT(m_nImgType == IMAGE_COMBINE);
	int Process=0;
	int RPro;
	int i,j;

	// 变更图象数据块
	int nBmpColNum = (m_nImgWidth*3+3)/4*4;
	if(m_pUndoData != NULL)
	{
		delete []m_pUndoData;
	}
	m_pUndoData = m_pImgData;
	m_pImgData = NULL;
	m_pImgData = (LPBYTE)new BYTE[nBmpColNum*m_nImgHeight];
	if(m_pImgData == NULL)
	{
		AfxMessageBox("没有足够内存完成操作!");
		return;
	}

	for(i=0; i<m_nImgHeight; i++)				//行
	{
		RPro=(int)(100.0 * (i+1) / m_nImgHeight);	//设置进程指示
		if(RPro>Process)
		{
			for(j=0; j<RPro-Process; j++)
				UpdateStatusBar();
			Process=RPro;
		}
		for(j=0; j<m_nImgWidth; j++)			//列
		{
			m_pImgData[i*nBmpColNum+j*3+2] = pLUTRed[m_pUndoData[i*nBmpColNum+j*3+2]];
			m_pImgData[i*nBmpColNum+j*3+1] = pLUTGreen[m_pUndoData[i*nBmpColNum+j*3+1]];
			m_pImgData[i*nBmpColNum+j*3] = pLUTBlue[m_pUndoData[i*nBmpColNum+j*3]];	
		}
	}
	UpdateStatusBar();
}

// 对单波段遥感图象进行彩色分割
void CRSImage::Posterize(BYTE *lp,int nNum)
{
	if(m_nImgType != IMAGE_SINGLEBAND)
	{
		AfxMessageBox("该功能只适于单波段图象!");
		return;
	}

	//Look up table
	BYTE *pbLUT = new BYTE[256];
	ASSERT(pbLUT != NULL);
	BYTE *pTemp = new BYTE[256];
	ASSERT(pTemp != NULL);

	for(int j=0; j<nNum; j++)
	{
		pTemp[j] = BYTE(j*255.0/(nNum-1));
	}
	for(j=0; j<nNum; j++)
		for(int i=lp[j]; i<lp[j+1]; i++)
			pbLUT[i] = pTemp[j];
	pbLUT[255] = 255;
	
	delete []pTemp;
	AdjustUsingLUT(pbLUT);
	delete []pbLUT;
}

// 对单波段图象进行滤波(均值、中值、众数滤波)
void CRSImage::Filter(int WinSize,int Type)
{
	if(m_nImgType != IMAGE_SINGLEBAND)
	{
		AfxMessageBox("该功能只适于单波段图象!");
		return;
	}
	
	BYTE *TempLines = new BYTE[WinSize*m_nImgWidth];
	ASSERT(TempLines != NULL);
	BYTE *TempBlock = new BYTE[WinSize*WinSize];
	ASSERT(TempBlock != NULL);

	int RealSize1,RealSize2;
	int nBmpCol = (m_nImgWidth+3)/4*4;

	if(m_pUndoData != NULL)
	{
		delete []m_pUndoData;
	}
	m_pUndoData = m_pImgData;
	m_pImgData = NULL;
	m_pImgData = (LPBYTE)new BYTE[nBmpCol*m_nImgHeight];
	if(m_pImgData == NULL)
	{
		AfxMessageBox("没有足够内存完成操作!");
		return;
	}

	int Order;
	int Process=0;
	int RPro;
	int BegX;
	int BegY;
	int i,j,k,t;

	//Get the first (WinSize-1) lines
	for(i=0; i<=(WinSize/2-1); i++)
	{
		for(j=0; j<m_nImgWidth; j++)						//2:4/2
			TempLines[(i+WinSize/2)*m_nImgWidth+j] 
			= m_pUndoData[(m_nImgHeight-i-1)*nBmpCol+j];
	}

	for(i=0; i<m_nImgHeight; i++)
	{
		RPro=(int)(100.0 * (i+1) / m_nImgHeight);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}

		if(i<WinSize/2)
		{
			RealSize1 = WinSize/2+i+1;
			BegY = 0;
		}
		else if(i+WinSize/2>m_nImgHeight-1)
		{
			RealSize1 = WinSize/2+(m_nImgHeight-i);
			BegY = i-WinSize/2;
		}
		else
		{
			RealSize1 = WinSize;
			BegY = i-WinSize/2;
		}

		if(i+WinSize/2<m_nImgHeight)	//Should get a new line
		{
			for(j=0; j<m_nImgWidth; j++)						//2:4/2
				TempLines[((i+WinSize-1)%WinSize)*m_nImgWidth+j] =