match.cpp

图像处理软件,功能比较基础

		if ( Mask1[i][j] == 255 )
		{
			SumX += rel1[i][j];
			SumXX += rel1[i][j]*rel1[i][j];
			counts ++;
		}

		if ( Mask2[i][j] == 255 )
		{
			SumX += rel2[i][j];
			SumXX += rel2[i][j]*rel2[i][j];
			counts ++;
		}
	}

	SumXX -= SumX*SumX/counts;

	for ( i=0;i<mr;i++)
	for (int j=0;j<mc;j++) 
	{
		SumY = SumYY = SumXY = 0;
		for (int m=0;m<r2;m++) 
		for (int n=0;n<c2;n++) 
		{
			if( Mask1[m][n] == 255 ) 
			{
				SumXY += ref1[i+m][j+n] * rel1[m][n];
				SumY  += ref1[i+m][j+n];
				SumYY += ref1[i+m][j+n] * ref1[i+m][j+n];
			}

			if( Mask2[m][n] == 255 ) 
			{
				SumXY += ref2[i+m][j+n] * rel2[m][n];
				SumY  += ref2[i+m][j+n];
				SumYY += ref2[i+m][j+n] * ref2[i+m][j+n];
			}
		}

		SumYY -= SumY*SumY/counts;
		SumXY -= SumX*SumY/counts;

		ret[i][j] = (float) SumXY / sqrt(SumXX*SumYY);
	}

	return ret;
}


/*******************************************************/
/* 计算匹配相关面数据                                  */
/*******************************************************/
float ** CMatch::CalCorMap(BYTE * * ref, BYTE * * rel, BYTE ** Mask, CSize s1, CSize s2)
{
	int r1 = s1.cy;
	int c1 = s1.cx;
	int r2 = s2.cy;
	int c2 = s2.cx;
	int mr = r1-r2 + 1;
	int mc = c1-c2 + 1;
	float SumX ,SumY , SumYY, SumXX , SumXY;
	
	float  ** ret = (float ** )CComlib::fspace_2d(mr,mc, sizeof(float));

	SumX = SumXX = 0;
	float counts = 0;
	for (int i=0;i<r2;i++) 
	for (int j=0;j<c2;j++) 
	{
		if ( Mask[i][j] == 255 )
		{
			SumX += rel[i][j];
			SumXX += rel[i][j]*rel[i][j];
			counts ++;
		}
	}
	SumXX -= SumX*SumX/counts;

	for ( i=0;i<mr;i++)
	for (int j=0;j<mc;j++) 
	{
		SumY = SumYY = SumXY = 0;
		for (int m=0;m<r2;m++) 
		for (int n=0;n<c2;n++) 
		{
			if( Mask[m][n] == 255 ) 
			{
				SumXY += ref[i+m][j+n] * rel[m][n];
				SumY  += ref[i+m][j+n];
				SumYY += ref[i+m][j+n] * ref[i+m][j+n];
			}
		}

		SumYY -= SumY*SumY/counts;
		SumXY -= SumX*SumY/counts;

		ret[i][j] = (float) SumXY / sqrt(SumXX*SumYY);
	}

	return ret;
}

/***********************************************/
/* 改进后的相关系数数据计算（带参考图象预处理）*/
/* 输入文件：                                  */ 
/*          DspFile[2]  --- 参考图标准差       */ 
/*          DspFile[3]  --- 参考图均值         */ 
/***********************************************/
float ** CMatch::CalCormap_LoadDspFile(BYTE * * ref, BYTE * * rel, CSize s1, CSize s2)
{
	int r1 = s1.cy;
	int c1 = s1.cx;
	int r2 = s2.cy;
	int c2 = s2.cx;
	int mr = r1-r2 + 1;
	int mc = c1-c2 + 1;
	long SumX ,SumXY;
	
	float  ** ret = (float ** )CComlib::fspace_2d(mr,mc, sizeof(float));
	long  * KRef = new long[mr * mc];
	long  * AvgY = new long[mr * mc];

	/*  读入参考图象的预处理数据  */
	int  length;
	CComlib::LoadAsDspDataFile(KRef, &length, DspFile[2] ,'l');
	CComlib::LoadAsDspDataFile(AvgY, &length, DspFile[3] ,'l');

	int  counts = r2*c2;
	SumX = 0;
	for (int m=0;m<r2;m++) 
	for (int n=0;n<c2;n++) 
	{
		SumX += rel[m][n];
	}

	for (int i=0;i<mr;i++)
	for (int j=0;j<mc;j++) 
	{
		SumXY = 0;
		for (int m=0;m<r2;m++) 
		for (int n=0;n<c2;n++) 
		{
			SumXY += ref[i+m][j+n] * rel[m][n];
		}

		long tmp = (long) (SumXY- SumX * AvgY[i*mc+j])/KRef[i*mc+j];
		ret[i][j] = (float) tmp;
	}

	return ret;
}




#include "omlib.h"
/* the size of  relimage and refimage is same , dig a  */
/* region box from relimage and match it in refimage , */
/* then save the result to the resultfile .            */
/* a stand alone function                              */   
void CMatch::MultiMatch_Box( CString reffile , CString relfile , 
							CString cordatafile , CString resultfile ,
							CString postfile , int num, int step , int size, int ErrSize)
{
	
}

// 单个光学图象匹配，整个实时图区均有效
NPOT CMatch::SingleMatch_Box(BYTE **ref, BYTE **rel, BYTE ** mask, int rR, int rC, int sR, int sC,POINT first)
{
	NPOT ret = {0,0,0};

	BYTE ** Mask = mask;
	// 有效区模板

	int mr = rR - sR + 1;
	int mc = rC - sC + 1;	
	if(first.x!=0||first.y!=0)
	{
	BYTE  ** temppic = (BYTE ** )CComlib::fspace_2d(sR+64,sC+64, sizeof(BYTE));
	for(int i=0;i<sR+64;i++)
	{
		memcpy(temppic[i],ref[i+first.y]+first.x,sC+64);		
	}
	float ** cor = CalCorMap(temppic, rel, Mask, CSize(sR+64, sC+64) , CSize(sC, sR) );
	ret = CComlib::GetMaxisum( cor , 64, 64);

	CComlib::ffree_2d((void**) cor , 64);
	CComlib::ffree_2d((void**) temppic,sR+64);
	}	
	else
	{	
		float ** cor = CalCorMap(ref, rel, Mask, CSize(rR, rC) , CSize(sC, sR) );
		ret = CComlib::GetMaxisum( cor ,mr,mc);		
		CComlib::ffree_2d((void**) cor , 64);
	}
	return ret ;
}

NPOT CMatch::SingleMatch_Box1(BYTE **ref, BYTE **rel, BYTE ** mask, int rR, int rC, int sR, int sC,BOOL flag)
{

	NPOT ret = {0,0,0};
	BYTE ** Mask = mask;
	// 有效区模板
	int mr = rR - sR + 1;
	int mc = rC - sC + 1;	
	float ** cor = CalCorMap(ref, rel, Mask, CSize(rR, rC) , CSize(sC, sR) );
	if(flag==FALSE)
		ret = CComlib::GetMaxisum( cor ,mr,mc);		
	if(flag==TRUE)
		ret = CComlib::GetMinisum( cor ,mr,mc);		
	CComlib::ffree_2d((void**) cor ,mr);	
	return ret ;
}



NPOT CMatch::SingleMatch_BoxSub(CString reffile , CString relfile , CString cordatafile)
{
	NPOT ret = {0,0,0};

	return ret ;
}

NPOT CMatch::SingleMatch_Box(CString reffile , CString relfile , CString cordatafile , CString maskfile, BOOL bSaveDsp, BOOL bVer)
{
	NPOT ret = {0,0,0};


	return ret ;
}

void CMatch::MultiMatch_Circ( SMATCH in , BOOL bDspCode )
{
	CString reffile , relfile , datafile , posfile , resultfile;

	BOOL bPath = ! CString(in.PathName).IsEmpty();
	relfile = datafile = posfile = resultfile = reffile = bPath ? in.PathName : "";

	reffile += in.RefFile;
	relfile +=  in.RelFile ;
	datafile += in.CorFile;
	posfile += in.PosFile ;
	resultfile += in.ResultFile ;


	int num = in.numbs;
	int r0 = in.rad0;
	int r1 = in.rad1;
	int ErrSize = in.nErrMax;
	int TSize = in.bsize;

	if( bDspCode )
		MultiMatch_Circ_DspCode( reffile , relfile , datafile , resultfile, posfile,  num,  r0, r1 , ErrSize , TSize);
	else
		MultiMatch_Circ( reffile , relfile , datafile , resultfile, posfile,  num,  r0, r1 , ErrSize , TSize);
}

void CMatch::MultiMatch_Sect( SMATCH in )
{
	CString reffile , relfile , datafile , posfile , resultfile;

	BOOL bPath = ! CString(in.PathName).IsEmpty();
	relfile = datafile = posfile = resultfile = reffile = bPath ? in.PathName : "";

	reffile += in.RefFile;
	relfile +=  in.RelFile ;
	datafile += in.CorFile;
	posfile += in.PosFile ;
	resultfile += in.ResultFile ;

	int num = in.numbs;
	int bFlightDir = in.bFlightDir;
	int fScanTheta = in.fScanTheta;
	BOOL bVerL  = in.bVerL;
	BOOL bVerR  = in.bVerR;
	float fRatioLR  = in.fRatioLR;   // Left weight ratio
	int TSize = in.bsize;
	int ErrSize = in.nErrMax;

	int nSize = RELIMGSIZE;

	int nL= reffile.Find('.');
	if( nL != -1) reffile = reffile.Left( nL ) + ".pic";
	nL=relfile.Find('.');
	if( nL != -1) relfile = relfile.Left( nL ) + ".pic";

	MultiMatch_Sect( reffile , relfile , datafile , resultfile, 
		posfile,  num, bFlightDir , fScanTheta , nSize , 
		ErrSize , TSize, bVerL, bVerR, fRatioLR);
}

void CMatch::MultiMatch_Circ( CString reffile , CString relfile ,
		CString datafile ,  CString resultfile, 
		CString postfile, int num,  int r0, int r1 ,int ErrSize ,int TSIZE)
{

	return ; 
}

/*****************************************/
/* 实孔径雷达图象有边界下的匹配          */
/* 相关面数据图象文件： corfile          */
/*****************************************/
NPOT CMatch::SingleMatch_Circ(CString reffile , CString relfile , CString corfile,
							  int rad0, int rad1 , BOOL bSaveDsp, BOOL bVer, int nTSize , float fSigma)
{
	NPOT ret;

	return ret ;
}

/*****************************************/
/* 实孔径雷达图象有边界下的匹配          */
/* 相关面数据图象文件： corfile          */
/*****************************************/
NPOT CMatch::SingleMatch_Circ2(CString reffile , CString relfile , CString corfile, int rad0, int rad1 , int nTSize)
{
	NPOT ret;

	return ret ;
}

static int bDot4(BYTE * p1, BYTE * p2, int size)
{	
	int ret=0;
	int k;

	for(k=0 ; k< size ; k++)
		ret += p1[k]*p2[k];
	
	return ret;
}

// 利用降维法快速计算匹配相关内积
void CMatch::CalRxy_Fast(BYTE * refimg, BYTE ** relimg, float * Ey , float * Dy , float **dRxy , CSize s1, CSize s2)
{
	BYTE * pRelImg  =  CComlib::Trans2To1(relimg , s2);

	CalRxy_Fast(refimg, pRelImg, Ey , Dy , dRxy , s1,s2) ;

	CComlib::ffree_1d( ( void*) pRelImg) ;
}

// 利用降维法快速计算匹配相关内积
void CMatch::CalRxy_Fast(BYTE * refimg, BYTE * relimg, float * Ey , float * Dy , float **dRxy , CSize s1, CSize s2)
{
	int  i,j,m;
	int  k , Num;

	int r1 = s1.cy;
	int c1 = s1.cx;
	int r2 = s2.cy;
	int c2 = s2.cx;
	int r3 = r1-r2 + 1;
	int c3 = c1-c2 + 1;
	int RealSize = r2 * c2;
	
	long  SumX=0;

	// 创建图象缓冲区
	BYTE  * pTmpRef = new BYTE[r1*c1];
	BYTE  * pTmpRel = new BYTE[r2*c2];
	long  * pSumXY  = new long[r3*c3];
	BYTE  * pref = pTmpRef;
	BYTE  * prel = pTmpRel;
	BYTE  * pApp;

	/* only suitable for memcopy byte data */
	for(i=0;i<r2;i++)
	{	
		memcpy(pTmpRel + i*c2 , relimg + i*c2 , c2 * sizeof(BYTE));
		memcpy(pTmpRef + i*c2 , refimg + i*c1 , c2 * sizeof(BYTE));
	}

	/* 计算实时图灰度值之和 */
	for(k=0 ; k < r2*c2 ; k++)	SumX += pTmpRel[k];

	prel = pTmpRel;
	pref = pTmpRef;
	/* 计算相关面: Rxy */
	for(i=0 ; i< c3 ; i+=2 )
	{
		Num = i;
		/* 拷入一列数据  */
		for (m=0 ; m< r2 ; m++)
			*(pref + (m+1) * c2 -1) = *(refimg + m*c1 + c2+i-1);
		pSumXY[Num] = bDot4(prel, pref, RealSize);

		pApp = refimg + (r2-1)*c1 + i ;
		/* from UP to DOWN for calculate the Rxy */
		for(j=1 ; j < r3 ; j++)     /* begin at  j = 1 */
		{	
			pApp += c1;
			memcpy(pref + r2*c2 , pApp , c2 * sizeof(BYTE));

			pref += c2;
			Num += c3 ;
			pSumXY[Num] = bDot4(prel, pref, RealSize);
		}

		if( c3 - i ==1 ) break;               /* the size is odd then end here */

		/* 拷入一列数据 */
		for (m=0 ; m< r2 ; m++)
			*(pref + (m+1) * c2) = *(refimg + (m+r3-1)*c1 + c2+i);
		pref ++;
		Num ++;  /* shift right by ONE pixel */
		pSumXY[Num] = bDot4(prel, pref, RealSize);

		pApp = 	refimg + (r3-1)*c1 + i+1 ;
		/* from DOWN to UP for calculate the Rxy */
		for(j = r3 - 2 ; j >= 0 ; j--)  /* begin at nMight-2 */
		{	
			pApp -= c1;
			memcpy(pref - c2 , pApp , c2 * sizeof(BYTE));

			pref -= c2;
			Num  -= c3; 
			pSumXY[Num] = bDot4(prel, pref, RealSize);
		}

		pref ++;
	}
	
	for(i=0;i<r3;i++)
	for(j=0;j<c3;j++)
		dRxy[i][j] = (float) ( pSumXY[i*c3+j] - SumX * Ey[i*c3 + j]) / Dy[i*c3 + j] ;

	delete pTmpRef;
	delete pTmpRel;
	delete pSumXY;

	return ; 
}