www.pudn.com > jingdianWavlet.rar > WVLTDOC.CPP

// WvltDoc.cpp : implementation of the CWvltDoc class 
// 
 
#include "stdafx.h" 
#include "Wavelets.h" 
#include "WvltDoc.h" 
#include "TextureDlg.h" 
//#include "WvltApp.h" 
#include "ImageView.h" 
#include "WvltView.h" 
#include  
#include  
 
#include "WvltTrans.h" 
#include "WFilter.h" 
#include "Diproc.h" 
 
#ifdef _DEBUG 
#define new DEBUG_NEW 
#undef THIS_FILE 
static char THIS_FILE[] = __FILE__; 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// CWvltDoc 
 
IMPLEMENT_DYNCREATE(CWvltDoc, CDocument) 
 
BEGIN_MESSAGE_MAP(CWvltDoc, CDocument) 
	//{{AFX_MSG_MAP(CWvltDoc) 
	ON_COMMAND(IDM_WVLT_HORTRANS, OnWvltHortrans) 
	ON_COMMAND(IDM_WVLT_VERTRANS, OnWvltVertrans) 
	ON_COMMAND(IDM_WVLT_ONCE, OnWvltTransOnce) 
	ON_COMMAND(IDM_WVLT_TWICE, OnWvltTransTwice) 
	ON_COMMAND(IDM_WVLT_TRBL, OnWvltTransTrbl) 
	ON_COMMAND(IDM_DIPROC_ENHACE, OnDiprocEnhace) 
	ON_COMMAND(IDM_DIPROC_FUSION, OnDiprocFusion) 
	ON_COMMAND(IDM_DIPROC_REVER, OnDiprocRever) 
	ON_COMMAND(IDM_FILTER_BLUR, OnFilterBlur) 
	ON_COMMAND(IDM_FILTER_SHARPNESS, OnFilterSharpness) 
	ON_COMMAND(IDM_FILTER_BLUR2, OnFilterBlur2) 
	ON_COMMAND(ID_FILE_SAVE, OnFileSave) 
	ON_COMMAND(IDM_FILTER_SHARPNESS2, OnFilterSharpness2) 
	//}}AFX_MSG_MAP 
 
END_MESSAGE_MAP() 
 
///////////////////////////////////////////////////////////////////////////// 
// CWvltDoc construction/destruction 
 
CWvltDoc::CWvltDoc() 
{ 
	m_fDirty = FALSE; 
	m_pBitmap = NULL ; 
	m_pTransfered = NULL; 
	m_bTribl = FALSE;	m_bOnce = FALSE;	m_bTwice = FALSE;	m_bFilter = FALSE; 
} 
 
CWvltDoc::~CWvltDoc() 
{ 
	if( m_pBitmap != NULL) 
		free( m_pBitmap); 
	if( m_pTransfered != NULL) 
		free( m_pTransfered	); 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CWvltDoc serialization 
 
void CWvltDoc::Serialize(CArchive& ar) 
{ 
	if (ar.IsStoring()) 
	{ 
		// TODO: add storing code here 
	} 
	else 
	{ 
		// TODO: add loading code here 
	} 
} 
 
///////////////////////////////////////////////////////////////////////////// 
// CWvltDoc diagnostics 
 
#ifdef _DEBUG 
void CWvltDoc::AssertValid() const 
{ 
	CDocument::AssertValid(); 
} 
 
void CWvltDoc::Dump(CDumpContext& dc) const 
{ 
	CDocument::Dump(dc); 
} 
#endif //_DEBUG 
 
///////////////////////////////////////////////////////////////////////////// 
// CWvltDoc commands 
 
BOOL CWvltDoc::OnNewDocument() 
{ 
	if (!CDocument::OnNewDocument()) 
		return FALSE; 
 
	// TODO: add reinitialization code here 
	// (SDI documents will reuse this document) 
 
	return TRUE; 
} 
 
BOOL CWvltDoc::OnOpenDocument(LPCTSTR lpszPathName)  
{ 
	if (!CDocument::OnOpenDocument(lpszPathName)) 
		return FALSE; 
	m_strFileName = lpszPathName; 
	m_strFileFusion = m_strFileName; 
	if (ReadBitmap(lpszPathName, m_pBitmap)) 
		UpdateAllViews(NULL); 
	return TRUE; 
} 
 
BOOL CWvltDoc::ReadBitmap(LPCTSTR lpszPathName, unsigned char *& buffer) 
{ 
	FILE *file; 
	file = fopen( lpszPathName, "rb"); 
	if(!file) 
		return FALSE; 
	fpos_t posend, posbegin; 
 
	fseek(file, 0, SEEK_END); 
	fgetpos(file, &posend); 
	fseek(file, 0, SEEK_SET); 
	fgetpos(file,&posbegin); 
	size_t filesize = (size_t)(posend - posbegin); 
	 
	if( buffer == NULL ) 
		buffer = (unsigned char*)malloc( filesize); 
	if( buffer == NULL ) 
	{ 
		AfxMessageBox(IDM_MEMORY_INSUFFICIENT, MB_OK, 0); 
		return FALSE; 
	} 
	memset(buffer, 0, filesize); 
	size_t sizeread = fread(buffer, sizeof(unsigned char), filesize, file); 
	if(sizeread != filesize) 
	{ 
		AfxMessageBox(IDM_READFILE_ERROR, MB_OK, 0); 
		free(buffer); 
		buffer = NULL; 
		fclose(file); 
		return FALSE; 
	} 
	if( buffer[0] != 'B'||buffer[1] != 'M') 
	{ 
		AfxMessageBox(IDM_FILEFORMAT_ERROR, MB_OK, 0); 
		free(buffer); 
		buffer = NULL; 
		fclose(file); 
		return FALSE; 
	} 
	fclose(file); 
	return TRUE; 
} 
 
void CWvltDoc::OnWvltHortrans()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像矩阵坐标与像素数值 
	int x,y,cur; 
	unsigned char tempR, tempG, tempB; 
	short **spOriginData, **spTransData0; 
	float fTempBufforDisp; 
	short MaxPixVal,MinPixVal,Diff; 
	//分配数据空间 
	spOriginData = new short* [biHeight]; 
	spTransData0 = new short* [biHeight]; 
	// 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		spOriginData[i] = new short [biWidth]; 
		spTransData0[i] = new short [biWidth]; 
	} 
	//创建图像小波变换类 
	CWvltTrans *pTrans; 
	//从设备缓存中获得原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			spOriginData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//完成图像水平方向的一次小波变换 
	pTrans->Hori_Transform(spOriginData,spTransData0,biHeight,biWidth/2,1); 
	//屏蔽图像复原操作标志 
	m_bFilter = TRUE; 
	m_bFilter = m_bFilter & ~m_bOnce & ~m_bTwice & ~m_bTribl; 
	MaxPixVal=spTransData0[0][0]; 
	MinPixVal=spTransData0[0][0]; 
	//得到图像小波系数的极大值与极小值 
	for( y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			if(MaxPixValspTransData0[y][x]) 
				MinPixVal=spTransData0[y][x]; 
		} 
	} 
	//计算获取图像小波系数的极值差 
	Diff=MaxPixVal-MinPixVal; 
	//小波经过处理后，放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
		//因为小波变换后的小波系数有可能超过255甚至更多，那么就将 
		//小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的 
			fTempBufforDisp=spTransData0[biHeight-1-y][x]; 
			fTempBufforDisp-=MinPixVal; 
			fTempBufforDisp*=255; 
			fTempBufforDisp/=Diff; 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+1]= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+2]= (unsigned char)fTempBufforDisp; 
		} 
	} 
	//小波图像水平方向小波变换 
	UpdateAllViews(NULL); 
	//删除临时的数据空间 
	delete spOriginData; 
	delete spTransData0; 
} 
 
void CWvltDoc::OnWvltVertrans()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像矩阵坐标与像素数据 
	int x,y,cur; 
	unsigned char tempR, tempG, tempB; 
	float fTempBufforDisp; 
	short MaxPixVal,MinPixVal,Diff; 
	short **spOriginData, **spTransData1; 
	//分配图像小波变换所需的数据空间 
	spOriginData = new short* [biHeight]; 
	spTransData1 = new short* [biHeight]; 
 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		spOriginData[i] = new short [biWidth]; 
		spTransData1[i] = new short [biWidth]; 
	} 
	//创建图像小波变换类 
	CWvltTrans *pTrans; 
	//从设备缓存中获取原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			spOriginData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//完成一次竖直方向的图像小波变换 
	pTrans->Vert_Transform(spOriginData,spTransData1,biHeight/2,biWidth,1); 
	//屏蔽图像复原操作标志 
	m_bFilter = TRUE; 
	m_bFilter = m_bFilter & ~m_bOnce & ~m_bTwice & ~m_bTribl; 
	MaxPixVal=spTransData1[0][0]; 
	MinPixVal=spTransData1[0][0]; 
	//计算得到图像小波系数的极大值和极小值 
	for( y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			if(MaxPixValspTransData1[y][x]) 
				MinPixVal=spTransData1[y][x]; 
		} 
	} 
	//计算小波系数的极值差 
	Diff=MaxPixVal-MinPixVal; 
	//将小波系数处理后，放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
		//因为小波变换后的小波系数有可能超过255甚至更多，那么就将 
		//小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的 
			fTempBufforDisp=spTransData1[biHeight-1-y][x]; 
			fTempBufforDisp-=MinPixVal; 
			fTempBufforDisp*=255; 
			fTempBufforDisp/=Diff; 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+1]= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+2]= (unsigned char)fTempBufforDisp; 
		} 
	} 
	//显示图像的小波系数 
	UpdateAllViews(NULL); 
	//删除临时的数据空间 
	delete spOriginData; 
	delete spTransData1; 
 
} 
 
void CWvltDoc::OnWvltTransOnce()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像矩阵坐标与像素数据	 
	int x,y,cur; 
	unsigned char tempR, tempG, tempB; 
	float fTempBufforDisp; 
	short MaxPixVal,MinPixVal,Diff; 
	short **spOriginData, **spTransData0, **spTransData1; 
	//分配图像小波变换所用的数据空间 
	spOriginData = new short* [biHeight]; 
	spTransData0 = new short* [biHeight]; 
	spTransData1 = new short* [biHeight]; 
	m_WvltCoeff	= new short * [biHeight]; 
 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		spOriginData[i] = new short [biWidth]; 
		spTransData0[i] = new short [biWidth]; 
		spTransData1[i] = new short [biWidth]; 
		m_WvltCoeff[i] = new short [biWidth]; 
	} 
	//创建图像小波变换类 
	CWvltTrans *pTrans; 
	//从设备缓存中获取原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			spOriginData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//完成一次图像小波变换 
	pTrans->DWT_Once(spOriginData,spTransData0,spTransData1,biHeight,biHeight/2,biWidth,biWidth/2,1,1.414); 
	//允许图像复原操作标志 
	m_bOnce = TRUE; 
	m_bOnce = m_bOnce & ~m_bTwice & ~m_bTribl & ~m_bFilter; 
	MaxPixVal=spTransData1[0][0]; 
	MinPixVal=spTransData1[0][0]; 
	for( y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			if(MaxPixValspTransData1[y][x]) 
				MinPixVal=spTransData1[y][x]; 
			m_WvltCoeff[y][x] = spTransData1[y][x]; 
		} 
	} 
	Diff=MaxPixVal-MinPixVal; 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
		//因为小波变换后的小波系数有可能超过255甚至更多，那么就将 
		//小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的 
			fTempBufforDisp=spTransData1[biHeight-1-y][x]; 
			fTempBufforDisp-=MinPixVal; 
			fTempBufforDisp*=255; 
			fTempBufforDisp/=Diff; 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+1]= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+2]= (unsigned char)fTempBufforDisp; 
		} 
	} 
	//显示图像的小波系数 
	UpdateAllViews(NULL); 
	//删除临时的数据空间 
	delete spOriginData; 
	delete spTransData0; 
	delete spTransData1; 
} 
 
void CWvltDoc::OnWvltTransTwice()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像矩阵坐标与像素数值 
	int x,y,cur; 
	unsigned char tempR, tempG, tempB; 
	float fTempBufforDisp; 
	short MaxPixVal,MinPixVal,Diff; 
	short **spOriginData, **spTransData0, **spTransData1; 
	//分配数据空间 
	spOriginData = new short* [biHeight]; 
	spTransData0 = new short* [biHeight]; 
	spTransData1 = new short* [biHeight]; 
	m_WvltCoeff	= new short * [biHeight]; 
 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		spOriginData[i] = new short [biWidth]; 
		spTransData0[i] = new short [biWidth]; 
		spTransData1[i] = new short [biWidth]; 
		m_WvltCoeff[i] = new short [biWidth]; 
	} 
	//创建图像小波变化类 
	CWvltTrans *pTrans; 
	//从设备缓存中获取原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			spOriginData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//完成图像的两次小波变换 
	pTrans->DWT_TwoLayers(spOriginData,spTransData0,spTransData1,biHeight,biHeight/2,biWidth,biWidth/2,2,1.414); 
	//允许图像复原操作标志 
	m_bTwice = TRUE; 
	m_bTwice = m_bTwice & ~m_bTribl & ~m_bOnce & ~m_bFilter; 
	MaxPixVal=spTransData1[0][0]; 
	MinPixVal=spTransData1[0][0]; 
	//计算得到图像小波系数的极大值与极小值 
	for( y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			if(MaxPixValspTransData1[y][x]) 
				MinPixVal=spTransData1[y][x]; 
			m_WvltCoeff[y][x] = spTransData1[y][x]; 
		} 
	} 
	//计算获得小波系数的极值差 
	Diff=MaxPixVal-MinPixVal; 
	//小波系数经过处理后，放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
		//因为小波变换后的小波系数有可能超过255甚至更多，那么就将 
		//小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的 
			fTempBufforDisp=spTransData1[biHeight-1-y][x]; 
			fTempBufforDisp-=MinPixVal; 
			fTempBufforDisp*=255; 
			fTempBufforDisp/=Diff; 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+1]= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+2]= (unsigned char)fTempBufforDisp; 
		} 
	} 
	//显示图像的小波系数 
	UpdateAllViews(NULL); 
	//删除临时的数据空间 
	delete spOriginData; 
	delete spTransData0; 
	delete spTransData1; 
} 
 
void CWvltDoc::OnWvltTransTrbl()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像矩阵坐标与像素数据 
	int x,y,cur; 
	unsigned char tempR, tempG, tempB; 
	float fTempBufforDisp; 
	short MaxPixVal,MinPixVal,Diff; 
	short **spOriginData, **spTransData0, **spTransData1; 
	//分配图像小波变换的数据内存空间 
	spOriginData = new short* [biHeight]; 
	spTransData0 = new short* [biHeight]; 
	spTransData1 = new short* [biHeight]; 
	m_WvltCoeff	= new short * [biHeight]; 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		spOriginData[i] = new short [biWidth]; 
		spTransData0[i] = new short [biWidth]; 
		spTransData1[i] = new short [biWidth]; 
		m_WvltCoeff[i] = new short [biWidth]; 
	} 
	//创建图像小波类 
	CWvltTrans *pTrans; 
	//从设备的图像缓存中获取原始图像的数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			spOriginData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//完成图像的三次小波变换 
	pTrans->DWT_TriLayers(spOriginData,spTransData0,spTransData1,biHeight,biHeight/2,biWidth,biWidth/2,3,1.414); 
	//允许图像复员操作标志 
	m_bTribl = TRUE; 
	m_bTribl = m_bTribl & ~m_bTwice & ~m_bOnce & ~m_bFilter; 
	MaxPixVal=spTransData1[0][0]; 
	MinPixVal=spTransData1[0][0]; 
	//得到小波系数的极大值和极小值 
	for( y=0; y<(int)biHeight; y++) 
	{ 
		for( x=0; x<(int)biWidth; x++) 
		{ 
			if(MaxPixValspTransData1[y][x]) 
				MinPixVal=spTransData1[y][x]; 
			m_WvltCoeff[y][x] = spTransData1[y][x]; 
		} 
	} 
	//计算出小波系数的极值差 
	Diff=MaxPixVal-MinPixVal; 
	//将图像的小波数据处理后放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
		//因为小波变换后的小波系数有可能超过255甚至更多，那么就将 
		//小波系数的范围映射到0~255区间内，以后出现类似的处理，目的都是一样的 
			fTempBufforDisp=spTransData1[biHeight-1-y][x]; 
			fTempBufforDisp-=MinPixVal; 
			fTempBufforDisp*=255; 
			fTempBufforDisp/=(float)Diff; 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+1]= (unsigned char)fTempBufforDisp; 
			m_pTransfered[cur+2]= (unsigned char)fTempBufforDisp; 
		} 
	} 
	//显示图像的小波变换 
	UpdateAllViews(NULL); 
	//删除临时的数据空间 
	delete spOriginData; 
	delete spTransData0; 
	delete spTransData1; 
} 
 
void CWvltDoc::OnDiprocEnhace()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像矩阵的坐标与像素数据 
	int x, y, cur; 
	int tempR, tempG, tempB; 
	//正则化小波系数的波动范围，NormWvltRng[0]存放极小值，NormWvltRng[1]存放极大值 
	float NormWvltRng[2]; 
	//原始图像数据存储，数据用于图像对比度增强 
	short **pData; 
	//分配图像数据的内存空间 
	pData = new short *[biHeight]; 
	for(int i = 0; i < biWidth; i++) 
		pData[i] = new short [biWidth]; 
	//从设备缓存中获取原始图像的数据 
	for(y = 0; y < biHeight; y ++) 
	{ 
		for (x = 0; x < biWidth; x++) 
		{ 
			cur = y * biAlign + 3 * x; 
			tempB = lpData[cur]; 
			tempG = lpData[cur + 1]; 
			tempR = lpData[cur + 2]; 
			pData[biHeight - 1 - y][x] = 0.3 * tempR + 0.59 * tempG + 0.11 * tempB; 
		} 
	} 
	//创建图像处理类 
	CDiproc *pDIP; 
	pDIP->DIP_ConsEnhance(pData, biHeight, biWidth, NormWvltRng); 
	//将复原后的图像信息写入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)pData[biHeight - 1- y][x]; 
 			m_pTransfered[cur+1]= (unsigned char)pData[biHeight - 1 - y][x]; 
			m_pTransfered[cur+2]= (unsigned char)pData[biHeight - 1 - y][x]; 
		} 
	} 
	//显示图像复原的结果 
	UpdateAllViews(NULL); 
	//删除临时的数据内存空间 
	delete pData; 
 
} 
 
void CWvltDoc::OnDiprocFusion()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	//定义图像的内存数据空间指针 
	short **pData, **pDataFusion; 
	CString cstrFileName = m_strFileFusion; 
	//图像矩阵的坐标与像素数据 
	int x, y, cur; 
	int tempR, tempG, tempB; 
	//分配图像的数据空间 
	pData = new short * [biHeight]; 
	pDataFusion = new short * [biHeight]; 
	for(int i = 0; i < biWidth; i ++) 
	{ 
		pDataFusion[i] = new short [biWidth]; 
		pData[i] = new short [biWidth]; 
	} 
	//从设备的显示缓存中获取原始图像的数据 
	for(y = 0; y < (int) biHeight; y ++) 
	{ 
		for(x = 0; x < (int) biWidth; x ++) 
		{ 
			cur = y * biAlign + 3 * x; 
			tempB = lpData[cur]; 
			tempG = lpData[cur + 1]; 
			tempR = lpData[cur + 2]; 
			pData[biHeight - 1 - y][x] = 0.3 * tempR + 0.59 * tempG + 0.11 * tempB; 
		} 
	} 
	//释放设备占用的显示缓存 
	//m_pBitmap = NULL; 
	//打开另外一幅用于融合的图像文件 
	MessageBoxA(NULL,_T("请在WvltDip\\Fusion目录中打开另外一幅图像，进行图像融合"),_T("Message"),MB_ICONEXCLAMATION|MB_OK); 
	while(!abs((int)strcmp(m_strFileFusion, cstrFileName))) 
	{ 
		CFileDialog dlg( TRUE,NULL,NULL, 
	                 OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, 
	                 _T("Bitmap (*.BMP)|*.BMP|")); 
		if( dlg.DoModal()==IDOK ) 
			cstrFileName = dlg.GetPathName(); 
		//如果文件重名，提示重新打开文件 
		if(!abs((int)strcmp(m_strFileFusion, cstrFileName)))  
			MessageBoxA(NULL,_T("文件"+m_strFileFusion+"已打开，请打开该目录中另外一个文件"),_T("Message"),MB_ICONEXCLAMATION|MB_OK); 
		else 
			MessageBoxA(NULL,_T("用于图像融合的文件是：\n"+m_strFileFusion+"\n"+cstrFileName),_T("Message"),MB_ICONEXCLAMATION|MB_OK); 
	} 
	//读取位图数据，载入显示缓存中 
	ReadBitmap(cstrFileName, m_pTransfered); 
	//显示新打开的图像 
	UpdateAllViews(NULL); 
	//读取另外一幅图像的数据 
	lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pTransfered+14); 
	lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pTransfered; 
	unsigned char *lpImgData = m_pTransfered + lpBitmapFileHeader->bfOffBits; 
	//从设备的显示缓存中获取原始图像的数据 
	for(y = 0; y < biHeight; y ++) 
	{ 
		for (x = 0; x < biWidth; x++) 
		{ 
			cur = y * biAlign + 3 * x; 
			tempB = lpImgData[cur]; 
			tempG = lpImgData[cur + 1]; 
			tempR = lpImgData[cur + 2]; 
			pDataFusion[biHeight - 1 - y][x] = 0.3 * tempR + 0.59 * tempG + 0.11 * tempB; 
		} 
	} 
	//清空显示缓存，并重新分配显示缓存 
	m_pTransfered = NULL; 
	m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//创建用于图像融合的Diproc类 
	CDiproc *pDIP; 
	pDIP->DIP_ImageFusion(pData, pDataFusion, biHeight, biWidth); 
	//将图像数据放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)pDataFusion[biHeight - 1- y][x]; 
			m_pTransfered[cur+1]= (unsigned char)pDataFusion[biHeight - 1 - y][x]; 
			m_pTransfered[cur+2]= (unsigned char)pDataFusion[biHeight - 1 - y][x]; 
		} 
	} 
	//显示图像复原的结果 
	UpdateAllViews(NULL); 
	//删除临时的数据内存空间 
	delete pData; 
	delete pDataFusion;	 
} 
 
void CWvltDoc::OnDiprocRever()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像矩阵的坐标 
	int x,y,cur; 
	int tempR, tempG, tempB; 
	//图像数据与图像处理数据的存放空间 
	short **spOriginData, **spTransData0; 
	spOriginData = new short* [biHeight]; 
	spTransData0 = new short* [biHeight]; 
	////spTransData1 = new short* [biHeight]; 
	//分配数据的内存空间 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		spOriginData[i] = new short [biWidth]; 
		spTransData0[i] = new short [biWidth]; 
	//	spTransData1[i] = new short [biWidth]; 
	} 
	//创建数字处理类 
	CDiproc *pDip; 
	//如果图像只经过一次小波变换，则进行相应的逆变换 
	if(m_bOnce) 
	{ 
		pDip->DIP_WvltRevers(spOriginData, spTransData0, m_WvltCoeff,biHeight,biHeight/2,biWidth,biWidth/2,1,1.414); 
		m_bOnce = FALSE; 
		delete m_WvltCoeff; 
	} 
	//如果图像只经过两次小波变换，则进行相应的逆变换 
	else if(m_bTwice) 
	{ 
		pDip->DIP_WvltRevers(spOriginData, spTransData0, m_WvltCoeff,biHeight ,biHeight/2,biWidth,biWidth/2,2,1.414); 
		m_bTwice = FALSE; 
		delete m_WvltCoeff; 
	} 
	//如果图像只经过三次小波变换，则进行相应的逆变换 
	else if(m_bTribl) 
	{ 
		pDip->DIP_WvltRevers(spOriginData, spTransData0, m_WvltCoeff, biHeight, biHeight/2,biWidth,biWidth/2,3,1.414); 
		m_bTribl = FALSE; 
		delete m_WvltCoeff; 
	} 
	//判断是否有小波系数可以进行图像的复原 
	else if(m_bFilter) 
	{ 
		MessageBoxA(NULL,_T("没有找到可用小波系数，或者是未做小波变换"),_T("Message"),MB_ICONEXCLAMATION|MB_OK); 
		m_bFilter = FALSE; 
	} 
	//将图像数据放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur= y*biAlign+3*x;		//current pixel	 
			m_pTransfered[cur]	= (unsigned char)spOriginData[biHeight - 1- y][x]; 
			m_pTransfered[cur+1]= (unsigned char)spOriginData[biHeight - 1 - y][x]; 
			m_pTransfered[cur+2]= (unsigned char)spOriginData[biHeight - 1 - y][x]; 
		} 
	} 
	//显示图像复原的结果 
	UpdateAllViews(NULL); 
	//删除临时的数据内存空间 
	delete spOriginData; 
	delete spTransData0; 
	//delete spTransData1; 
} 
 
void CWvltDoc::OnFilterBlur()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像小波系数的低通滤波层数为3层 
	int MaxLayer = 3; 
	short **ImgData; 
	float fTempBufforDisp;	 
	//图像矩阵坐标与图像数据 
	int tempR, tempG, tempB, x, y, cur; 
	//分配图像数据的内存空间 
	ImgData = new short * [biHeight]; 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		ImgData[i] = new short [biWidth]; 
	} 
	//获取显示缓存中的原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			ImgData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//创建小波滤波器类 
	CWFilter Filter; 
	//小波低通滤波处理 
	Filter.LPass_Filter(ImgData, biHeight, biWidth, MaxLayer, 1); 
	//屏蔽图像复原操作标志 
	m_bFilter = TRUE; 
	//将处理后的图像数据放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur= y*biAlign+3*x;		//当前像素的位置	 
			m_pTransfered[cur]	= (unsigned char)Filter.m_FilterData[biHeight - 1- y][x]; 
			m_pTransfered[cur+1]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
			m_pTransfered[cur+2]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
		} 
	} 
	//显示图像 
	UpdateAllViews(NULL); 
	//删除临时的图像数据空间 
	delete ImgData; 
} 
 
void CWvltDoc::OnFilterBlur2()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像小波系数的低通滤波层数为3层 
	int MaxLayer = 3; 
	short **ImgData; 
	float fTempBufforDisp;	 
	//图像矩阵坐标与图像数据 
	int tempR, tempG, tempB, x, y, cur; 
	//分配图像数据的内存空间 
	ImgData = new short * [biHeight]; 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		ImgData[i] = new short [biWidth]; 
	} 
	//获取显示缓存中的原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			ImgData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//创建小波滤波器类 
	CWFilter Filter; 
	//小波低通滤波处理 
	Filter.LPass_Filter(ImgData, biHeight, biWidth, MaxLayer, 2); 
	//屏蔽图像复原操作标志 
	m_bFilter = TRUE; 
	//将处理后的图像数据放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur= y*biAlign+3*x;		//当前像素的位置	 
			m_pTransfered[cur]	= (unsigned char)Filter.m_FilterData[biHeight - 1- y][x]; 
			m_pTransfered[cur+1]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
			m_pTransfered[cur+2]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
		} 
	} 
	//显示图像 
	UpdateAllViews(NULL); 
	//删除临时的图像数据空间 
	delete ImgData; 
	 
} 
 
void CWvltDoc::OnFilterSharpness()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像小波系数的高通滤波层数为3层 
	int MaxLayer = 3; 
	short **ImgData; 
	float fTempBufforDisp;	 
	//图像矩阵坐标与图像数据 
	int tempR, tempG, tempB, x, y, cur; 
	//分配图像数据的内存空间 
	ImgData = new short * [biHeight]; 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		ImgData[i] = new short [biWidth]; 
	} 
	//获取显示缓存中的原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			ImgData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//创建小波滤波器类 
	CWFilter Filter; 
	//小波高通滤波处理 
	Filter.HPass_Filter(ImgData, biHeight, biWidth, MaxLayer); 
	//屏蔽图像复原操作标志 
	m_bFilter = TRUE; 
	//将处理后的图像数据放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur= y*biAlign+3*x;		//当前像素的位置	 
			m_pTransfered[cur]	= (unsigned char)Filter.m_FilterData[biHeight - 1- y][x]; 
			m_pTransfered[cur+1]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
			m_pTransfered[cur+2]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
		} 
	} 
	//显示图像 
	UpdateAllViews(NULL); 
	//删除临时的图像数据空间 
	delete ImgData; 
} 
 
 
 
 
 
void CWvltDoc::OnFilterSharpness2()  
{ 
	// TODO: Add your command handler code here 
	//读取数字图像的文件头，获取图像的属性参数 
	LPBITMAPINFOHEADER lpBitmapInfoHeader = (LPBITMAPINFOHEADER)(m_pBitmap+14); 
	LPBITMAPFILEHEADER lpBitmapFileHeader = (LPBITMAPFILEHEADER)m_pBitmap; 
	unsigned char *lpData = m_pBitmap + lpBitmapFileHeader->bfOffBits; 
	unsigned long biHeight = lpBitmapInfoHeader->biHeight; 
	unsigned long biWidth = lpBitmapInfoHeader->biWidth; 
	unsigned long biAlign = (biWidth*3+3)/4 *4; 
	unsigned long bmSize = biHeight * biAlign; 
	if(m_pTransfered==NULL) 
		m_pTransfered=(unsigned char*) malloc (bmSize); 
	if(m_pTransfered==NULL) 
		return; 
	//图像小波系数的高通滤波层数为3层 
	int MaxLayer = 3; 
	short **ImgData; 
	float fTempBufforDisp;	 
	//图像矩阵坐标与图像数据 
	int tempR, tempG, tempB, x, y, cur; 
	//分配图像数据的内存空间 
	ImgData = new short * [biHeight]; 
	for(int i = 0; i < biHeight; i ++) 
	{ 
		ImgData[i] = new short [biWidth]; 
	} 
	//获取显示缓存中的原始图像数据 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur = y*biAlign+3*x; 
			tempB=lpData[cur]; 
			tempG=lpData[cur+1]; 
			tempR=lpData[cur+2]; 
			ImgData[biHeight-1-y][x]=(short)(0.3*tempR+0.59*tempG+0.11*tempB);  //no problem 
		} 
	} 
	//创建小波滤波器类 
	CWFilter Filter; 
	//小波高通滤波处理 
	Filter.HPass_Filter2(ImgData, biHeight, biWidth, MaxLayer); 
	//屏蔽图像复原操作标志 
	m_bFilter = TRUE; 
	//将处理后的图像数据放入显示缓存中 
	for(y=0; y<(int)biHeight; y++) 
	{ 
		for(x=0; x<(int)biWidth; x++) 
		{ 
			cur= y*biAlign+3*x;		//当前像素的位置	 
			m_pTransfered[cur]	= (unsigned char)Filter.m_FilterData[biHeight - 1- y][x]; 
			m_pTransfered[cur+1]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
			m_pTransfered[cur+2]= (unsigned char)Filter.m_FilterData[biHeight - 1 - y][x]; 
		} 
	} 
	//显示图像 
	UpdateAllViews(NULL); 
	//删除临时的图像数据空间 
	delete ImgData; 
}