convolutionfilter.cpp

visual c++数字图像与图形处理中的光盘内容

			m_pnKernel[6] = m_pnKernel[7] = -1; m_pnKernel[8] = 1;
			break;					
		}
		//Prewitt边缘增强, 东南
		case IMAGE_PREWITT_SOUTHEAST_DETECT:
		{
			m_nRows = m_nCols = 3;
			m_nKernelWeight = 0;
			m_pnKernel = new int[9];
			m_pnKernel[0] = m_pnKernel[1] = -1; m_pnKernel[2] = 1;
			m_pnKernel[3] = -1; m_pnKernel[4] = -2; m_pnKernel[5] = 1;
			m_pnKernel[6] = m_pnKernel[7] = m_pnKernel[8] = 1;
			break;					
		}

		//Prewitt边缘增强, 西北
		case IMAGE_PREWITT_NORTHWEST_DETECT:
		{
			m_nRows = m_nCols = 3;
			m_nKernelWeight = 0;
			m_pnKernel = new int[9];
			m_pnKernel[0] = m_pnKernel[1] = m_pnKernel[2] = 1;
			m_pnKernel[3] = 1; m_pnKernel[4] = -2; m_pnKernel[5] = -1;
			m_pnKernel[6] = 1; m_pnKernel[7] = m_pnKernel[8] = -1;
			break;					
		}

		//水平线检测
		case IMAGE_LINE_HORIZONTAL_DETECT:
		{
			m_nRows = m_nCols = 3;
			m_nKernelWeight = 0;
			m_pnKernel = new int[9];
			m_pnKernel[0] = m_pnKernel[1] = m_pnKernel[2] = -1;
			m_pnKernel[3] = m_pnKernel[4] = m_pnKernel[5] = 2;
			m_pnKernel[6] = m_pnKernel[7] = m_pnKernel[8] = -1;
			break;			
		}

		//垂直线检测
		case IMAGE_LINE_VERTICAL_DETECT:
		{
			m_nRows = m_nCols = 3;
			m_nKernelWeight = 0;
			m_pnKernel = new int[9];
			m_pnKernel[0] = m_pnKernel[3] = m_pnKernel[6] = -1;
			m_pnKernel[1] = m_pnKernel[4] = m_pnKernel[7] = 2;
			m_pnKernel[2] = m_pnKernel[5] = m_pnKernel[8] = -1;
			break;			
		}
		//左对角线检测,  45度, 斜率为-1 
		case IMAGE_LINE_LEFT_DIAGONAL_DETECT:
		{
			m_nRows = m_nCols = 3;
			m_nKernelWeight = 0;
			m_pnKernel = new int[9];
			m_pnKernel[1] = m_pnKernel[2] = m_pnKernel[3] = -1;
			m_pnKernel[0] = m_pnKernel[4] = m_pnKernel[8] = 2;
			m_pnKernel[5] = m_pnKernel[6] = m_pnKernel[7] = -1;
			break;		
		}
		//右对角线检测,  45度, 斜率为1
		case IMAGE_LINE_RIGHT_DIAGONAL_DETECT:
		{
			m_nRows = m_nCols = 3;
			m_nKernelWeight = 0;
			m_pnKernel = new int[9];
			m_pnKernel[0] = m_pnKernel[1] = m_pnKernel[3] = -1;
			m_pnKernel[2] = m_pnKernel[4] = m_pnKernel[6] = 2;
			m_pnKernel[5] = m_pnKernel[7] = m_pnKernel[8] = -1;
			break;		
		}


		//可以任意添加, 该类是开放的

		default : break;
	}
}

//设置卷积核
void CConvolutionFilter::SetKernel(const int *pnKernel,  int nRows,  int nCols)
{
	m_dwOperation = IMAGE_GENERAL_CONVOLUTION_FILTER;
	//保证为奇数
	m_nRows = 2 * (nRows / 2) + 1;
	m_nCols = 2 * (nCols / 2) + 1;

	if(m_pnKernel)delete[] m_pnKernel;
	m_pnKernel = new int[m_nRows * m_nCols];
	int i;
	for( i = 0;i < m_nRows * m_nCols;i++)m_pnKernel[i] = 0;
	
	m_nKernelWeight = 0;
	for(i = 0;i < nRows;i++)
	{
		for(int j = 0; j < nCols;j++)
		{
			int index = m_nCols * i + j;
			m_pnKernel[index] = pnKernel[nCols * i + j];
			m_nKernelWeight += m_pnKernel[index];
		}
	}
}

//有时候, 你可以觉得自己设置一个权值更加灵活, 这个函数就提供了这个功能
//但是, 你必须是在SetKernel()和SetOperation()之后用它.
void CConvolutionFilter::SetKernelWeight(int nKernelWeight)
{
	m_nKernelWeight = nKernelWeight;
}

//x, y, nWidth,  int nHeight, 定义区域的宽度
//nScanWidth,  int nScanHeight, 扫描宽度和扫描高度
//lpbyBits32----传递源像素值, 回载结果值

BOOL CConvolutionFilter::Filter(LPBYTE lpbyBits32,  int x,  int y,  int nWidth,  int nHeight,  int nScanWidth,  int nScanHeight)
{
	//第一步, 参数合法性检测
	ASSERT(lpbyBits32);
	ASSERT(m_pnKernel);

	if((x > (nScanWidth - 1)) || (y > (nScanHeight - 1))) return FALSE;
	//有效区域的宽度和高度
	int w = min(nWidth, nScanWidth - x);
	int h = min(nHeight, nScanHeight - y);

	//行字节数
	DWORD dwWidthBytes = (DWORD)nScanWidth * 4;

	//建立一份拷贝
	BYTE* pbySrcCopy =  new BYTE[ (dwWidthBytes * nScanHeight) ];
	if(pbySrcCopy == NULL) return FALSE;

	::CopyMemory(pbySrcCopy, lpbyBits32, dwWidthBytes * nScanHeight);

	int i, j;

	//处理上下边界
	//上下边界的高度:
	int nBorderH = (m_nRows - 1) / 2;
	for(i = 0;i < nBorderH;i++)
	{
		//当前像素y坐标
		int yy = y + i;

		//将改变源数据
		BYTE* pbyDst = lpbyBits32 + yy * dwWidthBytes + 4 * x;
		for(j = 0;j < w;j++)
		{
			//当前像素x坐标
			int xx = x + j;

			//进行卷积操作
			PIXELCOLORRGB rgb = FilterPixelOnBorder(pbySrcCopy, xx, yy, nScanWidth, nScanHeight);
	
			//写向目的数据缓冲区
			*pbyDst++ = rgb.blue;
			*pbyDst++ = rgb.green;
			*pbyDst++ = rgb.red;
			pbyDst++;
		}
	}
	
	
	//下边界Y坐标
	int nYBottom = (y + h - 1);
	//处理下边界
	for(i = 0;i < nBorderH;i++)
	{
		//当前像素y坐标
		int yy = nYBottom - i;

		//指向目的地址
		BYTE* pbyDst = lpbyBits32 + yy * dwWidthBytes + 4 * x;
		for(j = 0;j < w;j++)
		{
			//当前像素x坐标
			int xx = x + j;

			//进行卷积操作
			PIXELCOLORRGB rgb = FilterPixelOnBorder(pbySrcCopy, xx, yy, nScanWidth, nScanHeight);
	
			//写向目的数据缓冲区
			*pbyDst++ = rgb.blue;
			*pbyDst++ = rgb.green;
			*pbyDst++ = rgb.red;
			pbyDst++;
		}
	}

	//垂直边界宽度
	int nBorderW = (m_nCols - 1) / 2;

	
	//剩余高度 + 1 + nBorderH: 
	int nRemnantH = (h - nBorderH);
	
	//处理左边界
	for(i = nBorderH; i < nRemnantH;i++)
	{
		//当前像素y坐标
		int yy = y + i;
		//指向目的地址
		BYTE* pbyDst = lpbyBits32 + yy * dwWidthBytes + 4 * x;

		for(j = 0;j < nBorderW;j++)
		{
			//当前像素x坐标
			int xx = x + j;
			//进行卷积操作
			PIXELCOLORRGB rgb = FilterPixelOnBorder(pbySrcCopy, xx, yy, nScanWidth, nScanHeight);
	
			//写向目的数据缓冲区
			*pbyDst++ = rgb.blue;
			*pbyDst++ = rgb.green;
			*pbyDst++ = rgb.red;
			pbyDst++;
		}
	}

	//右边界x坐标起点
	int nXRight = x + w - nBorderW; 

	//处理右边界
	for(i = nBorderH; i < nRemnantH;i++)
	{
		//当前像素y坐标
		int yy = y + i;
		//指向目的地址
		BYTE* pbyDst = lpbyBits32 + yy * dwWidthBytes + 4 * nXRight;

		for(j = 0;j < nBorderW;j++)
		{
			//当前像素x坐标
			int xx = nXRight + j;
			//进行卷积操作
			PIXELCOLORRGB rgb = FilterPixelOnBorder(pbySrcCopy, xx, yy, nScanWidth, nScanHeight);
	
			//写向目的数据缓冲区
			*pbyDst++ = rgb.blue;
			*pbyDst++ = rgb.green;
			*pbyDst++ = rgb.red;
			pbyDst++;
		}
	}

	//内部宽度 - nBorderW + 1
	int nInnerW = w - nBorderW;
	
	//处理内部
	for(i = nBorderH; i < nRemnantH;i++)
	{
		//当前像素y坐标
		int yy = y + i;
		//指向目的地址
		BYTE* pbyDst = lpbyBits32 + yy * dwWidthBytes + 4 * x;

		for(j = 0;j < nInnerW;j++)
		{
			//当前像素x坐标
			int xx = x + j;
			//进行卷积操作
			PIXELCOLORRGB rgb = FilterPixelInner(pbySrcCopy, xx, yy, nScanWidth, nScanHeight);
	
			//写向目的数据缓冲区
			*pbyDst++ = rgb.blue;
			*pbyDst++ = rgb.green;
			*pbyDst++ = rgb.red;
			pbyDst++;
		}
	}
	
	delete[] pbySrcCopy;
	return TRUE;
}

//60%的计算时间都花在这个函数上面:
//时间开销分为两部分:
//其一, 运算函数体;其二, 调用该函数的调度开销
//虚拟成员函数
PIXELCOLORRGB CConvolutionFilter::Convolute(BYTE *pbyRed, BYTE *pbyGreen, BYTE *pbyBlue,  int nNum)
{
	int i, nSumRed, nSumGreen, nSumBlue;

	nSumRed = nSumGreen = nSumBlue = 0;

	for(i = 0 ; i < nNum;i++)
	{
		nSumRed += pbyRed[i] * m_pnKernel[i];
		nSumGreen += pbyGreen[i] * m_pnKernel[i];
		nSumBlue += pbyBlue[i] * m_pnKernel[i];
	}

	if((m_nKernelWeight != 0) && (m_nKernelWeight != 1))
	{
		nSumRed /= m_nKernelWeight;
		nSumGreen /= m_nKernelWeight;
		nSumBlue /= m_nKernelWeight;
	}

	PIXELCOLORRGB rgb;

	rgb.red = (BYTE)(BOUND(nSumRed, 0, 255));
	rgb.green = (BYTE)(BOUND(nSumGreen, 0, 255));
	rgb.blue = (BYTE)(BOUND(nSumBlue, 0, 255));

	return rgb;
}

//lpbyBitsSrc32----源像素值
//x, y当前像素的绝对地址, 其坐标是相对于(0, 0)点的.
//nScanWidth,  int nScanHeight, 扫描宽度和扫描高度

PIXELCOLORRGB CConvolutionFilter::FilterPixelOnBorder(LPBYTE lpbyBitsSrc32,  int x,  int y,  int nScanWidth,  int nScanHeight)
{
	//卷积核元素的总个数;
	int nNum = m_nRows * m_nCols;

	//行字节数
	DWORD dwWidthBytes = (DWORD)nScanWidth * 4;

	//存储一个像素邻域的RGB三分量
	BYTE* pbyRed = new BYTE[nNum];
	BYTE* pbyGreen = new BYTE[nNum];
	BYTE* pbyBlue = new BYTE[nNum];

	//邻域中的左上角点.
	int xx = x - ((m_nCols - 1) / 2);
	int yy = y - ((m_nRows - 1) / 2);

	//三个数组pnRed, pnGreen, pnBlue的索引值
	int index = 0;

	//用嵌套循环获取小邻域数据.
	
	for(int i = 0;i < m_nRows;i++)
	{
		//y坐标
		int nY = yy + i;

		//复制边界
		nY = (nY < 0) ? 0 : ((nY > (nScanHeight - 1)) ? (nScanHeight - 1) : nY);

		//指针, 指向行数据
		BYTE* pbySrc = lpbyBitsSrc32 + ((DWORD)nY) * dwWidthBytes; 

		for(int j = 0;j < m_nCols;j++)
		{
			//x坐标	
			int nX = xx + j;

			//复制边界
			nX = (nX < 0) ? 0 : ((nX > (nScanWidth - 1)) ? (nScanWidth - 1) : nX);
			
			BYTE* pbyRaw = pbySrc + 4 * nX;
			
			//记录颜色分量
			pbyBlue[index] = *pbyRaw++; 
			pbyGreen[index] = *pbyRaw++;
			pbyRed[index] = *pbyRaw++;
			index++;
		}
	}
	//RGB颜色结构, 在 IMG.H 中定义
	//计算卷积
	PIXELCOLORRGB rgb = Convolute(pbyRed, pbyGreen, pbyBlue, nNum);

	delete[] pbyBlue;
	delete[] pbyGreen;
	delete[] pbyRed;
	return rgb;
}

//与FilterPixelOnBorder()函数相比, 该函数只是少了几个判断语句而已.
PIXELCOLORRGB CConvolutionFilter::FilterPixelInner(LPBYTE lpbyBitsSrc32,  int x,  int y,  int nScanWidth,  int nScanHeight)
{
	//卷积核元素的总个数;
	int nNum = m_nRows * m_nCols;

	//行字节数
	DWORD dwWidthBytes = (DWORD)nScanWidth * 4;

	//存储一个像素邻域的RGB三分量
	BYTE* pbyRed = new BYTE[nNum];
	BYTE* pbyGreen = new BYTE[nNum];
	BYTE* pbyBlue = new BYTE[nNum];

	//邻域中的左上角点.
	int xx = x - ((m_nCols - 1) / 2);
	int yy = y - ((m_nRows - 1) / 2);

	//三个数组pnRed, pnGreen, pnBlue的索引值
	int index = 0;

	//用嵌套循环获取小邻域数据.
	
	for(int i = 0;i < m_nRows;i++)
	{
		//y坐标
		int nY = yy + i;

		//指针, 指向行数据
		BYTE* pbySrc = lpbyBitsSrc32 + ((DWORD)nY) * dwWidthBytes + 4 * xx;

		for(int j = 0;j < m_nCols;j++)
		{
			//x坐标	
			//记录颜色分量
			pbyBlue[index] = *pbySrc++; 
			pbyGreen[index] = *pbySrc++;
			pbyRed[index] = *pbySrc++;
			pbySrc++;
			index++;
		}
	}

	//计算卷积
	PIXELCOLORRGB rgb = Convolute(pbyRed, pbyGreen, pbyBlue, nNum);

	delete[] pbyBlue;
	delete[] pbyGreen;
	delete[] pbyRed;
	return rgb;
}