C++中把线形存储的像素转化为二维数组形式，做图像增前处理_电工电气_中国百科网
C++中把线形存储的像素转化为二维数组形式，做图像增前处理
    #include &StdAfx.h&=========数字图像处理原理与实践；基于VC++开发源代码===第九章
#include &improve.h&
#include &iostream&
#include &vector&
#include &algorithm&
#pragma warning ( disable : 4018)
int GetAsh(BYTE** imageBuf, int x, int y)
clr = (imageBuf[y][x*4] + imageBuf[y][x*4+1]
+imageBuf[y][x*4+2]) / 3;
/********************************************************
* 把线形存储的像素转化为二维数组形式
* 参数: image 线形存储的像素， width,height 图象的长宽
********************************************************/
BYTE** CreatImage(BYTE* image, unsigned int width, unsigned int height, int bt=4)
BYTE** imageBuf = (BYTE**)malloc(sizeof(BYTE*)*(height));
for(int y=0; y& y++)
//使imageBuf中每个指针分别指向其下标表示的行的行首地址
imageBuf[y] = image+y*width*
return imageB
/**************************************************
* 功能: 设定指定位置的像素灰度
* 参数: imageBuf为目标图像 x,y为要设定像素的坐标
**************************************************/
void SetPixelXY(BYTE** imageBuf1, int x, int y, int a)
imageBuf1[y][x*4] =
imageBuf1[y][x*4+1] =
imageBuf1[y][x*4+2] =
imageBuf1[y][x*4+3]= 255;
/**************************************************
* 功能: 使用模板对彩色图邻域进行运算
* 参数: imageBuf为目标图像 w、h为图像大小
* templt为模板 tw为邻域大小
* x,y为要取得像素的坐标
* cn为颜色分量编号 0为蓝色 1为绿色 2为红色
**************************************************/
int TempltExcuteCl(BYTE** imageBuf0, int w, int h, int* templt, int tw, int x, int y, int cn)
int i,j; //循环变量
int m=0; //用来存放加权和
//依次对邻域中每个像素进行运算
for(i=0; i& i++)
for(j=0; j& j++)
//计算对应模板上位置的像素在原图像中的位置
py=y-tw/2+i;
px=x-tw/2+j;
//加权求和
m+=imageBuf0[py][px*4+cn] * templt[i*tw+j];
//返回结果
/*****************************************************************
* 功能: 使用模板对灰度图邻域进行运算
* 参数: imageBuf为目标图像 w、h为图像大小
* templt为模板 tw为邻域大小
* x,y为要取得像素的坐标
******************************************************************/
int TempltExcuteAsh(BYTE** imageBuf0, int w, int h,
int* templt, int tw, int x, int y)
int i,j; //循环变量
int m=0; //用来存放加权和
//依次对邻域中每个像素进行运算
for(i=0; i& i++)
for(j=0; j& j++)
//计算对应模板上位置的像素在原图像中的位置
py=y-tw/2+i;
px=x-tw/2+j;
//加权求和
m+=GetAsh(imageBuf0,px,py) * templt[i*tw+j];
//返回结果
/******************************************************************
* 功能: 灰度图像的简单平滑处理
* 参数: image0为原图形，image1为平滑结果，
* w、h为图象的宽和高
* size为进行平滑的邻域边长
******************************************************************/
void SmoothAsh(BYTE* image0, BYTE* image1,
unsigned int w, unsigned int h, unsigned int size)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//定义模板
//根据邻域大小设定模板
templt = new int[size * size];
for(x=0; x&size* x++)
templt[x]=1;
//设定衰减因子
scale = size*
//依次对原图像的每个像素进行处理
for(y=size/2; y&h-size/2; y++)
for(x=size/2; x&w-size/2; x++)
a=TempltExcuteAsh(imageBuf0,w,h,templt,size,x,y);
//过限处理
a = a&255?255:a;
a = a&0?0:a;
SetPixelXY(imageBuf1,x,y,a);
//清理内存
free(imageBuf0);
free(imageBuf1);
/******************************************************************
* 功能: 彩色图像的简单平滑处理
* 参数: image0为原图形，image1平滑结果，
* w、h为图象的宽和高
* size为进行平滑的邻域边长
******************************************************************/
void SmoothCl(BYTE* image0, BYTE* image1,
unsigned int w, unsigned int h, unsigned int size)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//定义模板
int x,y,c;
//根据邻域大小设定模板
templt = new int[size * size];
for(x=0; x&size* x++)
templt[x]=1;
//设定衰减因子
scale = size*
//依次对原图像的每个像素进行处理
for(y=size/2; y&h-size/2; y++)
for(x=size/2; x&w-size/2; x++)
//依次对彩色图像的三个分量灰度进行处理
for(c=0; c&3; c++)
a=TempltExcuteCl(imageBuf0,w,h,templt,size,x,y,c);
//过限处理
a = a&255?255:a;
a = a&0?0:a;
imageBuf1[y][x*4+c]=a;
//清理内存
free(imageBuf0);
free(imageBuf1);
/******************************************************************
* 功能: 彩色图像的高斯平滑处理
* 参数: image0为原图形，image1平滑结果，
* w、h为图像的宽和高
******************************************************************/
void SmoothGaussCl(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//设定模板
int templt[9]={1,2,1,2,4,2,1,2,1};
int x,y,c;
//设定衰减因子
scale = 16;
//依次对原图像的每个像素进行处理
for(y=1; y&h-1; y++)
for(x=1; x&w-1; x++)
for(c=0; c&3; c++)
//利用高斯模板对邻域进行处理
a=TempltExcuteCl(imageBuf0,w,h,templt,3,x,y,c);
//过限处理
a = a&255?255:a;
a = a&0?0:a;
imageBuf1[y][x*4+c]=a;
//清理内存
free(imageBuf0);
free(imageBuf1);
/**************************************************
* 功能: 使用模板对灰度图邻域排序取中值
* 参数: imageBuf为目标图像 w、h为图像大小
* templt为模板 tw为邻域大小
* x,y为当前采样窗口中心像素的坐标
**************************************************/
int MedianValueAsh(BYTE** imageBuf0, int w, int h, int* templt, int tw, int x, int y)
int i,j,k;
int px,py,c;
int* //用来保存要排序的数值
//用来保存采样窗口的像素数量
value= new int[tw*tw];
//从采样窗口中取得像素灰度
for(i=0; i& i++)
for(j=0; j& j++)
py=y-tw/2+i;
px=x-tw/2+j;
//如果该像素位于采样窗口中
if(templt[i*tw+j]&0)
//保存像素灰度
value[k]=GetAsh(imageBuf0,px,py);
k++;
//记录保存的像素个数
//对保存的像素灰度数据进行排序
for(i=0; i&count-1; i++)
for(j=i+1; j& j++)
if(value[j]&value[k]) k=j;
c=value[i];
value[i]=value[k];
value[k]=c;
//保存中值
c=value[count/2];
//清理内存
/******************************************************************
* 功能: 灰度图像的中值滤波平滑处理
* 参数: image0为原图形，image1平滑结果，
* w、h为图象的宽和高
* size为进行平滑的邻域边长
******************************************************************/
void SmoothMedianAsh(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h, unsigned int size)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//设定模板
//根据邻域大小设定模板
templt = new int[size * size];
for(x=0; x&size* x++) templt[x]=1;
//设定衰减因子
scale = 1;
//依次对原图像的每个像素进行处理
for(y=size/2; y&h-size/2; y++)
for(x=size/2; x&w-size/2; x++)
//取采样窗口中像素灰度的中值
a=MedianValueAsh(imageBuf0,w,h,templt,size,x,y);
//过限处理
a = a&255?255:a;
a = a&0?0:a;
SetPixelXY(imageBuf1,x,y,a);
//清理内存
free(imageBuf0);
free(imageBuf1);
/**************************************************
* 功能: 使用模板对彩色图邻域排序取中值
* 参数: imageBuf为目标图像 w、h为图像大小
* templt为模板 tw为邻域大小
* x,y为当前采样窗口中心像素的坐标
* cn为颜色分量编号 0为蓝色 1为绿色 2为红色
**************************************************/
int MedianValueCl(BYTE** imageBuf0, int w, int h, int* templt, int tw, int x, int y, int cn)
int i,j,k;
int px,py,c;
int* //用来保存要排序的数值
//用来保存采样窗口的像素数量
value = new int[tw*tw];
//从采样窗口中取得像素灰度
for(i=0; i& i++)
for(j=0; j& j++)
py=y-tw/2+i;
px=x-tw/2+j;
//如果该像素位于采样窗口中
if(templt[i*tw+j]&0)
//保存像素灰度
value[k]=imageBuf0[py][px*4+cn];
k++;
vector&int& nums(tw*tw);
for (int i = 0; i & tw* i++)
nums[i] = value[i];
//对保存的像素灰度数据进行排序
sort(nums.begin(), nums.end());
//保存中值
c=nums[count/2];
//清理内存
/******************************************************************
* 功能: 彩色图像的中值滤波平滑处理
* 参数: image0为原图形，image1平滑结果，
* w、h为图象的宽和高
* size为进行平滑的邻域边长
******************************************************************/
void SmoothMedianCl(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h, unsigned int size)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//设定模板
int x,y,c;
//根据邻域大小设定模板
templt = new int[size * size];
for(x=0; x&size* x++)
templt[x]=1;
//设定衰减因子
scale = 1;
//依次对原图像的每个像素进行处理
for(y=size/2; y&h-size/2; y++)
for(x=size/2; x&w-size/2; x++)
for(c=0; c&3; c++)
//取采样窗口中像素灰度的中值
a=MedianValueCl(imageBuf0,w,h,templt,size,x,y,c);
//过限处理
a = a&255?255:a;
a = a&0?0:a;
imageBuf1[y][x*4+c]=a;
//清理内存
free(imageBuf0);
free(imageBuf1);
/******************************************************************
* 功能: 灰度图像的拉普拉斯锐化处理（scale = 3）
* 参数: image0为原图形，image1锐化结果，
* w、h为图象的宽和高
******************************************************************/
void SharpLaplacianAsh(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//设定模板
int templt[9]={-1,-1,-1,-1,8,-1,-1,-1,-1};
scale = 3;//设定衰减因子
//依次对原图像的每个像素进行处理
for(y=1; y&h-1; y++)
for(x=1; x&w-1; x++)
//利用拉普拉斯模板对邻域进行处理
a=TempltExcuteAsh(imageBuf0,w,h,templt,3,x,y);
//对中心像素进行增强
a=GetAsh(imageBuf0,x,y)+a;
//过限处理
a = a&255?255:a;
a = a&0?0:a;
SetPixelXY(imageBuf1,x,y,a);
//清理内存
free(imageBuf0);
free(imageBuf1);
/******************************************************************
* 功能: 彩色图像的拉普拉斯锐化处理（scale = 3）
* 参数: image0为原图形，image1锐化结果，
* w、h为图象的宽和高
******************************************************************/
void SharpLaplacianCl(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//设定模板
int templt[9]={-1,-1,-1,-1,8,-1,-1,-1,-1};
int x,y,c;
//设定衰减因子
scale = 3;
//依次对原图像的每个像素进行处理
for(y=1; y&h-1; y++)
for(x=1; x&w-1; x++)
for(c=0; c&3; c++)
//利用拉普拉斯模板对邻域进行处理
a=TempltExcuteCl(imageBuf0,w,h,templt,3,x,y,c);
//对中心像素进行增强
a=imageBuf0[y][x*4+c]+a;
//过限处理
a = a&255?255:a;
a = a&0?0:a;
imageBuf1[y][x*4+c]=a;
//清理内存
free(imageBuf0);
free(imageBuf1);
void SetPixel(BYTE* image1, unsigned int n, int a)
image1[n] =
image1[n+1] =
image1[n+2] =
image1[n+3] = 255;
/***********************************************************************
* Sobel边缘检测 （scale=0.5）
* 参数: image0为原图形，image1为边缘检测结果，w、h为图像的宽和高
* 当type为true时，差分结果取水平和垂直方向差分中较大者，否则取平均值
************************************************************************/
void SideSobel(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h, bool type)
int x, y, a, aHr, aHg, aHb, aVr, aVg, aVb, aH, aV;
double scale = 0.5;
//依次处理每个像素
for(y = 1; y & h-1; y++)
for(x = 1; x & w-1; x++)
//计算像素的偏移位置
n = (y*w+x)*4;
//计算红色分量水平灰度差
aHr = abs( (image0[n-w*4-4]+image0[n-4]*2+image0[n+w*4-4])
- (image0[n-w*4+4]+image0[n+4]*2+image0[n+w*4+4]) );
//计算红色分量垂直灰度差
aVr = abs( (image0[n-w*4-4]+image0[n-w*4]*2+image0[n-w*4+4])
- (image0[n+w*4-4]+image0[n+w*4]*2+image0[n+w*4+4]) );
//计算绿色分量水平灰度差
aHg = abs( (image0[n-w*4-4+1]+image0[n-4+1]*2+image0[n+w*4-4+1])
- (image0[n-w*4+4+1]+image0[n+4+1]*2+image0[n+w*4+4+1]) );
//计算绿色分量垂直灰度差
aVg = abs( (image0[n-w*4-4+1]+image0[n-w*4+1]*2+image0[n-w*4+4+1])
- (image0[n+w*4-4+1]+image0[n+w*4+1]*2+image0[n+w*4+4+1]) );
//计算蓝色分量水平灰度差
aHb = abs( (image0[n-w*4-4+2]+image0[n-4+2]*2+image0[n+w*4-4+2])
- (image0[n-w*4+4+2]+image0[n+4+2]*2+image0[n+w*4+4+2]) );
//计算蓝色分量垂直灰度差
aVb = abs( (image0[n-w*4-4+2]+image0[n-w*4+2]*2+image0[n-w*4+4+2])
- (image0[n+w*4-4+2]+image0[n+w*4+2]*2+image0[n+w*4+4+2]) );
//计算水平综合灰度差
aH = aHr + aHg + aHb;
//计算垂直综合灰度差
aV = aVr + aVg + aVb;
//取水平和垂直方向差分中较大者
if(aH & aV) a = aH;
else a = aV;
//取水平和垂直方向差分的平均值
a = (aH + aV)/2;
a = a&255?255:a;
//生成边缘扫描结果
SetPixel(image1,n,a);
/******************************************************************
* 功能: 对图像进行二值化处理
* 参数: image0为原图形，image1为处理的结果图像，
* w、h为图象的宽和高
* K为阈值
******************************************************************/
void ToTwoValue(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h, int K)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//依次对原图像的每个像素进行处理
for(y=0; y&h; y++)
for(x=0; x&w; x++)
//如果当前点已经为单点 则在结果图中用黑色标记
if( GetAsh(imageBuf0,x,y) &=K )
SetPixelXY (imageBuf1,x,y,255 );
//如果当前点不是单点 则在结果图中用白色标记
SetPixelXY(imageBuf1,x,y,0);
//清理内存
free(imageBuf0);
free(imageBuf1);
/******************************************************************
* 功能: 对两副图像进行减法运算
* 参数: image0为原图形，image1为要减去的图像，
* w、h为图象的宽和高
******************************************************************/
void Subtract(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
//依次对原图像的每个像素进行处理
for(y=0; y&h; y++)
for(x=0; x&w; x++)
//取得原图像灰度
a=GetAsh(imageBuf0,x,y);
//进行减法运算
a=a-GetAsh(imageBuf1,x,y);
//过限处理
a = a&255?255:a;
a = a&0?0:a;
SetPixelXY(imageBuf1,x,y,a);
//清理内存
free(imageBuf0);
free(imageBuf1);
/******************************************************************
* 功能: 对两副图像进行加法运算
* 参数: image0为原图形，image1为要减去的图像，
* w、h为图象的宽和高
******************************************************************/
void AshAdd(BYTE* image0, BYTE* image1, unsigned int w, unsigned int h)
//将图像转化为矩阵形式
BYTE** imageBuf0 = CreatImage(image0, w, h);
BYTE** imageBuf1 = CreatImage(image1, w, h);
int x,y,c;
//依次对原图像的每个像素进行处理
for(y=0; y&h; y++)
for(x=0; x&w; x++)
//取得原图像灰度
a=GetAsh(imageBuf0,x,y);
//进行减法运算
a=a+GetAsh(imageBuf1,x,y);
//过限处理
a = a&255?255:a;
a = a&0?0:a;
SetPixelXY(imageBuf1,x,y,a);
//清理内存
free(imageBuf0);
free(imageBuf1);
收录时间:日 11:49:52 来源:高校自动化网 作者:匿名
上一篇： &(&&)
创建分享人
喜欢此文章的还喜欢
Copyright by ；All rights reserved. 联系：QQ：随笔 - 696&
文章 - 8&评论 - 845&trackbacks - 19
基本的二维变换可包括旋转、缩放、扭曲，和平移四种，
&&&&&&&&&&&&&&&&&&&&
而这些几何运算则可以转换为一些基本的矩阵运算：
这几个变换都是线性的，但平移运算不是线性的，不能通过2*2矩阵运算完成。若要将点 (2, 1)在 x 方向将其平移 3 个单位，在 y 方向将其平移 4 个单位。&可通过先使用矩阵乘法再使用矩阵加法来完成此操作。
综合这几种基本运算，数学家们将其统一为一个3*3矩阵，存储形式如下：
由于表示仿射变换的矩阵的第三列总是（0，0，1），在存储矩阵的时候，大多只存成一个2*3的数组。
变换的原点
二维变换的参考点是非常重要的，例如如下旋转的结果就大不相同：
当然，有一种特殊的变换除外。那就是平移变换，无论原点是什么其变换的结果都是没有变化的。
复合变换的矩阵可通过将几个单独的变换矩阵相乘而得到，这就意味着任何仿射变换的序列均可存储于单个的 Matrix 对象中。
需要注意的是，复合变换是有顺序的，一般说来，先旋转、再缩放、然后平移，与先缩放、再旋转、然后平移是不同的。
可以根据一定的运算求出某个矩阵的逆矩阵，这个矩阵可以用来求出新的坐标点在原坐标系的位置。但需要注意的是，并非所有矩阵都是可逆的，可逆矩阵要求是。
微软有一个几何变换的在线预览的页面，可以非常直观的帮助我们理解这些变换，感兴趣的朋友不妨试试。
矩阵运算其实是非常基础的数学知识，在图形学中应用得还是非常广泛的，但大学学的时候往往不知道干嘛用，现在用的时候却又忘了啥原理了。本文这里只是介绍了一些矩阵运算的基本概念，具体详细的内容可以参考下下面的这些参考资料。下一篇文章再简单的介绍一下矩阵变换的实际使用。
参考资料：
阅读(...) 评论()2773人阅读
图片处理（12）
/// &summary&
/// 使用指针扫描图片,返回存放像素值的二维数组(高,宽)
/// &/summary&
/// &param name=&bmp&&预处理图片&/param&
/// &param name=&grizzly&&是否为灰色图片&/param&
/// &returns&返回存放像素值的二维数组(高,宽)&/returns&
public string[,] LeveScan(Bitmap bmp, bool grizzly)
//创建图像
(防止LockBits方法出错,多加了一步)
Bitmap bmNew = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format24bppRgb);
Graphics g = Graphics.FromImage(bmNew);
g.DrawImage(bmp, new Point(0, 0));
g.Dispose();
string[,] temp = new string[bmp.Height, bmp.Width];
//获取图像的BitmapData对像
BitmapData data = bmNew.LockBits(new Rectangle(0, 0, bmNew.Width, bmNew.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
//循环处理
byte* ptr = (byte*)(data.Scan0);
for (int i = 0; i & data.H i++)
for (int j = 0; j & data.W j++)
if (grizzly)
temp[i, j] = ptr[2].ToString(); //红
temp[i, j] = ptr[2].ToString() + &-&; //红
temp[i, j] += ptr[1].ToString() + &-&; //绿
temp[i, j] += ptr[0].ToString();
ptr += data.Stride - data.Width * 3;
bmNew.UnlockBits(data);
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：570452次
积分：6083
积分：6083
排名：第3764名
原创：69篇
转载：125篇
评论：69条
(1)(3)(2)(1)(1)(2)(1)(1)(1)(1)(1)(1)(5)(1)(3)(3)(2)(3)(1)(1)(5)(2)(2)(1)(1)(2)(1)(1)(6)(1)(2)(1)(3)(2)(4)(2)(1)(5)(5)(1)(2)(12)(1)(2)(8)(8)(1)(3)(6)(1)(2)(1)(6)(4)(8)(1)(8)(3)(2)(5)(1)(1)(3)(11)(1)(10)