www.pudn.com > UltraSound.rar > UltraSoundView.cpp

// UltraSoundView.cpp : implementation of the CUltraSoundView class 
// 
 
#include "stdafx.h" 
#include "UltraSound.h" 
#include "mainfrm.h" 
#include "UltraSoundDoc.h" 
#include "UltraSoundView.h" 
#include "math.h" 
 
#include "ippm.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
extern CString g_name; 
///////////////////////////////////////////////////////////////////////////// 
// CUltraSoundView 
 
IMPLEMENT_DYNCREATE(CUltraSoundView, CScrollView) 
 
BEGIN_MESSAGE_MAP(CUltraSoundView, CScrollView) 
	//{{AFX_MSG_MAP(CUltraSoundView) 
	ON_COMMAND(ID_START, OnStart) 
	ON_UPDATE_COMMAND_UI(ID_START, OnUpdateStart) 
	ON_WM_ERASEBKGND() 
	//}}AFX_MSG_MAP 
	ON_WM_CONTEXTMENU() 
	// Standard printing commands 
	ON_COMMAND(ID_FILE_PRINT, CScrollView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CScrollView::OnFilePrint) 
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, OnFilePrintPreview) 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CUltraSoundView construction/destruction 
 
CUltraSoundView::CUltraSoundView() 
{ 
	// TODO: add construction code here 
 
} 
 
CUltraSoundView::~CUltraSoundView() 
{ 
} 
 
BOOL CUltraSoundView::PreCreateWindow(CREATESTRUCT& cs) 
{ 
	// TODO: Modify the Window class or styles here by modifying 
	//  the CREATESTRUCT cs 
 
	return CScrollView::PreCreateWindow(cs); 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CUltraSoundView drawing 
 
void CUltraSoundView::OnDraw(CDC* pDC) 
{ 
	CUltraSoundDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
	// TODO: add draw code for native data here 
	 
	CRect rect; 
	GetClientRect(rect); 
	pDC->FillSolidRect (rect, RGB(255,255,255)); 
 
	int xpos, ypos; 
	if (m_EndImg != NULL) 
	{ 
		xpos = (rect.Width () - m_EndImg->width) / 2; 
		ypos = (rect.Height () - m_EndImg->height) / 2; 
 
		ShowImageGray(m_EndImg, xpos, ypos); 
	} 
} 
 
void CUltraSoundView::OnInitialUpdate() 
{ 
	CScrollView::OnInitialUpdate(); 
 
	CSize sizeTotal; 
	// TODO: calculate the total size of this view 
	sizeTotal.cx = sizeTotal.cy = 100; 
	SetScrollSizes(MM_TEXT, sizeTotal); 
 
	m_Dx = 0; 
	m_Dy = 0; 
	m_GlobalDx = 0; 
	m_GlobalDy = 0; 
	m_ImageWidth = 0; 
	m_ImageHeight = 0; 
	m_GlobalHeight = 0; 
	m_GlobalWidth =0; 
	m_GlobalOffsetX = 0; 
	m_GlobalOffsetY = 0; 
	m_dx = NULL; 
	m_dy = NULL; 
	m_totaldx = 0; 
	m_totaldy = 0; 
	m_MotionDir = TRUE; 
 
	m_BlockHeight = 32;  
    m_BlockWidth  = 32; 
 
	m_EndImg = NULL; 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CUltraSoundView printing 
 
void CUltraSoundView::OnFilePrintPreview()  
{ 
	BCGPPrintPreview (this); 
} 
 
BOOL CUltraSoundView::OnPreparePrinting(CPrintInfo* pInfo) 
{ 
	// default preparation 
	return DoPreparePrinting(pInfo); 
} 
 
void CUltraSoundView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add extra initialization before printing 
} 
 
void CUltraSoundView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/) 
{ 
	// TODO: add cleanup after printing 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CUltraSoundView diagnostics 
 
#ifdef _DEBUG 
void CUltraSoundView::AssertValid() const 
{ 
	CScrollView::AssertValid(); 
} 
 
void CUltraSoundView::Dump(CDumpContext& dc) const 
{ 
	CScrollView::Dump(dc); 
} 
 
CUltraSoundDoc* CUltraSoundView::GetDocument() // non-debug version is inline 
{ 
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CUltraSoundDoc))); 
	return (CUltraSoundDoc*)m_pDocument; 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CUltraSoundView message handlers 
 
void CUltraSoundView::OnContextMenu(CWnd*, CPoint point) 
{ 
	theApp.ShowPopupMenu (IDR_CONTEXT_MENU, point, this); 
} 
 
//　此函数将一帧图像数据复制到float型的矩阵中。 
float* CUltraSoundView::Matrix(IplImage* img, float* Matrix) 
{ 
	float* Image32 = Matrix; 
 
	unsigned char* ptr = (unsigned char*)img->imageData; 
	for(int i=0;iimageSize;i++) 
	{ 
		*Image32 = *ptr; 
 		Image32++; 
 		ptr++; 
	} 
 
	return Matrix; 
} 
 
 
 
void CUltraSoundView::OnStart()  
{ 
	// TODO: Add your command handler code here 
	CUltraSoundDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
  
	int i; 
	int ImageNum = pDoc->m_ImgNum; 
 
	IplImage* Image = pDoc->m_pImageList[0]; 
 
	m_ImageWidth = Image->width; 
	m_ImageHeight = Image->height; 
 
	m_GlobalWidth = m_ImageWidth; 
	m_GlobalHeight = m_ImageHeight; 
 
	m_dx = (int*)malloc((ImageNum-1)*sizeof(int)); 
	m_dy = (int*)malloc((ImageNum-1)*sizeof(int)); 
 
	m_sub = (float*)malloc(m_BlockWidth*m_BlockHeight*sizeof(float)); 
	 
	m_OldImageMat = (float*)malloc(Image->imageSize*sizeof(float)*5); 
	m_DstImageMat = (float*)malloc(Image->imageSize*sizeof(float)*5); 
	m_ShowImageMat = (float*)malloc(Image->imageSize*sizeof(float)*5); 
 
	m_AddImageMat = (float*)malloc(Image->imageSize*sizeof(float)); 
	m_CurImageMat = (float*)malloc(Image->imageSize*sizeof(float)); 
	m_HalfCurImageMat = (float*)malloc(Image->imageSize*sizeof(float)); 
	m_HalfOldImageMat  = (float*)malloc(Image->imageSize*sizeof(float)); 
 
	IppStatus 
	Status = ippmMul_mc_32f(m_DstImageMat,Image->imageSize*sizeof(float),0, 
					m_DstImageMat,Image->imageSize*sizeof(float),Image->imageSize,5); 
 
	Status = ippmMul_mc_32f(m_OldImageMat,Image->imageSize*sizeof(float),0, 
					m_OldImageMat,Image->imageSize*sizeof(float),Image->imageSize,5); 
 
	Status = ippmMul_mc_32f(m_ShowImageMat,Image->imageSize*sizeof(float),0, 
					m_ShowImageMat,Image->imageSize*sizeof(float),Image->imageSize,5); 
 
	Status = ippmMul_mc_32f(m_AddImageMat,Image->imageSize*sizeof(float),0, 
				m_AddImageMat,Image->imageSize*sizeof(float),Image->imageSize,1); 
 
	Status = ippmMul_mc_32f(m_CurImageMat,Image->imageSize*sizeof(float),0, 
				m_CurImageMat,Image->imageSize*sizeof(float),Image->imageSize,1); 
 
	Status = ippmMul_mc_32f(m_HalfCurImageMat,Image->imageSize*sizeof(float),0, 
			m_HalfCurImageMat,Image->imageSize*sizeof(float),Image->imageSize,1); 
 
	Status = ippmMul_mc_32f(m_HalfOldImageMat,Image->imageSize*sizeof(float),0, 
			m_HalfOldImageMat,Image->imageSize*sizeof(float),Image->imageSize,1); 
	 
	m_OldImageMat = Matrix(Image,m_OldImageMat); 
 
	m_HalfOldImageMat = Matrix(Image,m_HalfOldImageMat); 
 
	((CMainFrame*)theApp.m_pMainWnd)->m_wndStatusBar.EnablePaneProgressBar(1, ImageNum, true); 
 
	//运动检测，确定相邻两帧之间的位置偏移。 
	for(i=1;im_wndStatusBar.SetPaneProgress(1, i+1); 
	} 
	((CMainFrame*)theApp.m_pMainWnd)->m_wndStatusBar.EnablePaneProgressBar(1, -1); 
 
/*	//确定移动方向。 
	for(int j=0;j=abs(m_totaldy))  
		m_MotionDir = TRUE; 
	else 
		m_MotionDir = FALSE; 
*/ 
 
	//图像拼接。 
	for(i=1;iimageSize,0,DstMat, 
//				Image->imageSize,Image->imageSize,5); 
		Image = pDoc->m_pImageList[i]; 
		m_CurImageMat = Matrix(Image,m_CurImageMat); 
		Mosacing(i); 
	} 
 
	free(m_sub); 
 
	free(m_OldImageMat); 
	free(m_DstImageMat); 
	free(m_ShowImageMat); 
 
	free(m_AddImageMat); 
	free(m_CurImageMat); 
	free(m_HalfCurImageMat); 
	free(m_HalfOldImageMat); 
 
	free(m_dx); 
	free(m_dy); 
} 
 
CPoint CUltraSoundView::LeastSquare(int i) 
{ 
	CUltraSoundDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
	 
//	IplImage* BaseImage = pDoc->m_pImageList[i-1]; 
	IplImage* CurImage = pDoc->m_pImageList[i]; 
//	IplImage* Image = pDoc->m_pImageList[0]; 
 
	int SearchLeft = -10; 
	int SearchRight = 10; 
	int SeatchTop = -3; 
	int SearchBottom = 3; 
 
//	int m_BlockHeight = 32;  
//    int m_BlockWidth  = 32; 
 
//	float* m_HalfOldImageMat = (float*)malloc(Image->imageSize*sizeof(float)); 
//	float* m_CurImageMat = (float*)malloc(Image->imageSize*sizeof(float)); 
//	m_HalfOldImageMat = Matrix(BaseImage,m_HalfOldImageMat); 
	m_CurImageMat = Matrix(CurImage,m_CurImageMat); 
 
//	float* pDst = (float*)malloc(BlockHeight*BlockWidth*sizeof(float)); 
	 
	float MSAD = 0; 
	float OffsetX = 0; 
	float OffsetY = 0; 
	int Dx = 0; 
	int Dy = 0; 
 
	int xNumofSubImage = m_ImageWidth/m_BlockWidth; 
	int yNumofSubImage = m_ImageHeight/m_BlockHeight;  
 
	//每帧图像行与行之间的内存偏移量。 
	Ipp32s  srce1Stride1 =  CurImage->widthStep*sizeof(float); 
	Ipp32s  srce2Stride1 =  CurImage->widthStep*sizeof(float);//因为每帧大小相同。 
	Ipp32s  dst1Stride1  =  m_BlockWidth*sizeof(float); 
 
//	float aa[1000]; 
 
	//least square; 
//	for(int j=0;j< yNumofSubImage;j++) 
//		for(int k=0;km_ImageWidth - m_BlockWidth - 1 )	x1 = m_ImageWidth - m_BlockWidth - 1; 
			if(y1>m_ImageHeight - m_BlockHeight - 1 )	y1 = m_ImageHeight - m_BlockHeight - 1; 
		 
			float SAD = 0; 
 
//			for(int y=y0;y<=y1;y++) 
//				for(int x=x0;x<=x1;x++) 
			for(int x=x0;x<=x1;x++)	 
				for(int y=y0;y<=y1;y++) 
				{ 
					SAD = 0; 
					Ipp32f* pSrc1 = m_HalfOldImageMat + x + y*CurImage->widthStep; 
					Ipp32f* pSrc2 = m_CurImageMat + InitX + InitY*CurImage->widthStep; 
 
					IppStatus status = ippmSub_mm_32f (pSrc1,srce1Stride1,  
														pSrc2,srce2Stride1, 
														m_sub, dst1Stride1,  
														32, 32); 
 
					status = ippmFrobNorm_m_32f(m_sub,32*sizeof(float),32,32,&SAD); 
/*---------------------------------------------------------------------------------------------- 
//					int a[32][32]; 
					float* p =pDst; 
					for(int suby=0;suby<32;suby++) 
						for(int subx=0;subx<32;subx++) 
						{ 
//							a[suby][subx] = (int)*p; 
							SAD = SAD+(float)fabs(*p); 
							p++; 
						} 
					aa[ss]=SAD; 
					ss++; 
//-----------------------------------------------------------------------------------------------		 
*/ 
					if(MSAD>SAD||MSAD==0) 
					{ 
						MSAD = SAD;	  
						dx = x-InitX; 
						dy = y-InitY; 
					} 
				}	 
			OffsetX = OffsetX + dx; 
			OffsetY = OffsetY + dy; 
 
			SAD=0; 
			MSAD = 0; 
		} 
 
	OffsetX = (float)OffsetX/(xNumofSubImage*yNumofSubImage); 
	OffsetY = (float)OffsetY/(xNumofSubImage*yNumofSubImage); 
 
	if(m_GlobalOffsetX>=0) 
		Dx = (int)(m_GlobalOffsetX + OffsetX +0.5) - (int)(m_GlobalOffsetX + 0.5); 
	else 
		Dx = (int)(m_GlobalOffsetX + OffsetX -0.5) - (int)(m_GlobalOffsetX - 0.5); 
	if(m_GlobalOffsetY>=0) 
		Dy = (int)(m_GlobalOffsetY + OffsetY +0.5) - (int)(m_GlobalOffsetY + 0.5); 
	else 
		Dy = (int)(m_GlobalOffsetY + OffsetY -0.5) - (int)(m_GlobalOffsetY - 0.5); 
 
	m_GlobalOffsetX= m_GlobalOffsetX + OffsetX; 
	m_GlobalOffsetY= m_GlobalOffsetY + OffsetY; 
 
	float* p = m_HalfOldImageMat; 
	m_HalfOldImageMat = m_CurImageMat; 
	m_CurImageMat = p; 
 
	CPoint pt; 
	pt.x = Dx; 
	pt.y = Dy; 
	 
	return pt;   
} 
 
void CUltraSoundView::Mosacing(int i) 
{	 
	m_Dx = m_dx[i-1]; 
	m_Dy = m_dy[i-1]; 
 
	if(abs(m_GlobalDx)>abs(m_GlobalDy)) 
	{ 
		 if(m_GlobalDx<0) 
		 { 
			if(m_Dx>=0) return; 
			if(m_Dx<0 && m_Dy*m_GlobalDy<0) return; 
		 } 
          
		 if(m_GlobalDx>0) 
		 { 
			if(m_Dx<=0) return; 
			if(m_Dx>0 && m_Dy*m_GlobalDy<0) return; 
		 } 
	} 
 
	if(abs(m_GlobalDy)>abs(m_GlobalDx)) 
	{ 
		 if(m_GlobalDy<0) 
		 { 
			if(m_Dy>=0) return; 
			if(m_Dy<0 && m_Dx*m_GlobalDx<0) return; 
		 } 
          
		 if(m_GlobalDy>0) 
		 { 
			if(m_Dy<=0) return; 
			if(m_Dy>0 && m_Dx*m_GlobalDx<0) return; 
		 } 
	} 
 
	//向坐上角运动． 
	if(m_Dx < 0 && m_Dy<=0) 
	{ 
		int	srcROIShift = 0; 
		int srcStride1 = m_GlobalWidth*sizeof(float); 
		int srcStride2 = 1*sizeof(float); 
 
		int	dstROIShift =-m_Dx*sizeof(float)-m_Dy*(m_GlobalWidth-m_Dx)*sizeof(float); 
		int dstStride1 = (m_GlobalWidth-m_Dx)*sizeof(float); 
		int dstStride2 = 1*sizeof(float); 
 
		IppStatus Status; 
		//step 1;将前一帧图像复制到右下角。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_OldImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_GlobalWidth,m_GlobalHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = (m_GlobalWidth-m_Dx)*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step2;前一帧重叠部分除二 
		Status =ippmMul_mac_32f_L((const float**)&m_DstImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfOldImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step3;复制当前帧； 
		Status = ippmCopy_ma_32f_LL((const float**)&m_CurImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_HalfCurImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = -m_Dx*sizeof(float)-m_Dy*m_ImageWidth*sizeof(float); 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = -m_Dx*sizeof(float)-m_Dy*m_ImageWidth*sizeof(float); 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step4；当前帧重叠部分除二。 
		Status =ippmMul_mac_32f_L((const float**)&m_CurImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfCurImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth+m_Dx,m_ImageHeight+m_Dy,1); 
 
		int src1ROIShift = 0; 
		int src1Stride1 = m_ImageWidth*sizeof(float); 
 
		int src2ROIShift = 0; 
		int src2Stride1 = m_ImageWidth*sizeof(float); 
 
		dstROIShift =0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step5:重叠部分图像相加。 
 
		ippmAdd_mama_32f_L((const float**)&m_HalfOldImageMat,src1ROIShift,src1Stride1, 
							(const float**)&m_HalfCurImageMat,src2ROIShift,src2Stride1, 
							&m_AddImageMat,dstROIShift,dstStride1,  
							m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift =0; 
		dstStride1 = (m_GlobalWidth-m_Dx)*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		 
		//step6:重叠部分复制回去。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_AddImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
		 
 
		float* mat = m_OldImageMat; 
		m_OldImageMat = m_DstImageMat; 
		m_DstImageMat = mat; 
 
		//更新拼接图的宽度和高度。 
		if(m_Dx<=0) 
		{ 
			m_GlobalWidth = m_GlobalWidth - m_Dx; 
		} 
		else 
		{ 
			m_GlobalWidth = m_GlobalWidth + m_Dx; 
		} 
 
		if(m_Dy<=0) 
		{ 
			m_GlobalHeight = m_GlobalHeight - m_Dy; 
		} 
		else 
		{ 
			m_GlobalHeight = m_GlobalHeight + m_Dy; 
		} 
//		ShowImage(); 
	} 
    ////////////////////////////////////////////////////////////////////////////////// 
	//向左下角运动 
	if(m_Dx <= 0 && m_Dy > 0) 
	{ 
		int	srcROIShift = 0; 
		int srcStride1 = m_GlobalWidth*sizeof(float); 
		int srcStride2 = 1*sizeof(float); 
 
		int	dstROIShift =-m_Dx*sizeof(float); 
		int dstStride1 = (m_GlobalWidth-m_Dx)*sizeof(float); 
		int dstStride2 = 1*sizeof(float); 
 
		IppStatus Status; 
		//step 1;将前一帧图像复制到右上角。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_OldImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_GlobalWidth,m_GlobalHeight,1); 
 
		srcROIShift = (m_GlobalHeight - m_ImageHeight+m_Dy)*(m_GlobalWidth-m_Dx)*sizeof(float); 
		srcStride1 = (m_GlobalWidth-m_Dx)*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step2;前一帧重叠部分除二 
		Status =ippmMul_mac_32f_L((const float**)&m_DstImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfOldImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step3;复制当前帧； 
		Status = ippmCopy_ma_32f_LL((const float**)&m_CurImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_HalfCurImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = -m_Dx*sizeof(float); 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = -m_Dx*sizeof(float); 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step4；当前帧重叠部分除二。 
		Status =ippmMul_mac_32f_L((const float**)&m_CurImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfCurImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth+m_Dx,m_ImageHeight-m_Dy,1); 
 
		int src1ROIShift = 0; 
		int src1Stride1 = m_ImageWidth*sizeof(float); 
 
		int src2ROIShift = 0; 
		int src2Stride1 = m_ImageWidth*sizeof(float); 
 
		dstROIShift =0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step5:重叠部分图像相加。 
 
		ippmAdd_mama_32f_L((const float**)&m_HalfOldImageMat,src1ROIShift,src1Stride1, 
							(const float**)&m_HalfCurImageMat,src2ROIShift,src2Stride1, 
							&m_AddImageMat,dstROIShift,dstStride1,  
							m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = (m_GlobalHeight - m_ImageHeight+m_Dy)*(m_GlobalWidth-m_Dx)*sizeof(float); 
		dstStride1 = (m_GlobalWidth-m_Dx)*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		 
		//step6:重叠部分复制回去。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_AddImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
 
		float* mat = m_OldImageMat; 
		m_OldImageMat = m_DstImageMat; 
		m_DstImageMat = mat; 
 
		//更新拼接图的宽度和高度。 
		if(m_Dx<=0) 
		{ 
			m_GlobalWidth = m_GlobalWidth - m_Dx; 
		} 
		else 
		{ 
			m_GlobalWidth = m_GlobalWidth + m_Dx; 
		} 
 
		if(m_Dy<=0) 
		{ 
			m_GlobalHeight = m_GlobalHeight - m_Dy; 
		} 
		else 
		{ 
			m_GlobalHeight = m_GlobalHeight + m_Dy; 
 
		} 
//		ShowImage(); 
	} 
	//以上代码实现向左下角运动拼接 
	////////////////////////////////////////////////////////////////////////////////// 
 
	//向右下角运动 
	if(m_Dx > 0 && m_Dy >= 0) 
	{ 
		int	srcROIShift = 0; 
		int srcStride1 = m_GlobalWidth*sizeof(float); 
		int srcStride2 = 1*sizeof(float); 
 
		int	dstROIShift =0; 
		int dstStride1 = (m_GlobalWidth+m_Dx)*sizeof(float); 
		int dstStride2 = 1*sizeof(float); 
 
		IppStatus Status; 
		//step 1;将前一帧图像复制到左上角。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_OldImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_GlobalWidth,m_GlobalHeight,1); 
 
		srcROIShift = m_Dx*sizeof(float)+(m_GlobalHeight - m_ImageHeight+m_Dy)*(m_GlobalWidth+m_Dx)*sizeof(float); 
		srcStride1 = (m_GlobalWidth+m_Dx)*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = m_Dx*sizeof(float)+(m_GlobalHeight - m_ImageHeight+m_Dy)*(m_GlobalWidth+m_Dx)*sizeof(float); 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step2;前一帧重叠部分除二 
		Status =ippmMul_mac_32f_L((const float**)&m_DstImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfOldImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step3;复制当前帧； 
		Status = ippmCopy_ma_32f_LL((const float**)&m_CurImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_HalfCurImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step4；当前帧重叠部分除二。 
		Status =ippmMul_mac_32f_L((const float**)&m_CurImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfCurImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth-m_Dx,m_ImageHeight-m_Dy,1); 
 
		int src1ROIShift = 0; 
		int src1Stride1 = m_ImageWidth*sizeof(float); 
 
		int src2ROIShift = 0; 
		int src2Stride1 = m_ImageWidth*sizeof(float); 
 
		dstROIShift =0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step5:重叠部分图像相加。 
 
		ippmAdd_mama_32f_L((const float**)&m_HalfOldImageMat,src1ROIShift,src1Stride1, 
							(const float**)&m_HalfCurImageMat,src2ROIShift,src2Stride1, 
							&m_AddImageMat,dstROIShift,dstStride1,  
							m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = m_Dx*sizeof(float)+(m_GlobalHeight - m_ImageHeight+m_Dy)*(m_GlobalWidth+m_Dx)*sizeof(float); 
		dstStride1 = (m_GlobalWidth+m_Dx)*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		 
		//step6:重叠部分复制回去。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_AddImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
 
		float* mat = m_OldImageMat; 
		m_OldImageMat = m_DstImageMat; 
		m_DstImageMat = mat; 
 
		//更新拼接图的宽度和高度。 
		if(m_Dx<=0) 
		{ 
			m_GlobalWidth = m_GlobalWidth - m_Dx; 
		} 
		else 
		{ 
			m_GlobalWidth = m_GlobalWidth + m_Dx; 
		} 
 
		if(m_Dy<=0) 
		{ 
			m_GlobalHeight = m_GlobalHeight - m_Dy; 
		} 
		else 
		{ 
			m_GlobalHeight = m_GlobalHeight + m_Dy; 
 
		} 
//		ShowImage(); 
	} 
	//以上代码实现向右下角拼接 
	///////////////////////////////////////////////////////////////////////// 
 
	//向右上角运动 
	if(m_Dx > 0 && m_Dy < 0) 
	{ 
		int	srcROIShift = 0; 
		int srcStride1 = m_GlobalWidth*sizeof(float); 
		int srcStride2 = 1*sizeof(float); 
 
		int	dstROIShift = -m_Dy*(m_GlobalWidth+m_Dx)*sizeof(float); 
		int dstStride1 = (m_GlobalWidth+m_Dx)*sizeof(float); 
		int dstStride2 = 1*sizeof(float); 
 
		IppStatus Status; 
		//step 1;将前一帧图像复制到左下角。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_OldImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_GlobalWidth,m_GlobalHeight,1); 
 
		srcROIShift = m_Dx*sizeof(float); 
		srcStride1 = (m_GlobalWidth+m_Dx)*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step2;前一帧重叠部分除二 
		Status =ippmMul_mac_32f_L((const float**)&m_DstImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfOldImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = 0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step3;复制当前帧； 
		Status = ippmCopy_ma_32f_LL((const float**)&m_CurImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_HalfCurImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = -m_Dy*m_ImageWidth*sizeof(float); 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step4；当前帧重叠部分除二。 
		Status =ippmMul_mac_32f_L((const float**)&m_CurImageMat,srcROIShift,srcStride1,0.5, 
								  &m_HalfCurImageMat,dstROIShift,dstStride1, 
								  m_ImageWidth-m_Dx,m_ImageHeight+m_Dy,1); 
 
		int src1ROIShift = 0; 
		int src1Stride1 = m_ImageWidth*sizeof(float); 
 
		int src2ROIShift = 0; 
		int src2Stride1 = m_ImageWidth*sizeof(float); 
 
		dstROIShift =0; 
		dstStride1 = m_ImageWidth*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		//step5:重叠部分图像相加。 
 
		ippmAdd_mama_32f_L((const float**)&m_HalfOldImageMat,src1ROIShift,src1Stride1, 
							(const float**)&m_HalfCurImageMat,src2ROIShift,src2Stride1, 
							&m_AddImageMat,dstROIShift,dstStride1,  
							m_ImageWidth,m_ImageHeight,1); 
 
		srcROIShift = 0; 
		srcStride1 = m_ImageWidth*sizeof(float); 
		srcStride2 = 1*sizeof(float); 
 
		dstROIShift = m_Dx*sizeof(float); 
		dstStride1 = (m_GlobalWidth+m_Dx)*sizeof(float); 
		dstStride2 = 1*sizeof(float); 
		 
		//step6:重叠部分复制回去。 
		Status = ippmCopy_ma_32f_LL((const float**)&m_AddImageMat,srcROIShift,srcStride1,srcStride2, 
									&m_DstImageMat,dstROIShift,dstStride1,dstStride2, 
									m_ImageWidth,m_ImageHeight,1); 
 
		float* mat = m_OldImageMat; 
		m_OldImageMat = m_DstImageMat; 
		m_DstImageMat = mat; 
 
		//更新拼接图的宽度和高度。 
		if(m_Dx<=0) 
		{ 
			m_GlobalWidth = m_GlobalWidth - m_Dx; 
		} 
		else 
		{ 
			m_GlobalWidth = m_GlobalWidth + m_Dx; 
		} 
 
		if(m_Dy<=0) 
		{ 
			m_GlobalHeight = m_GlobalHeight - m_Dy; 
		} 
		else 
		{ 
			m_GlobalHeight = m_GlobalHeight + m_Dy; 
 
		} 
//		ShowImage(); 
	} 
	ShowImage(); 
 
} 
 
void CUltraSoundView::ShowImage() 
{ 
	CUltraSoundDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
	////////////////////////////////////////////////////////////////////////////////// 
	//图像显示。 
//	if(m_Dx <= 0 && m_Dy <=0) 
//	{ 
//		m_Dx = 0; 
//		m_Dy = 0; 
 
		int addpix = 0; 
		int mod = m_GlobalWidth%4; 
		if(mod!=0) 
		{ 
			addpix = 4 - mod; 
		} 
 
		int	srcROIShift = 0; 
		int srcStride1 = (m_GlobalWidth)*sizeof(float); 
		int srcStride2 = 1*sizeof(float); 
 
		int	dstROIShift = addpix*sizeof(float); 
 
		int dstStride1 = (m_GlobalWidth + addpix)*sizeof(float); 
		int dstStride2 = 1*sizeof(float); 
 
		IppStatus Status = ippmCopy_ma_32f_LL((const float**)&m_OldImageMat,srcROIShift,srcStride1,srcStride2, 
											  &m_ShowImageMat,dstROIShift,dstStride1,dstStride2, 
											  m_GlobalWidth,m_GlobalHeight,1); 
 
		CvSize size; 
		size.width = m_GlobalWidth + addpix; 
		size.height = m_GlobalHeight; 
 
		if(m_EndImg!=NULL) 
			cvReleaseImage(&m_EndImg); 
 
		m_EndImg = cvCreateImage(size, IPL_DEPTH_8U, 1 ); 
 
		char* pointer1 = m_EndImg->imageData; 
		float* pointer2 = m_ShowImageMat; 
 
		for(int endheight=0;endheightm_pImageList[0]->imageSize,0,m_ShowImageMat, 
				pDoc->m_pImageList[0]->imageSize,pDoc->m_pImageList[0]->imageSize,5); 
 
		Status = ippmMul_mc_32f(m_DstImageMat,pDoc->m_pImageList[0]->imageSize,0,m_DstImageMat, 
				pDoc->m_pImageList[0]->imageSize,pDoc->m_pImageList[0]->imageSize,5); 
 
		Invalidate(); 
} 
 
void CUltraSoundView::OnUpdateStart(CCmdUI* pCmdUI)  
{ 
	CUltraSoundDoc* pDoc = GetDocument(); 
	ASSERT_VALID(pDoc); 
 
	pCmdUI->Enable (pDoc->m_ImgNum > 0); 
} 
 
void CUltraSoundView::ShowImageGray(IplImage* pImage, int xpos, int ypos) 
{ 
	uchar* data = 0; 
	int step = 0; 
	CvSize size; 
	cvGetRawData( pImage, &data, &step, &size ); 
 
	IplImage* tempImg = cvCreateImage( size, IPL_DEPTH_8U, 4 ); 
	cvCvtColor(pImage, tempImg, CV_GRAY2RGBA); 
	cvGetRawData( tempImg, &data, &step, &size ); 
 
	CDC* pDC = GetDC(); 
	CBitmap bitmap; 
	CDC	dcMemory; 
	dcMemory.CreateCompatibleDC(pDC); 
	bitmap.CreateCompatibleBitmap(pDC, size.width, size.height); 
	bitmap.SetBitmapBits(size.width*size.height*4, data); 
	dcMemory.SelectObject(&bitmap); 
	pDC->BitBlt(xpos, ypos, size.width, size.height, &dcMemory, 0, 0, SRCCOPY);  
 
	cvReleaseImageHeader(&tempImg); 
} 
 
BOOL CUltraSoundView::OnEraseBkgnd(CDC* pDC)  
{ 
	return true; 
}