lfilterdlg.cpp

可调节自适应滤波器-代码.rar

{
	CRaderDoc*	pDoc = m_pView->GetDocument();
	ASSERT_VALID(pDoc);
	ASSERT(m_pData == m_pView->m_pImageData);

	double	dTemp, dTemp2;
	BYTE	Index;
	if(!bIs5)
	{
		//公式：y=k*x+(1-k)*x_average
		for(UINT i = 0; i < m_dwHeight; i++)
		{
			for(UINT j = 0; j < m_dwWidth; j++)
			{
				ASSERT(0.0 <= dSd[j + i * m_dwWidth] && dSd[j + i * m_dwWidth] <= 1.0);
				Index = (BYTE)(dSd[j + i * m_dwWidth] * 255.0);
				dTemp = pDoc->m_K[Index]; 
				ASSERT( dTemp >=0 && dTemp <=1.0);
				m_pShowData[j + i * m_dwWidth]	= (UNDATA)(dTemp * m_pData[j + i * m_dwWidth]
												+ (1.0 - dTemp)*m_pAverage[j + i * m_dwWidth]);
				//m_pShowData[j + i * m_dwWidth]	= (UNDATA)(m_pData[j + i * m_dwWidth]);
			}
		}
	}
	else//第五种算法
	{
		//打开文件
		CFile	f1, f2;
		CFileException e;
		DWORD	i, j;
		if(!f1.Open(pDoc->m_szXL,CFile::modeRead,&e))
		{
			AfxMessageBox("Cannot Open XL file!");
			return FALSE;
		}
		if(!f2.Open(pDoc->m_szXH,CFile::modeRead,&e))
		{
			AfxMessageBox("Cannot Open XH file!");
			return FALSE;
		}
		//UNDATA	dwTemp;
		UNDATA*	pData1 = new UNDATA[m_dwWidth];
		UNDATA*	pData2 = new UNDATA[m_dwWidth];
		for(i = 0; i < m_dwHeight; i++)
		{
			f1.Seek(((m_dwTop + i) * pDoc->m_dwWidth + m_dwLeft) * sizeof(UNDATA), CFile::begin);
			f2.Seek(((m_dwTop + i) * pDoc->m_dwWidth + m_dwLeft) * sizeof(UNDATA), CFile::begin);
			VERIFY(f1.Read(pData1, m_dwWidth * sizeof(UNDATA)));
			VERIFY(f2.Read(pData2, m_dwWidth * sizeof(UNDATA)));
			for(j = 0; j < m_dwWidth; j++)
			{
				//公式：y=nk*Xl+(1-nk)*Xh
				ASSERT(0.0 <= dSd[j + i * m_dwWidth] && dSd[j + i * m_dwWidth] <= 1.0);
				Index = (BYTE)(dSd[j + i * m_dwWidth] * 255.0);
				dTemp = pDoc->m_K[Index]; 
				ASSERT( dTemp >=0 && dTemp <=1.0);
				dTemp2 = pDoc->m_dN * dTemp * pData1[j] + (1.0 - pDoc->m_dN * dTemp) * pData2[j];
				
				if(dTemp2 < 0)
				{
					int yj=0;
				}
				
				//结果处理方式
				if(pDoc->m_nStrech == 0)	//（0-255）两侧截断
				{
					if(dTemp2 < 0)
						m_pShowData[j + i * m_dwWidth] = 0;
					else if(sizeof(UNDATA) == sizeof(DWORD) && dTemp2 >= pow(2, 32))
							m_pShowData[j + i * m_dwWidth] = (UNDATA)(pow(2, 32)-1);
					else if(sizeof(UNDATA) == sizeof(unsigned short) && dTemp2 >= pow(2, 16))
							m_pShowData[j + i * m_dwWidth] = (UNDATA)(pow(2, 16)-1);
					else if(sizeof(UNDATA) == sizeof(BYTE) && dTemp2 >= 256)
							m_pShowData[j + i * m_dwWidth] = 255;
					else
						m_pShowData[j + i * m_dwWidth] = (UNDATA)(dTemp2);
				}
				else if(pDoc->m_nStrech == 1)	//拉伸至（0-255）区间
				{
					m_pShowData[j + i * m_dwWidth] = (UNDATA)(dTemp2);
				}
				else
					ASSERT(FALSE);
			}
		}
		if(pDoc->m_nStrech == 1)	//拉伸至（0-255）区间:开始拉伸
		{
			double dMaxValue, dMinValue;
			double	dPOW;
			if(sizeof(UNDATA) == sizeof(DWORD))
			{
				dMaxValue = -pow(2, 32)+1;
				dMinValue = pow(2, 32)-1;
				dPOW = pow(2, 32);
			}
			else if(sizeof(UNDATA) == sizeof(unsigned short))
			{
				dMaxValue = -pow(2, 16)+1;
				dMinValue = pow(2, 16)-1;
				dPOW = pow(2, 16);
			}
			else if(sizeof(UNDATA) == sizeof(BYTE))
			{
				dMaxValue = -255;
				dMinValue = 255;
				dPOW = 256;
			}
			else
				ASSERT(FALSE);
			for(i = 0; i < m_dwHeight; i++)
			{
				for(j = 0; j < m_dwWidth; j++)
				{
					if(dMaxValue < m_pShowData[j + i * m_dwWidth])
						dMaxValue = m_pShowData[j + i * m_dwWidth];
					if(dMinValue > m_pShowData[j + i * m_dwWidth])
						dMinValue = m_pShowData[j + i * m_dwWidth];
				}
			}
			for(i = 0; i < m_dwHeight; i++)
			{
				for(j = 0; j < m_dwWidth; j++)
				{
					m_pShowData[j + i * m_dwWidth] = (UNDATA)((m_pShowData[j + i * m_dwWidth]-dMinValue)/
													(dMaxValue-dMinValue)*(dPOW-1.0));
				}
			}
		}
		f1.Close();
		f2.Close();
		delete[] pData1;
		delete[] pData2;	
	}

	if(m_pAverage != NULL)
	{
		delete m_pAverage;
		m_pAverage=NULL;
	}
	if(dSd != NULL)
	{
		delete dSd;
		dSd=NULL;
	}

	return TRUE;
}
BOOL LFilterDlg::RadarImageLFilter1()
{
	CRaderDoc*	pDoc = m_pView->GetDocument();
	ASSERT_VALID(pDoc);

	ASSERT(m_pData == m_pView->m_pImageData);

	UNDATA pdPixel[8];
	CMainFrame* pMainFrame = ((CMainFrame*)AfxGetMainWnd());
	pMainFrame->SetStatusBarText(0, "Start LFilter...");
	pMainFrame->OnProcessBegin();

	for(UINT i=1; i<m_dwHeight-1; i++)
	{
		pMainFrame->OnProcessUpdate(i-1, m_dwHeight - 2);
		for(UINT j=1; j<m_dwWidth-1; j++)
		{
			UINT dTemp;
			dTemp=0;
			UINT pt,pt1,pt2;
			for(UINT i1=i-1; i1<=i+1; i1++)
			{
				for(UINT j1=j-1; j1<=j+1; j1++)
				{
					if(i1==i&&j1==j)
					{
					}
					else
					{
						pdPixel[dTemp]=(UNDATA)fabs(m_pData[j1+i1*m_dwWidth]
							-m_pData[j+i*m_dwWidth]);
						dTemp++;
					}
				}
			}

			for(UINT k=0; k<7; k++)
			{
				UNDATA bMin,T;
	
				bMin=pdPixel[k];
				pt=k;
				for(UINT n=k; n<8; n++)
				{
					if(pdPixel[n]<bMin)
					{
						bMin=pdPixel[n];
						pt=n;
					}
				}

				T=pdPixel[k];
				pdPixel[k]=pdPixel[pt];
				pdPixel[pt]=T;
				if(k==0)
				{
					pt1=pt;
				}
				if(k==1)
				{
					pt2=pt;
				}
			}
			UINT dh1,dw1;
			UINT dh2,dw2;
			switch(pt1)
			{
			case 0:
				dh1=j-1;
				dw1=i-1;
				break;
			case 1:
				dh1=j;
				dw1=i-1;
				break;
			case 2:
				dh1=j+1;
				dw1=i-1;
				break;
			case 3:
				dh1=j-1;
				dw1=i;
				break;
			case 4:
				dh1=j+1;
				dw1=i;
				break;
			case 5:
				dh1=j-1;
				dw1=i+1;
				break;
			case 6:
				dh1=j;
				dw1=i+1;
				break;
			case 7:
				dh1=j+1;
				dw1=i+1;
				break;
			}
			switch(pt2)
			{
			case 1:
				dh2=j;
				dw2=i-1;
				break;
			case 2:
				dh2=j+1;
				dw2=i-1;
				break;
			case 3:
				dh2=j-1;
				dw2=i;
				break;
			case 4:
				dh2=j+1;
				dw2=i;
				break;
			case 5:
				dh2=j-1;
				dw2=i+1;
				break;
			case 6:
				dh2=j;
				dw2=i+1;
				break;
			case 7:
				dh2=j+1;
				dw2=i+1;
				break;
			}
			if(m_pData[j+i*m_dwWidth]<m_pData[dh1+dw1*m_dwWidth])
			{
				m_pShowData[j+i*m_dwWidth]=m_pData[dh1+dw1*m_dwWidth];
			}
			else if(m_pData[j+i*m_dwWidth]>m_pData[dh2+dw2*m_dwWidth])
			{
				m_pShowData[j+i*m_dwWidth]=m_pData[dh2+dw2*m_dwWidth];
			}
			else
			{
				m_pShowData[j+i*m_dwWidth]=m_pData[j+i*m_dwWidth];
			}
		
		}
	}
	pMainFrame->OnProcessEnd(i-1, m_dwHeight - 2);
	pMainFrame->SetStatusBarText(0, "");

	return TRUE;
}

void LFilterDlg::CalculateSD(const DWORD dwTemplateSize)
{
	ASSERT(m_pData == m_pView->m_pImageData);
	DWORD i, j;
	m_dwTemplateSize = dwTemplateSize;

	m_tempSize = (m_dwTemplateSize-1) / 2;
	if(m_pAverage != NULL)
		delete m_pAverage;
	m_pAverage = new double[m_dwWidth*m_dwHeight];
	if(dSd != NULL)
		delete dSd;
	dSd = new double[m_dwWidth*m_dwHeight];
	for(i = 0; i < m_dwWidth*m_dwHeight; i++)
	{
		m_pAverage[i]=0;
		dSd[i]=0;
	}
	CMainFrame* pMainFrame = ((CMainFrame*)AfxGetMainWnd());
	pMainFrame->SetStatusBarText(0, "Start calculate average value and variance...");
	pMainFrame->OnProcessBegin();
	//m_tempSize = 1, 2, 3
	UNDATA*	pData = NULL;
	pData = new UNDATA[(m_tempSize*2+1) * (m_tempSize*2+1)];
	for(i=m_tempSize;i<m_dwHeight-m_tempSize;i++)
	{
		pMainFrame->OnProcessUpdate(i-m_tempSize, m_dwHeight-m_tempSize*2);
		for(j=m_tempSize;j<m_dwWidth-m_tempSize;j++)
		{
			//计算均值
			DWORD	dwCount = 0;
			for(UINT i1=i-m_tempSize;i1<=i+m_tempSize;i1++)
				for(UINT j1=j-m_tempSize;j1<=j+m_tempSize;j1++)
				{
					pData[dwCount] = m_pData[j1+i1*m_dwWidth];
					dwCount ++;
				}
			if(m_bMidValue)
				m_pAverage[j+i*m_dwWidth] = GetMidValue(pData, (m_tempSize*2+1) * (m_tempSize*2+1), TRUE);
			else
				m_pAverage[j+i*m_dwWidth] = GetMidValue(pData, (m_tempSize*2+1) * (m_tempSize*2+1), FALSE);

			double dSum2=0.0;
			for(UINT i2=i-m_tempSize;i2<=i+m_tempSize;i2++){
				for(UINT j2=j-m_tempSize;j2<=j+m_tempSize;j2++){
					dSum2 += (m_pData[j2+i2*m_dwWidth]-m_pAverage[j+i*m_dwWidth]) * 
							 (m_pData[j2+i2*m_dwWidth]-m_pAverage[j+i*m_dwWidth]);
				}
			}
					
			dSd[j+i*m_dwWidth] = sqrt( dSum2 / (m_dwTemplateSize*m_dwTemplateSize-1) );		
			if(dSd[j+i*m_dwWidth]>sd_max)
			{
				sd_max=dSd[j+i*m_dwWidth];
			}
			if(dSd[j+i*m_dwWidth]<sd_min)
			{
				sd_min=dSd[j+i*m_dwWidth];
			}
		}
	}
	delete[] pData;
	pMainFrame->OnProcessEnd(i-m_tempSize, m_dwHeight-m_tempSize*2);
	pMainFrame->SetStatusBarText(0, "");
	//标准化
	for(UINT i3=m_tempSize;i3<m_dwHeight-m_tempSize;i3++)
	{
		for(UINT j3=m_tempSize;j3<m_dwWidth-m_tempSize;j3++)
		{
			dSd[j3+i3*m_dwWidth]=(dSd[j3+i3*m_dwWidth] - sd_min) / (sd_max - sd_min);
			ASSERT(dSd[j3+i3*m_dwWidth] >=0 && dSd[j3+i3*m_dwWidth] <=1.0);
		}
	}		

	//补数据...暂时不补
	/*
	for(i=0;i<m_tempSize;i++)
	{
		//上行
		for(j=0; j<m_dwWidth; j++)
		{
			m_pAverage[i * m_dwWidth + j] = m_pAverage[(m_tempSize + i) * m_dwWidth + j];
			dSd[i * m_dwWidth + j] = dSd[(m_tempSize + i) * m_dwWidth + j];
		}
		//下行
		for(j=0; j<m_dwWidth; j++)
		{
			m_pAverage[(m_dwHeight-m_tempSize+i) * m_dwWidth + j] 
						= m_pAverage[(m_dwHeight-m_tempSize*2+i) * m_dwWidth + j];
			dSd[(m_dwHeight-m_tempSize+i) * m_dwWidth + j] 
						= dSd[(m_dwHeight-m_tempSize*2+i) * m_dwWidth + j];
		}
	}
	for(i=0;i<m_dwHeight;i++)
	{
		//左列
		for(j=0; j<m_tempSize; j++)
		{
			m_pAverage[i * m_dwWidth + j] = m_pAverage[i * m_dwWidth + j + m_tempSize];
			dSd[i * m_dwWidth + j] = dSd[i * m_dwWidth + j + m_tempSize];
		}
		//右列
		for(j=0; j<m_tempSize; j++)
		{
			m_pAverage[i * m_dwWidth + (m_dwWidth-m_tempSize+j)] = 
						m_pAverage[i * m_dwWidth + (m_dwWidth-m_tempSize*2+j)];
			dSd[i * m_dwWidth + (m_dwWidth-m_tempSize+j)] = 
						dSd[i * m_dwWidth + (m_dwWidth-m_tempSize*2+j)];
		}
	}*/
}

void LFilterDlg::OnChangeModel() 
{
	CRaderDoc*	pDoc = m_pView->GetDocument();
	ASSERT_VALID(pDoc);

	CModelDlg dlg;
	switch(m_nModel)
	{
	case 3:
		dlg.m_nModel = 0;
		break;
	case 5:
		dlg.m_nModel = 1;
		break;
	case 7:
		dlg.m_nModel = 2;
		break;
	case 9:
		dlg.m_nModel = 3;
		break;
	case 11:
		dlg.m_nModel = 4;
		break;
	case 13:
		dlg.m_nModel = 5;
		break;
	case 15:
		dlg.m_nModel = 6;
		break;
	default:
		ASSERT(FALSE);
		break;
	}
	if(m_bMidValue)
		dlg.m_nMid = 0;
	else
		dlg.m_nMid = 1;

	dlg.m_bOutFile = pDoc->m_bOutFile;
	dlg.m_szXH = pDoc->m_szXH;
	dlg.m_szXL = pDoc->m_szXL;
	dlg.m_dN = pDoc->m_dN;
	dlg.m_nStrech = pDoc->m_nStrech;

	if(IDOK == dlg.DoModal())
	{
		switch(dlg.m_nModel)
		{
		case 0:
			m_nModel = 3;
			break;
		case 1:
			m_nModel = 5;
			break;
		case 2:
			m_nModel = 7;
			break;
		case 3:
			m_nModel = 9;
			break;
		case 4:
			m_nModel = 11;
			break;
		case 5:
			m_nModel = 13;
			break;
		case 6:
			m_nModel = 15;
			break;
		default:
			ASSERT(FALSE);
			break;
		}
		if(dlg.m_nMid == 0)
			m_bMidValue = TRUE;
		else if(dlg.m_nMid == 1)
			m_bMidValue = FALSE;

		pDoc->m_bOutFile = dlg.m_bOutFile;
		pDoc->m_szXH = dlg.m_szXH;
		pDoc->m_szXL = dlg.m_szXL;
		pDoc->m_dN = dlg.m_dN;
		pDoc->m_nStrech = dlg.m_nStrech;
		m_pView->GetDocument()->m_nModel = m_nModel;
	}
}

void LFilterDlg::OnCurveDefault() 
{
	RECT Rect;
	//SetRect(&Rect,7,7,117,117);
	SetRect(&Rect,5,5,133,52);
	MapDialogRect(&Rect);

	CPoint *pPoint;
	int i;
	for(i=0;i<m_aPoints.GetSize();i++)
	{
		pPoint = (CPoint *)(m_aPoints[i]);
		delete pPoint;
	}
	m_aPoints.RemoveAll();

	int		nMin, nMax;
	double	dSum = 0.0;
	double	dTotalSum = 0.0;
	for(i=0; i<256; i++)
	{
		dTotalSum += m_ColorData[i];
	}
	for(i=0; i<255; i++)
	{
		dSum += m_ColorData[i];
		if(dSum/dTotalSum <= 0.05 && (dSum+m_ColorData[i+1])/dTotalSum >= 0.05)
			nMin = i;
		else if(dSum/dTotalSum <= 0.95 && (dSum+m_ColorData[i+1])/dTotalSum >= 0.95)
			nMax = i;
	}
	ASSERT(nMin >= 0 && nMin <= 255);
	ASSERT(nMax >= 0 && nMax <= 255);
	pPoint = new CPoint(0,0);
	m_aPoints.Add(pPoint);
	pPoint = new CPoint(nMin,0);
	m_aPoints.Add(pPoint);
	pPoint = new CPoint(nMax,100);
	m_aPoints.Add(pPoint);
	pPoint = new CPoint(255,100);
	m_aPoints.Add(pPoint);
	
	InvalidateRect(&Rect);
}

void LFilterDlg::OnCurveOpen() 
{
	CFileDialog dlg( TRUE, "*.cuv", NULL,  
					OFN_HIDEREADONLY | OFN_FILEMUSTEXIST,
					"LFilter curve(*.cuv) | *.cuv"
					"||");