function.h

额外耳闻目睹 挖饿亽亽的额外负担为额外饿本挖 额发挖额额外负担

#if !defined(AFX_FUNCTION_H__6E194843_FEB3_491F_8062_765AA3465CBC__INCLUDED_)
#define AFX_FUNCTION_H__6E194843_FEB3_491F_8062_765AA3465CBC__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include "DibProcessDoc.h"
#include <math.h>
// 常数π
#define pi 3.1415926535
#define WIDTHBYTES(bits)    (((bits) + 31) / 32 * 4)
#include <direct.h>
#include <complex>
using namespace std;
#define PI 3.14159265358979323846


/*************************************************************************
* \函数名称：
 *   GrayHistEnhance()
* \输入参数:
 *	 LPSTR lpDIBBits		//指向源图像的像素指针
 *	 LONG lmageWidth		//源图像的宽度
 *	 LONG lmageHeight		//源图像的高度
 * \返回值:
 *   BOOL		       	//成功则返回TRUE，否则返回FALSE
 * \说明:
 *   该函数对指定的图像进行直方图均衡化处理
*************************************************************************/
BOOL GrayHistEnhance(LPSTR lpDIBBits, LONG lmageWidth, LONG lmageHeight)
{
	unsigned char*	lpSrc;									//指向源图像的指针
	int	nTemp;											//临时变量
	int j;													//循环变量
	int i;													//循环变量
	BYTE	byMap[256];									//累积直方图，即灰度映射表
	int	nCount[256];										//直方图
	for (i = 0; i < 256; i ++)									//重置计数为0
	{
		nCount[i] = 0;										//清零
	}
	for(i = 0; i < lmageHeight; i++)								//每行
	{
		for(j = 0; j < lmageWidth; j++)							//每列
		{
			// 指向DIB第i行，第j个象素的指针
			lpSrc = (unsigned char*)lpDIBBits + lmageWidth * (lmageHeight - 1 - i) + j;
			nCount[*(lpSrc)]++;								//计数加1
		}
	}
	for (i = 0; i < 256; i++)										//计算累积直方图
	{
		nTemp = 0;										//初始为0
		for (j = 0; j <= i ; j++)
		{
			nTemp += nCount[j];
		}
		byMap[i] = (BYTE) (nTemp * 255 / lmageHeight / lmageWidth); 	//计算对应的新灰度值
		//说明：* 255实际上就是将新的灰度值也转换为0～255的范围。
	}
	for(i = 0; i < lmageHeight; i++)
	{
		for(j = 0; j < lmageWidth; j++)							//每列
		{
			//指向DIB第i行，第j个象素的指针
			lpSrc = (unsigned char*)lpDIBBits + lmageWidth * (lmageHeight - 1 - i) + j;
			*lpSrc = byMap[*lpSrc];							//计算新的灰度值
		}
	}
	return TRUE;											//返回
}	

/*************************************************************************
* 函数名称：
 *   MedianValue()
* 参数:
 *   unsigned char * FiltValue	- 指向要获取中值的数组指针
 *   int   iFilterLen				- 数组长度
* 返回值:
 *   unsigned char				- 返回指定数组的中值。
* 说明:
 *   该函数用冒泡法对一维数组进行排序，并返回数组元素的中值。
************************************************************************/

unsigned char  MedianValue(unsigned char * FiltValue, int mFilterLen)
{
	int		i;										// 循环变量
	int		j;										// 循环变量
	unsigned char Temp;									// 中间变量
	// 用冒泡法对数组进行排序
	for (j = 0; j < mFilterLen - 1; j ++)
	{
		for (i = 0; i < mFilterLen - j - 1; i ++)
		{
			if (FiltValue[i] > FiltValue[i + 1])					// 前面的值大于后面的
			{
				Temp = FiltValue[i];
				FiltValue[i] = FiltValue[i + 1];				// 二者的值互换
				FiltValue[i + 1] = Temp;
			}
		}
	}
	if ((mFilterLen & 1) > 0)								// 计算中值
	{
		//数组有奇数个元素，返回中间一个元素
		Temp = FiltValue[(mFilterLen + 1) / 2];
	}
	else
	{
		//数组有偶数个元素，返回中间两个元素平均值
		Temp = (FiltValue[mFilterLen / 2] + FiltValue[mFilterLen / 2 + 1]) / 2;
	}
	return Temp;										// 返回中值
}


/*************************************************************************
* 函数名称：
 *   MedianFilter()
* 参数:
 *   LPSTR lpDIBBits			- 指向源DIB图像指针
 *   LONG  lmageWidth		- 源图像宽度（象素数）
 *   LONG  lmageHeight		- 源图像高度（象素数）
 *   int   mFilterH				- 滤波器的高度
 *   int   mFilterW			- 滤波器的宽度
 *   int   mFilterMX			- 滤波器的中心元素X坐标
 *   int   mFilterMY			- 滤波器的中心元素Y坐标
* 返回值:
 *   BOOL					- 成功返回TRUE，否则返回FALSE。
 * 说明:
 *   该函数对DIB图像进行中值滤波。
************************************************************************/

BOOL  MedianFilter(LPSTR lpDIBBits, LONG lmageWidth, LONG lmageHeight, 
						 int mFilterH, int mFilterW, int mFilterMX, int mFilterMY)
{
	unsigned char*	lpSrc;								// 指向源图像的指针
	unsigned char*	lpDst;								// 指向要复制区域的指针
	LPBYTE lpImage;									// 指向复制图像的指针
	unsigned char* FiltValue;								// 指向滤波器数组的指针
	int			i;									// 循环变量
	int			j;									// 循环变量
	int			k;									// 循环变量
	int			l;									// 循环变量
	lpImage = (LPBYTE) new char[lmageWidth *lmageHeight];		// 暂时分配内存，以保存新图像
	if (lpImage == NULL)									// 判断是否内存分配失败
	{
		return FALSE;									// 分配内存失败
	}	
	memcpy(lpImage, lpDIBBits, lmageWidth *lmageHeight);		// 初始化图像为原始图像
	FiltValue = new unsigned char[mFilterH *mFilterW];			// 暂时分配内存，以保存滤波器数组
	if (FiltValue == NULL)								// 判断是否内存分配失败
	{
		delete[]lpImage;									// 释放已分配内存
		return FALSE;									// 分配内存失败
	}
	// 开始中值滤波
	for(i = mFilterMY; i < lmageHeight - mFilterH + mFilterMY + 1; i++)
	{
		for(j = mFilterMX; j < lmageWidth - mFilterW + mFilterMX + 1; j++)
		{
			// 指向新DIB第i行，第j个象素的指针
			lpDst = (unsigned char*)lpImage + lmageWidth * (lmageHeight - 1 - i) + j;
			for (k = 0; k < mFilterH; k++)					// 读取滤波器数组
			{
				for (l = 0; l < mFilterW; l++)
				{
					// 指向DIB第i - iFilterMY + k行，第j - iFilterMX + l个象素的指针
					lpSrc = (unsigned char*)lpDIBBits + lmageWidth  * (lmageHeight - 1 - i + mFilterMY 
						  - k) + j - mFilterMX + l;
					FiltValue[k * mFilterW + l] = *lpSrc;		// 保存象素值
				}
			}
			*lpDst= MedianValue(FiltValue, (mFilterH * mFilterW)); // 获取中值
		}
	}
	memcpy(lpDIBBits, lpImage, lmageWidth*lmageHeight);			// 复制变换后的图像
	delete[]lpImage;										// 释放内存
	delete[]FiltValue;
	return TRUE;										// 返回
}

/*************************************************************************
* \函数名称：
*  Template()
* \输入参数:
*	 LPSTR lpDIBBits		- 指向源图像的像素指针
*	 LONG lmageWidth		- 源图像的宽度
*	 LONG lmageHeight		- 源图像的高度
*   int nTempWidth		- 模板的宽度
*   int nTempHeight		- 模板的高度
*   int nTempCenX		- 模板中心的X坐标（相对于模板）
*   int nTempCenY		- 模板中心的Y坐标（相对于模板）
*   double* Tempdata		- 模板数组的指针
*   double* TempCoef		- 模板的系数
* \返回值:
*   BOOL			- 成功则返回TRUE，否则返回FALSE
* \说明:
*   该函数用指定的模板对lpDIBBits指向的图象进行模板操作。模板的定义了宽度，高度，中心坐标
*和系数，模板的数据存放在Tempdata中。对图象进行模板操作后，仍然存放在lpDIBBits指向的对象
*中。需要注意的是，该函数只能处理8位的图象，否则，指向的数据将出错。
**************************************************************************/
BOOL  Template(LPSTR lpDIBBits, LONG lmageWidth, LONG lmageHeight,
			   int nTempWidth, int nTempHeight, 
			   int nTempCenX, int nTempCenY,
			   double* Tempdata, double TempCoef)
{
	LPBYTE			lpImage;								// 临时存放图像数据的指针
	int 		i;											// 循环变量
	int		j;											// 循环变量
	int 		k;											// 循环变量
	int 		l;											// 循环变量
	unsigned char*	lpSrc;									// 指向源图像的指针
	unsigned char*	lpDst;									// 指向要复制区域的指针
	double	dbResult;										// 计算结果
	lpImage = (LPBYTE) new  char[lmageWidth*lmageHeight];			// 分配内存
	if (lpImage == NULL)										// 判断是否内存分配失败
	{
		return FALSE;										// 分配内存失败
	}
	
	// 将原始图像的数据拷贝到临时存放内存中
	memcpy(lpImage, lpDIBBits, lmageWidth*lmageHeight);
	// 进行模板计算，行(除去边缘几行)
	for(i = nTempCenY ; i <lmageHeight - nTempHeight + nTempCenY + 1; i++)
	{
		// 列(除去边缘几列)
		for(j = nTempCenX; j < lmageWidth - nTempWidth + nTempCenX + 1; j++)
		{
			// 指向新DIB第i行，第j个象素的指针
			lpDst = (unsigned char*)lpImage + lmageWidth * (lmageHeight - 1 - i) + j;
			dbResult = 0;										// 置0
			for (k = 0; k < nTempHeight; k++)
			{
				for (l = 0; l < nTempWidth; l++)
				{
					// 指向DIB第i - iFilterMY + k行，第j - iFilterMX + l个象素的指针
					lpSrc = (unsigned char*)lpDIBBits + lmageWidth * (lmageHeight - 1 - i + nTempCenY - k) + j - nTempCenX + l;
					dbResult += (* lpSrc) * Tempdata[k * nTempWidth + l];	// 保存象素值
				}
			}
			dbResult *= TempCoef;								// 乘上系数
			dbResult = (double ) fabs(dbResult);						// 取绝对值
			if(dbResult > 255)									// 判断是否超过255
			{
				* lpDst = 255;									// 直接赋值为255
			}
			else
			{
				* lpDst = (unsigned char) (dbResult + 0.5);				// 赋值
			}
		}
	}
	memcpy(lpDIBBits, lpImage, lmageWidth*lmageHeight);				//复制变换后的图像
	delete[] lpImage;												// 释放内存
	return TRUE;												// 返回
}




#endif