dibimage.cpp

使用VC编写的图像傅立叶变换,余弦变换,沃尔什变换

	}
	
	return TRUE;
}

/*************************************************************************
 * 函数名称：
 *   InteEqualize()
 * 参数:
 *   LPSTR lpDIBBits    - 指向源DIB图像指针
 *   LONG  lWidth       - 源图像宽度（象素数）
 *   LONG  lHeight      - 源图像高度（象素数）
 * 返回值:
 *   BOOL               - 成功返回TRUE，否则返回FALSE。
 * 说明:
 *   该函数用来对图像进行直方图均衡。
 ************************************************************************/
BOOL CDibImage::InteEqualize(LPSTR lpDIBBits, LONG lWidth, LONG lHeight)
{	
	unsigned char*	lpSrc;				// 指向源图像的指针	
	LONG	lTemp;						// 临时变量	
	LONG	i;							// 循环变量
	LONG	j;	
	BYTE	bMap[256];					// 灰度映射表	
	LONG	lCount[256];				// 灰度映射表
	LONG	lLineBytes;					// 图像每行的字节数
		
	lLineBytes = WIDTHBYTES(lWidth * 8);// 计算图像每行的字节数
		
	for (i = 0; i < 256; i ++)			// 重置计数为0
	{
		lCount[i] = 0;
	}
	
	// 计算各个灰度值的计数
	for (i = 0; i < lHeight; i ++)
	{
		for (j = 0; j < lWidth; j ++)
		{
			lpSrc = (unsigned char *)lpDIBBits + lLineBytes * i + j;
			lCount[*(lpSrc)]++;
		}
	}
	
	// 计算灰度映射表
	for (i = 0; i < 256; i++)
	{
		lTemp = 0;		
		for (j = 0; j <= i ; j++)
		{
			lTemp += lCount[j];
		}
		
		// 计算对应的新灰度值
		bMap[i] = (BYTE) (lTemp * 255 / lHeight / lWidth);
	}
		
	for(i = 0; i < lHeight; i++)			// 每行
	{
		for(j = 0; j < lWidth; j++)			// 每列
		{
			// 指向DIB第i行，第j个象素的指针
			lpSrc = (unsigned char*)lpDIBBits + lLineBytes * (lHeight - 1 - i) + j;			
			// 计算新的灰度值
			*lpSrc = bMap[*lpSrc];
		}
	}
	
	return TRUE;
}

//////////////////////////////////////////////////////////////////////
// 图像几何变换函数
//////////////////////////////////////////////////////////////////////

/*************************************************************************
 * 函数名称：
 *   TranslationDIB1()
 * 参数:
 *   LPSTR lpDIBBits    - 指向源DIB图像指针
 *   LONG  lWidth       - 源图像宽度（象素数）
 *   LONG  lHeight      - 源图像高度（象素数）
 *   LONG  lXOffset     - X轴平移量（象素数）
 *   LONG  lYOffset     - Y轴平移量（象素数）
 * 返回值:
 *   BOOL               - 平移成功返回TRUE，否则返回FALSE。
 * 说明:
 *   该函数用来水平移动DIB图像。函数不会改变图像的大小，移出的部分图像
 * 将截去，空白部分用白色填充。
 ************************************************************************/
BOOL CDibImage::TranslationDIB1(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, 
								LONG lXOffset, LONG lYOffset)
{	
	LPSTR	lpSrc;					// 指向源图像的指针	
	LPSTR	lpDst;					// 指向要复制区域的指针
	LPSTR	lpNewDIBBits;			// 指向复制图像的指针
	HLOCAL	hNewDIBBits;
	LONG	i;						// 象素在新DIB中的坐标
	LONG	j;	
	LONG	i0;						// 象素在源DIB中的坐标
	LONG	j0;	
	LONG lLineBytes;				// 图像每行的字节数
	
	lLineBytes = WIDTHBYTES(lWidth * 8);// 计算图像每行的字节数
	
	// 暂时分配内存，以保存新图像
	hNewDIBBits = LocalAlloc(LHND, lLineBytes * lHeight);
	if (hNewDIBBits == NULL)
	{
		return FALSE;
	}
		
	lpNewDIBBits = (char * )LocalLock(hNewDIBBits);	
		
	for(i = 0; i < lHeight; i++)					// 每行
	{		
		for(j = 0; j < lWidth; j++)					// 每列
		{
			// 指向新DIB第i行，第j个象素的指针
			// 注意由于DIB中图像第一行其实保存在最后一行的位置，因此lpDst
			// 值不是(char *)lpNewDIBBits + lLineBytes * i + j，而是
			// (char *)lpNewDIBBits + lLineBytes * (lHeight - 1 - i) + j
			lpDst = (char *)lpNewDIBBits + lLineBytes * (lHeight - 1 - i) + j;
			
			// 计算该象素在源DIB中的坐标
			i0 = i - lXOffset;
			j0 = j - lYOffset;
			
			// 判断是否在源图范围内
			if( (j0 >= 0) && (j0 < lWidth) && (i0 >= 0) && (i0 < lHeight))
			{
				// 指向源DIB第i0行，第j0个象素的指针
				// 同样要注意DIB上下倒置的问题
				lpSrc = (char *)lpDIBBits + lLineBytes * (lHeight - 1 - i0) + j0;							
				*lpDst = *lpSrc;					// 复制象素
			}
			else
			{
				// 对于源图中没有的象素，直接赋值为255
				* ((unsigned char*)lpDst) = 255;
			}
		}
	}
	
	// 复制平移后的图像
	memcpy(lpDIBBits, lpNewDIBBits, lLineBytes * lHeight);
	
	LocalUnlock(hNewDIBBits);
	LocalFree(hNewDIBBits);
	return TRUE;
}

/*************************************************************************
 * 函数名称：
 *   TranslationDIB()
 * 参数:
 *   LPSTR lpDIBBits    - 指向源DIB图像指针
 *   LONG  lWidth       - 源图像宽度（象素数）
 *   LONG  lHeight      - 源图像高度（象素数）
 *   LONG  lXOffset     - X轴平移量（象素数）
 *   LONG  lYOffset     - Y轴平移量（象素数）
 * 返回值:
 *   BOOL               - 平移成功返回TRUE，否则返回FALSE。
 * 说明:
 *   该函数用来水平移动DIB图像。函数不会改变图像的大小，移出的部分图像
 * 将截去，空白部分用白色填充。
 ************************************************************************/
BOOL CDibImage::TranslationDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, 
							   LONG lXOffset, LONG lYOffset)
{	
	CRect	rectSrc;	// 平移后剩余图像在源图像中的位置（矩形区域）	
	CRect	rectDst;	// 平移后剩余图像在新图像中的位置（矩形区域）	
	LPSTR	lpSrc;		// 指向源图像的指针	
	LPSTR	lpDst;		// 指向要复制区域的指针	
	LPSTR	lpNewDIBBits;	// 指向复制图像的指针
	HLOCAL	hNewDIBBits;
	BOOL	bVisible;	// 指明图像是否全部移去可视区间	
	LONG	i;			// 循环变量	
	LONG lLineBytes;	// 图像每行的字节数
		
	lLineBytes = WIDTHBYTES(lWidth * 8);	// 计算图像每行的字节数	
	bVisible = TRUE;	// 赋初值
	
	// 计算rectSrc和rectDst的X坐标
	if (lXOffset <= -lWidth)
	{		
		bVisible = FALSE;	// X轴方向全部移出可视区域
	}
	else if (lXOffset <= 0)
	{		
		rectDst.left = 0;	// 移动后，有图区域左上角X坐标为0
		
		// 移动后，有图区域右下角X坐标为lWidth - |lXOffset| = lWidth + lXOffset
		rectDst.right = lWidth + lXOffset;
	}
	else if (lXOffset < lWidth)
	{	
		rectDst.left = lXOffset;	// 移动后，有图区域左上角X坐标为lXOffset	
		rectDst.right = lWidth;		// 移动后，有图区域右下角X坐标为lWidth
	}
	else
	{		
		bVisible = FALSE;			// X轴方向全部移出可视区域
	}
	
	// 平移后剩余图像在源图像中的X坐标
	rectSrc.left = rectDst.left - lXOffset;
	rectSrc.right = rectDst.right - lXOffset;
	
	//  计算rectSrc和rectDst的Y坐标
	if (lYOffset <= -lHeight)
	{		
		bVisible = FALSE;			// Y轴方向全部移出可视区域
	}
	else if (lYOffset <= 0)
	{		
		rectDst.top = 0;			// 移动后，有图区域左上角Y坐标为0
		
		// 移动后，有图区域右下角Y坐标为lHeight - |lYOffset| = lHeight + lYOffset
		rectDst.bottom = lHeight + lYOffset;
	}
	else if (lYOffset < lHeight)
	{		
		rectDst.top = lYOffset;		// 移动后，有图区域左上角Y坐标为lYOffset		
		rectDst.bottom = lHeight;	// 移动后，有图区域右下角Y坐标为lHeight
	}
	else
	{		
		bVisible = FALSE;			// X轴方向全部移出可视区域
	}
	
	// 平移后剩余图像在源图像中的Y坐标
	rectSrc.top = rectDst.top - lYOffset;
	rectSrc.bottom = rectDst.bottom - lYOffset;
	
	// 暂时分配内存，以保存新图像
	hNewDIBBits = LocalAlloc(LHND, lLineBytes * lHeight);
	if (hNewDIBBits == NULL)
	{
		return FALSE;
	}
	
	lpNewDIBBits = (char * )LocalLock(hNewDIBBits);
	
	// 初始化新分配的内存，设定初始值为255
	lpDst = (char *)lpNewDIBBits;
	memset(lpDst, (BYTE)255, lLineBytes * lHeight);
		
	if (bVisible)		// 如果有部分图像可见
	{
		// 平移图像
		for(i = 0; i < (rectSrc.bottom - rectSrc.top); i++)
		{
			// 要复制区域的起点，注意由于DIB图像内容是上下倒置的，第一行内容是保存
			// 在最后一行，因此复制区域的起点不是lpDIBBits + lLineBytes * (i + 
			// rectSrc.top) + rectSrc.left，而是 lpDIBBits + lLineBytes * 
			// (lHeight - i - rectSrc.top - 1) + rectSrc.left。
			
			lpSrc = (char *)lpDIBBits + lLineBytes * (lHeight - i - rectSrc.top
				- 1) + rectSrc.left;
			
			// 要目标区域的起点，同样注意上下倒置的问题。
			lpDst = (char *)lpNewDIBBits + lLineBytes * (lHeight - i - rectDst.top
				- 1) + rectDst.left;
			
			// 拷贝每一行，宽度为rectSrc.right - rectSrc.left
			memcpy(lpDst, lpSrc, rectSrc.right - rectSrc.left);
			
		}
	}

	// 复制平移后的图像
	memcpy(lpDIBBits, lpNewDIBBits, lLineBytes * lHeight);
	
	LocalUnlock(hNewDIBBits);
	LocalFree(hNewDIBBits);
	return TRUE;
}

/*************************************************************************
 * 函数名称：
 *   MirrorDIB()
 * 参数:
 *   LPSTR lpDIBBits    - 指向源DIB图像指针
 *   LONG  lWidth       - 源图像宽度（象素数）
 *   LONG  lHeight      - 源图像高度（象素数）
 *   BOOL  bDirection   - 镜像的方向，TRUE表示水平镜像，FALSE表示垂直镜像
 * 返回值:
 *   BOOL               - 镜像成功返回TRUE，否则返回FALSE。
 * 说明:
 *   该函数用来镜像DIB图像。可以指定镜像的方式是水平还是垂直。
 ************************************************************************/
BOOL CDibImage::MirrorDIB(LPSTR lpDIBBits, LONG lWidth, LONG lHeight, 
						  BOOL bDirection)
{		
	LPSTR	lpSrc;						// 指向源图像的指针	
	LPSTR	lpDst;						// 指向要复制区域的指针	
	LPSTR	lpBits;						// 指向复制图像的指针
	HLOCAL	hBits;	
	LONG	i;							// 循环变量
	LONG	j;	
	LONG lLineBytes;					// 图像每行的字节数	
	
	lLineBytes = WIDTHBYTES(lWidth * 8);// 计算图像每行的字节数		
	hBits = LocalAlloc(LHND, lLineBytes);	// 暂时分配内存，以保存一行图像
	if (hBits == NULL)
	{
		return FALSE;
	}
	
	lpBits = (char * )LocalLock(hBits);
	
	// 判断镜像方式
	if (bDirection)		// 水平镜像
	{	
		// 针对图像每行进行操作
		for(i = 0; i < lHeight; i++)
		{
			// 针对每行图像左半部分进行操作
			for(j = 0; j < lWidth / 2; j++)
			{				
				// 指向倒数第i行，第j个象素的指针
				lpSrc = (char *)lpDIBBits + lLineBytes * i + j;				
				// 指向倒数第i行，倒数第j个象素的指针
				lpDst = (char *)lpDIBBits + lLineBytes * (i + 1) - j;
				
				// 备份一个象素
				*lpBits = *lpDst;
				
				// 将倒数第i行，第j个象素复制到倒数第i行，倒数第j个象素
				*lpDst = *lpSrc;				
				// 将倒数第i行，倒数第j个象素复制到倒数第i行，第j个象素
				*lpSrc = *lpBits;
			}			
		}
	}
	else				// 垂直镜像
	{
		// 针对上半图像进行操作
		for(i = 0; i < lHeight / 2; i++)
		{			
			// 指向倒数第i行象素起点的指针
			lpSrc = (char *)lpDIBBits + lLineBytes * i;			
			// 指向第i行象素起点的指针
			lpDst = (char *)lpDIBBits + lLineBytes * (lHeight - i - 1);
			
			// 备份一行，宽度为lWidth
			memcpy(lpBits, lpDst, lLineBytes);
			
			// 将倒数第i行象素复制到第i行
			memcpy(lpDst, lpSrc, lLineBytes);			
			// 将第i行象素复制到倒数第i行
			memcpy(lpSrc, lpBits, lLineBytes);			
		}
	}
	
	LocalUnlock(hBits);
	LocalFree(hBits);
	return TRUE;
}

/*************************************************************************
 * 函数名称：
 *   TransposeDIB()
 * 参数:
 *   LPSTR lpDIB		- 指向源DIB的指针
 * 返回值:
 *   BOOL               - 转置成功返回TRUE，否则返回FALSE。
 * 说明:
 *   该函数用来转置DIB图像，即图像x、y坐标互换。函数将不会改变图像的大小，
 * 但是图像的高宽将互换。
 ************************************************************************/
BOOL CDibImage::TransposeDIB(LPSTR lpDIB)
{	
	LONG	lWidth;				// 图像的宽度
	LONG	lHeight;			// 图像的高度	
	LPSTR	lpDIBBits;			// 指向源图像的指针	
	LPSTR	lpSrc;				// 指向源象素的指针	
	LPSTR	lpDst;				// 指向转置图像对应象素的指针	
	LPSTR	lpNewDIBBits;		// 指向转置图像的指针
	HLOCAL	hNewDIBBits;
	LPBITMAPINFOHEADER lpbmi;	// 指向BITMAPINFO结构的指针（Win3.0）
	LPBITMAPCOREHEADER lpbmc;	// 指向BITMAPCOREINFO结构的指针
	LONG	i;					
	LONG	j;	
	LONG lLineBytes;			// 图像每行的字节数
	LONG lNewLineBytes;			// 新图像每行的字节数

	lpbmi = (LPBITMAPINFOHEADER)lpDIB;
	lpbmc = (LPBITMAPCOREHEADER)lpDIB;

	
	lpDIBBits = FindDIBBits(lpDIB);		// 找到源DIB图像象素起始位置	
	lWidth = DIBWidth(lpDIB);			// 获取图像的"宽度"（4的倍数）
	lHeight = DIBHeight(lpDIB);			// 获取图像的高度
	lLineBytes = WIDTHBYTES(lWidth * 8);// 计算图像每行的字节数
	lNewLineBytes = WIDTHBYTES(lHeight * 8);	// 计算新图像每行的字节数
	
	// 暂时分配内存，以保存新图像
	hNewDIBBits = LocalAlloc(LHND, lWidth * lNewLineBytes);
	if (hNewDIBBits == NULL)