rsimage.cpp

基于小波的SAR斑点处理

					m_pUndoData[(DWORD)(m_nImgHeight-(i+WinSize/2)-1)*nBmpCol+j];
		}
		for(j=0; j<m_nImgWidth; j++)
		{
			if(j<WinSize/2)
			{
				RealSize2 = WinSize/2+j+1;
				BegX = 0;
			}
			else if(j+WinSize/2>m_nImgWidth-1)
			{
				RealSize2 = WinSize/2+(m_nImgWidth-j);
				BegX = j-WinSize/2;
			}
			else
			{
				RealSize2 = WinSize;
				BegX = j-WinSize/2;
			}
			Order = 0;
			for(k=0;k<RealSize1;k++)
				for(t=0;t<RealSize2;t++)
				{
					TempBlock[Order] =
						TempLines[((BegY+k+WinSize/2)%WinSize)*m_nImgWidth+BegX+t];
					Order++;
				}
			if(Type==0)						//均值滤波
				*(m_pImgData+(DWORD)(m_nImgHeight-i-1)*nBmpCol+j) = mean(TempBlock,RealSize1*RealSize2);
			else if(Type==1)				//中值滤波
				*(m_pImgData+(DWORD)(m_nImgHeight-i-1)*nBmpCol+j) = media(TempBlock,RealSize1*RealSize2);
			else							//众数滤波
				*(m_pImgData+(DWORD)(m_nImgHeight-i-1)*nBmpCol+j) = many(TempBlock,RealSize1*RealSize2);
		}
	}
	UpdateStatusBar();

	delete []TempLines;
	delete []TempBlock;
}

// 垂直翻转遥感影象
void CRSImage::VertFlip()
{
	BYTE *pbTemp;

	int nBmpCol;
	if(m_nImgType==1||m_nImgType==2)
		nBmpCol = (m_nImgWidth+3)/4*4;
	else
		nBmpCol = (m_nImgWidth*3+3)/4*4;

	pbTemp = new BYTE[nBmpCol];
	ASSERT(pbTemp != NULL);

	int RPro;
	int Process = 0;
	int HalfHeight = m_nImgHeight/2;

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

	delete []pbTemp; 
}

// 水平翻转遥感影象
void CRSImage::HoriFlip()
{
	BYTE TempC;
	int nBmpCol;

	if(m_nImgType != IMAGE_COMBINE)
		nBmpCol = (m_nImgWidth+3)/4*4;
	else
		nBmpCol = (m_nImgWidth*3+3)/4*4;
	
	int RPro;
	int Process = 0;
	int HalfWidth = m_nImgWidth/2;

	for(int 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;
		}

		for(int j=0; j<HalfWidth; j++)
		{
			if(m_nImgType != IMAGE_COMBINE)
			{
				TempC = *(m_pImgData+(DWORD)i*nBmpCol+j);
				*(m_pImgData+(DWORD)i*nBmpCol+j) = 
					*(m_pImgData+(DWORD)i*nBmpCol+m_nImgWidth-j-1);
				*(m_pImgData+(DWORD)i*nBmpCol+m_nImgWidth-j-1) = TempC;
			}
			if(m_nImgType==3)
			{
				TempC = *(m_pImgData+(DWORD)i*nBmpCol+j*3);
				*(m_pImgData+(DWORD)i*nBmpCol+j*3) =
					*(m_pImgData+(DWORD)i*nBmpCol+(m_nImgWidth-j-1)*3);
				*(m_pImgData+(DWORD)i*nBmpCol+(m_nImgWidth-j-1)*3) = TempC;

				TempC = *(m_pImgData+(DWORD)i*nBmpCol+j*3+1);
				*(m_pImgData+(DWORD)i*nBmpCol+j*3+1) =
					*(m_pImgData+(DWORD)i*nBmpCol+(m_nImgWidth-j-1)*3+1);
				*(m_pImgData+(DWORD)i*nBmpCol+(m_nImgWidth-j-1)*3+1) = TempC;

				TempC = *(m_pImgData+(DWORD)i*nBmpCol+j*3+2);
				*(m_pImgData+(DWORD)i*nBmpCol+j*3+2) =
					*(m_pImgData+(DWORD)i*nBmpCol+(m_nImgWidth-j-1)*3+2);
				*(m_pImgData+(DWORD)i*nBmpCol+(m_nImgWidth-j-1)*3+2) = TempC;
			}
		}
	}
}

// 边缘检测
void CRSImage::FindEdge()
{
	if(m_nImgType != IMAGE_SINGLEBAND)
	{
		AfxMessageBox("该功能只适于单波段图象!");
		return;
	}

	int nBmpCol = (m_nImgWidth+3)/4*4;
	BYTE Byte1;
	BYTE Byte2;
	BYTE Byte3;
	BYTE Byte4;

	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 RPro;
	int Process = 0;
	int i,j;

	BYTE *bLineFirst = new BYTE[m_nImgWidth];
	ASSERT(bLineFirst != NULL);
	BYTE *bLineSecond = new BYTE[m_nImgWidth];
	ASSERT(bLineSecond != NULL);

	for(i=0; i<m_nImgHeight-1; i++)
	{
		RPro=(int)(100.0 * (i+2) / m_nImgHeight);
		if(RPro>Process)
		{
			for(int j=0;j<RPro-Process;j++)
				UpdateStatusBar();
			Process=RPro;
		}
		//Get two lines from the source image
		for(j=0; j<m_nImgWidth; j++)
		{
			bLineFirst[j] = m_pUndoData[(m_nImgHeight-1-i)*nBmpCol+j];
			bLineSecond[j] = m_pUndoData[(m_nImgHeight-1-(i+1))*nBmpCol+j];
		}
		for(j=0;j<m_nImgWidth-1;j++)
		{
			Byte1 = bLineFirst[j];
			Byte2 = bLineFirst[j+1];
			Byte3 = bLineSecond[j];
			Byte4 = bLineSecond[j+1];

			m_pImgData[(m_nImgHeight-i-1)*nBmpCol+j] = (BYTE)sqrt((float)(Byte4-Byte1)*(Byte4-Byte1)+
							 (float)(Byte2-Byte3)*(Byte2-Byte3));
		}
	}

	//Write The Last Line
	for(i=0; i<m_nImgWidth; i++)
		m_pImgData[(m_nImgHeight-1)*nBmpCol+i] = 
			m_pImgData[(m_nImgHeight-2)*nBmpCol+i];

	for(j=0; j<m_nImgHeight; j++)
		m_pImgData[(DWORD)j*nBmpCol+m_nImgWidth-1] = 
			m_pImgData[(DWORD)j*nBmpCol+m_nImgWidth-2];
	
	delete bLineFirst;
	delete bLineSecond;
}

// 影象二值化
void CRSImage::Threshold(int Limit)
{
	if(m_nImgType != IMAGE_SINGLEBAND)
	{
		AfxMessageBox("该功能只适于单波段图象!");
		return;
	}

	ASSERT(Limit<256 && Limit>=0);
	BYTE *pbLUT = new BYTE[256];
	ASSERT(pbLUT != NULL);

	for(int i=0; i<256; i++)
	{
		if(i<Limit)
			pbLUT[i] = 0;
		else
			pbLUT[i] = 255;
	}

	AdjustUsingLUT(pbLUT);

	delete pbLUT;
}

// 亮度与对比度调整
void CRSImage::BrightContrast(BYTE *pNewData,int NewBright,int NewContrast)
{
	if(m_nImgType == IMAGE_THEMATIC)
	{
		AfxMessageBox("本软件不提供对专题遥感图象进行亮度和对比度调整的功能。");
		return;
	}

	double Res;
	//int BmpColNum = (m_nImgWidth+3)/4*4;
	double Ratio1;
	double Ratio2;
	int i;

	if(NewContrast >= 0)
		Ratio1 = (double)NewContrast*NewContrast/10000*127+1;
	else
		Ratio1 = (double)(100+NewContrast)/100;

	if(NewBright >= 0)
		Ratio2 = (double)NewBright/100+1;
	else
		Ratio2 = (double)(100+NewBright)/100;

	BYTE *pbLUT = new BYTE[256];
	for(i=0; i<256; i++)
	{
		if(i >= 128)
			Res = (127+(i-127)*Ratio1)*Ratio2;
		else
			Res = (127-(127-i)*Ratio1)*Ratio2;
		
		if(Res > 255)
			pbLUT[i] = 255;
		else 
			if(Res < 0)
				pbLUT[i] = 0;
			else
				pbLUT[i] = (BYTE)Res;
	}

	if(m_nImgType == IMAGE_SINGLEBAND)					//单波段遥感图象
		AdjustUsingLUT(pbLUT);
	else	
		AdjustUsingLUT(pbLUT,pbLUT,pbLUT);		//真彩色合成图象
	
	delete []pbLUT;
}

// 对单波段遥感影象进行基于直方图的线性拉伸
void CRSImage::Stretch(BYTE *pNewData,int BegLim,int EndLim,int DownLim,int TopLim)
{
	ASSERT(m_nImgType == IMAGE_SINGLEBAND);
	double Res;
	BYTE ByteRes[256];

	for(int i=0; i<256; i++)
	{
		Res = (double)(i-BegLim)/(EndLim-BegLim+1)*255;
		if(Res > 255)
			Res=255;
		else if(Res<0)
			Res=0;
		Res = Res/255*(TopLim-DownLim+1)+DownLim;
		if(Res > 255)
			ByteRes[i]=255;
		else if(Res<0)
			ByteRes[i]=0;
		else
			ByteRes[i] = (BYTE)Res;
	}
	AdjustUsingLUT(ByteRes);
}

// 对彩色合成影象进行基于直方图的线性拉伸
void CRSImage::Stretch(BYTE *pNewData,int *BegLim,int *EndLim,int *DownLim,int *TopLim)
{
	ASSERT(m_nImgType == IMAGE_COMBINE);
	BYTE ByteRes[3][256];
	int i,j;
	float Res;
	for(j=0; j<3; j++)
		for(i=0; i<256; i++)
		{
			Res = (float)(i-BegLim[j])/(EndLim[j]-BegLim[j]+1)*255;
			if(Res > 255)
				Res = 255;
			else if(Res<0)
				Res=0;
			Res = Res/255*(TopLim[j]-DownLim[j]+1)+DownLim[j];
			if(Res > 255)
				ByteRes[j][i]=255;
			else if(Res<0)
				ByteRes[j][i]=0;
			else
				ByteRes[j][i] = (BYTE)Res;
		}

	AdjustUsingLUT(ByteRes[0],ByteRes[1],ByteRes[2]);
}

// 直方图均衡化(对专题遥感影象，做直方图均衡化是没有意义的)
void CRSImage::Equalize()
{
	if(m_nImgType == IMAGE_THEMATIC)
	{
		AfxMessageBox("对专题遥感图象做直方图均衡化没有任何意义!");
		return;
	}

	if(m_pdwHistogram == NULL)
		CalHistogram();

	DWORD dwSumPointNum = m_nImgHeight*m_nImgWidth;
	DWORD Unit = (DWORD)dwSumPointNum/256;
	DWORD Sum = 0;
	BYTE Res[3][256];
	int i,j;

	if(m_nImgType == IMAGE_SINGLEBAND)		//单波段遥感图象
		for(i=0; i<256; i++)
		{
			Sum += m_pdwHistogram[i];
			if((int)(Sum/Unit)-1<0)
				Res[0][i] = 0;
			else
				Res[0][i] = (int)(Sum/Unit)-1;
		}
	else									//真彩色合成遥感影象
	{
		for(i=0; i<3; i++)
			for(j=0; j<256; j++)
			{
				Sum += m_pdwHistogram[i*256+j];
				if((int)(Sum/Unit)-1<0)
					Res[i][j] = 0;
				else
					Res[i][j] = (int)(Sum/Unit)-1;
			}
	}

	if(m_nImgType == IMAGE_COMBINE)			//真彩色合成遥感影象
		AdjustUsingLUT(Res[0],Res[1],Res[2]);	
	else									//单波段遥感影象
		AdjustUsingLUT(Res[0]);
}

// 5*5窗口大小，将图象四周补两行两列零
void CRSImage::UserFilter(int *Matrix,int Factor,int Bias,int bInvert)
{
	if(m_nImgType != IMAGE_SINGLEBAND)
	{
		AfxMessageBox("该功能只适于单波段图象!");
		return;
	}

	int nBmpCol = (m_nImgWidth+3)/4*4;
	BYTE *Gray = new BYTE[5*(m_nImgWidth+4)];
	ASSERT(Gray != NULL);

	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 Res;
	int RPro;
	int Process = 0;
	int l,n;

	//Get the first four lines
	for(int i=-2; i<=1; i++)
	{
		if(i<0)
		{
			for(l=0; l<m_nImgWidth+4; l++)
				Gray[(i+2)*(m_nImgWidth+4)+l] = 0;
			continue;
		}
		for(int j=2; j<m_nImgWidth+2; j++)						//2:4/2
			Gray[(i+2)*(m_nImgWidth+4)+j] = m_pUndoData[(DWORD)(m_nImgHeight-i-1)*nBmpCol+j-2];

		//Fill the begin and the last location of one line
		Gray[(i+2)*(m_nImgWidth+4)+0] = 0;
		Gray[(i+2)*(m_nImgWidth+4)+1] = 0;
		Gray[(i+2)*(m_nImgWidth+4)+m_nImgWidth+2] = 0;
		Gray[(i+2)*(m_nImgWidth+4)+m_nImgWidth+3] = 0;
	}

	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+2>=m_nImgHeight)
			for(l=0; l<m_nImgWidth+4; l++)
				Gray[((i+4)%5)*(m_nImgWidth+4)+l] = 0;
		else
		{
			for(int j=2; j<m_nImgWidth+2; j++)						//2:4/2
				Gray[((i+4)%5)*(m_nImgWidth+4)+j] = 
					m_pUndoData[(m_nImgHeight-(i+2)-1)*nBmpCol+j-2];
			//Fill the begin and the last data
			Gray[((i+4)%5)*(m_nImgWidth+4)+0] = 0;
			Gray[((i+4)%5)*(m_nImgWidth+4)+1] = 0;
			Gray[((i+4)%5)*(m_nImgWidth+4)+m_nImgWidth+2] = 0;
			Gray[((i+4)%5)*(m_nImgWidth+4)+m_nImgWidth+3] = 0;
		}
		for(int j=0; j<m_nImgWidth; j++)
		{
			Res = 0;
			for(l=0; l<5; l++)
			{
				for(n=0; n<5; n++)
					Res += (int)Matrix[l*5+n]*Gray[(l+i)%5*(m_nImgWidth+4)+j+n];
			}
			Res = Res/Factor+Bias;							
			if(bInvert)
				Res = 255-Res;


			if(Res>255)
				m_pImgData[(DWORD)(m_nImgHeight-i-1)*nBmpCol+j] = 255;
			else if(Res<0)
				m_pImgData[(DWORD)(m_nImgHeight-i-1)*nBmpCol+j] = 0;
			else
				m_pImgData[(DWORD)(m_nImgHeight-i-1)*nBmpCol+j] = (BYTE)Res;
		}
	}
	delete []Gray;
}

// 影象重采样
void CRSImage::Resample(int nResHeight, int nResWidth, int nType)
{
	int BmpCol;
	int ResBmpCol;
	int Times;
	if(m_nImgType == IMAGE_COMBINE)
	{
		BmpCol = (m_nImgWidth*3+3)/4*4;
		ResBmpCol = (nResWidth*3+3)/4*4;
		Times = 3;
	}
	else
	{
		BmpCol = (m_nImgWidth+3)/4*4;
		ResBmpCol = (nResWidth+3)/4*4;
		Times = 1;
	}

	if(m_pUndoData != NULL)
		delete []m_pUndoData;
	m_pUndoData = m_pImgData;
	m_pImgData = (BYTE *)new BYTE[nResHeight*ResBmpCol];
	if(m_pImgData == NULL)
	{
		AfxMessageBox("没有足够内存完成重采样!");
		return;
	}

	float SearchX,SearchY;
	int  ISearchX,ISearchY;
	BYTE Byte[4][4];
	float Res[4],tempRes;
	float XShift,YShift;
	int RPro;
	int Process = 0;
	int tempX,tempY;

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