check.cpp

一个实用超声波滤波算法

#include "stdafx.h"
#include "check.h"

//函数名规范:check_
//数据规整化
int check_DataNormal(double * inData,int * outData,int nDataLength,double d_T)
{
	if(inData==NULL) return -1;//输入参数错误!	
	if(outData==NULL) return -2;//输出参数错误!
	int i;	
	
	//高电平起始位置和结束位置
	for(i=0;i<nDataLength;i++)
	{
		outData[i]=0;
	}
	
	for(i=0;i<nDataLength;i++)
	{
		if(inData[i]>=d_T)
		{
			outData[i]=1;
		}
		else
		{
			outData[i]=0;
		}
	}
	return 1;
}

//单通道数据预处理
int check_DataPrepare(int * inData,int * outData,
                                          int nDataLength,int nWidth_T,int nDistance_T)
{
	if(inData==NULL) return -1;//输入参数错误!	
	if(outData==NULL) return -2;//输出参数错误!
	int i;
	int j;
	int k;
	
	//高电平起始位置和结束位置
	int iBegin1;
	int iEnd1;
//	int iBegin2;
//	int iEnd2;	
	
	//高电平长度
//	int tWidth1;
//	int tWidth2;
	
	//循环控制参数
	int nEndFlag=0;
	int nContinueFlag=1;	
	
	//初始化输出数据
	for(i=0;i<nDataLength;i++)
	{
		outData[i]=0;
	}
	
	iBegin1=0;
	iEnd1=0;
	i=0;
	while(i<nDataLength)
	{
		if(inData[i]==1)
		{
			iBegin1=i;
			iEnd1=iBegin1;
			j=iBegin1+1;
			
			//寻找高电平的断点，并将合理的高电平修补
			nContinueFlag=1;
			while((j<nDataLength) && (nContinueFlag))
			{
				while(j<nDataLength)
				{				
					if(inData[j]==0)
					{
						iEnd1=j-1;
						break;//高电平断点
					}
					else
					{
						j++;
					}
				}
				//寻找断点长度				
				while(j<nDataLength)
				{
					if(inData[j]==1)
					{
						break;				
					}
					else
					{
						j++;
					}
				}
				if((j-iEnd1-1)<=nDistance_T)
				{
					iEnd1=j-1;
				}
				else//符合高电平合并的条件，并且已无新的合并可能
				{
					for(k=iBegin1;k<=iEnd1;k++)
					{
						outData[k]=1;						
					}
					nContinueFlag=0;
				}
			}
			i=j;			
			
		}	
		else
		{
			i++;
		}	
	}
	
	//去除宽度小于阈值高电平部分
	i=0;
	j=0;	
	while(i<nDataLength)
	{
		if(outData[i]==1)
		{
			iBegin1=i;
			iEnd1=iBegin1;
			j=iBegin1;
			while(j<nDataLength)
			{
				if(outData[j]==0)
				{
					break;
				}
				j++;
			}
			
			
			//去除不符合条件的高电平
			if((j-iBegin1)<nWidth_T)
			{
				iEnd1=j-1;
				for(k=iBegin1;k<=iEnd1;k++)
				{
					outData[k]=0;
				}
			}
			
			i=j;			
		}
		else
		{
			i++;
		}
	}
	return 1;
	
		
}

int check_ConvertDataFormat(int * inData,int nDataLength)
{
	if(inData==NULL) return -1;//输入参数错误
	int i=0;
	for(i=0;i<nDataLength;i++)
	{
		if(inData[i]==1)
		{
			inData[i]=2;
		}
	}
	return 1;
}

int check_ExpandData(int * inData, int nDataLength, int nDistance_T)
{
	if(inData==NULL) return -1;//输入参数错误
	int i=0;
	int j=0;
	int k=0;

	int iBegin;
	int iEnd;
 
	while(i<nDataLength)
	{
		if(inData[i]==2)
		{
			j=i+1;
			while(j<nDataLength)
			{
				if(inData[j]==0)
				{
					break;
				}
				j++;
			}
			iBegin=i-nDistance_T;
			iEnd=j-1+nDistance_T;
			if(iBegin<0) iBegin=0;
			if(iEnd>=nDataLength-1) iEnd=nDataLength-1;
			for(k=iBegin;k<=iEnd;k++)
			{
				if(inData[k]==0) inData[k]=1;
				if(inData[k]==2) inData[k]=3;
			}
			i=j;
		}
		else
		{
			i++;
		}
	}
	return 1;
}
int check_DataTwoChannel(int * inDataA, int * inDataB, int * outData,int nDataLength, int nChannelD_T)
{
	if((inDataA==NULL) || (inDataB==NULL)) return -1;//输入参数错误
	if(outData==NULL) return -2;//输出参数错误
	
	int i=0;
    int j=0;
	int k=0;
	
//	int iBegin;
//	int iEnd;

//	int iBegin1;
//	int iEnd1;

	int * sumAB=new int[nDataLength];
	
	check_ConvertDataFormat(inDataA,nDataLength);
    check_ConvertDataFormat(inDataB,nDataLength);
	check_ExpandData(inDataA,nDataLength,nChannelD_T);
	check_ExpandData(inDataB,nDataLength,nChannelD_T);

	for(i=0;i<nDataLength;i++)
	{
		outData[i]=0;
		sumAB[i]=inDataA[i]+inDataB[i];
	}

	//单裂纹，查1 3 * * 3 1 
	//或查2 3 * * 3 1
	//或查1 3 * * 3 2
	i=0;
	while(i<nDataLength-1)
	{
		if(((sumAB[i]==1) || (sumAB[i]==2))&& (sumAB[i+1]==3))
		{
			j=i+2;			
			while(j<nDataLength-1)
			{
				if(sumAB[j]==3) 
				{
					if((sumAB[j+1]==2) || (sumAB[j+1]==1))
					{
						if(inDataA[i+(j+1-i+1)/2]==3)
						{
							outData[i+(j+1-i+1)/2]=1;//A通道
						}
						else
						{
							outData[i+(j+1-i+1)/2]=2;//B通道
						}
						break;
					}
					else
					{
						if(sumAB[j+1]==3)
						{
							j++;
						}
						else
						{
							break;
						}
					}
				}
				else
				{
					j++;
				}
				//j++;
			}						
			i=j;
		}
		else
		{
			i++;
		}
	}

	//交叉，查6
	i=0;
	while(i<nDataLength)
	{
		if(sumAB[i]==6)
		{
			j=i+1;			
			while(j<nDataLength)
			{
				if(sumAB[j]!=6) 
				{
					break;
				}
				j++;
			}
			outData[i+(j-i)/2]=3;//双裂纹				
			i=j;			
		}
		else
		{
			i++;
		}
	}

	//扩展交叉,查3 4 * * 4 3	
	i=0;
	while(i<nDataLength-1)
	{
		if((sumAB[i]==3) && (sumAB[i+1]==4))
		{
			j=i+2;			
			while(j<nDataLength-1)
			{
				if(sumAB[j]==4) 
				{
					if(sumAB[j+1]==3)
					{
						outData[i+(j+1-i+1)/2]=3;//双裂纹
						break;
					}
					else
					{
						break;
					}
				}
				j++;
			}						
			i=j;
		}
		else
		{
			i++;
		}
	}

	//扩展交叉4 * 4 其中*是4或2
    i=0;
	while(i<nDataLength-1)
	{
		if((sumAB[i]<4) && (sumAB[i+1]==4))
		{
			j=i+2;			
			while(j<nDataLength-1)
			{
				if(sumAB[j]!=4)
				{
					if((sumAB[j]==6)) 
					{
						break;
					}					
				}
				
				if(sumAB[j+1]!=4)
				{
					if(sumAB[j+1]==6)
					{
						break;
					}
					else 
					{
						if(sumAB[j+1]!=2)
						{
							outData[i+(j+1-i+1)/2]=3;//交叉孔
							break;
						}
					}
				}
				j++;
			}						
			i=j;
		}
		else
		{
			i++;
		}
	}

	delete [] sumAB;
	return 1;
}

//inDataA和inDataB的值在函数执行的过程中已经改变
int check_Inspection(double * inDataA,double * inDataB, int * outData,int nDataLength,Check_T inCheck_T)
{
	if((inDataA==NULL) || (inDataB==NULL)) return -1;//输入参数错误
	if(outData==NULL) return -2;//输出参数错误

	double dA_T=inCheck_T.dA_T;//高电平门限
	double dB_T=inCheck_T.dB_T;//高电平门限

	int nSingleChannel_Distance_T=inCheck_T.nSingleChannel_Distance_T;//单通道高电平距离门限
	int nAWidth_T=inCheck_T.nAWidth_T;//高电平宽度门限
	int nBWidth_T=inCheck_T.nBWidth_T;
	int nTwoChannel_Distance_T=inCheck_T.nTwoChannel_Distance_T;//双通道高电平距离门限 
    
	//函数的临时工作空间,大约是数据长度的 5 倍
	int * outData1=new int[nDataLength];
	int * outData2=new int[nDataLength];  
	
	int * outData3=new int[nDataLength];
	int * outData4=new int[nDataLength];
	
	check_DataNormal(inDataA,outData1,nDataLength,dA_T);
	check_DataNormal(inDataB,outData2,nDataLength,dB_T);

	check_DataPrepare(outData1,outData3,nDataLength,nAWidth_T,nSingleChannel_Distance_T);
	check_DataPrepare(outData2,outData4,nDataLength,nBWidth_T,nSingleChannel_Distance_T);

	check_DataTwoChannel(outData3,outData4,outData,nDataLength,nTwoChannel_Distance_T);

	delete [] outData1;
	delete [] outData2;
	delete [] outData3;
	delete [] outData4;
	return 1;
}