ip.cpp

本光盘包含了《精通Visual C++图像处理编程(第3版)》一书中全部的源代码、示例程序的可执行文件以及一些供图像处理测试用的图像文件。

	// new DIB attributes
	WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
	WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
	WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);
	DWORD dwImageSize = wBytesPerLine * wDIBHeight;

	// Allocate and lock memory for filtered image data
	HGLOBAL hFilteredBits = GlobalAlloc(GHND, dwImageSize);
	if (!hFilteredBits) 
	{
		WaitCursorEnd();
		return FALSE;
	}
	LPBYTE lpDestImage = (LPBYTE)GlobalLock(hFilteredBits);

	// get bits address in DIB
	LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
	LPBYTE lpDIBits = FindDIBBits(lpDIB);

	// process...
	for (int i=1; i<wDIBHeight-1; i++) 
	{
		for (int j=1; j<wDIBWidth-1; j++) 
		{
			LONG lOffset = PIXEL_OFFSET(i,j, wBytesPerLine);
			BYTE b1 = *(lpDIBits + lOffset++);
			BYTE g1 = *(lpDIBits + lOffset++);
			BYTE r1 = *(lpDIBits + lOffset);

			BYTE r2 = 0;
			BYTE g2 = 0;
			BYTE b2 = 0;
			if (i >= 1 && j >= 1)
			{
				lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
				b2 = *(lpDIBits + lOffset++);
				g2 = *(lpDIBits + lOffset++);
				r2 = *(lpDIBits + lOffset);
			}

			BYTE rr = r1 - r2 + nBackground;
			BYTE gg = g1 - g2 + nBackground;
			BYTE bb = b1 - b2 + nBackground;

			lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
			*(lpDestImage + lOffset++) = BOUND(bb, 0, 255);
			*(lpDestImage + lOffset++) = BOUND(gg, 0, 255);
			*(lpDestImage + lOffset)   = BOUND(rr, 0, 255);
		}
	}

	// a filtered image is available in lpDestImage
	// copy it to DIB bits
	memcpy(lpDIBits, lpDestImage, dwImageSize);

	// cleanup temp buffers
	GlobalUnlock(hFilteredBits);
	GlobalFree(hFilteredBits);
	GlobalUnlock(hNewDib);

	// rebuild hDib
	HDIB hTmp = NULL;
	if (wBitCount != 24)
		hTmp = ConvertDIBFormat(hNewDib, wBitCount, NULL);
	else
		hTmp = CopyHandle(hNewDib);
	GlobalFree(hNewDib);
	DWORD dwSize = GlobalSize(hTmp);
	memcpy((LPBYTE)GlobalLock(hDib), (LPBYTE)GlobalLock(hTmp), dwSize);
	GlobalUnlock(hTmp);
	GlobalFree(hTmp);
	GlobalUnlock(hDib);
	WaitCursorEnd();

	return TRUE;
}

/************************************************************************* 
 * SpreadDIB() 
 * 
 * Parameters: 
 *		HDIB hDib        - handle to global memory with a DIB spec 
 *							in it followed by the DIB bits 
 *      nBlockSize		 - block size to spread
 * Return Value: 
 *		BOOL				- TRUE is success, else FALSE
 * Description: 
 *		Spread DIB
 ************************************************************************/ 
BOOL SpreadDIB(HDIB hDib, int nBlockSize)
{
	WaitCursorBegin();

	HDIB hNewDib = NULL;
	// we only convolute 24bpp DIB, so first convert DIB to 24bpp
	WORD wBitCount = DIBBitCount(hDib);
	if (wBitCount != 24)
		hNewDib = ConvertDIBFormat(hDib, 24, NULL);
	else
		hNewDib = CopyHandle(hDib);

	if (! hNewDib)
	{
		WaitCursorEnd();
		return FALSE;
	}

	// new DIB attributes
	WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
	WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
	WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);
	DWORD dwImageSize = wBytesPerLine * wDIBHeight;

	// Allocate and lock memory for filtered image data
	HGLOBAL hFilteredBits = GlobalAlloc(GHND, dwImageSize);
	if (!hFilteredBits) 
	{
		WaitCursorEnd();
		return FALSE;
	}
	LPBYTE lpDestImage = (LPBYTE)GlobalLock(hFilteredBits);

	// get bits address in DIB
	LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
	LPBYTE lpDIBits = FindDIBBits(lpDIB);

	// process...
    for (UINT x=nBlockSize/2; x<wDIBHeight-nBlockSize/2; x++)
	{
	    for (UINT y=nBlockSize/2; y<wDIBWidth-nBlockSize/2; y++)	
		{
			int nRand1 = rand();
			int nDeltx = nRand1%nBlockSize-nBlockSize/2;
			int nRand2 = rand();
			int nDelty = nRand2%nBlockSize-nBlockSize/2;

			LONG lOffset = PIXEL_OFFSET(x+nDeltx, y+nDelty, wBytesPerLine);
			BYTE b = *(lpDIBits + lOffset++);
			BYTE g = *(lpDIBits + lOffset++);
			BYTE r = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(x,y, wBytesPerLine);
			*(lpDestImage + lOffset++) = b;
			*(lpDestImage + lOffset++) = g;
			*(lpDestImage + lOffset)   = r;
		}
	}

	// a filtered image is available in lpDestImage
	// copy it to DIB bits
	memcpy(lpDIBits, lpDestImage, dwImageSize);

	// cleanup temp buffers
	GlobalUnlock(hFilteredBits);
	GlobalFree(hFilteredBits);
	GlobalUnlock(hNewDib);

	// rebuild hDib
	HDIB hTmp = NULL;
	if (wBitCount != 24)
		hTmp = ConvertDIBFormat(hNewDib, wBitCount, NULL);
	else
		hTmp = CopyHandle(hNewDib);
	GlobalFree(hNewDib);
	DWORD dwSize = GlobalSize(hTmp);
	memcpy((LPBYTE)GlobalLock(hDib), (LPBYTE)GlobalLock(hTmp), dwSize);
	GlobalUnlock(hTmp);
	GlobalFree(hTmp);
	GlobalUnlock(hDib);
	WaitCursorEnd();

	return TRUE;
}

/************************************************************************* 
 * EdegeDetectDIB() 
 * 
 * Parameters: 
 *		HDIB hDIB        - handle to global memory with a DIB spec 
 *							in it followed by the DIB bits 
 *		KERNEL *lpKernel - kernel used to detect edge
 * Return Value: 
 *		BOOL			 - TRUE is success, else FALSE
 * Description: 
 *		Edege Detect DIB
 ************************************************************************/ 
BOOL EdegeDetectDIB(HDIB hDib, KERNEL *lpKernel) 
{
	WaitCursorBegin();

	// 1. filter noise
	if (! MedianFilterDIB(hDib))
	{
		WaitCursorEnd();
		return FALSE;
	}

	// 2. convert to gray scale
	ConvertToGrayscale(hDib, MEAN_GRAY, 0, 0, 0);
	HDIB hNewDib = CopyHandle(hDib);

	if (! hNewDib)
	{
		WaitCursorEnd();
		return FALSE;
	}

	// new DIB attributes
	WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
	WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
	WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);

	// original DIB become dest image
	LPBYTE lpDestDIB = (LPBYTE)GlobalLock(hDib);
	LPBYTE lpDestImage = FindDIBBits(lpDestDIB);

	// get bits address in DIB
	LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
	LPBYTE lpDIBits = FindDIBBits(lpDIB);

	// 3. detect...
	int i,j,y,x,ir;
	LONG lOffset;
	BYTE dst;
	double v, g, gx, gy, maxV = 0;
	for (i=1; i<wDIBHeight-1; i++)
	{
		for (j=1; j<wDIBWidth-1; j++) 
		{
			gx = gy = 0;

			BYTE b[9];
			lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
			b[0] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
			b[1] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
			b[2] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
			b[3] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
			b[4] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
			b[5] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
			b[6] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
			b[7] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
			b[8] = *(lpDIBits + lOffset);

			for (int k=0; k<=8; ++k)
			{
				gx += lpKernel[0].Element[k]*b[k];
				gy += lpKernel[1].Element[k]*b[k];
			}

			// get gradient value
			g = min(abs(gx) + abs(gy), 255.0);	// approximation
			if (g > maxV)
				maxV = g;
			lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
			*(lpDestImage + lOffset) = (BYTE) g;
		}
	}

	double ratio = 255.0/(double)maxV;

	for (i=1; i<wDIBHeight-1; i++)
	{
		for (j=1; j<wDIBWidth-1; j++) 
		{
			LONG lOffset= PIXEL_OFFSET(i, j, wBytesPerLine);
			double value = (double)*(lpDestImage + lOffset) * ratio;
			*(lpDestImage + lOffset) = value;
		}
	}

	// cleanup temp buffers
	GlobalUnlock(hNewDib);
	GlobalFree(hNewDib);
	GlobalUnlock(hDib);
	
	WaitCursorEnd();

	return TRUE;
}

/************************************************************************* 
 * EdegeDetectDIB() 
 * 
 * Parameters: 
 *		HDIB hDIB        - handle to global memory with a DIB spec 
 *							in it followed by the DIB bits 
 *		int nAlgorithm   - algorithm used to detect edge
 * Return Value: 
 *		BOOL			 - TRUE is success, else FALSE
 * Description: 
 *		Edege Detect DIB
 ************************************************************************/ 
BOOL EdgeDetectDIB(HDIB hDib, int nAlgorithm)
{
	switch (nAlgorithm)
	{
	case SOBEL:
		return EdegeDetectDIB(hDib, Sobel);
	case HOUGH:
		return EdegeDetectDIB(hDib, Hough);
	}

	return FALSE;
}

/************************************************************************* 
 * HomogenityEdegeDetectDIB() 
 * 
 * Parameters: 
 *		HDIB hDIB        - handle to global memory with a DIB spec 
 *							in it followed by the DIB bits 
 * Return Value: 
 *		BOOL			 - TRUE is success, else FALSE
 * Description: 
 *		Homogenity Edege Detect DIB
 ************************************************************************/ 
BOOL HomogenityEdegeDetectDIB(HDIB hDib) 
{
	WaitCursorBegin();

	// 1. filter noise
	if (! MedianFilterDIB(hDib))
	{
		WaitCursorEnd();
		return FALSE;
	}
	
	// 2. convert to gray scale
	ConvertToGrayscale(hDib, MEAN_GRAY, 0, 0, 0);
	HDIB hNewDib = CopyHandle(hDib);

	if (! hNewDib)
	{
		WaitCursorEnd();
		return FALSE;
	}

	// new DIB attributes
	WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
	WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
	WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);

	// original DIB become dest image
	LPBYTE lpDestDIB = (LPBYTE)GlobalLock(hDib);
	LPBYTE lpDestImage = FindDIBBits(lpDestDIB);

	// get bits address in DIB
	LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
	LPBYTE lpDIBits = FindDIBBits(lpDIB);

	// 3. detect...
	LONG lOffset;
	BYTE dst;
	int maxV = 0;
	for (int i=1; i<wDIBHeight-1; i++)
	{
		for (int j=1; j<wDIBWidth-1; j++) 
		{
			maxV = 0;

			BYTE b[9];
			lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
			b[0] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
			b[1] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
			b[2] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
			b[3] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
			b[4] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
			b[5] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
			b[6] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
			b[7] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
			b[8] = *(lpDIBits + lOffset);

			for (int k=0; k<=8; ++k)
			{
				if (k != 4)
				{
					int d = b[4] - b[k];
					if (d < 0)
						d = -d;
					if (d > maxV)
						maxV = d;
				}
			}

			lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
			*(lpDestImage + lOffset) = (BYTE)maxV;
		}
	}

	// cleanup temp buffers
	GlobalUnlock(hNewDib);
	GlobalFree(hNewDib);
	GlobalUnlock(hDib);
	
	WaitCursorEnd();

	return TRUE;
}

/************************************************************************* 
 * DifferenceEdegeDetectDIB() 
 * 
 * Parameters: 
 *		HDIB hDIB        - handle to global memory with a DIB spec 
 *							in it followed by the DIB bits 
 * Return Value: 
 *		BOOL			 - TRUE is success, else FALSE
 * Description: 
 *		Difference Edege Detect DIB
 ************************************************************************/ 
BOOL DifferenceEdegeDetectDIB(HDIB hDib) 
{
	WaitCursorBegin();

	// 1. filter noise
	if (! MedianFilterDIB(hDib))
	{
		WaitCursorEnd();
		return FALSE;
	}

	// 2. convert to gray scale
	ConvertToGrayscale(hDib, MEAN_GRAY, 0, 0, 0);
	HDIB hNewDib = CopyHandle(hDib);

	if (! hNewDib)
	{
		WaitCursorEnd();
		return FALSE;
	}

	// new DIB attributes
	WORD wDIBWidth = (WORD)DIBWidth(hNewDib);
	WORD wDIBHeight = (WORD)DIBHeight(hNewDib);
	WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib);

	// original DIB become dest image
	LPBYTE lpDestDIB = (LPBYTE)GlobalLock(hDib);
	LPBYTE lpDestImage = FindDIBBits(lpDestDIB);

	// get bits address in DIB
	LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib);
	LPBYTE lpDIBits = FindDIBBits(lpDIB);

	// 3. detect...
	LONG lOffset;
	BYTE dst;
	int maxV = 0;
	for (int i=1; i<wDIBHeight-1; i++)
	{
		for (int j=1; j<wDIBWidth-1; j++) 
		{
			maxV = 0;

			BYTE b[9];
			lOffset= PIXEL_OFFSET(i-1,j-1, wBytesPerLine);
			b[0] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i-1,j, wBytesPerLine);
			b[1] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i-1,j+1, wBytesPerLine);
			b[2] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j-1, wBytesPerLine);
			b[3] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
			b[4] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i,j+1, wBytesPerLine);
			b[5] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j-1, wBytesPerLine);
			b[6] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j, wBytesPerLine);
			b[7] = *(lpDIBits + lOffset);

			lOffset= PIXEL_OFFSET(i+1,j+1, wBytesPerLine);
			b[8] = *(lpDIBits + lOffset);

			// left diagonal
			int d = (int) b[0] - b[8];
			if (d < 0)
				d = -d;
			if (d > maxV)
				maxV = d;
			// right diagonal
			d = (int) b[2] - b[6];
			if (d < 0)
				d = -d;
			if (d > maxV)
				maxV = d;
			// vertical
			d = (int) b[1] - b[7];
			if (d < 0)
				d = -d;
			if (d > maxV)
				maxV = d;
			// horizontal
			d = (int) b[3] - b[5];
			if (d < 0)
				d = -d;
			if (d > maxV)
				maxV = d;

			lOffset= PIXEL_OFFSET(i,j, wBytesPerLine);
			*(lpDestImage + lOffset) = (BYTE)maxV;
		}
	}

	// cleanup temp buffers
	GlobalUnlock(hNewDib);
	GlobalFree(hNewDib);
	GlobalUnlock(hDib);
	
	WaitCursorEnd();

	return TRUE;
}

/************************************************************************* 
 * GausianFilterDIB
 * 
 * Parameters: 
 *		HDIB hDIB        - handle to global memory with a DIB spec 
 *							in it followed by the DIB bits 
 * Return Value: 
 *		BOOL			 - TRUE is success, else FALSE
 * Description: 
 *		Process Gausian filtering
 ************************************************************************/ 
BOOL GausianFilterDIB(HDIB hDib)
{
	unsigned char mask[5][5];
	int r, c, i, j;
	int SUM;

	WaitCursorBegin();

	// 5x5 Gaussian mask
	mask[0][0] = 2; mask[0][1] =  4; mask[0][2] =  5; mask[0][3] =  4; mask[0][4] = 2;
	mask[1][0] = 4; mask[1][1] =  9; mask[1][2] = 12; mask[1][3] =  9; mask[1][4] = 4;
	mask[2][0] = 5; mask[2][1] = 12; mask[2][2] = 15; mask[2][3] = 12; mask[2][4] = 5;
	mask[3][0] = 4; mask[3][1] =  9; mask[3][2] = 12; mask[3][3] =  9; mask[3][4] = 4;
	mask[4][0] = 2; mask[4][1] =  4; mask[4][2] =  5; mask[4][3] =  4; mask[4][4] = 2;

	// copy to a new DIB to store original data
	HDIB hNewDib = CopyHandle(hDib);
	if (! hNewDib)
	{
		WaitCursorEnd();
		return FALSE;
	}

	// new DIB attributes
	WORD wDIBWidth = (WORD)DIBWi