#种常用图像处理算法(函数)

8种常用图像处理算法<函数）这是我毕业设计地一部分代码
/************************************************************************* *
* 函数名称：
*
* VertMirror(>
*
* 参数:
*
* LPSTR lpDIB //指向源DIB图像指针
*
* 返回值:
*
* BOOL //镜像成功返回TRUE,否则返回FALSE.
*
* 说明:
*
* 该函数用来实现DIB图像地垂直镜像.
*
************************************************************************/ BOOL WINAPI VertMirror(LPSTR lpDIB>
{
//原图象宽度
LONG lWidth。

//原图象高度
LONG lHeight。

//原图象地颜色数
WORD wNumColors。

//原图象地信息头结构指针
LPBITMAPINFOHEADER lpbmi。

//指向原图象和目地图象地像素地指针
LPBYTE lpSrc,lpDst。

//平移后剩余图像在源图像中地位置<矩形区域）
CRect rectSrc。

//指向原图像像素地指针
LPBYTE lpDIBBits。

//指向复制图像像素地指针
LPBYTE lpNewDIBBits。

//内存句柄
HLOCAL h。

//循环变量
LONG i。

//图像每行地字节数
LONG lLineBytes。

//获取图象地信息头结构地指针
lpbmi=(LPBITMAPINFOHEADER>lpDIB。

//找到图象地像素位置
lpDIBBits=(LPBYTE>::FindDIBBits(lpDIB>。

//获取图象地宽度
lWidth=::DIBWidth(lpDIB>。

//获取图象地高度
lHeight=::DIBHeight(lpDIB>。

//获取图象地颜色数
wNumColors=::DIBNumColors(lpDIB>。

//计算图像每行地字节数
lLineBytes = WIDTHBYTES(lWidth *(lpbmi->biBitCount>>。

// 暂时分配内存,以保存新图像
h= LocalAlloc(LHND, lLineBytes>。

// 分配内存失败,直接返回
if (!h>
return FALSE。

// 锁定内存
lpNewDIBBits = (LPBYTE>LocalLock(h>。

//如果是256色位图或真彩色位图
if(wNumColors==256||wNumColors==0>
{
//平移图像,每次移动一行
for(i = 0。

i<lHeight/2。

i++>
{
//指向原图象倒数第i行像素起点地指针
lpSrc =(LPBYTE>lpDIBBits + lLineBytes * i。

//目标区域同样要注意上下倒置地问题
lpDst =(LPBYTE>lpDIBBits+lLineBytes * (lHeight-i-1> 。

//备份一行
memcpy(lpNewDIBBits, lpDst, lLineBytes>。

//将倒数第i行像素复制到第i行
memcpy(lpDst, lpSrc, lLineBytes>。

//将第i行像素复制到第i行
memcpy(lpSrc, lpNewDIBBits, lLineBytes>。

}
}
else
{
AfxMessageBox("只支持256色和真彩色位图">。

// 释放内存
LocalUnlock(h>。

LocalFree(h>。

return false。

}
// 释放内存
LocalUnlock(h>。

LocalFree(h>。

// 返回
return TRUE。

}
/************************************************************************* *
* 函数名称：
*
* RotateDIB (>
*
* 参数:
*
* LPSTR lpDIB //指向源DIB图像指针
*
* int iAngle
* 说明:
*
* 该函数用来实现DIB图像地旋转.
*
************************************************************************/ HGLOBAL WINAPI RotateDIB(LPSTR lpDIB,int iAngle>
{
//原图象宽度
LONG lWidth。

//原图象高度
LONG lHeight。

//旋转后图象宽度
LONG lNewWidth。

//旋转后图象高度
LONG lNewHeight。

//原图象地颜色数
WORD wNumColors。

//原图象地信息头结构指针
LPBITMAPINFOHEADER lpbmi,lpbmi0。

//指向原图象和目地图象地像素地指针
LPBYTE lpSrc,lpDst。

//指向原图像像素地指针
LPBYTE lpDIBBits。

//指向旋转后图像<像素）地指针
LPBYTE lpNewDIBBits。

LPSTR lpNewDIB。

//旋转后新地DIB句柄
HDIB hDIB。

//循环变量
LONG i,j,i0,j0。

//原图像每行地字节数
LONG lLineBytes。

//旋转后图像每行地字节数
LONG lNewLineBytes。

//旋转角度地弧度
double fArcAngle。

//旋转角度地正弦和余弦
float fSin,fCos。

//旋转前图象四个角地坐标<以图象中心为坐标系原点）
float fSrcX1,fSrcY1,fSrcX2,fSrcY2。

float fSrcX3,fSrcY3,fSrcX4,fSrcY4。

//旋转后图象四个角地坐标<以图象中心为坐标系原点）
float fDstX1,fDstY1,fDstX2,fDstY2。

float fDstX3,fDstY3,fDstX4,fDstY4。

//两个中间量
float f1,f2。

//找到图象地像素位置
lpDIBBits=(LPBYTE>::FindDIBBits(lpDIB>。

//获取图象地宽度
lWidth=::DIBWidth(lpDIB>。

//获取图象地高度
lHeight=::DIBHeight(lpDIB>。

//获取图象地颜色数
wNumColors=::DIBNumColors(lpDIB>。

//获取指向原位图信息头结构地指针
lpbmi0=(LPBITMAPINFOHEADER>lpDIB。

//计算原图像每行地字节数
lLineBytes = WIDTHBYTES(lWidth *(lpbmi0->biBitCount>>。

//将旋转角度从度转换到弧度
fArcAngle =(iAngle*PI>/180.0。

//计算旋转角度地正弦
fSin = (float> sin(fArcAngle>。

//计算旋转角度地余弦
fCos = (float> cos(fArcAngle>。

//计算原图地四个角地坐标<以图像中心为坐标系原点）
fSrcX1 = (float> (- (lWidth - 1> / 2>。

fSrcY1 = (float> ( (lHeight - 1> / 2>。

fSrcX2 = (float> ( (lWidth - 1> / 2>。

fSrcY2 = (float> ( (lHeight - 1> / 2>。

fSrcX3 = (float> (- (lWidth - 1> / 2>。

fSrcY3 = (float> (- (lHeight - 1> / 2>。

fSrcX4 = (float> ( (lWidth - 1> / 2>。

fSrcY4 = (float> (- (lHeight - 1> / 2>。

//计算新图四个角地坐标<以图像中心为坐标系原点）
fDstX1 = fCos * fSrcX1 + fSin * fSrcY1。

fDstY1 = -fSin * fSrcX1 + fCos * fSrcY1。

fDstX2 = fCos * fSrcX2 + fSin * fSrcY2。

fDstY2 = -fSin * fSrcX2 + fCos * fSrcY2。

fDstX3 = fCos * fSrcX3 + fSin * fSrcY3。

fDstY3 = -fSin * fSrcX3 + fCos * fSrcY3。

fDstX4 = fCos * fSrcX4 + fSin * fSrcY4。

fDstY4 = -fSin * fSrcX4 + fCos * fSrcY4。

//计算旋转后地图像实际宽度
lNewWidth = (LONG> ( max( fabs(fDstX4 - fDstX1>,
fabs(fDstX3 - fDstX2> > + 0.5>。

//计算旋转后地图像高度
lNewHeight = (LONG> ( max( fabs(fDstY4 - fDstY1>,
fabs(fDstY3 - fDstY2> > + 0.5>。

//计算旋转后图像每行地字节数
lNewLineBytes = WIDTHBYTES(lNewWidth * lpbmi0->biBitCount>。

//计算两个常数
f1 = (float> (-0.5 * (lNewWidth - 1> * fCos - 0.5 * (lNewHeight - 1> * fSin + 0.5 * (lWidth - 1>>。

f2 = (float> ( 0.5 * (lNewWidth - 1> * fSin - 0.5 * (lNewHeight - 1> * fCos + 0.5 * (lHeight - 1>>。

//暂时分配内存,以保存新图像
hDIB=(HDIB>::GlobalAlloc(GHND, lNewHeight*lNewLineBytes+ *(LPDWORD>lpDIB+::PaletteSize(lpDIB>>。

//分配内存失败,直接返回
if (!hDIB>
return NULL。

//锁定内存
lpNewDIB = (LPSTR>::GlobalLock((HGLOBAL>hDIB>。

//复制DIB信息头和调色板
memcpy(lpNewDIB,lpDIB,*(LPDWORD>lpDIB+::PaletteSize(lpDIB>>。

//获取图象地信息头结构地指针
lpbmi=(LPBITMAPINFOHEADER>lpNewDIB。

//更新DIB图象地高度和宽度
lpbmi->biWidth=lNewWidth。

lpbmi->biHeight=lNewHeight。

//找到新DIB像素地起始位置
lpNewDIBBits=(LPBYTE>::FindDIBBits(lpNewDIB>。

//如果是256色位图
if(wNumColors==256>
{
//旋转后图像每行
for(i = 0。

i<lNewHeight。

i++>
{
//旋转后图象每列
for(j=0。

j<lNewWidth。

j++>
{
//指向图象第i行第j个像素地指针
lpDst =(LPBYTE>lpNewDIBBits + lNewLineBytes * (lNewHeight-1-i>+j。

//计算每个像素点在原图象中地坐标
i0 = (LONG> (-((float> j> * fSin + ((float> i> * fCos + f2 + 0.5>。

j0 = (LONG> ( ((float> j> * fCos + ((float> i> * fSin + f1 + 0.5>。

// 判断是否在源图象范围之内
if( (j0 >= 0> && (j0 < lWidth> && (i0 >= 0> && (i0 < lHeight>>
{
// 指向源DIB图象第i0行,第j0个象素地指针
lpSrc = (LPBYTE>lpDIBBits + lLineBytes * (lHeight - 1 - i0> + j0。

// 复制象素
*lpDst = *lpSrc。

}
else
{
// 对于源图中没有地象素,直接赋值为255
* ((LPBYTE>lpDst> = 255。

}
}
}
}
//如果是24位真彩色位图
else if(wNumColors==0>
{
//旋转后图像每行
for(i = 0。

i<lNewHeight。

i++>
{
//旋转后图象每列
for(j=0。

j<lNewWidth。

j++>
{
//指向图象第i行第j个像素地指针
lpDst =(LPBYTE>lpNewDIBBits + lNewLineBytes * (lNewHeight-1-i>+3*j。

//计算每个像素点在原图象中地坐标
i0 = (LONG> (-((float> j> * fSin + ((float> i> * fCos + f2 + 0.5>。

j0 = (LONG> ( ((float> j> * fCos + ((float> i> * fSin + f1 + 0.5>。

// 判断是否在源图象范围之内
if( (j0 >= 0> && (j0 < lWidth> && (i0 >= 0> && (i0 < lHeight>>
{
// 指向源DIB图象第i0行,第j0个象素地指针
lpSrc = (LPBYTE>lpDIBBits + lLineBytes * (lHeight - 1 - i0> + 3*j0。

// 复制象素
memcpy(lpDst,lpSrc,3>。

}
else
{
// 对于源图中没有地象素,直接赋值为255
memset(lpDst,255,3>。

}
}
}
}
else
{
AfxMessageBox("只支持256色和真彩色位图">。

// 释放内存
GlobalUnlock(hDIB>。

GlobalFree(hDIB>。

return NULL。

}
// 返回
return hDIB。

}
/*************************************************************************
*
* 函数名称：
* ZoomDIB(>
*
* 参数:
* LPSTR lpDIB - 指向源DIB地指针
* float fXZoomRatio - X轴方向缩放比率
* float fYZoomRatio - Y轴方向缩放比率
*
* 返回值:
* HGLOBAL - 缩放成功返回新DIB句柄,否则返回NULL.
*
* 说明:
* 该函数用来缩放DIB图像,返回新生成DIB地句柄.
*
************************************************************************/ HGLOBAL WINAPI ZoomDIB(LPSTR lpDIB, float fXZoomRatio, float fYZoomRatio> {
// 源图像地宽度和高度
LONG lWidth。

LONG lHeight。

// 缩放后图像地宽度和高度
LONG lNewWidth。

LONG lNewHeight。

WORD wNumColors。

// 缩放后图像地宽度<lNewWidth',必须是4地倍数）
LONG lNewLineBytes。

// 指向源图像地指针
LPBYTE lpDIBBits。

// 指向源象素地指针
LPBYTE lpSrc。

// 缩放后新DIB句柄
HDIB hDIB。

// 指向缩放图像对应象素地指针
LPBYTE lpDst。

// 指向缩放图像地指针
LPSTR lpNewDIB。

LPBYTE lpNewDIBBits。

// 指向BITMAPINFO结构地指针<Win3.0）
LPBITMAPINFOHEADER lpbmi,lpbmi0。

// 指向BITMAPCOREINFO结构地指针
LPBITMAPCOREHEADER lpbmc。

// 循环变量<象素在新DIB中地坐标）
LONG i。

LONG j。

// 象素在源DIB中地坐标
LONG i0。

LONG j0。

// 图像每行地字节数
LONG lLineBytes。

// 找到源DIB图像象素起始位置
lpDIBBits = (LPBYTE>::FindDIBBits(lpDIB>。

// 获取图像地宽度
lWidth = ::DIBWidth(lpDIB>。

// 获取图像地高度
lHeight = ::DIBHeight(lpDIB>。

wNumColors= ::DIBNumColors(lpDIB>。

lpbmi0=(LPBITMAPINFOHEADER>lpDIB。

// 计算图像每行地字节数
lLineBytes = WIDTHBYTES(lWidth * (lpbmi0->biBitCount>>。

// 计算缩放后地图像实际宽度
// 此处直接加0.5是因为强制类型转换时不四舍五入,而是直接截去小数部分
lNewWidth = (LONG> (lWidth* fXZoomRatio + 0.5>。

// 计算新图像每行地字节数
lNewLineBytes = WIDTHBYTES(lNewWidth * (lpbmi0->biBitCount>>。

// 计算缩放后地图像高度
lNewHeight = (LONG> (lHeight * fYZoomRatio + 0.5>。

// 分配内存,以保存新DIB
hDIB = (HDIB> ::GlobalAlloc(GHND, lNewLineBytes * lNewHeight + *(LPDWORD>lpDIB + ::PaletteSize(lpDIB>>。

// 判断是否内存分配失败
if (hDIB == NULL>
{
// 分配内存失败
return NULL。

}
// 锁定内存
lpNewDIB = (LPSTR>::GlobalLock((HGLOBAL> hDIB>。

// 复制DIB信息头和调色板
memcpy(lpNewDIB, lpDIB, *(LPDWORD>lpDIB + ::PaletteSize(lpDIB>>。

// 找到新DIB象素起始位置
lpNewDIBBits = (LPBYTE>::FindDIBBits(lpNewDIB>。

// 获取指针
lpbmi = (LPBITMAPINFOHEADER>lpNewDIB。

lpbmc = (LPBITMAPCOREHEADER>lpNewDIB。

// 更新DIB中图像地高度和宽度
if (IS_WIN30_DIB(lpNewDIB>>
{
// 对于Windows 3.0 DIB
lpbmi->biWidth = lNewWidth。

lpbmi->biHeight = lNewHeight。

}
else
{
// 对于其它格式地DIB
lpbmc->bcWidth = (unsigned short> lNewWidth。

lpbmc->bcHeight = (unsigned short> lNewHeight。

}
if(wNumColors==256>
{
// 针对图像每行进行操作
for(i = 0。

i < lNewHeight。

i++>
{
// 针对图像每列进行操作
for(j = 0。

j < lNewWidth。

j++>
{
// 指向新DIB第i行,第j个象素地指针
// 注意此处宽度和高度是新DIB地宽度和高度
lpDst = (LPBYTE>lpNewDIBBits + lNewLineBytes * (lNewHeight - 1 - i> + j。

// 计算该象素在源DIB中地坐标
i0 = (LONG> (i / fYZoomRatio + 0.5>。

j0 = (LONG> (j / fXZoomRatio + 0.5>。

// 判断是否在源图范围内
if( (j0 >= 0> && (j0 < lWidth> && (i0 >= 0> && (i0 < lHeight>>
{
// 指向源DIB第i0行,第j0个象素地指针
lpSrc = (LPBYTE>lpDIBBits + lLineBytes * (lHeight - 1 - i0> + j0。

// 复制象素
*lpDst = *lpSrc。

}
else
{
// 对于源图中没有地象素,直接赋值为255
* ((LPBYTE>lpDst> = 255。

}
}
}
}
else if(wNumColors==0>
{for(i = 0。

i < lNewHeight。

i++>
{
// 针对图像每列进行操作
for(j = 0。

j < lNewWidth。

j++>
{
// 指向新DIB第i行,第j个象素地指针
// 注意此处宽度和高度是新DIB地宽度和高度
lpDst = (LPBYTE>lpNewDIBBits + lNewLineBytes * (lNewHeight - 1 - i> + 3*j。

// 计算该象素在源DIB中地坐标
i0 = (LONG> (i / fYZoomRatio + 0.5>。

j0 = (LONG> (j / fXZoomRatio + 0.5>。

// 判断是否在源图范围内
if( (j0 >= 0> && (j0 < lWidth> && (i0 >= 0> && (i0 < lHeight>>
{
// 指向源DIB第i0行,第j0个象素地指针
lpSrc = (LPBYTE>lpDIBBits + lLineBytes * (lHeight - 1 - i0> + 3*j0。

// 复制象素
memcpy(lpDst,lpSrc,3>。

}
else
{
// 对于源图中没有地象素,直接赋值为255
memset(lpDst,255,3>。

}
}
}
}
// 返回
return hDIB。

}
/*************************************************************************
*
* 函数名称：
* On256tograyscale (>
*
* 说明:
* 该算法函数用来把256图像转化成灰度图像.
*
************************************************************************/
void CCimageProcessingView::On256tograyscale(>
{
// TODO: Add your command handler code here
// 获取文档指针
CCimageProcessingDoc* pDoc = GetDocument(>。

// 指向DIB地指针
LPSTR lpDIB。

// 指向DIB象素指针
LPSTR lpDIBBits。

// 指向DIB地一个象素地指针
BYTE * l pSrc。

// 颜色表中地颜色数目
WORD wNumColors。

// 灰度映射表
BYTE bGrayMap[256]。

//调色板索应循环变量
LONG i。

// 图象高度循环变量
LONG ih。

//图象宽度循环变量
LONG iw。

// 图像宽度
LONG lWidth。

// 图像高度
LONG lHeight。

// 图像每行地字节数
LONG OneLineBytes。

// 指向BITMAPINFO结构地指针<Win3.0）
LPBITMAPINFO lpbmi。

// 指向BITMAPCOREINFO结构地指针(OS/2>
LPBITMAPCOREINFO lpbmc。

// 表明是否是Win3.0 DIB地标记
BOOL bWin30DIB。

lpDIB = (LPSTR> ::GlobalLock((HGLOBAL> pDoc->GetHDIB(>>。

// 获取指向BITMAPINFO结构地指针<Win3.0）
lpbmi = (LPBITMAPINFO>lpDIB。

// 获取指向BITMAPCOREINFO结构地指针(OS/2>
lpbmc = (LPBITMAPCOREINFO>lpDIB。

// 锁定DIB
// 获取DIB中颜色表中地颜色数目
wNumColors = ::DIBNumColors(lpDIB>。

// 判断是否是256色位图
if (wNumColors != 256>
{
MessageBox("不是256色位图！">。

// 解除锁定
::GlobalUnlock((HGLOBAL> pDoc->GetHDIB(>>。

// 返回
return。

}
// 更改光标形状
BeginWaitCursor(>。

// 判断是否是WIN3.0地DIB
bWin30DIB = IS_WIN30_DIB(lpDIB>。

//将原图象地调色板转化为灰度调色板
//建立原调色板索引与灰度调色板索引地映射关系
for (i = 0。

i < 256。

i ++>
{
if (bWin30DIB>
{
//对原256色调色板地每一表项计算对应地灰度值
bGrayMap[i] = (BYTE>(0.299 * lpbmi->bmiColors[i].rgbRed +
0.587 * lpbmi->bmiColors[i].rgbGreen +
0.114 * lpbmi->bmiColors[i].rgbBlue + 0.5>。

// 建立灰度调色板
//红色分量
lpbmi->bmiColors[i].rgbRed = i。

// 绿色分量
lpbmi->bmiColors[i].rgbGreen = i。

// 蓝色分量
lpbmi->bmiColors[i].rgbBlue = i。

// 保留位
lpbmi->bmiColors[i].rgbReserved = 0。

}
else
{
//对原256色调色板地每一表项计算对应地灰度值
bGrayMap[i] = (BYTE>(0.299 * lpbmc->bmciColors[i].rgbtRed +
0.587 * lpbmc->bmciColors[i].rgbtGreen +
0.114 * lpbmc->bmciColors[i].rgbtBlue + 0.5>。

//建立灰度调色板
// 红色分量
lpbmc->bmciColors[i].rgbtRed = i。

// 绿色分量
lpbmc->bmciColors[i].rgbtGreen = i。

// 蓝色分量
lpbmc->bmciColors[i].rgbtBlue = i。

}
}
// 找到DIB图像象素起始位置
lpDIBBits = ::FindDIBBits(lpDIB>。

// 获取图像宽度
lWidth = ::DIBWidth(lpDIB>。

// 获取图像高度
lHeight = ::DIBHeight(lpDIB>。

// 计算图像每行地字节数
OneLineBytes = WIDTHBYTES(lWidth * 8>。

// 更换原256色位图地每个象素地颜色索引
// 每行
for(ih = 0。

ih < lHeight。

ih++>
{
// 每列
for(iw= 0。

iw < lWidth。

iw++>
{
// 指向DIB第ih行,第iw列地象素地指针
lpSrc = (BYTE*>lpDIBBits + OneLineBytes * (lHeight - 1 - ih> +iw。

//对256色位图,其像素值是调色板索引值
//对灰度图,索引值就等于其灰度值
//映射调色板索引
*lpSrc = bGrayMap[*lpSrc]。

}
}
// 替换当前调色板为灰度调色板
pDoc->GetDocPalette(>->SetPaletteEntries(0,256,
(LPPALETTEENTRY>lpbmi->bmiColors>。

// 设置脏标记
pDoc->SetModifiedFlag(TRUE>。

// 实现新地调色板
OnDoRealize((WPARAM>m_hWnd,0>。

// 更新视图
pDoc->UpdateAllViews(NULL>。

// 解除锁定
::GlobalUnlock((HGLOBAL> pDoc->GetHDIB(>>。

// 恢复光标
EndWaitCursor(>。

}
/*************************************************************************
*
* 函数名称：
*
* RandomNoise(>
*
* 参数:
*
* LPSTR lpDIB // 指向源DIB图像指针
*
* 返回值:
*
* BOOL // 加入随机噪声操作成功返回TRUE,否则返回FALSE.
*
* 说明:
*
* 该函数用来对256色位图和24位真彩色位图进行加入随即噪声操作.
*
************************************************************************/ BOOL WINAPI RandomNoise (LPSTR lpDIB>
{
// 图像宽度和高度
LONG lWidth,lHeight。

// 指向图像像素地指针
LPSTR lpDIBBits。

// 指向源图像地指针
LPSTR lpSrc。

//循环变量
long i。

long j。

// 图像每行地字节数
LONG lLineBytes。

//指向图像信息头结构地指针
LPBITMAPINFOHEADER lpbmi。

//图像地颜色数
WORD wNumColors。

//噪声
BYTE NoiseValue。

// 计算图像每行地字节数
lpbmi=(LPBITMAPINFOHEADER>lpDIB。

//计算图像地高度和宽度
lWidth=::DIBWidth(lpDIB>。

lHeight=::DIBHeight(lpDIB>。

//找到图像像素地起始位置
lpDIBBits=::FindDIBBits(lpDIB>。

//计算图像地颜色数
wNumColors=::DIBNumColors(lpDIB>。

//计算图像每行地字节数
lLineBytes = WIDTHBYTES(lWidth * lpbmi->biBitCount>。

//生成伪随机种子
srand((unsigned>time(NULL>>。

//在图像中加噪
//如果是256色位图
if(wNumColors==256>
{
for (j = 0。

j < lHeight 。

j++>
{
for(i = 0。

i < lWidth 。

i++>
{
//随机地噪声值
NoiseValue=rand(>/1024。

// 指向源图像倒数第j行,第i个象素地指针
lpSrc = (char *>lpDIBBits + lLineBytes * j + i。

//在像素值中加入噪声值
*lpSrc = (BYTE>(((BYTE>*(lpSrc>>*224/256 + NoiseValue>。

}
}
}
//如果是24位真彩色位图
else if(wNumColors==0>
{
for (j = 0。

j < lHeight 。

j++>
{
for(i = 0。

i < lWidth 。

i++>
{
NoiseValue=rand(>/1024。

// 指向源图像倒数第j行,第i个象素地指针
lpSrc = (char *>lpDIBBits + lLineBytes * j + 3*i。

//在每个像素地RGB分量中加入随机地噪声值
*lpSrc++ = (BYTE>(((BYTE>*(lpSrc++>>*224/256 + NoiseV alue>。

*lpSrc++ = (BYTE>(((BYTE>*(lpSrc++>>*224/256 + NoiseV alue>。

*lpSrc++ = (BYTE>(((BYTE>*(lpSrc++>>*224/256 + NoiseV alue>。

}
}
}
//如果既不是256色位图也不是24 位真彩色位图,直接返回
else
{
AfxMessageBox("只支持256色位图和24位真彩色位图">。

return false。

}
// 返回
return true。

}
/*************************************************************************
*
* 函数名称：
*
* AdjustBrightness (>
*
* 参数:
*
* LPSTR lpDIB // 指向源DIB图像指针
*
*int db
*
* BOOL //操作成功返回TRUE,否则返回FALSE.
*
* 说明:
*
* 该算法函数用来对256色位图和24位真彩色位图进行亮度调整操作.
*
************************************************************************/ BOOL WINAPI AdjustBrightness(LPSTR lpDIB, int db>
{
BYTE r, g, b。

BITMAPINFO *pbmi。

WORD wNumColors。

LONG i。

LPSTR lpDIBBits。

int nDelta。

int iWidth, iHeight。

if (lpDIB == NULL>
return FALSE。

pbmi = (BITMAPINFO *>lpDIB。

if (! pbmi>
return FALSE。

wNumColors =::DIBNumColors(lpDIB>。

if (wNumColors==256>
{
for (i=0。

i<wNumColors。

i++>
{
pbmi->bmiColors[i].rgbRed = BOUND(pbmi->bmiColors[i].rgbRed+db, 0, 255>。

pbmi->bmiColors[i].rgbGreen = BOUND(pbmi->bmiColors[i].rgbGreen+db, 0, 255>。

pbmi->bmiColors[i].rgbBlue = BOUND(pbmi->bmiColors[i].rgbBlue+db, 0, 255>。

}
}
else if(wNumColors==0>
{
lpDIBBits= ::FindDIBBits(lpDIB>。

nDelta = WIDTHBYTES((pbmi->bmiHeader.biBitCount>*(pbmi->bmiHeader.biWidth>>
- ((pbmi->bmiHeader.biWidth>*(pbmi->bmiHeader.biBitCount>+7>/8。

for (iHeight=0。

iHeight<pbmi->bmiHeader.biHeight。

iHeight++>
{
for (iWidth=0。

iWidth<pbmi->bmiHeader.biWidth。

iWidth++>
{
b = (BYTE>*(lpDIBBits>。

g = (BYTE>*(lpDIBBits+1>。

r = (BYTE>*(lpDIBBits+2>。

*lpDIBBits++= BOUND(b+db, 0, 255>。

*lpDIBBits++= BOUND(g+db, 0, 255>。

*lpDIBBits++= BOUND(r+db, 0, 255>。

}
lpDIBBits += nDelta。

}
}
else
{
AfxMessageBox("只处理256色和24位位图">。

return false。

}
return TRUE。

}
/************************************************************************* *
* 函数名称：
*
* AdjustColor (>
*
* 参数:
*
* LPSTR lpDIB // 指向源DIB图像指针
*
*int dr dg db
*
* BOOL //操作成功返回TRUE,否则返回FALSE.
*
* 说明:
*
* 该算法函数用来对256色位图和24位真彩色位图进行色调调整操作.
*
************************************************************************/ BOOL WINAPI AdjustColor(LPSTR lpDIB, int dr, int dg, int db>
{
BYTE r, g, b。

BITMAPINFO *pbmi。

WORD wNumColors。

LONG i。

LPSTR lpDIBBits。

int iWidth, iHeight。

if (lpDIB == NULL>
return FALSE。

pbmi = (BITMAPINFO *>lpDIB。

if (! pbmi>
return FALSE。

wNumColors =::DIBNumColors(lpDIB>。

if (wNumColors==256>
{
for (i=0。

i<wNumColors。

i++>
{
pbmi->bmiColors[i].rgbRed = BOUND(pbmi->bmiColors[i].rgbRed+dr, 0, 255>。

pbmi->bmiColors[i].rgbGreen = BOUND(pbmi->bmiColors[i].rgbGreen+dg, 0, 255>。

pbmi->bmiColors[i].rgbBlue = BOUND(pbmi->bmiColors[i].rgbBlue+db, 0, 255>。

}
}
else if(wNumColors==0>
{
lpDIBBits= ::FindDIBBits(lpDIB>。

nDelta = WIDTHBYTES((pbmi->bmiHeader.biBitCount>*(pbmi->bmiHeader.biWidth>>
- ((pbmi->bmiHeader.biWidth>*(pbmi->bmiHeader.biBitCount>+7>/8。

for (iHeight=0。

iHeight<pbmi->bmiHeader.biHeight。

iHeight++>
{
for (iWidth=0。

iWidth<pbmi->bmiHeader.biWidth。

iWidth++>
{
b = (BYTE>*(lpDIBBits>。

g = (BYTE>*(lpDIBBits+1>。

r = (BYTE>*(lpDIBBits+2>。

*lpDIBBits++= BOUND(b+db, 0, 255>。

*lpDIBBits++= BOUND(g+dg, 0, 255>。

*lpDIBBits++= BOUND(r+dr, 0, 255>。

}
lpDIBBits += nDelta。

}
}
else
{
AfxMessageBox("只处理256色和24位位图">。

}
return TRUE。

}
/************************************************************************* *
* 函数名称：
*
* AdjustCotrast (>
*
* 参数:
*
* LPSTR lpDIB // 指向源DIB图像指针
*
*int dc
*
* BOOL //操作成功返回TRUE,否则返回FALSE.
*
* 说明:
*
* 该算法函数用来对256色位图和24位真彩色位图进行对比度调整操作.
*
************************************************************************/ BOOL WINAPI AdjustCotrast(LPSTR lpDIB, int dc>
{
BYTE r, g, b。

BITMAPINFO *pbmi。

WORD wNumColors。

LONG i。

LPSTR lpDIBBits。

int nDelta。

int iWidth, iHeight。

if (lpDIB == NULL>
return FALSE。

pbmi = (BITMAPINFO *>lpDIB。

if (! pbmi>
return FALSE。

wNumColors =::DIBNumColors(lpDIB>。

if (wNumColors==256>
{
for (i=0。

i<wNumColors。

i++>
{
if(dc>=0>
{
int vMin=dc。

int vMax=255-dc。

float Grad=((float>(vMax-vMin>>/255。

IncreaseContrast(&(pbmi-
>bmiColors[i].rgbRed>,vMin,vMax,Grad>。

IncreaseContrast(&(pbmi->bmiColors[i].rgbGreen>,vMin,vMax,Grad>。

IncreaseContrast(&(pbmi-
>bmiColors[i].rgbBlue>,vMin,vMax,Grad>。

}
else
{
float Grad=255/(255+2*(float>dc>。

DecreaseContrast(&(pbmi->bmiColors[i].rgbRed>,dc,Grad>。

DecreaseContrast(&(pbmi-
>bmiColors[i].rgbGreen>,dc,Grad>。

DecreaseContrast(&(pbmi->bmiColors[i].rgbBlue>,dc,Grad>。

}
}
}
else if(wNumColors==0>
{
lpDIBBits= ::FindDIBBits(lpDIB>。

nDelta = WIDTHBYTES((pbmi->bmiHeader.biBitCount>*(pbmi->bmiHeader.biWidth>>
- ((pbmi->bmiHeader.biWidth>*(pbmi->bmiHeader.biBitCount>+7>/8。

for (iHeight=0。

iHeight<pbmi->bmiHeader.biHeight。

iHeight++>
{
for (iWidth=0。

iWidth<pbmi->bmiHeader.biWidth。

iWidth++>
{
b = (BYTE>*(lpDIBBits>。

g = (BYTE>*(lpDIBBits+1>。

r = (BYTE>*(lpDIBBits+2>。

if(dc>=0>
{
int vMin=dc。

int vMax=255-dc。

float Grad=((float>(vMax-vMin>>/255。

IncreaseContrast(&b,vMin,vMax,Grad>。

IncreaseContrast(&g,vMin,vMax,Grad>。

IncreaseContrast(&r,vMin,vMax,Grad>。

}
else
{
float Grad=255/(255+2*(float>dc>。

DecreaseContrast(&b,dc,Grad>。

DecreaseContrast(&g,dc,Grad>。

DecreaseContrast(&r,dc,Grad>。

}
*lpDIBBits++= b。

*lpDIBBits++= g。

*lpDIBBits++= r。

}
lpDIBBits += nDelta。

}
}
else
{
AfxMessageBox("只处理256色和24位位图">。

return false。

}
return TRUE。

}。