raderdoc.cpp

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

	if(!f1.Open(m_szFilePath,CFile::modeRead,&e))
	{
		AfxMessageBox("Cannot Open file!");
		return FALSE;
	}
	if(!f2.Open(szResultPath,CFile::modeCreate | CFile::modeWrite,&e))
	{
		AfxMessageBox("Cannot Save file!");
		return FALSE;
	}

	DWORD	dwD = (m_nModel-1)/2; //d: 1, 2, 3
	UNDATA*	pData = new UNDATA[m_dwWidth * m_nModel];
	UNDATA*	pTemplette = NULL;
	pTemplette = new UNDATA[m_nModel*m_nModel];
	UNDATA*	pLineWriteData = new UNDATA[m_dwWidth];

	CMainFrame* pMainFrame = ((CMainFrame*)AfxGetMainWnd());
	pMainFrame->SetStatusBarText(0, "Start calculate average value and variance...");
	pMainFrame->OnProcessBegin();

	DWORD	k;
	for(i = 0; i < m_dwHeight-m_nModel+1; i++)
	{
		pMainFrame->OnProcessUpdate(i, m_dwHeight-m_nModel+1);

		f1.Seek(i * m_dwWidth * sizeof(UNDATA), CFile::begin);
		VERIFY(f1.Read(pData, m_nModel * m_dwWidth * sizeof(UNDATA)));
		if(i == 0)
		{
			for(j=0; j<dwD; j++)
			{
				for(k = 0; k < m_dwWidth; k++)
					pLineWriteData[k] = 0;

				f2.Write(pLineWriteData, m_dwWidth * sizeof(UNDATA));
			}

		}

		for(j = 0; j < m_dwWidth-m_nModel+1; j++)
		{
			DWORD	dwCount = 0;
			for(m=0; m<m_nModel; m++)
			{
				for(n=0; n<m_nModel; n++)
				{
					pTemplette[dwCount] = pData[m * m_dwWidth + j + n];
					dwCount ++;
				}
			}
			pLineWriteData[j+dwD] = (UNDATA)GetOutValue4(pTemplette, m_nModel*m_nModel,m_dwM4);
		}
		//补左数据
		for(j=0; j<dwD; j++)
		{
			pLineWriteData[j] = 0;//pLineWriteData[dwD];
		}
		//补右数据
		for(j=m_dwWidth-dwD; j<m_dwWidth; j++)
		{
			pLineWriteData[j] = 0;//pLineWriteData[m_dwWidth-dwD-1];
		}
		f2.Write(pLineWriteData, m_dwWidth * sizeof(UNDATA));
	}
	pMainFrame->OnProcessEnd(i, m_dwHeight-m_nModel+1);
	pMainFrame->SetStatusBarText(0, "");

	for(j=0; j<dwD; j++)
	{
		for(k = 0; k < m_dwWidth; k++)
			pLineWriteData[k] = 0;
		f2.Write(pLineWriteData, m_dwWidth * sizeof(UNDATA));
	}
	f1.Close();
	f2.Close();
	delete[]	pData;
	delete[]	pTemplette;
	delete[]	pLineWriteData;

	return TRUE;
}
BOOL CRaderDoc::LeeFilter2(CString szResultPath, BOOL bIs5)
{
	ASSERT(m_szFilePath != "");
	ASSERT(m_szAvrPath != "");
	ASSERT(m_szSdPath != "");
	ASSERT(szResultPath != "");
	ASSERT(m_bHasReady);
	ASSERT(m_dwWidth != 0);
	ASSERT(m_dwHeight != 0);

	//打开文件
	CFile	f0, f1, f2, f3;
	CFile	file1, file2;
	CFileException e;
	DWORD	i, j;
	if(!f0.Open(m_szFilePath,CFile::modeRead,&e))
	{
		AfxMessageBox("Cannot Open file!");
		return FALSE;
	}
	if(!f1.Open(m_szAvrPath,CFile::modeRead,&e))
	{
		AfxMessageBox("Cannot Open Avr file!");
		return FALSE;
	}
	if(!f2.Open(m_szSdPath,CFile::modeRead,&e))
	{
		AfxMessageBox("Cannot Open Sd file!");
		return FALSE;
	}
	if(!f3.Open(szResultPath,CFile::modeCreate | CFile::modeWrite,&e))
	{
		AfxMessageBox("Cannot Save file!");
		return FALSE;
	}
	if(bIs5)
	{
		if(!file1.Open(m_szXL,CFile::modeRead,&e))
		{
			AfxMessageBox("Cannot Open XL file!");
			return FALSE;
		}
		if(!file2.Open(m_szXH,CFile::modeRead,&e))
		{
			AfxMessageBox("Cannot Open XH file!");
			return FALSE;
		}
	}
	UNDATA*	pLineData = new UNDATA[m_dwWidth];
	double*	pLineAvrData = new double[m_dwWidth];
	double*	pLineSdData = new double[m_dwWidth];
	UNDATA*	pResultData = new UNDATA[m_dwWidth];
	UNDATA*	pData1 = NULL;
	UNDATA*	pData2 = NULL;
	CMainFrame* pMainFrame = ((CMainFrame*)AfxGetMainWnd());
	BYTE	Index;
	double	dTemp, dTemp2;
	if(bIs5)
	{
		pData1 = new UNDATA[m_dwWidth];
		pData2 = new UNDATA[m_dwWidth];
	}
	pMainFrame->SetStatusBarText(0, "LFilter...");
	pMainFrame->OnProcessBegin();
	for(i = 0; i < m_dwHeight; i++)
	{
		pMainFrame->OnProcessUpdate(i, m_dwHeight);
		f0.Seek(i * m_dwWidth * sizeof(UNDATA), CFile::begin);
		VERIFY(f0.Read(pLineData, m_dwWidth * sizeof(UNDATA)));
		f1.Seek(i * m_dwWidth * sizeof(double), CFile::begin);
		VERIFY(f1.Read(pLineAvrData, m_dwWidth * sizeof(double)));
		f2.Seek(i * m_dwWidth * sizeof(double), CFile::begin);
		VERIFY(f2.Read(pLineSdData, m_dwWidth * sizeof(double)));

		if(bIs5)
		{
			file1.Seek(i * m_dwWidth * sizeof(UNDATA), CFile::begin);
			file2.Seek(i * m_dwWidth * sizeof(UNDATA), CFile::begin);
			VERIFY(file1.Read(pData1, m_dwWidth * sizeof(UNDATA)));
			VERIFY(file2.Read(pData2, m_dwWidth * sizeof(UNDATA)));
		}
		for(j = 0; j < m_dwWidth; j++)
		{
			if(!bIs5)
			{
				//公式：y=k*x+(1-k)*x_average
				ASSERT(pLineSdData[j] >= m_dMinSd && pLineSdData[j] <= m_dMaxSd);
				dTemp = (pLineSdData[j] - m_dMinSd)/(m_dMaxSd-m_dMinSd);
				ASSERT(dTemp >=0 && dTemp <=1.0);
				Index = (BYTE)(dTemp * 255.0);

				dTemp = m_K[Index]; 
				ASSERT( dTemp >=0 && dTemp <=1.0);

				pResultData[j] = (UNDATA)(dTemp * pLineData[j]
							+ (1.0 - dTemp) * pLineAvrData[j]);
			}
			else
			{
				//公式：y=nk*Xl+(1-nk)*Xh
				ASSERT(pLineSdData[j] >= m_dMinSd && pLineSdData[j] <= m_dMaxSd);
				dTemp = (pLineSdData[j] - m_dMinSd)/(m_dMaxSd-m_dMinSd);
				ASSERT(dTemp >=0 && dTemp <=1.0);
				Index = (BYTE)(dTemp*255);
				dTemp = m_K[Index]; 
				ASSERT( dTemp >=0 && dTemp <=1.0);
				dTemp2 = m_dN * dTemp * pData1[j] + (1.0 - m_dN * dTemp) * pData2[j];
				//结果处理方式
				if(m_nStrech == 0)	//（0-255）两侧截断
				{
					if(dTemp2 < 0)
						pResultData[j] = 0;
					else if(sizeof(UNDATA) == sizeof(DWORD) && dTemp2 >= pow(2, 32))
							pResultData[j] = (UNDATA)(pow(2, 32)-1);
					else if(sizeof(UNDATA) == sizeof(unsigned short) && dTemp2 >= pow(2, 16))
							pResultData[j] = (UNDATA)(pow(2, 16)-1);
					else if(sizeof(UNDATA) == sizeof(BYTE) && dTemp2 >= 256)
							pResultData[j] = 255;
					else
						pResultData[j] = (UNDATA)(dTemp2);
				}
				else if(m_nStrech == 1)	//拉伸至（0-255）区间
				{
					pResultData[j] = (UNDATA)(dTemp2);
				}
				else
					ASSERT(FALSE);

			}
		}
		f3.Write(pResultData, m_dwWidth * sizeof(UNDATA));
	}
	pMainFrame->OnProcessEnd(i, m_dwHeight);
	pMainFrame->SetStatusBarText(0, "");
	
	f0.Close();
	f1.Close();
	f2.Close();
	f3.Close();
	delete[] pLineData;
	delete[] pLineAvrData;
	delete[] pLineSdData;
	if(bIs5)
	{
		file1.Close();
		file2.Close();
		delete[]	pData1;
		delete[]	pData2;

		if(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);
			
			//求最大值与最小值
			f3.Open(szResultPath,CFile::modeRead,&e);
			for(i = 0; i < m_dwHeight; i++)
			{
				VERIFY(f3.Read(pResultData, m_dwWidth * sizeof(UNDATA)));
				for(j = 0; j < m_dwWidth; j++)
				{
					if(dMaxValue < pResultData[j])
						dMaxValue = pResultData[j];
					if(dMinValue > pResultData[j])
						dMinValue = pResultData[j];
				}
				
			}
			f3.Close();
			//开始正规化...
			for(i = 0; i < m_dwHeight; i++)
			{
				//读取
				f3.Open(szResultPath,CFile::modeRead,&e);
				f3.Seek(i * m_dwWidth * sizeof(UNDATA), CFile::begin);
				VERIFY(f3.Read(pResultData, m_dwWidth * sizeof(UNDATA)));
				for(j = 0; j < m_dwWidth; j++)
				{
					pResultData[j] = (UNDATA)(	(pResultData[j]-dMinValue)/
												(dMaxValue-dMinValue)*(dPOW-1.0));
				}
				f3.Close();	

				f3.Open(szResultPath,CFile::modeWrite,&e);
				f3.Seek(i * m_dwWidth * sizeof(UNDATA), CFile::begin);
				f3.Write(pResultData, m_dwWidth * sizeof(UNDATA));
				f3.Close();
			}
		}
	}
	
	delete[] pResultData;
	return TRUE;
}
BOOL CRaderDoc::LeeFilter1(CString szResultPath)
{
	ASSERT(m_szFilePath != "");
	ASSERT(szResultPath != "");
	ASSERT(m_bHasReady);
	ASSERT(m_dwWidth != 0);
	ASSERT(m_dwHeight != 0);

	//打开文件
	CFile	f1, f2;
	CFileException e;
	DWORD	i, j;
	if(!f1.Open(m_szFilePath,CFile::modeRead,&e))
	{
		AfxMessageBox("Cannot Open file!");
		return FALSE;
	}
	if(!f2.Open(szResultPath,CFile::modeCreate | CFile::modeWrite,&e))
	{
		AfxMessageBox("Cannot Save file!");
		return FALSE;
	}

	UNDATA pdPixel[8];
	UNDATA*	pData = new UNDATA[m_dwWidth * 3];
	UNDATA*	pLineData = new UNDATA[m_dwWidth];

	CMainFrame* pMainFrame = ((CMainFrame*)AfxGetMainWnd());
	pMainFrame->SetStatusBarText(0, "Start calculate average value...");
	pMainFrame->OnProcessBegin();

	for(i = 1; i < m_dwHeight - 1; i++)
	{
		pMainFrame->OnProcessUpdate(i-1, m_dwHeight - 2);

		f1.Seek((i-1) * m_dwWidth * sizeof(UNDATA), CFile::begin);
		VERIFY(f1.Read(pData, 3 * m_dwWidth * sizeof(UNDATA)));

		if(i == 1)
		{
			for(j = 0; j < m_dwWidth; j++)
				pLineData[j] = 0;
			f2.Write(pLineData, m_dwWidth * sizeof(UNDATA));
		}
		for(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(pData[j1+(i1-i+1) * m_dwWidth]
									-pData[j + 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;
			}
			//pLineData[j]=pData[j + m_dwWidth];
			dw1 = dw1-i+1;
			dw2 = dw2-i+1;
			if(pData[j + m_dwWidth] < pData[dh1 + dw1 * m_dwWidth])
			{
				pLineData[j]=pData[dh1 + dw1 * m_dwWidth];
			}
			else if(pData[j + m_dwWidth] > pData[dh2 + dw2 * m_dwWidth])
			{
				pLineData[j]=pData[dh2 + dw2 * m_dwWidth];
			}
			else
			{
				pLineData[j]=pData[j + m_dwWidth];//???
			}
		
		}
		
		//补左数据
		pLineData[0] = 0;//pLineData[1];
		//补右数据
		pLineData[m_dwWidth-1] = 0;//pLineData[m_dwWidth-2];
		f2.Write(pLineData, m_dwWidth * sizeof(UNDATA));
	}
	pMainFrame->OnProcessEnd(i-1, m_dwHeight-2);
	pMainFrame->SetStatusBarText(0, "");

	for(j = 0; j < m_dwWidth; j++)
		pLineData[j] = 0;

	f2.Write(pLineData, m_dwWidth * sizeof(UNDATA));
	
	f1.Close();
	f2.Close();
	delete[] pData;
	delete[] pLineData;

	return TRUE;
}
double CRaderDoc::GetMidValue(UNDATA * pData,DWORD NumOfData, BOOL bFlag)
{
	double sum;
	UNDATA temp;
	DWORD i,j;

	//确定窗口数据存在。
	ASSERT(pData != NULL);

	//快速排序。
	for(i = 3;i > 0;i--)
		for(j = 0;j < NumOfData-i;j++)
			if(pData[j+i] > pData[j])
			{
				temp = pData[j];
				pData[j] = pData[j+i];
				pData[j+i] = temp;
			}
	if(bFlag)
	{
		//返回中值。
		return (double)pData[(NumOfData-1)/2];
	}
	else
	{
		//返回均值。
		sum = 0;
		for(i = 0;i < NumOfData;i++)
			sum = sum + pData[i];
		return sum/(double)NumOfData;
	}
}

double CRaderDoc::GetOutValue(UNDATA * pData,DWORD NumOfData, BOOL bFlag, DWORD m)
{
	int middle;
	double average;
	DWORD i;
	double sum;
	double k,stdDiverse;

	k = sqrt(NumOfData/(double)m - 1);

	sum = 0;
	average = GetMidValue(pData,NumOfData,FALSE);
	for(i = 0;i < NumOfData;i++)
		sum = sum + fabs(pData[i] - average);
	stdDiverse = k * sum/(double)NumOfData;

	middle = (NumOfData-1)/2;
	//???
	if( pData[middle]>average-stdDiverse && pData[middle]<average+stdDiverse )
	{
		return (double)pData[middle];
	}
	else
	{
		if(bFlag)
		{
			return GetMidValue(pData,NumOfData,TRUE);
		}
		else
		{
			return average;
		}
	}
}
UNDATA CRaderDoc::GetOutValue4(UNDATA * pData, DWORD NumOfData, DWORD m)
{
	ASSERT(pData != NULL);
	ASSERT(m <= (NumOfData-3)/2);

	UNDATA CurrentData = pData[(NumOfData-1)/2];
	UNDATA	Min, Max;
	UNDATA temp;
	DWORD	i, j;
	//快速排序。
	for(i = 3;i > 0;i--)
	{
		for(j = 0;j < NumOfData-i;j++)
		{
			if(pData[j+i] > pData[j])
			{
				temp = pData[j];
				pData[j] = pData[j+i];
				pData[j+i] = temp;
			}
		}
	}
	Max = pData[m];
	Min = pData[NumOfData - m - 1];
	if(CurrentData <= Min)
		return Min;
	else if(CurrentData >= Max)
		return Max;
	else
		return CurrentData;
}
void CRaderDoc::ExportRect(CString	szFileName, CRect rect)
{
	ASSERT(m_szFilePath != "");
	ASSERT(szFileName != "");
	ASSERT(m_bHasReady);
	ASSERT(m_dwWidth != 0);
	ASSERT(m_dwHeight != 0);

	//打开文件
	CFile	f1, f2;
	CFileException e;
	int		i, j;
	if(!f1.Open(m_szFilePath,CFile::modeRead,&e))
	{
		AfxMessageBox("Cannot Open file!");
		return;
	}
	if(!f2.Open(szFileName,CFile::modeCreate | CFile::modeWrite,&e))
	{
		AfxMessageBox("Cannot Save file!");
		return;
	}
	UNDATA*	pData = new UNDATA[m_dwWidth];
	UNDATA*	pLineData = new UNDATA[rect.Width()];

	CMainFrame* pMainFrame = ((CMainFrame*)AfxGetMainWnd());
	pMainFrame->SetStatusBarText(0, "Saveing selected data...");
	for(i = rect.top; i < rect.bottom; i++)
	{
		f1.Seek(i * m_dwWidth * sizeof(UNDATA), CFile::begin);
		VERIFY(f1.Read(pData, m_dwWidth * sizeof(UNDATA)));

		for(j = rect.left; j < rect.right; j++)
		{
			pLineData[j-rect.left] = pData[j];
		}
		f2.Write(pLineData, rect.Width()* sizeof(UNDATA));
	}
	pMainFrame->SetStatusBarText(0, "");
	f1.Close();
	f2.Close();
	delete[] pData;
	delete[] pLineData;

	return;
}