图像处理之qt实现

朴灿烈づ我的快乐病毒、 2022-08-03 15:34 198阅读 0赞

作为图像处理的入门，会文件操作，能顺利得到图像的像素就足够了。但是在这方面做出成就就很难了，因为它涉及了很多算法，要做的出众就要有一定的创新就很难了。像海康这样做安防的，在视频方面做得之所以出众，就是因为他们在图像处理、画面处理方面的算法都有自己的创新。

下面是这段时间，我关于图像处理方面的一些入门算法的实现代码，使用qt实现的，为自己后期实现图像处理（如：图像变形、分割等）做准备，代码分享如下：

点击(此处)折叠或打开

1.  \#include \\"mainwindow.h\\"  
    
2.  \#include \\"ui\_mainwindow.h\\"  
    
3.  \#include <QFileDialog>  
    
4.  \#include <QMovie>  
    
5.  \#include <QRgb>  
    
6.  \#include <math.h>  
    
7.  \#include <QInputDialog>  
    
8.  \#include <QDebug>  
    
9.  \#include <QDialog>  
    
10. \#include <QDoubleSpinBox>  
    
11. \#include <QSpinBox>  
    
12. \#include <QLabel>  
    
13.   
    
14. MainWindow::MainWindow(QWidget \*parent)  :  
    
15.     QMainWindow(parent),  
    
16.     ui(new Ui::MainWindow)  
    
17. \{   
    
18.     ui\->setupUi(this);  
    
19.     QMenu \*editMenu=ui\->menuBar\->addMenu(QObject::tr(\\"图片(&P)\\"));  
    
20.     QAction \*action\_Open=editMenu\->addAction(QObject::tr(\\"打开图片&O\\"));  
    
21.     QMenu \*editMenuMake=ui\->menuBar\->addMenu(QObject::tr(\\"图像几何变换(&M)\\"));  
    
22.     QAction \*action\_Make1=editMenuMake\->addAction(QObject::tr(\\"图像平移(&T)\\"));  
    
23.     QAction \*action\_Make2=editMenuMake\->addAction(QObject::tr(\\"图像放缩(&S)\\"));  
    
24.     QMenu \*editMenuBetter=ui\->menuBar\->addMenu(QObject::tr(\\"图像增强(&B)\\"));  
    
25.     QAction \*action\_Better1=editMenuBetter\->addAction(QObject::tr(\\"图像锐化(&E)\\"));  
    
26.     QAction \*action\_Better2=editMenuBetter\->addAction(QObject::tr(\\"直方图均衡化(&A)\\"));  
    
27.     QAction \*action\_Better3=editMenuBetter\->addAction(QObject::tr(\\"消除噪声(&D)\\"));  
    
28.     QMenu \*editMenuTiqu=ui\->menuBar\->addMenu(QObject::tr(\\"提取(&G)\\"));  
    
29.     QAction \*action\_Gray=editMenuTiqu\->addAction(QObject::tr(\\"图像灰度化\\"));  
    
30.     QAction \*action\_Get1=editMenuTiqu\->addAction(QObject::tr(\\"Sobel算子提取\\"));  
    
31.     action\_Open\->setCheckable(true);  
    
32.     action\_Make1\->setCheckable(true);  
    
33.     action\_Make2\->setCheckable(true);  
    
34.     action\_Better1\->setCheckable(true);  
    
35.     action\_Better2\->setCheckable(true);  
    
36.     action\_Better3\->setCheckable(true);  
    
37.     action\_Gray\->setCheckable(true);  
    
38.     action\_Get1\->setCheckable(true);  
    
39.     connect(action\_Open,SIGNAL(triggered()),this,SLOT(OpenPicture()));  
    
40.     connect(action\_Make1,SIGNAL(triggered()),this,SLOT(SetChangeValue()));  
    
41.     connect(action\_Make2,SIGNAL(triggered()),this,SLOT(SetSouValue()));  
    
42.     connect(action\_Better1,SIGNAL(triggered()),this,SLOT(SetBetterValue()));  
    
43.     connect(action\_Better2,SIGNAL(triggered()),this,SLOT(MakePicAverage()));  
    
44.     connect(action\_Gray,SIGNAL(triggered()),this,SLOT(RgbToGray()));  
    
45.     connect(action\_Get1,SIGNAL(triggered()),this,SLOT(SobelGet()));  
    
46.     connect(action\_Better3,SIGNAL(triggered()),this,SLOT(SelectYanKind()));  
    
47. \}  
    
48.   
    
49. MainWindow::~MainWindow()  
    
50. \{   
    
51.     delete ui;  
    
52. \}  
    
53.   
    
54. //获取要处理的图像并显示出来  
    
55. void MainWindow::OpenPicture()  
    
56. \{   
    
57.     fileName=QFileDialog::getOpenFileName( this,tr(\\"打开文件\\"),\\"/usr/local/Trolltech\\",  
    
58.                                                    tr(\\"任何文件(\*.\*)\\"\\";;文本文件(\*.txt)\\"\\";;XML文件(\*.xml)\\"\\";;Images (\*.png \*.xpm \*.jpg)\\"));  
    
59.     QMovie \*move=new QMovie(fileName);  
    
60.     ui\->label\->move(50,100);  
    
61.     ui\->label\->setMovie(move);  
    
62.     move\->start();  
    
63. \}  
    
64.   
    
65. //确定图像左右、上下的平移量，并触发平移函数  
    
66. void MainWindow::SetChangeValue()  
    
67. \{   
    
68.     dialog=new QDialog(this);  
    
69.     QLabel \*WidthLabel=new QLabel(dialog);  
    
70.     WidthLabel\->move(30,50);  
    
71.     WidthLabel\->setText(tr(\\"设置宽度的平移量\\"));  
    
72.     setWidthChange=new QSpinBox(dialog);  
    
73.     setWidthChange\->setMaximum(20);  
    
74.     setWidthChange\->setMinimum(\-20);  
    
75.     setWidthChange\->move(180,50);  
    
76.     QLabel \*HeightLabel=new QLabel(dialog);  
    
77.     HeightLabel\->move(30,80);  
    
78.     HeightLabel\->setText(tr(\\"设置高度的平移量\\"));  
    
79.     setHeightChange=new QSpinBox(dialog);  
    
80.     setHeightChange\->setMaximum(20);  
    
81.     setHeightChange\->setMinimum(\-20);  
    
82.     setHeightChange\->move(180,80);  
    
83.     QPushButton \*button=new QPushButton(dialog);  
    
84.     button\->move(180,120);  
    
85.     button\->setText(tr(\\"确定\\"));  
    
86.     dialog\->show();  
    
87.     connect(button,SIGNAL(clicked()),this,SLOT(ShowChangePic()));  
    
88. \}  
    
89. //平移函数  
    
90. void MainWindow::ShowChangePic()  
    
91. \{   
    
92.   
    
93.     image=new QImage(fileName);  
    
94.     QImage ChangeImage;  
    
95.     ChangeImage=QImage(image\->width(),image\->height(),QImage::Format\_ARGB32);  
    
96.     QRgb rgb;  
    
97.     int width,height;  
    
98.     int i,j;  
    
99.     int widthOffset,heightOffset;  
    
100.     width=image\->width();  
    
101.     height=image\->height();  
    
102.     widthOffset=setWidthChange\->value();  
    
103.     heightOffset=setHeightChange\->value();  
    
104.     for(i=0;i<width;i\+\+)  
    
105.     \{   
    
106.         for(j=0;j<height;j\+\+)  
    
107.         \{   
    
108.             rgb=image\->pixel(i,j);  
    
109.             if(ChangeImage.valid(i\+widthOffset,j\+heightOffset))  
    
110.             \{   
    
111.                 ChangeImage.setPixel(i\+widthOffset,j\+heightOffset,rgb);  
    
112.             \}  
    
113.         \}  
    
114.      \}  
    
115.      ui\->label\_2\->resize(ChangeImage.width(),ChangeImage.height());  
    
116.      ui\->label\_2\->setPixmap(QPixmap::fromImage(ChangeImage));  
    
117.      delete image;  
    
118.      delete dialog;  
    
119. \}  
    
120.   
    
121. //设置图像伸缩的比例并触发伸缩函数  
    
122. void MainWindow::SetSouValue()  
    
123. \{   
    
124.     dialog=new QDialog(this);  
    
125.     QLabel \*WidthLabel=new QLabel(dialog);  
    
126.     WidthLabel\->move(30,50);  
    
127.     WidthLabel\->setText(tr(\\"设置宽度的缩放比例\\"));  
    
128.     setWidthBi=new QDoubleSpinBox(dialog);  
    
129.     setWidthBi\->setMaximum(20);  
    
130.     setWidthBi\->setMinimum(0.1);  
    
131.     setWidthBi\->move(180,50);  
    
132.     QLabel \*HeightLabel=new QLabel(dialog);  
    
133.     HeightLabel\->move(30,80);  
    
134.     HeightLabel\->setText(tr(\\"设置高度的缩放比例\\"));  
    
135.     setHeightBi=new QDoubleSpinBox(dialog);  
    
136.     setHeightBi\->setMaximum(20);  
    
137.     setHeightBi\->setMinimum(0.1);  
    
138.     setHeightBi\->move(180,80);  
    
139.     QPushButton \*button=new QPushButton(dialog);  
    
140.     button\->move(180,120);  
    
141.     button\->setText(tr(\\"确定\\"));  
    
142.     dialog\->show();  
    
143.     connect(button,SIGNAL(clicked()),this,SLOT(ShowSouPic()));  
    
144. \}  
    
145. //伸缩函数  
    
146. void MainWindow::ShowSouPic()  
    
147. \{   
    
148.     int width,height;  
    
149.     image=new QImage(fileName);  
    
150.     width=image\->width();  
    
151.     height=image\->height();  
    
152.     double x,y,r1,r2,g1,g2,b1,b2;  
    
153.     int i,j;  
    
154.     double width\_bi,height\_bi;  
    
155.     QRgb rgb00,rgb01,rgb10,rgb11;  
    
156.     int r,g,b;  
    
157.     QImage SouImage;  
    
158.     width\_bi=setWidthBi\->value();  
    
159.     height\_bi=setHeightBi\->value();  
    
160.     SouImage=QImage(width\*width\_bi,height\*height\_bi,QImage::Format\_ARGB32);  
    
161.     for(i=0;i<width\*width\_bi;i\+\+)  
    
162.     \{   
    
163.         for(j=0;j<height\*height\_bi;j\+\+)  
    
164.         \{   
    
165.             x=i\*(1/width\_bi);  
    
166.             y=j\*(1/height\_bi);  
    
167.   
    
168.             //边界采用单线性插值  
    
169.             if(ceil(x)==0&&ceil(y)!=0)  
    
170.             \{   
    
171.                 rgb00=image\->pixel(0,ceil(y)\-1);  
    
172.                 rgb01=image\->pixel(0,ceil(y));  
    
173.                 r=(ceil(y)\-y)\*qRed(rgb00)\+(y\-(ceil(y)\-1))\*qRed(rgb01);  
    
174.                 g=(ceil(y)\-y)\*qGreen(rgb00)\+(y\-(ceil(y)\-1))\*qGreen(rgb01);  
    
175.                 b=(ceil(y)\-y)\*qBlue(rgb00)\+(y\-(ceil(y)\-1))\*qBlue(rgb01);  
    
176.                 SouImage.setPixel(i,j,qRgb(r,g,b));  
    
177.             \}  
    
178.   
    
179.             if(ceil(y)==0&&ceil(y)!=0)  
    
180.             \{   
    
181.                 rgb00=image\->pixel(ceil(x)\-1,0);  
    
182.                 rgb10=image\->pixel(ceil(x),0);  
    
183.                 r=(ceil(x)\-x)\*qRed(rgb00)\+(x\-(ceil(x)\-1))\*qRed(rgb10);  
    
184.                 g=(ceil(x)\-x)\*qGreen(rgb00)\+(x\-(ceil(x)\-1))\*qGreen(rgb10);  
    
185.                 b=(ceil(x)\-x)\*qBlue(rgb00)\+(x\-(ceil(x)\-1))\*qBlue(rgb10);  
    
186.                 SouImage.setPixel(i,j,qRgb(r,g,b));  
    
187.             \}  
    
188.   
    
189.             //(0,0)点特殊处理  
    
190.             if(ceil(y)==0&&ceil(y)==0)  
    
191.             \{   
    
192.                 rgb00=image\->pixel(0,0);  
    
193.                 SouImage.setPixel(i,j,rgb00);  
    
194.             \}  
    
195.   
    
196.             //非边界采用双线性插值  
    
197.             if(ceil(x)!=0&&ceil(y)!=0)  
    
198.             \{   
    
199.                 rgb00=image\->pixel(ceil(x)\-1,ceil(y)\-1);  
    
200.                 rgb01=image\->pixel(ceil(x)\-1,ceil(y));  
    
201.                 rgb10=image\->pixel(ceil(x),ceil(y)\-1);  
    
202.                 rgb11=image\->pixel(ceil(x),ceil(y));  
    
203.   
    
204.                 r1=(ceil(x)\-x)\*qRed(rgb00)\+(x\-(ceil(x)\-1))\*qRed(rgb10);  
    
205.                 r2=(ceil(x)\-x)\*qRed(rgb01)\+(x\-(ceil(x)\-1))\*qRed(rgb11);  
    
206.                 r=(int)((ceil(y)\-y)\*r1\+(y\-(ceil(y)\-1))\*r2);  
    
207.   
    
208.                 g1=(ceil(x)\-x)\*qGreen(rgb00)\+(x\-(ceil(x)\-1))\*qGreen(rgb10);  
    
209.                 g2=(ceil(x)\-x)\*qGreen(rgb01)\+(x\-(ceil(x)\-1))\*qGreen(rgb11);  
    
210.                 g=(int)((ceil(y)\-y)\*g1\+(y\-(ceil(y)\-1))\*g2);  
    
211.   
    
212.                 b1=(ceil(x)\-x)\*qBlue(rgb00)\+(x\-(ceil(x)\-1))\*qBlue(rgb10);  
    
213.                 b2=(ceil(x)\-x)\*qBlue(rgb01)\+(x\-(ceil(x)\-1))\*qBlue(rgb11);  
    
214.                 b=(int)((ceil(y)\-y)\*b1\+(y\-(ceil(y)\-1))\*b2);  
    
215.   
    
216.                 SouImage.setPixel(i,j,qRgb(r,g,b));  
    
217.             \}  
    
218.         \}  
    
219.     \}  
    
220.     ui\->label\_2\->resize(SouImage.width(),SouImage.height());  
    
221.     ui\->label\_2\->setPixmap(QPixmap::fromImage(SouImage));  
    
222.     delete image;  
    
223.     delete dialog;  
    
224. \}  
    
225.   
    
226. //设置图像锐化的阈值并触发图像锐化函数  
    
227. void MainWindow::SetBetterValue()  
    
228. \{   
    
229.     dialog=new QDialog(this);  
    
230.     QLabel \*WidthLabel=new QLabel(dialog);  
    
231.     WidthLabel\->move(30,50);  
    
232.     WidthLabel\->setText(tr(\\"设置锐化的阈值\\"));  
    
233.     setBetterValue=new QSpinBox(dialog);  
    
234.     setBetterValue\->setMaximum(100);  
    
235.     setBetterValue\->setMinimum(10);  
    
236.     setBetterValue\->move(180,50);  
    
237.     QPushButton \*button=new QPushButton(dialog);  
    
238.     button\->move(180,70);  
    
239.     button\->setText(tr(\\"确定\\"));  
    
240.     dialog\->show();  
    
241.     connect(button,SIGNAL(clicked()),this,SLOT(MakePicBetter()));  
    
242. \}  
    
243. //图像锐化  
    
244. void MainWindow::MakePicBetter()  
    
245. \{   
    
246.     image=new QImage(fileName);  
    
247.     QImage ImageBetter;  
    
248.     ImageBetter=QImage(image\->width(),image\->height(),QImage::Format\_ARGB32);  
    
249.     int i,j;  
    
250.     int r,g,b,tmpR,tmpG,tmpB;  
    
251.     QRgb rgb00,rgb01,rgb10;  
    
252.     int width=image\->width(),height=image\->height();  
    
253.     int betterValue=setBetterValue\->value();  
    
254.     for(i=0;i<width;i\+\+)  
    
255.     \{   
    
256.         for(j=0;j<height;j\+\+)  
    
257.         \{   
    
258.             if(image\->valid(i,j)&&image\->valid(i\+1,j)&&image\->valid(i,j\+1))  
    
259.             \{   
    
260.                 rgb00=image\->pixel(i,j);  
    
261.                 rgb01=image\->pixel(i,j\+1);  
    
262.                 rgb10=image\->pixel(i\+1,j);  
    
263.                 r=qRed(rgb00);  
    
264.                 g=qGreen(rgb00);  
    
265.                 b=qBlue(rgb00);  
    
266.                 tmpR=abs(qRed(rgb00)\-qRed(rgb01))\+abs(qRed(rgb00)\-qRed(rgb10));  
    
267.                 tmpG=abs(qGreen(rgb00)\-qGreen(rgb01))\+abs(qGreen(rgb00)\-qGreen(rgb10));  
    
268.                 tmpB=abs(qBlue(rgb00)\-qBlue(rgb01))\+abs(qBlue(rgb00)\-qBlue(rgb10));  
    
269.                 if((tmpR\+120)<255)  
    
270.                 \{   
    
271.                     if(tmpR>betterValue)  
    
272.                     \{   
    
273.                         r=tmpR\+120;  
    
274.                     \}  
    
275.                 \}  
    
276.                 else  
    
277.                 \{   
    
278.                     r=255;  
    
279.                 \}  
    
280.   
    
281.                 if((tmpG\+120)<255)  
    
282.                 \{   
    
283.                     if(tmpG>betterValue)  
    
284.                     \{   
    
285.                         g=tmpG\+120;  
    
286.                     \}  
    
287.                 \}  
    
288.                 else  
    
289.                 \{   
    
290.                     g=255;  
    
291.                 \}  
    
292.   
    
293.                 if((tmpB\+120)<255)  
    
294.                 \{   
    
295.                     if(tmpB>betterValue)  
    
296.                     \{   
    
297.                         b=tmpB\+120;  
    
298.                     \}  
    
299.                 \}  
    
300.                 else  
    
301.                 \{   
    
302.                     b=255;  
    
303.                 \}  
    
304.                 ImageBetter.setPixel(i,j,qRgb(r,g,b));  
    
305.         \}  
    
306.         \}  
    
307.     \}  
    
308.     ui\->label\_2\->resize(ImageBetter.width(),ImageBetter.height());  
    
309.     ui\->label\_2\->setPixmap(QPixmap::fromImage(ImageBetter));  
    
310.     delete image;  
    
311.     delete dialog;  
    
312. \}  
    
313. //图像的直方图均衡化  
    
314. void MainWindow::MakePicAverage()  
    
315. \{   
    
316.     image=new QImage(fileName);  
    
317.     QImage ImageAverage;  
    
318.     ImageAverage=QImage(image\->width(),image\->height(),QImage::Format\_ARGB32);  
    
319.     int i,j;  
    
320.     int width,height;  
    
321.     width=image\->width();  
    
322.     height=image\->height();  
    
323.     QRgb rgb;  
    
324.     int r\[256\],g\[256\],b\[256\];//原图各个灰度数量的统计  
    
325.     int rtmp,gtmp,btmp,rj,gj,bj;  
    
326.     float rPro\[256\],gPro\[256\],bPro\[256\];//原图各个灰度级的概率  
    
327.     float rTemp\[256\],gTemp\[256\],bTemp\[256\];//均衡化后各个灰度级的概率  
    
328.     int rJun\[256\],gJun\[256\],bJun\[256\];//均衡化后对应像素的值  
    
329.     memset(r,0,sizeof(r));  
    
330.     memset(g,0,sizeof(g));  
    
331.     memset(b,0,sizeof(b));  
    
332.   
    
333.     //获取原图各个灰度的数量  
    
334.     for(i=0;i<width;i\+\+)  
    
335.     \{   
    
336.         for(j=0;j<height;j\+\+)  
    
337.         \{   
    
338.             rgb=image\->pixel(i,j);  
    
339.             r\[qRed(rgb)\]\+\+;  
    
340.             g\[qGreen(rgb)\]\+\+;  
    
341.             b\[qBlue(rgb)\]\+\+;  
    
342.         \}  
    
343.     \}  
    
344.   
    
345.     //获取原图各个灰度级的概率  
    
346.     for(i=0;i<256;i\+\+)  
    
347.     \{   
    
348.         rPro\[i\]=(r\[i\]\*1.0)/(width\*height);  
    
349.         gPro\[i\]=(g\[i\]\*1.0)/(width\*height);  
    
350.         bPro\[i\]=(b\[i\]\*1.0)/(width\*height);  
    
351.     \}  
    
352.   
    
353.     //均衡化后各个灰度级的概率，同时获取均衡化后对应像素的值  
    
354.     for(i=0;i<256;i\+\+)  
    
355.     \{   
    
356.         if(i==0)  
    
357.         \{   
    
358.             rTemp\[0\]=rPro\[0\];  
    
359.             gTemp\[0\]=gPro\[0\];  
    
360.             bTemp\[0\]=bPro\[0\];  
    
361.         \}  
    
362.         else  
    
363.         \{   
    
364.             rTemp\[i\]=rTemp\[i\-1\]\+rPro\[i\];  
    
365.             gTemp\[i\]=gTemp\[i\-1\]\+gPro\[i\];  
    
366.             bTemp\[i\]=bTemp\[i\-1\]\+bPro\[i\];  
    
367.         \}  
    
368.         rJun\[i\]=(int)(255\*rTemp\[i\]\+0.5);  
    
369.         gJun\[i\]=(int)(255\*gTemp\[i\]\+0.5);  
    
370.         bJun\[i\]=(int)(255\*bTemp\[i\]\+0.5);  
    
371.     \}  
    
372.   
    
373.     for(i=0;i<width;i\+\+)  
    
374.     \{   
    
375.         for(j=0;j<height;j\+\+)  
    
376.         \{   
    
377.             rgb=image\->pixel(i,j);  
    
378.             rtmp=qRed(rgb);  
    
379.             gtmp=qGreen(rgb);  
    
380.             btmp=qBlue(rgb);  
    
381.             rj=rJun\[rtmp\];  
    
382.             gj=gJun\[gtmp\];  
    
383.             bj=bJun\[btmp\];  
    
384.             ImageAverage.setPixel(i,j,qRgb(rj,gj,bj));  
    
385.         \}  
    
386.     \}  
    
387.     ui\->label\_2\->resize(ImageAverage.width(),ImageAverage.height());  
    
388.     ui\->label\_2\->setPixmap(QPixmap::fromImage(ImageAverage));  
    
389.     delete image;  
    
390. \}  
    
391.   
    
392. //Sobel算子提取图像边界  
    
393. void MainWindow::SobelGet()  
    
394. \{   
    
395.     image=new QImage(fileName);  
    
396.     QImage SobelIma;  
    
397.     SobelIma=QImage(image\->width(),image\->height(),QImage::Format\_ARGB32);  
    
398.     Template(SobelIma);  
    
399.     ui\->label\_2\->resize(SobelIma.width(),SobelIma.height());  
    
400.     ui\->label\_2\->setPixmap(QPixmap::fromImage(SobelIma));  
    
401. \}  
    
402. //与算子进行卷积的函数  
    
403. void MainWindow::Template(QImage &SobelImage)  
    
404. \{   
    
405.     int width=image\->width(),height=image\->height();  
    
406.     int pixelNum=width\*height;  
    
407.     int i,j,k,l;  
    
408.     float rResult,gResult,bResult;  
    
409.     float sobel1\[9\]=\{ 1,2,1,0,0,0,\-1,\-2,\-1\},sobel2\[9\]=\{ 1,0,\-1,2,0,\-2,1,0,\-1\};  
    
410.     QRgb pixelOld\[pixelNum\],pixelTemp1\[pixelNum\],pixelTemp2\[pixelNum\];  
    
411.     int rtmp,gtmp,btmp;  
    
412.     memset(pixelTemp1,255,pixelNum);  
    
413.     memset(pixelTemp2,255,pixelNum);  
    
414.     QRgb tmpRgb;  
    
415.     for(j=0;j<height;j\+\+)  
    
416.     \{   
    
417.         for(i=0;i<width;i\+\+)  
    
418.         \{   
    
419.             tmpRgb=image\->pixel(i,j);  
    
420.             pixelOld\[j\*width\+i\]=tmpRgb;  
    
421.         \}  
    
422.     \}  
    
423.     for(j=1;j<height\-1;j\+\+)  
    
424.     \{   
    
425.         for(i=1;i<width\-1;i\+\+)  
    
426.         \{   
    
427.             rResult=0;  
    
428.             gResult=0;  
    
429.             bResult=0;  
    
430.             for(k=0;k<3;k\+\+)  
    
431.             \{   
    
432.                 for(l=0;l<3;l\+\+)  
    
433.                 \{   
    
434.                     rResult\+=qRed(pixelOld\[(j\-1\+k)\*width\+(i\-1\+l)\])\*sobel1\[k\*3\+l\];  
    
435.                     gResult\+=qGreen(pixelOld\[(j\-1\+k)\*width\+(i\-1\+l)\])\*sobel1\[k\*3\+l\];  
    
436.                     bResult\+=qBlue(pixelOld\[(j\-1\+k)\*width\+(i\-1\+l)\])\*sobel1\[k\*3\+l\];  
    
437.                 \}  
    
438.             \}  
    
439.             rResult=(float)fabs(rResult);  
    
440.             gResult=(float)fabs(gResult);  
    
441.             bResult=(float)fabs(bResult);  
    
442.             if(rResult>255)  
    
443.             \{   
    
444.                 rtmp=255;  
    
445.             \}  
    
446.             else  
    
447.                 rtmp=(int)(rResult\+0.5);  
    
448.             if(gResult>255)  
    
449.                 gtmp=255;  
    
450.             else  
    
451.                 gtmp=(int)(gResult\+0.5);  
    
452.             if(bResult>255)  
    
453.                 btmp=255;  
    
454.             else  
    
455.                 btmp=(int)(bResult\+0.5);  
    
456.             pixelTemp1\[j\*width\+i\]=qRgb(rtmp,gtmp,btmp);  
    
457.         \}  
    
458.     \}  
    
459.   
    
460.     for(j=1;j<height\-1;j\+\+)  
    
461.     \{   
    
462.         for(i=1;i<width\-1;i\+\+)  
    
463.         \{   
    
464.             rResult=0;  
    
465.             gResult=0;  
    
466.             bResult=0;  
    
467.             for(k=0;k<3;k\+\+)  
    
468.             \{   
    
469.                 for(l=0;l<3;l\+\+)  
    
470.                 \{   
    
471.                     rResult\+=qRed(pixelOld\[(j\-1\+k)\*width\+(i\-1\+l)\])\*sobel2\[k\*3\+l\];  
    
472.                     gResult\+=qGreen(pixelOld\[(j\-1\+k)\*width\+(i\-1\+l)\])\*sobel2\[k\*3\+l\];  
    
473.                     bResult\+=qBlue(pixelOld\[(j\-1\+k)\*width\+(i\-1\+l)\])\*sobel2\[k\*3\+l\];  
    
474.                 \}  
    
475.             \}  
    
476.             rResult=(float)fabs(rResult);  
    
477.             gResult=(float)fabs(gResult);  
    
478.             bResult=(float)fabs(bResult);  
    
479.             if(rResult>255)  
    
480.                 rtmp=255;  
    
481.             else  
    
482.                 rtmp=(int)(rResult\+0.5);  
    
483.             if(gResult>255)  
    
484.                 gtmp=255;  
    
485.             else  
    
486.                 gtmp=(int)(gResult\+0.5);  
    
487.             if(bResult>255)  
    
488.                 btmp=255;  
    
489.             else  
    
490.                 btmp=(int)(bResult\+0.5);  
    
491.             pixelTemp2\[j\*width\+i\]=qRgb(rtmp,gtmp,btmp);  
    
492.         \}  
    
493.     \}  
    
494.   
    
495.     for(i=0;i<pixelNum;i\+\+)  
    
496.     \{   
    
497.         if(pixelTemp2\[i\]>pixelTemp1\[i\])  
    
498.             pixelTemp1\[i\]=pixelTemp2\[i\];  
    
499.     \}  
    
500.     for(j=0;j<height;j\+\+)  
    
501.     \{   
    
502.         for(i=0;i<width;i\+\+)  
    
503.         \{   
    
504.             SobelImage.setPixel(i,j,pixelTemp1\[j\*width\+i\]);  
    
505.         \}  
    
506.     \}  
    
507.     delete\[\] pixelTemp1;  
    
508.     delete\[\] pixelTemp2;  
    
509.     delete image;  
    
510. \}  
    
511.   
    
512. //设置图像平滑的方法  
    
513. void MainWindow::SelectYanKind()  
    
514. \{   
    
515.     dialog=new QDialog(this);  
    
516.     QLabel \*Label=new QLabel(dialog);  
    
517.     Label\->move(45,20);  
    
518.     Label\->setText(tr(\\"设置图像平滑的方法\\"));  
    
519.     QLabel \*DescLabel=new QLabel(dialog);  
    
520.     DescLabel\->move(60,45);  
    
521.     DescLabel\->setText(tr(\\" 1--邻域平均法\\\\n 2--加权平均法\\\\n 3--选择式掩膜平滑\\\\n\\"));  
    
522.     setKind=new QSpinBox(dialog);  
    
523.     setKind\->setMaximum(3);  
    
524.     setKind\->setMinimum(1);  
    
525.     setKind\->move(65,100);  
    
526.     QPushButton \*button=new QPushButton(dialog);  
    
527.     button\->move(65,130);  
    
528.     button\->setText(tr(\\"确定\\"));  
    
529.     dialog\->show();  
    
530.     connect(button,SIGNAL(clicked()),this,SLOT(DecreseVoice()));  
    
531. \}  
    
532. //将图像的像素信息存在缓存中，并通过调用图像平滑函数更改缓存中的信息  
    
533. void MainWindow::DecreseVoice()  
    
534. \{   
    
535.     image=new QImage(fileName);  
    
536.     int i,j,k,num;  
    
537.     int width=image\->width(),height=image\->height();  
    
538.     QImage MoreClear;  
    
539.     MoreClear=QImage(width,height,QImage::Format\_ARGB32);  
    
540.     num=width\*height;  
    
541.     QRgb tmpPixel\[num\];  
    
542.     int yanKind=setKind\->value();  
    
543.     for(i=0;i<width;i\+\+)  
    
544.     \{   
    
545.         for(j=0;j<height;j\+\+)  
    
546.         \{   
    
547.             k=i\*height\+j;  
    
548.             tmpPixel\[k\]=image\->pixel(i,j);  
    
549.         \}  
    
550.     \}  
    
551.     MoreClearPic(tmpPixel,yanKind,width,height);  
    
552.     for(i=0;i<width;i\+\+)  
    
553.     \{   
    
554.         for(j=0;j<height;j\+\+)  
    
555.         \{   
    
556.             k=i\*height\+j;  
    
557.             MoreClear.setPixel(i,j,tmpPixel\[k\]);  
    
558.         \}  
    
559.     \}  
    
560.     ui\->label\_2\->resize(width,height);  
    
561.     ui\->label\_2\->setPixmap(QPixmap::fromImage(MoreClear));  
    
562.     delete dialog;  
    
563. \}  
    
564. //，图形平滑函数，它通过调用相应的平滑化函数实现图像的不同平滑化  
    
565. void MainWindow::MoreClearPic(QRgb \*tmpPixel,int yanKind,int width,int height)  
    
566. \{   
    
567.     int i,j,k;  
    
568.     int num=width\*height;  
    
569.     int rtmpPixel\[num\],gtmpPixel\[num\],btmpPixel\[num\];  
    
570.     for(i=0;i<width;i\+\+)  
    
571.     \{   
    
572.        for(j=0;j<height;j\+\+)  
    
573.        \{   
    
574.            k=i\*height\+j;  
    
575.            rtmpPixel\[k\]=qRed(tmpPixel\[k\]);  
    
576.            gtmpPixel\[k\]=qGreen(tmpPixel\[k\]);  
    
577.            btmpPixel\[k\]=qBlue(tmpPixel\[k\]);  
    
578.        \}  
    
579.     \}  
    
580.     if(yanKind==1)  
    
581.     \{   
    
582.         YanMo1(rtmpPixel,width,height);  
    
583.         YanMo1(gtmpPixel,width,height);  
    
584.         YanMo1(btmpPixel,width,height);  
    
585.     \}  
    
586.     if(yanKind==2)  
    
587.     \{   
    
588.         YanMo2(rtmpPixel,width,height);  
    
589.         YanMo2(gtmpPixel,width,height);  
    
590.         YanMo2(btmpPixel,width,height);  
    
591.     \}  
    
592.     /\*if(yanKind==3)  
    
593.     \{   
    
594.         YanMo3(rtmpPixel,width,height);  
    
595.         YanMo3(gtmpPixel,width,height);  
    
596.         YanMo3(btmpPixel,width,height);  
    
597.     \}\*/  
    
598.     for(i=1;i<width\-1;i\+\+)  
    
599.     \{   
    
600.         for(j=1;j<height\-1;j\+\+)  
    
601.         \{   
    
602.             k=i\*height\+j;  
    
603.             tmpPixel\[k\]=qRgb(rtmpPixel\[k\],gtmpPixel\[k\],btmpPixel\[k\]);  
    
604.         \}  
    
605.     \}  
    
606. \}  
    
607. //邻域平均法平滑化函数  
    
608. void MainWindow::YanMo1(int \*tmpPixel,  int width,  int height)  
    
609. \{   
    
610.     float Template\[9\]=\{ 1.0/9,1.0/9,1.0/9,1.0/9,1.0/9,1.0/9,1.0/9,1.0/9,1.0/9\};  
    
611.     int i,j;  
    
612.     for(i=1;i<width\-1;i\+\+)  
    
613.     \{   
    
614.        for(j=1;j<height\-1;j\+\+)  
    
615.        \{   
    
616.          tmpPixel\[i\*height\+j\]=tmpPixel\[(i\-1)\*height\+j\-1\]\*Template\[0\]\+tmpPixel\[(i\-1)\*height\+j\]\*Template\[1\]\+  
    
617.          tmpPixel\[(i\-1)\*height\+j\+1\]\*Template\[2\]\+tmpPixel\[i\*height\+j\-1\]\*Template\[3\]\+tmpPixel\[i\*height\+j\]\*Template\[4\]  
    
618.          \+tmpPixel\[i\*height\+j\+1\]\*Template\[5\]\+tmpPixel\[(i\+1)\*height\+j\-1\]\*Template\[6\]\+tmpPixel\[(i\+1)\*height\+j\]\*Template\[7\]  
    
619.          \+tmpPixel\[(i\+1)\*height\+j\+1\]\*Template\[8\];  
    
620.        \}  
    
621.     \}  
    
622. \}  
    
623. //加权平均法平滑化函数  
    
624. void MainWindow::YanMo2(int \*tmpPixel,  int width,  int height)  
    
625. \{   
    
626.     float Template\[9\]=\{ 1.0/16,2.0/16,1.0/16,2.0/16,4.0/16,2.0/16,1.0/16,2.0/16,1.0/16\};  
    
627.     int i,j;  
    
628.     for(i=1;i<width\-1;i\+\+)  
    
629.     \{   
    
630.        for(j=1;j<height\-1;j\+\+)  
    
631.        \{   
    
632.          tmpPixel\[i\*height\+j\]=tmpPixel\[(i\-1)\*height\+j\-1\]\*Template\[0\]\+tmpPixel\[(i\-1)\*height\+j\]\*Template\[1\]\+  
    
633.          tmpPixel\[(i\-1)\*height\+j\+1\]\*Template\[2\]\+tmpPixel\[i\*height\+j\-1\]\*Template\[3\]\+tmpPixel\[i\*height\+j\]\*Template\[4\]  
    
634.          \+tmpPixel\[i\*height\+j\+1\]\*Template\[5\]\+tmpPixel\[(i\+1)\*height\+j\-1\]\*Template\[6\]\+tmpPixel\[(i\+1)\*height\+j\]\*Template\[7\]  
    
635.          \+tmpPixel\[(i\+1)\*height\+j\+1\]\*Template\[8\];  
    
636.        \}  
    
637.     \}  
    
638. \}