www.pudn.com > ImgSeg.rar > ImgPro.cpp

// ImgPro.cpp: implementation of the CImgPro class. 
// 
////////////////////////////////////////////////////////////////////// 
 
#include "stdafx.h" 
#include "ImgSeg.h" 
#include "ImgPro.h" 
#include "math.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
////////////////////////////////////////////////////////////////////// 
// Construction/Destruction 
////////////////////////////////////////////////////////////////////// 
 
CImgPro::CImgPro(LPBYTE lpBits,LONG lWidth,LONG lHeight) 
{ 
	//初始化 
	m_lpBits=lpBits; 
	m_lWidth=lWidth; 
	m_lHeight=lHeight; 
} 
 
CImgPro::~CImgPro() 
{ 
 
} 
 
BOOL CImgPro::Roberts() 
{ 
	//Robert边缘检测算法 
	 
	// 指向源图像的指针 
	LPSTR lpSrc; 
	 
	// 指向缓存图像的指针 
	LPSTR lpDst; 
	 
	// 指向缓存位图图像的指针 
	LPSTR lpNewBmpBits; 
	HLOCAL hNewBmpBits; 
 
	//循环变量 
	long i; 
	long j; 
 
	//像素值 
	double result; 
	unsigned char pixel[4]; 
 
	// 暂时分配内存，以保存新图像 
	hNewBmpBits=LocalAlloc(LHND,m_lWidth*m_lHeight); 
	 
	if(hNewBmpBits==NULL) 
	{ 
		//分配内存失败 
		return FALSE; 
	} 
	// 锁定内存 
	lpNewBmpBits=(char*)LocalLock(hNewBmpBits); 
 
	// 初始化新分配的内存，设定初始值为255 
	lpDst=(char*)lpNewBmpBits; 
	memset(lpDst,(BYTE)255,m_lWidth*m_lHeight); 
 
 
	//使用水平方向的结构元素进行腐蚀 
	for(j=m_lHeight-1;j>0;j--) 
	{ 
		for(i=0;i 255) 
			{ 
				// 直接赋值为255 
				* lpDst = 255; 
			} 
			else 
			{ 
				// 赋值 
				*lpDst=(unsigned char)(fResult+0.5); 
			} 
			 
		} 
	} 
	 
	// 复制变换后的图像 
	memcpy(lpBits, lpNewBmpBits, m_lWidth * m_lHeight); 
	 
	// 释放内存 
	LocalUnlock(hNewBmpBits); 
	LocalFree(hNewBmpBits); 
	 
	// 返回 
	return TRUE; 
} 
 
BOOL CImgPro::Sobel() 
{ 
	//Sobel算子 
	// 指向缓存图像的指针 
	LPSTR	lpDst1; 
	LPSTR	lpDst2; 
	 
	// 指向缓存位图图像的指针 
	LPSTR	lpNewBmpBits1; 
	HLOCAL	hNewBmpBits1; 
	LPSTR	lpNewBmpBits2; 
	HLOCAL	hNewBmpBits2; 
 
	//循环变量 
	long i; 
	long j; 
 
	// 模板高度 
	int	iTempH; 
	 
	// 模板宽度 
	int	iTempW; 
	 
	// 模板系数 
	FLOAT fTempC; 
	 
	// 模板中心元素X坐标 
	int	iTempMX; 
	 
	// 模板中心元素Y坐标 
	int	iTempMY; 
	 
	//模板数组 
	FLOAT aTemplate[9]; 
 
	// 暂时分配内存，以保存新图像 
	hNewBmpBits1 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBmpBits1 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBmpBits1 = (char * )LocalLock(hNewBmpBits1); 
 
	// 暂时分配内存，以保存新图像 
	hNewBmpBits2 = LocalAlloc(LHND, m_lWidth *m_lHeight); 
 
	if (hNewBmpBits2 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBmpBits2 = (char * )LocalLock(hNewBmpBits2); 
 
	// 拷贝源图像到缓存图像中 
	lpDst1 = (char *)lpNewBmpBits1; 
	memcpy(lpNewBmpBits1, m_lpBits, m_lWidth * m_lHeight); 
	lpDst2 = (char *)lpNewBmpBits2; 
	memcpy(lpNewBmpBits2, m_lpBits, m_lWidth * m_lHeight); 
 
	// 设置Sobel模板参数 
	iTempW = 3; 
	iTempH = 3; 
	fTempC = 1.0; 
	iTempMX = 1; 
	iTempMY = 1; 
	aTemplate[0] = -1.0; 
	aTemplate[1] = -2.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = 0.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 0.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 2.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBmpBits1,iTempH,iTempW,iTempMX,iTempMY,aTemplate,fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 设置Sobel模板参数 
	aTemplate[0] = -1.0; 
	aTemplate[1] = 0.0; 
	aTemplate[2] = 1.0; 
	aTemplate[3] = -2.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 2.0; 
	aTemplate[6] = -1.0; 
	aTemplate[7] = 0.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBmpBits2,iTempH,iTempW, 
		iTempMX,iTempMY,aTemplate,fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 复制经过模板运算后的图像到源图像 
	memcpy(m_lpBits, lpNewBmpBits1, m_lWidth * m_lHeight); 
 
	// 释放内存 
	LocalUnlock(hNewBmpBits1); 
	LocalFree(hNewBmpBits1); 
 
	LocalUnlock(hNewBmpBits2); 
	LocalFree(hNewBmpBits2); 
 
	// 返回 
	return TRUE; 
} 
 
BOOL CImgPro::Threshold(unsigned char iThreshold) 
{ 
	//如果阈值小于0或大于255，返回FALSE 
	if(iThreshold<0 || iThreshold>255) 
		return FALSE; 
	 
	int i,j;        //循环变量 
	unsigned cur;       //当前象素位置       
 
	for(i=0;i *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 复制经过模板运算后的图像到源图像 
	memcpy(m_lpBits, lpNewBmpBits1, m_lWidth * m_lHeight); 
 
	// 释放内存 
	LocalUnlock(hNewBmpBits1); 
	LocalFree(hNewBmpBits1); 
 
	LocalUnlock(hNewBmpBits2); 
	LocalFree(hNewBmpBits2); 
 
	// 返回 
	return TRUE; 
} 
 
unsigned char CImgPro::IterativeThreshold() 
{ 
	// 指向源图像的指针 
	LPSTR	lpSrc; 
 
	//循环变量 
	long i; 
	long j; 
 
	//像素值 
	unsigned char pixel; 
 
	//直方图数组 
	long lHistogram[256]; 
 
	//阈值，最大灰度值与最小灰度值，两个区域的平均灰度值 
	unsigned char iThreshold,iNewThreshold,iMaxGrayValue, 
		iMinGrayValue,iMean1GrayValue,iMean2GrayValue; 
 
	//用于计算区域灰度平均值的中间变量 
	long lP1,lP2,lS1,lS2; 
 
	//迭代次数 
	int iIterationTimes; 
 
	for (i = 0; i < 256;i++) 
	{ 
		lHistogram[i]=0; 
	} 
 
	//获得直方图 
	iMaxGrayValue = 0; 
	iMinGrayValue = 255; 
	for (i = 0;i  pixel) 
			{ 
				iMinGrayValue = pixel; 
			} 
			if(iMaxGrayValue < pixel) 
			{ 
				iMaxGrayValue = pixel; 
			} 
		} 
	} 
 
	//迭代求最佳阈值 
	iNewThreshold = (iMinGrayValue + iMaxGrayValue)/2; 
	iThreshold = 0; 
	 
	for(iIterationTimes = 0; iThreshold != iNewThreshold &&  
		iIterationTimes < 100;iIterationTimes ++) 
	{ 
		iThreshold = iNewThreshold; 
		lP1 =0; 
		lP2 =0; 
		lS1 = 0; 
		lS2 = 0; 
		//求两个区域的灰度平均值 
		for (i = iMinGrayValue;i < iThreshold;i++) 
		{ 
			lP1 += lHistogram[i]*i; 
			lS1 += lHistogram[i]; 
		} 
		if(lP1!=0 && lS1!=0) 
		{ 
			iMean1GrayValue = (unsigned char)(lP1 / lS1); 
		} 
		else 
		{ 
			iMean1GrayValue=(unsigned char)lP1; 
		} 
		for (i = iThreshold+1;i < iMaxGrayValue;i++) 
		{ 
			lP2 += lHistogram[i]*i; 
			lS2 += lHistogram[i]; 
		} 
		if(lP2!=0 && lS2!=0) 
		{ 
			iMean2GrayValue = (unsigned char)(lP2 / lS2); 
		} 
		else 
		{ 
			iMean2GrayValue = (unsigned char)lP2; 
		} 
		iNewThreshold =  (iMean1GrayValue + iMean2GrayValue)/2; 
	} 
 
	return iThreshold; 
 
} 
 
BOOL CImgPro::Prewitt() 
{ 
 
	// 指向缓存图像的指针 
	LPSTR	lpDst1; 
	LPSTR	lpDst2; 
	 
	// 指向缓存位图图像的指针 
	LPSTR	lpNewBits1; 
	HLOCAL	hNewBits1; 
	LPSTR	lpNewBits2; 
	HLOCAL	hNewBits2; 
 
	//循环变量 
	long i; 
	long j; 
 
	// 模板高度 
	int		iTempH; 
	 
	// 模板宽度 
	int		iTempW; 
	 
	// 模板系数 
	FLOAT	fTempC; 
	 
	// 模板中心元素X坐标 
	int		iTempMX; 
	 
	// 模板中心元素Y坐标 
	int		iTempMY; 
	 
	//模板数组 
	FLOAT aTemplate[9]; 
 
	// 暂时分配内存，以保存新图像 
	hNewBits1 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits1 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits1 = (char * )LocalLock(hNewBits1); 
 
	// 暂时分配内存，以保存新图像 
	hNewBits2 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits2 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits2 = (char * )LocalLock(hNewBits2); 
 
	// 拷贝源图像到缓存图像中 
	lpDst1 = (char *)lpNewBits1; 
	memcpy(lpNewBits1, m_lpBits, m_lWidth * m_lHeight); 
	lpDst2 = (char *)lpNewBits2; 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
 
	// 设置Prewitt模板参数 
	iTempW = 3; 
	iTempH = 3; 
	fTempC = 1.0; 
	iTempMX = 1; 
	iTempMY = 1; 
	aTemplate[0] = -1.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = 0.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 0.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits1,iTempH, iTempW, iTempMX, 
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 设置Prewitt模板参数 
	aTemplate[0] = 1.0; 
	aTemplate[1] = 0.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = 1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 0.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2,iTempH, iTempW, iTempMX, 
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 复制经过模板运算后的图像到源图像 
	memcpy(m_lpBits, lpNewBits1, m_lWidth * m_lHeight); 
 
	// 释放内存 
	LocalUnlock(hNewBits1); 
	LocalFree(hNewBits1); 
 
	LocalUnlock(hNewBits2); 
	LocalFree(hNewBits2); 
 
	// 返回 
	return TRUE; 
} 
 
BOOL CImgPro::Kirsch() 
{ 
 
	// 指向缓存图像的指针 
	LPSTR	lpDst1; 
	LPSTR	lpDst2; 
	 
	// 指向缓存位图图像的指针 
	LPSTR	lpNewBits1; 
	HLOCAL	hNewBits1; 
	LPSTR	lpNewBits2; 
	HLOCAL	hNewBits2; 
 
	//循环变量 
	long i; 
	long j; 
 
	// 模板高度 
	int		iTempH; 
	 
	// 模板宽度 
	int		iTempW; 
	 
	// 模板系数 
	FLOAT	fTempC; 
	 
	// 模板中心元素X坐标 
	int		iTempMX; 
	 
	// 模板中心元素Y坐标 
	int		iTempMY; 
	 
	//模板数组 
	FLOAT aTemplate[9]; 
 
	// 暂时分配内存，以保存新图像 
	hNewBits1 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits1 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits1 = (char * )LocalLock(hNewBits1); 
 
	// 暂时分配内存，以保存新图像 
	hNewBits2 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits2 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits2 = (char * )LocalLock(hNewBits2); 
 
	// 拷贝源图像到缓存图像中 
	lpDst1 = (char *)lpNewBits1; 
	memcpy(lpNewBits1, m_lpBits, m_lWidth * m_lHeight); 
	lpDst2 = (char *)lpNewBits2; 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
 
	// 设置Kirsch模板1参数 
	iTempW = 3; 
	iTempH = 3; 
	fTempC = 1.0; 
	iTempMX = 1; 
	iTempMY = 1; 
	aTemplate[0] = 5.0; 
	aTemplate[1] = 5.0; 
	aTemplate[2] = 5.0; 
	aTemplate[3] = -3.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -3.0; 
	aTemplate[6] = -3.0; 
	aTemplate[7] = -3.0; 
	aTemplate[8] = -3.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits1, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 设置Kirsch模板2参数 
	aTemplate[0] = -3.0; 
	aTemplate[1] = 5.0; 
	aTemplate[2] = 5.0; 
	aTemplate[3] = -3.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 5.0; 
	aTemplate[6] = -3.0; 
	aTemplate[7] = -3.0; 
	aTemplate[8] = -3.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
	// 设置Kirsch模板3参数 
	aTemplate[0] = -3.0; 
	aTemplate[1] = -3.0; 
	aTemplate[2] = 5.0; 
	aTemplate[3] = -3.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 5.0; 
	aTemplate[6] = -3.0; 
	aTemplate[7] = -3.0; 
	aTemplate[8] = 5.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置Kirsch模板4参数 
	aTemplate[0] = -3.0; 
	aTemplate[1] = -3.0; 
	aTemplate[2] = -3.0; 
	aTemplate[3] = -3.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 5.0; 
	aTemplate[6] = -3.0; 
	aTemplate[7] = 5.0; 
	aTemplate[8] = 5.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY,  
		aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置Kirsch模板5参数 
	aTemplate[0] = -3.0; 
	aTemplate[1] = -3.0; 
	aTemplate[2] = -3.0; 
	aTemplate[3] = -3.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -3.0; 
	aTemplate[6] = 5.0; 
	aTemplate[7] = 5.0; 
	aTemplate[8] = 5.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置Kirsch模板6参数 
	aTemplate[0] = -3.0; 
	aTemplate[1] = -3.0; 
	aTemplate[2] = -3.0; 
	aTemplate[3] = 5.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -3.0; 
	aTemplate[6] = 5.0; 
	aTemplate[7] = 5.0; 
	aTemplate[8] = -3.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置Kirsch模板7参数 
	aTemplate[0] = 5.0; 
	aTemplate[1] = -3.0; 
	aTemplate[2] = -3.0; 
	aTemplate[3] = 5.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -3.0; 
	aTemplate[6] = 5.0; 
	aTemplate[7] = -3.0; 
	aTemplate[8] = -3.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置Kirsch模板8参数 
	aTemplate[0] = 5.0; 
	aTemplate[1] = 5.0; 
	aTemplate[2] = -3.0; 
	aTemplate[3] = 5.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -3.0; 
	aTemplate[6] = -3.0; 
	aTemplate[7] = -3.0; 
	aTemplate[8] = -3.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 复制经过模板运算后的图像到源图像 
	memcpy(m_lpBits, lpNewBits1, m_lWidth * m_lHeight); 
 
	// 释放内存 
	LocalUnlock(hNewBits1); 
	LocalFree(hNewBits1); 
 
	LocalUnlock(hNewBits2); 
	LocalFree(hNewBits2); 
 
	// 返回 
	return TRUE; 
} 
 
BOOL CImgPro::Gauss() 
{ 
 
	// 指向源图像的指针 
	LPSTR lpSrc; 
 
	// 指向缓存图像的指针 
	LPSTR	lpDst; 
	 
	// 指向缓存位图图像的指针 
	LPSTR	lpNewBits; 
	HLOCAL  hNewBits; 
 
	// 模板高度 
	int		iTempH; 
	 
	// 模板宽度 
	int		iTempW; 
	 
	// 模板系数 
	FLOAT	fTempC; 
	 
	// 模板中心元素X坐标 
	int		iTempMX; 
	 
	// 模板中心元素Y坐标 
	int		iTempMY; 
	 
	//模板数组 
	FLOAT aTemplate[25]; 
 
	//像素值 
	double result=0.0; 
 
	//循环变量 
	LONG i; 
	LONG j; 
	LONG k; 
 
	//过零点检测求最终边缘点时原始图像 
	//的0和1区域灰度值之和与象素数量 
	int iGray0=0; 
	int iGray1=0; 
	int iGray0Num=0; 
	int iGray1Num=0; 
 
	//0区域与1区域灰度均值 
	float iGray0Av=0.0; 
	float iGray1Av=0.0; 
 
	//象素指针 
	char *lpPixel[18]; 
 
	// 暂时分配内存，以保存新图像 
	hNewBits = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits = (char * )LocalLock(hNewBits); 
 
	// 拷贝源图像到缓存图像中 
	lpDst = (char *)lpNewBits; 
	memcpy(lpNewBits, m_lpBits, m_lWidth * m_lHeight); 
 
	// 设置Gauss模板参数 
	iTempW = 5; 
	iTempH = 5; 
	fTempC = 1.0; 
	iTempMX = 2; 
	iTempMY = 2; 
	aTemplate[0] = -2.0; 
	aTemplate[1] = -4.0; 
	aTemplate[2] = -4.0; 
	aTemplate[3] = -4.0; 
	aTemplate[4] = -2.0; 
	aTemplate[5] = -4.0; 
	aTemplate[6] = 0.0; 
	aTemplate[7] = 8.0; 
	aTemplate[8] = 0.0; 
	aTemplate[9] = -4.0; 
	aTemplate[10] = -4.0; 
	aTemplate[11] = 8.0; 
	aTemplate[12] = 24.0; 
	aTemplate[13] = 8.0; 
	aTemplate[14] = -4.0; 
	aTemplate[15] = -4.0; 
	aTemplate[16] = 0.0; 
	aTemplate[17] = 8.0; 
	aTemplate[18] = 0.0; 
	aTemplate[19] = -4.0; 
	aTemplate[20] = -2.0; 
	aTemplate[21] = -4.0; 
	aTemplate[22] = -4.0; 
	aTemplate[23] = -4.0; 
	aTemplate[24] = -2.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits, iTempH, iTempW, iTempMX, iTempMY, 
		aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	/*//过零点检测 
	//除去面积小于t的区域 
	for(i=1;i=(p-fWin)) && (iGrayXY<=p)) 
		{ 
			return 2*(float)pow((iGrayXY-p+fWin)/(2*fWin),2); 
		} 
		else 
			if((iGrayXY>p) && (iGrayXY<=(p+fWin))) 
			{ 
				return 1-2*(float)pow((iGrayXY-p-fWin)/(2*fWin),2); 
			} 
			else  
			{ 
				return 1.0; 
			} 
} 
 
unsigned char CImgPro::FuzzyThreshold(unsigned char iWin) 
{ 
	//模糊阈值分割算法 
	//iWin为隶属函数窗口宽度 
 
	float fFuzzy;              //模糊率 
	float fMinFuzzy;           //最小模糊率 
	float s;                   //隶属函数返回值 
	unsigned char iThreshold;  //模糊阈值 
		 
	LPSTR	lpSrc;             // 指向源图像的指针 
 
	//循环变量 
	long i; 
	long j; 
	 
	//灰度循环变量 
	int l; 
 
	//窗口中心循环变量 
	unsigned char q; 
 
	//像素值 
	unsigned char pixel; 
 
	//直方图数组 
	long lHistogram[256]; 
 
	for (i = 0; i < 256;i++) 
	{ 
		lHistogram[i]=0; 
	} 
 
	for (i = 0;i 0.5) 
				s=1-s; 
			//求模糊率 
			fFuzzy+=s*lHistogram[l]; 
		} 
 
		fFuzzy=2*fFuzzy/(m_lWidth*m_lHeight); 
 
		if(fFuzzy=0; j--) 
		{ 
			// 指向缓存图像1第i行，第j个象素的指针			 
			lpDst1 = (char *)lpNewBits1 + m_lWidth * i + j; 
 
			// 指向目标图像（缓存图像2）第i行，第j个象素的指针			 
			lpDst2 = (char *)lpNewBits2 + m_lWidth * i + j; 
 
			//计算目标图像中的当前点 
			pixel[0]=(unsigned char)*lpDst1; 
			pixel[1]=(unsigned char)*((char *)lpNewBits2 + m_lWidth * i + j+1); 
			result=pixel[1]+a*(pixel[0]-pixel[1]); 
			*lpDst2 = (unsigned char)result; 
		} 
	} 
 
	// 缓存图像1清0 
	lpDst1=(char*)lpNewBits1; 
	memset(lpDst1,(BYTE)0,m_lWidth*m_lHeight); 
 
	//正向列递归滤波 
	for(i = 1; i =0; i--) 
	{ 
		for(j = 0;j >=m_lWidth; j++) 
		{ 
			// 指向缓存图像1第i行，第j个象素的指针			 
			lpDst1 = (char *)lpNewBits1 + m_lWidth * i + j; 
 
			// 指向目标图像第i行，第j个象素的指针			 
			lpDst2 = (char *)lpNewBits2 + m_lWidth * i + j; 
 
			//计算目标图像中的当前点 
			pixel[0]=(unsigned char)*lpDst1; 
			pixel[1]=(unsigned char)*((char *)lpNewBits2 + m_lWidth * (i+1) + j); 
			result=pixel[1]+a*(pixel[0]-pixel[1]); 
			*lpDst2 = (unsigned char)result; 
		} 
	} 
 
	//求滤波后的图像与原图像的差 
	for(i = 0; i 0) 
				*lpDst2 =(unsigned char)255; 
			else 
				*lpDst2=(unsigned char)0; 
		} 
	} 
 
	/*//过零点检测 
	//除去面积小于t的区域 
	for(i=1;i *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
	// 设置综合正交模板波纹1参数 
	aTemplate[0] = 0.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = 2.0; 
	aTemplate[3] = 1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = -2.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = 0.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置综合正交模板波纹2参数 
	aTemplate[0] = 2.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = 0.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 1.0; 
	aTemplate[6] = 0.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = -2.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY,  
		aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置综合正交模板直线模板1的参数 
	aTemplate[0] = 0.0; 
	aTemplate[1] = 1.0; 
	aTemplate[2] = 0.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = 0.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = 0.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置综合正交模板直线模板2参数 
	aTemplate[0] = -1.0; 
	aTemplate[1] = 0.0; 
	aTemplate[2] = 1.0; 
	aTemplate[3] = 0.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 0.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 0.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置综合正交模板Laplacian模板1的参数 
	aTemplate[0] = 1.0; 
	aTemplate[1] = -2.0; 
	aTemplate[2] = 1.0; 
	aTemplate[3] = -2.0; 
	aTemplate[4] = 4.0; 
	aTemplate[5] = -2.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = -2.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置综合正交模板Laplacian模板2参数 
	aTemplate[0] = -2.0; 
	aTemplate[1] = 1.0; 
	aTemplate[2] = -2.0; 
	aTemplate[3] = 1.0; 
	aTemplate[4] = 4.0; 
	aTemplate[5] = 1.0; 
	aTemplate[6] = -2.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = -2.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置综合正交模板平均模板的参数 
	fTempC = 9.0; 
	aTemplate[0] = 1.0; 
	aTemplate[1] = 1.0; 
	aTemplate[2] = 1.0; 
	aTemplate[3] = 1.0; 
	aTemplate[4] = 1.0; 
	aTemplate[5] = 1.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 复制经过模板运算后的图像到源图像 
	memcpy(m_lpBits, lpNewBits1, m_lWidth * m_lHeight); 
 
	// 释放内存 
	LocalUnlock(hNewBits1); 
	LocalFree(hNewBits1); 
 
	LocalUnlock(hNewBits2); 
	LocalFree(hNewBits2); 
 
	// 返回 
	return TRUE; 
} 
 
BOOL CImgPro::EdgeMod() 
{ 
	//边缘模板匹配 
 
	// 指向缓存图像的指针 
	LPSTR	lpDst1; 
	LPSTR	lpDst2; 
	 
	// 指向缓存位图图像的指针 
	LPSTR	lpNewBits1; 
	HLOCAL	hNewBits1; 
	LPSTR	lpNewBits2; 
	HLOCAL	hNewBits2; 
 
	//循环变量 
	long i; 
	long j; 
 
	// 模板高度 
	int		iTempH; 
	 
	// 模板宽度 
	int		iTempW; 
	 
	// 模板系数 
	FLOAT	fTempC; 
	 
	// 模板中心元素X坐标 
	int		iTempMX; 
	 
	// 模板中心元素Y坐标 
	int		iTempMY; 
	 
	//模板数组 
	FLOAT aTemplate[9]; 
 
	// 暂时分配内存，以保存新图像 
	hNewBits1 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits1 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits1 = (char * )LocalLock(hNewBits1); 
 
	// 暂时分配内存，以保存新图像 
	hNewBits2 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits2 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits2 = (char * )LocalLock(hNewBits2); 
 
	// 拷贝源图像到缓存图像中 
	lpDst1 = (char *)lpNewBits1; 
	memcpy(lpNewBits1, m_lpBits, m_lWidth * m_lHeight); 
	lpDst2 = (char *)lpNewBits2; 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
 
	// 设置边缘模板1参数 
	iTempW = 3; 
	iTempH = 3; 
	fTempC = 1.0; 
	iTempMX = 1; 
	iTempMY = 1; 
	aTemplate[0] = 1.0; 
	aTemplate[1] = 1.0; 
	aTemplate[2] = 1.0; 
	aTemplate[3] = 0.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 0.0; 
	aTemplate[6] = -1.0; 
	aTemplate[7] = -1.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits1, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 设置边缘模板2参数 
	aTemplate[0] = 1.0; 
	aTemplate[1] = 1.0; 
	aTemplate[2] = 0.0; 
	aTemplate[3] = 1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = 0.0; 
	aTemplate[7] = -1.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
	// 设置边缘模板3参数 
	aTemplate[0] = 1.0; 
	aTemplate[1] = 0.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = 1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 0.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置边缘模板4参数 
	aTemplate[0] = 0.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = 1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = 0.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY,  
		aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	/*// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置边缘模板5参数 
	aTemplate[0] = -1.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = 0.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 0.0; 
	aTemplate[6] = 1.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置边缘模板6参数 
	aTemplate[0] = -1.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = 0.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 1.0; 
	aTemplate[6] = 0.0; 
	aTemplate[7] = 1.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置边缘模板7参数 
	aTemplate[0] = -1.0; 
	aTemplate[1] = 0.0; 
	aTemplate[2] = 1.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 1.0; 
	aTemplate[6] = -1.0; 
	aTemplate[7] = 0.0; 
	aTemplate[8] = 1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置边缘模板8参数 
	aTemplate[0] = 0.0; 
	aTemplate[1] = 1.0; 
	aTemplate[2] = 1.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 0.0; 
	aTemplate[5] = 1.0; 
	aTemplate[6] = -1.0; 
	aTemplate[7] = -1.0; 
	aTemplate[8] = 0.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	}*/ 
 
	// 复制经过模板运算后的图像到源图像 
	memcpy(m_lpBits, lpNewBits1, m_lWidth * m_lHeight); 
 
	// 释放内存 
	LocalUnlock(hNewBits1); 
	LocalFree(hNewBits1); 
 
	LocalUnlock(hNewBits2); 
	LocalFree(hNewBits2); 
 
	// 返回 
	return TRUE; 
} 
 
BOOL CImgPro::LineMod() 
{ 
	//线模板匹配 
 
	// 指向缓存图像的指针 
	LPSTR	lpDst1; 
	LPSTR	lpDst2; 
	 
	// 指向缓存位图图像的指针 
	LPSTR	lpNewBits1; 
	HLOCAL	hNewBits1; 
	LPSTR	lpNewBits2; 
	HLOCAL	hNewBits2; 
 
	//循环变量 
	long i; 
	long j; 
 
	// 模板高度 
	int		iTempH; 
	 
	// 模板宽度 
	int		iTempW; 
	 
	// 模板系数 
	FLOAT	fTempC; 
	 
	// 模板中心元素X坐标 
	int		iTempMX; 
	 
	// 模板中心元素Y坐标 
	int		iTempMY; 
	 
	//模板数组 
	FLOAT aTemplate[9]; 
 
	// 暂时分配内存，以保存新图像 
	hNewBits1 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits1 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits1 = (char * )LocalLock(hNewBits1); 
 
	// 暂时分配内存，以保存新图像 
	hNewBits2 = LocalAlloc(LHND, m_lWidth * m_lHeight); 
 
	if (hNewBits2 == NULL) 
	{ 
		// 分配内存失败 
		return FALSE; 
	} 
	 
	// 锁定内存 
	lpNewBits2 = (char * )LocalLock(hNewBits2); 
 
	// 拷贝源图像到缓存图像中 
	lpDst1 = (char *)lpNewBits1; 
	memcpy(lpNewBits1, m_lpBits, m_lWidth * m_lHeight); 
	lpDst2 = (char *)lpNewBits2; 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
 
	// 设置点模板1参数 
	iTempW = 3; 
	iTempH = 3; 
	fTempC = 1.0; 
	iTempMX = 1; 
	iTempMY = 1; 
	aTemplate[0] = -1.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = 2.0; 
	aTemplate[4] = 2.0; 
	aTemplate[5] = 2.0; 
	aTemplate[6] = -1.0; 
	aTemplate[7] = -1.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits1, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	// 设置点模板2参数 
	aTemplate[0] = -1.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = 2.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 2.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = 2.0; 
	aTemplate[7] = -1.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
 
	// 设置点模板3参数 
	aTemplate[0] = -1.0; 
	aTemplate[1] = 2.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 2.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = -1.0; 
	aTemplate[7] = 2.0; 
	aTemplate[8] = -1.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX,  
		iTempMY, aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 拷贝源图像到缓存图像中 
	memcpy(lpNewBits2, m_lpBits, m_lWidth * m_lHeight); 
	 
	// 设置边缘模板4参数 
	aTemplate[0] = 2.0; 
	aTemplate[1] = -1.0; 
	aTemplate[2] = -1.0; 
	aTemplate[3] = -1.0; 
	aTemplate[4] = 2.0; 
	aTemplate[5] = -1.0; 
	aTemplate[6] = -1.0; 
	aTemplate[7] = -1.0; 
	aTemplate[8] = 2.0; 
 
	// 调用Template()函数 
	if (!Template(lpNewBits2, iTempH, iTempW, iTempMX, iTempMY,  
		aTemplate, fTempC)) 
	{ 
		return FALSE; 
	} 
 
	//求两幅缓存图像的最大值 
	for(j = 0; j  *lpDst1) 
				*lpDst1 = *lpDst2; 
		 
		} 
	} 
 
	// 复制经过模板运算后的图像到源图像 
	memcpy(m_lpBits, lpNewBits1, m_lWidth * m_lHeight); 
 
	// 释放内存 
	LocalUnlock(hNewBits1); 
	LocalFree(hNewBits1); 
 
	LocalUnlock(hNewBits2); 
	LocalFree(hNewBits2); 
 
	// 返回 
	return TRUE; 
} 
 
unsigned char CImgPro::OstuThreshold() 
{ 
	//最大类间方差法求最佳阈值 
 
	// 指向源图像的指针 
	LPSTR lpSrc; 
 
	//循环变量 
	long i; 
	long j; 
	long l; 
 
	//最佳阈值 
	unsigned char iThreshold; 
 
	//象素值 
	unsigned char pixel; 
 
	//两个类的出现概率 
	double fProb1; 
	double fProb2; 
 
	//两个类的灰度均值均值 
	double fAvg1; 
	double fAvg2; 
 
	//整副图像的灰度均值 
	double fAvg; 
 
	//类间方差 
	double fSqr; 
	//最大类间方差 
	double fMaxSqr; 
 
	//第一类灰度累计值 
	double iGray1; 
	//直方图数组 
	long   lHistogram[256]; 
	//归一化灰度直方图 
	double fHistogram[256]; 
 
	//赋初值 
	fMaxSqr=0.0; 
	iThreshold=0; 
	fProb1=0.0; 
	fProb2=0.0; 
	fAvg=0.0; 
	fAvg1=0.0; 
	fAvg2=0.0; 
	iGray1=0.0; 
 
	for (i = 0; i < 256;i++) 
	{ 
		lHistogram[i]=0; 
		fHistogram[i]=0.0; 
	} 
 
 
	//获取灰度直方图 
	for (i = 0;i < m_lHeight;i++) 
	{ 
		for(j = 0;j fMaxSqr) 
		{ 
			fMaxSqr=fSqr; 
			iThreshold=(unsigned char)l; 
		} 
		 
		//变量清零 
		fProb1=0.0; 
		fProb2=0.0; 
		fAvg1=0.0; 
		fAvg2=0.0; 
		iGray1=0; 
	} 
 
	//返回阈值 
	return iThreshold; 
} 
 
BOOL CImgPro::PalKing(float fd,unsigned char FuzzyNum) 
{ 
	//Pal.King模糊边缘检测算法 
 
	// 指向源图像的指针 
	LPSTR lpSrc; 
	 
	// 指向缓存图像的指针 
	LPSTR lpDst; 
	 
	// 指向缓存位图图像的指针 
	LPSTR lpNewBits; 
	HLOCAL hNewBits; 
 
	//模糊矩阵元素指针 
	double *pFuzzySet; 
 
	//模糊矩阵头指针及缓存句柄 
	double *lpFuzzy; 
	HLOCAL hFuzzy; 
 
	//循环变量 
	long i; 
	long j; 
	int k; 
 
	//象素值 
	double result; 
	unsigned char pixel; 
	unsigned char pixels[9]; 
 
	//最大最小灰度级 
	unsigned char MaxGray=0; 
	//模糊矩阵元素最小值 
	double minfuzzy; 
 
	// 暂时分配内存，以保存新图像 
	hNewBits=LocalAlloc(LHND,m_lWidth*m_lHeight); 
	 
	if(hNewBits==NULL) 
	{ 
		//分配内存失败 
		return FALSE; 
	} 
	// 锁定内存 
	lpNewBits=(char*)LocalLock(hNewBits); 
 
	// 拷贝源图像到缓存图像中 
	lpDst = (char *)lpNewBits; 
	memcpy(lpNewBits, m_lpBits, m_lWidth * m_lHeight); 
 
	// 暂时分配内存，以保存模糊矩阵 
	hFuzzy=LocalAlloc(LHND,m_lWidth*m_lHeight*sizeof(double)); 
	 
	if(hFuzzy==NULL) 
	{ 
		//分配内存失败 
		return FALSE; 
	} 
	// 锁定内存 
	lpFuzzy=(double *)LocalLock(hFuzzy); 
 
	//求最大灰度级 
	for(i = 0; i MaxGray) 
				MaxGray=pixel; 
		} 
	} 
 
	//进行G变换 
	for(i = 0; i 0) 
	{ 
		for(i = 0; i MaxGray) 
				MaxGray=pixel; 
		} 
	} 
 
	//求阈值 
	iThreshold=OstuThreshold(); 
 
	//求模糊增强表 
	for(i=0;i<256;i++) 
	{ 
		if(i<=iThreshold) 
			if(iThreshold!=0) 
				table[i]=(unsigned char)(i*i/iThreshold); 
			else 
				table[i]=(unsigned char)0; 
		else 
		{ 
			if(i!=MaxGray) 
				table[i]=(unsigned char)(MaxGray-(MaxGray-i)*(MaxGray-i)/(MaxGray-iThreshold)+0.5); 
			else 
				table[i]=(unsigned char)i; 
		} 
	} 
 
	//图象增强 
	while(FuzzyNum>0) 
	{ 
		for(i = 0; i  *lpDst1) 
				*lpDst1 = *lpDst2; 
		} 
	} 
		 
	while((n--)>0) 
	{ 
		// 复制经过第一次边缘提取的图象到缓存图象2和3 
		memcpy(lpNewBmpBits2, lpNewBmpBits1, m_lWidth * m_lHeight); 
		memcpy(lpNewBmpBits3, lpNewBmpBits1, m_lWidth * m_lHeight); 
		 
		// 设置Sobel模板参数 
		aTemplate[0] = -1.0; 
		aTemplate[1] = -2.0; 
		aTemplate[2] = -1.0; 
		aTemplate[3] = 0.0; 
		aTemplate[4] = 0.0; 
		aTemplate[5] = 0.0; 
		aTemplate[6] = 1.0; 
		aTemplate[7] = 2.0; 
		aTemplate[8] = 1.0; 
		 
		// 调用Template()函数 
		if (!Template(lpNewBmpBits2,iTempH,iTempW,iTempMX,iTempMY, 
			aTemplate,fTempC)) 
		{ 
			return FALSE; 
		} 
		 
		// 设置Sobel模板参数 
		aTemplate[0] = -1.0; 
		aTemplate[1] = 0.0; 
		aTemplate[2] = 1.0; 
		aTemplate[3] = -2.0; 
		aTemplate[4] = 0.0; 
		aTemplate[5] = 2.0; 
		aTemplate[6] = -1.0; 
		aTemplate[7] = 0.0; 
		aTemplate[8] = 1.0; 
		 
		// 调用Template()函数 
		if (!Template(lpNewBmpBits3,iTempH,iTempW, 
			iTempMX,iTempMY,aTemplate,fTempC)) 
		{ 
			return FALSE; 
		} 
		 
		//求两幅缓存图像的最大值 
		for(j = 0; j  *lpDst2) 
					*lpDst2 = *lpDst3; 
			} 
		} 
		 
		//求两次边缘检测结果的差 
		for(j = 0; j 0) 
	{ 
		// 复制经过第一次边缘提取的图象到缓存图象2和3 
		memcpy(lpNewBmpBits2, lpNewBmpBits1, m_lWidth * m_lHeight); 
		memcpy(lpNewBmpBits3, lpNewBmpBits1, m_lWidth * m_lHeight); 
		 
		// 设置Sobel模板参数 
		aTemplate[0] = -1.0; 
		aTemplate[1] = -2.0; 
		aTemplate[2] = -1.0; 
		aTemplate[3] = 0.0; 
		aTemplate[4] = 0.0; 
		aTemplate[5] = 0.0; 
		aTemplate[6] = 1.0; 
		aTemplate[7] = 2.0; 
		aTemplate[8] = 1.0; 
		 
		// 调用Template()函数 
		if (!Template(lpNewBmpBits2,iTempH,iTempW,iTempMX,iTempMY, 
			aTemplate,fTempC)) 
		{ 
			return FALSE; 
		} 
		 
		// 设置Sobel模板参数 
		aTemplate[0] = -1.0; 
		aTemplate[1] = 0.0; 
		aTemplate[2] = 1.0; 
		aTemplate[3] = -2.0; 
		aTemplate[4] = 0.0; 
		aTemplate[5] = 2.0; 
		aTemplate[6] = -1.0; 
		aTemplate[7] = 0.0; 
		aTemplate[8] = 1.0; 
		 
		// 调用Template()函数 
		if (!Template(lpNewBmpBits3,iTempH,iTempW, 
			iTempMX,iTempMY,aTemplate,fTempC)) 
		{ 
			return FALSE; 
		} 
		 
		//求两幅缓存图像的最大值 
		for(j = 0; j  *lpDst2) 
					*lpDst2 = *lpDst3; 
			} 
		} 
		 
		//求两次边缘检测结果的差 
		for(j = 0; j fMaxEntropy) 
		{ 
			//找使熵最小的iGray 
			fMaxEntropy=fOBEntropy; 
			iThreshold=(unsigned char)i; 
		} 
		 
		fLowProb=0.0; 
		fLowEntropy=0.0; 
	} 
 
	//返回阈值 
	return iThreshold; 
} 
 
unsigned char CImgPro::NormalThreshold() 
{ 
	// 指向源图像的指针 
	LPSTR	lpSrc; 
 
	//像素值 
	unsigned char pixel; 
 
	//循环变量 
	long i; 
	long j; 
	long k; 
	long m; 
 
	double minf; 
	double q[256],f[256]; 
 
	//阈值 
	unsigned char T; 
 
	//直方图数组 
	long h[256]; 
 
	for (i = 0; i < 256;i++) 
	{ 
		h[i]=0; 
		f[i]=0.0; 
		q[i]=0.0; 
	} 
 
	//求灰度直方图 
	for (i = 0;i f[j]) 
			{ 
				minf=f[j]; 
				T=(unsigned char)j; 
			} 
		} 
	return T; 
} 
 
unsigned char CImgPro::EqualityThreshold() 
{ 
	// 指向源图像的指针 
	LPSTR	lpSrc; 
 
	//像素值 
	unsigned char pixel; 
 
	int i,j,k; 
	unsigned char T2; 
	long h[256]; 
	double f[256]; 
    double minf; 
    T2=0; 
	minf=0.0; 
 
	for (i = 0; i < 256;i++) 
	{ 
		h[i]=0; 
		f[i]=0.0; 
	} 
 
	//求灰度直方图 
	for (i = 0;i f[j]) 
		{ 
			minf=f[i]; 
			f[i]=f[j]; 
			f[j]=minf; 
			T2=(unsigned char)j; 
		} 
	} 
		return T2; 
} 
 
unsigned char CImgPro::ImprovedThreshold() 
{ 
	// 指向源图像的指针 
	LPSTR	lpSrc; 
 
	//像素值 
	unsigned char pixel; 
 
	//直方图数组 
    float lHistogram[256]; 
 
	long i,j,k; 
	unsigned char maxt; 
	double maxf,HT; 
	double p[256],f[256]; 
 
	for (i = 0; i < 256;i++) 
	{ 
		lHistogram[i]=0.0; 
		f[i]=0.0; 
	} 
 
     
 
	//求灰度直方图 
	for (i = 0;i