怎么样才能得到bmp的每个pixel

[superman1234]

就是读每出bmp的个象素点,我要锐化图像,但是不知道怎么读出象素点.help

[pomelowu]

GetPixel

[superman1234]

楼上的能不能具体一点,我要怎么作??
就是把每个象素*5和四周的四个象素相减

[superman1234]

谁能帮帮我啊??我要作的就是vc来锐化一个图像,锐化因子是
0,-1,0
-1,5,-1
0,-1,0

[starlee325]

RGBQUAD cColor[50];
cColor[k]=m_dib.GetPixel(x, y);

[jerry]

1) 用 GetDIBits() 来获取象素数据, 然后对数据进行操作. 然后将数据再转换成Bitmap

卷积操作:

//设置卷积核
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.red;
*pbyDst++ = rgb.green;
*pbyDst++ = rgb.blue;
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.red;
*pbyDst++ = rgb.green;
*pbyDst++ = rgb.blue;
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.red;
*pbyDst++ = rgb.green;
*pbyDst++ = rgb.blue;
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.red;
*pbyDst++ = rgb.green;
*pbyDst++ = rgb.blue;
pbyDst++;
}
}

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

for(j = nStartW;j < nRemnantW;j++)
{
//当前像素x坐标
int xx = x + j;
//进行卷积操作
PIXELCOLORRGB rgb = FilterPixelInner(pbySrcCopy, xx, yy, nScanWidth, nScanHeight);

//写向目的数据缓冲区
*pbyDst++ = rgb.red;
*pbyDst++ = rgb.green;
*pbyDst++ = rgb.blue;
pbyDst++;
}
}

delete[] pbySrcCopy;
return TRUE;
}

[jerry]

//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;

//记录颜色分量
pbyRed[index] = *pbyRaw++;
pbyGreen[index] = *pbyRaw++;
pbyBlue[index] = *pbyRaw++;
index++;
}
}
//RGB颜色结构, 在 IMG.H 中定义
//计算卷积
PIXELCOLORRGB rgb = Convolute(pbyRed, pbyGreen, pbyBlue, nNum);

delete[] pbyRed;
delete[] pbyGreen;
delete[] pbyBlue;
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];
VERIFY(pbyRed!=NULL);
VERIFY(pbyGreen!=NULL);
VERIFY(pbyBlue!=NULL);

//邻域中的左上角点.
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坐标
//记录颜色分量
pbyRed[index] = *pbySrc++;
pbyGreen[index] = *pbySrc++;
pbyBlue[index] = *pbySrc++;
pbySrc++;
index++;
}
}

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

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

代码不是很完整, 但算法都在这里了