在qt中怎么实现图像处理_如何用qt实现一个图像处理 - CSDN
精华内容
参与话题
  • Qt可显示基本的图像类型,利用QImage、QPxmap类可以实现图像的显示,并且利用类的方法可以实现图像的基本操作(缩放、旋转)。 1. Qt可显示的图像类型 参考Qt的帮助文档,可支持的类型,即可以直接读取并显示...

    Qt可显示基本的图像类型,利用QImage、QPxmap类可以实现图像的显示,并且利用类中的方法可以实现图像的基本操作(缩放、旋转)。

    1. Qt可显示的图像类型

    参考Qt的帮助文档,可支持的类型,即可以直接读取并显示的格式有BMP、GIF、JPG、JPEG、PNG、TIFF、PBM、PGM、PPM、XBM、XPM。

    2. Qt用如何显示图像

    通常用QLabel显示图像,QLabel类有setPixmap()函数,可以用来显示图像。也可以直接用QPainter画出图像。

    如果图像过大,直接用QLabel显示,将会出现有部分图像显示不出来,这时可以用Scroll Area部件。方法:将QLabel部件放到Scroll Area部件里面,将两个采用栅格布局,当图像超出了QLabel部件大小时,就会产生滑动杆,这样图像就可以都看到了。

    3. 显示的方法

    步骤:先打开一个图像;将图像文件加载进QImage对象中;再用QPixmap对象获得图像;最后用QLabel选择一个QPixmap图像对象显示。

    代码如下:

    复制代码
        QString filename;
        filename=QFileDialog::getOpenFileName(this,
                                              tr("选择图像"),
                                              "",
                                              tr("Images (*.png *.bmp *.jpg *.tif *.GIF )"));
        if(filename.isEmpty())
        {
             return;
        }
        else
        {
            QImage* img=new QImage;
    
            if(! ( img->load(filename) ) ) //加载图像
            {
                QMessageBox::information(this,
                                         tr("打开图像失败"),
                                         tr("打开图像失败!"));
                delete img;
                return;
            }
            ui->label->setPixmap(QPixmap::fromImage(*img));
        }
    复制代码



    注:也可以直接用QPixmap类的对象采用Load函数加载图像。这里说下QImage和QPixmap类的用处:QImage为图像的像素级访问做了优化,QPixmap使用底层平台的绘制系统进行绘制,无法提供像素级别的操作,而QImage则是使用独立于硬件的绘制系统。

    4. 图像缩放

    图像缩放采用scaled函数。函数原型

    QImage QImage::scaled ( const QSize & size,Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationModetransformMode = Qt::FastTransformation ) const

    使用方法如下,还是利用上面的img:

    QImage* imgScaled = new QImage;
    *imgScaled=img->scaled(width,
                           height,
                           Qt::KeepAspectRatio);
    ui->label->setPixmap(QPixmap::fromImage(*imgScaled));

    scaled函数中width和height表示缩放后图像的宽和高,即将原图像缩放到(width,height)大小。

    5. 图像旋转

    图像旋转可以利用QImage类的transformed函数,向transformed函数传入QMatrix对象,QMatrix对象指定了旋转的角度。

    代码如下:

    QImage* imgRatate = new QImage;
    QMatrix matrix;
    matrix.rotate(270);
    *imgRotate = img->transformed(matrix);
    ui->label->setPixmap(QPixmap::fromImage(*imgRotate));

    注意:rotate函数中参数是旋转的角度,旋转是按顺时针方向旋转的,上面顺时针旋转270度,即逆时针旋转90度。

    6. 图像连续缩放
    有了图像缩放的基础,就可以实现图像的连续缩放,可以放置一个横向滑竿(中文解释不标准,就是Horizontal Slider部件 ),滑动滑轮的位置以实现图像连续缩放。

    Horizontal Slider部件指向的值为整型value,即缩放后的图像为

    img->scaled(orignalWidth*value/100,
                             orignalHeight*value/100,
                             Qt::KeepAspectRatio);

    orignalWidth和orignalHeight为原始图像的宽和高。

    注意:在对原始图像进行缩放多少倍数时,在相应的槽函数内只需要调用Horizontal Slider部件对象的setValue函数即可,因为Horizontal Slider部件滑竿指向的值一旦变化就会触发对应的槽函数来对图像进行缩放。

    展开全文
  • 图像处理qt实现

    千次阅读 2015-08-11 09:34:12
    作为图像处理的入门,会文件操作,能顺利得到图像的像素就足够了。... 下面是这段时间,我关于图像处理方面的一些入门算法的实现代码,使用qt实现的,为自己后期实现图像处理(如:图像变形、分割等)做准备,代
    作为图像处理的入门,会文件操作,能顺利得到图像的像素就足够了。但是在这方面做出成就就很难了,因为它涉及了很多算法,要做的出众就要有一定的创新就很难了。像海康这样做安防的,在视频方面做得之所以出众,就是因为他们在图像处理、画面处理方面的算法都有自己的创新。
       下面是这段时间,我关于图像处理方面的一些入门算法的实现代码,使用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. MainWindow::MainWindow(QWidget *parent) :
    14.     QMainWindow(parent),
    15.     ui(new Ui::MainWindow)
    16. {
    17.     ui->setupUi(this);
    18.     QMenu *editMenu=ui->menuBar->addMenu(QObject::tr(\"图片(&P)\"));
    19.     QAction *action_Open=editMenu->addAction(QObject::tr(\"打开图片&O\"));
    20.     QMenu *editMenuMake=ui->menuBar->addMenu(QObject::tr(\"图像几何变换(&M)\"));
    21.     QAction *action_Make1=editMenuMake->addAction(QObject::tr(\"图像平移(&T)\"));
    22.     QAction *action_Make2=editMenuMake->addAction(QObject::tr(\"图像放缩(&S)\"));
    23.     QMenu *editMenuBetter=ui->menuBar->addMenu(QObject::tr(\"图像增强(&B)\"));
    24.     QAction *action_Better1=editMenuBetter->addAction(QObject::tr(\"图像锐化(&E)\"));
    25.     QAction *action_Better2=editMenuBetter->addAction(QObject::tr(\"直方图均衡化(&A)\"));
    26.     QAction *action_Better3=editMenuBetter->addAction(QObject::tr(\"消除噪声(&D)\"));
    27.     QMenu *editMenuTiqu=ui->menuBar->addMenu(QObject::tr(\"提取(&G)\"));
    28.     QAction *action_Gray=editMenuTiqu->addAction(QObject::tr(\"图像灰度化\"));
    29.     QAction *action_Get1=editMenuTiqu->addAction(QObject::tr(\"Sobel算子提取\"));
    30.     action_Open->setCheckable(true);
    31.     action_Make1->setCheckable(true);
    32.     action_Make2->setCheckable(true);
    33.     action_Better1->setCheckable(true);
    34.     action_Better2->setCheckable(true);
    35.     action_Better3->setCheckable(true);
    36.     action_Gray->setCheckable(true);
    37.     action_Get1->setCheckable(true);
    38.     connect(action_Open,SIGNAL(triggered()),this,SLOT(OpenPicture()));
    39.     connect(action_Make1,SIGNAL(triggered()),this,SLOT(SetChangeValue()));
    40.     connect(action_Make2,SIGNAL(triggered()),this,SLOT(SetSouValue()));
    41.     connect(action_Better1,SIGNAL(triggered()),this,SLOT(SetBetterValue()));
    42.     connect(action_Better2,SIGNAL(triggered()),this,SLOT(MakePicAverage()));
    43.     connect(action_Gray,SIGNAL(triggered()),this,SLOT(RgbToGray()));
    44.     connect(action_Get1,SIGNAL(triggered()),this,SLOT(SobelGet()));
    45.     connect(action_Better3,SIGNAL(triggered()),this,SLOT(SelectYanKind()));
    46. }

    47. MainWindow::~MainWindow()
    48. {
    49.     delete ui;
    50. }

    51. //获取要处理的图像并显示出来
    52. void MainWindow::OpenPicture()
    53. {
    54.     fileName=QFileDialog::getOpenFileName( this,tr(\"打开文件\"),\"/usr/local/Trolltech\",
    55.                                                    tr(\"任何文件(*.*)\"\";;文本文件(*.txt)\"\";;XML文件(*.xml)\"\";;Images (*.png *.xpm *.jpg)\"));
    56.     QMovie *move=new QMovie(fileName);
    57.     ui->label->move(50,100);
    58.     ui->label->setMovie(move);
    59.     move->start();
    60. }

    61. //确定图像左右、上下的平移量,并触发平移函数
    62. void MainWindow::SetChangeValue()
    63. {
    64.     dialog=new QDialog(this);
    65.     QLabel *WidthLabel=new QLabel(dialog);
    66.     WidthLabel->move(30,50);
    67.     WidthLabel->setText(tr(\"设置宽度的平移量\"));
    68.     setWidthChange=new QSpinBox(dialog);
    69.     setWidthChange->setMaximum(20);
    70.     setWidthChange->setMinimum(-20);
    71.     setWidthChange->move(180,50);
    72.     QLabel *HeightLabel=new QLabel(dialog);
    73.     HeightLabel->move(30,80);
    74.     HeightLabel->setText(tr(\"设置高度的平移量\"));
    75.     setHeightChange=new QSpinBox(dialog);
    76.     setHeightChange->setMaximum(20);
    77.     setHeightChange->setMinimum(-20);
    78.     setHeightChange->move(180,80);
    79.     QPushButton *button=new QPushButton(dialog);
    80.     button->move(180,120);
    81.     button->setText(tr(\"确定\"));
    82.     dialog->show();
    83.     connect(button,SIGNAL(clicked()),this,SLOT(ShowChangePic()));
    84. }
    85. //平移函数
    86. void MainWindow::ShowChangePic()
    87. {

    88.     image=new QImage(fileName);
    89.     QImage ChangeImage;
    90.     ChangeImage=QImage(image->width(),image->height(),QImage::Format_ARGB32);
    91.     QRgb rgb;
    92.     int width,height;
    93.     int i,j;
    94.     int widthOffset,heightOffset;
    95.     width=image->width();
    96.     height=image->height();
    97.     widthOffset=setWidthChange->value();
    98.     heightOffset=setHeightChange->value();
    99.     for(i=0;i<width;i++)
    100.     {
    101.         for(j=0;j<height;j++)
    102.         {
    103.             rgb=image->pixel(i,j);
    104.             if(ChangeImage.valid(i+widthOffset,j+heightOffset))
    105.             {
    106.                 ChangeImage.setPixel(i+widthOffset,j+heightOffset,rgb);
    107.             }
    108.         }
    109.      }
    110.      ui->label_2->resize(ChangeImage.width(),ChangeImage.height());
    111.      ui->label_2->setPixmap(QPixmap::fromImage(ChangeImage));
    112.      delete image;
    113.      delete dialog;
    114. }

    115. //设置图像伸缩的比例并触发伸缩函数
    116. void MainWindow::SetSouValue()
    117. {
    118.     dialog=new QDialog(this);
    119.     QLabel *WidthLabel=new QLabel(dialog);
    120.     WidthLabel->move(30,50);
    121.     WidthLabel->setText(tr(\"设置宽度的缩放比例\"));
    122.     setWidthBi=new QDoubleSpinBox(dialog);
    123.     setWidthBi->setMaximum(20);
    124.     setWidthBi->setMinimum(0.1);
    125.     setWidthBi->move(180,50);
    126.     QLabel *HeightLabel=new QLabel(dialog);
    127.     HeightLabel->move(30,80);
    128.     HeightLabel->setText(tr(\"设置高度的缩放比例\"));
    129.     setHeightBi=new QDoubleSpinBox(dialog);
    130.     setHeightBi->setMaximum(20);
    131.     setHeightBi->setMinimum(0.1);
    132.     setHeightBi->move(180,80);
    133.     QPushButton *button=new QPushButton(dialog);
    134.     button->move(180,120);
    135.     button->setText(tr(\"确定\"));
    136.     dialog->show();
    137.     connect(button,SIGNAL(clicked()),this,SLOT(ShowSouPic()));
    138. }
    139. //伸缩函数
    140. void MainWindow::ShowSouPic()
    141. {
    142.     int width,height;
    143.     image=new QImage(fileName);
    144.     width=image->width();
    145.     height=image->height();
    146.     double x,y,r1,r2,g1,g2,b1,b2;
    147.     int i,j;
    148.     double width_bi,height_bi;
    149.     QRgb rgb00,rgb01,rgb10,rgb11;
    150.     int r,g,b;
    151.     QImage SouImage;
    152.     width_bi=setWidthBi->value();
    153.     height_bi=setHeightBi->value();
    154.     SouImage=QImage(width*width_bi,height*height_bi,QImage::Format_ARGB32);
    155.     for(i=0;i<width*width_bi;i++)
    156.     {
    157.         for(j=0;j<height*height_bi;j++)
    158.         {
    159.             x=i*(1/width_bi);
    160.             y=j*(1/height_bi);

    161.             //边界采用单线性插值
    162.             if(ceil(x)==0&&ceil(y)!=0)
    163.             {
    164.                 rgb00=image->pixel(0,ceil(y)-1);
    165.                 rgb01=image->pixel(0,ceil(y));
    166.                 r=(ceil(y)-y)*qRed(rgb00)+(y-(ceil(y)-1))*qRed(rgb01);
    167.                 g=(ceil(y)-y)*qGreen(rgb00)+(y-(ceil(y)-1))*qGreen(rgb01);
    168.                 b=(ceil(y)-y)*qBlue(rgb00)+(y-(ceil(y)-1))*qBlue(rgb01);
    169.                 SouImage.setPixel(i,j,qRgb(r,g,b));
    170.             }

    171.             if(ceil(y)==0&&ceil(y)!=0)
    172.             {
    173.                 rgb00=image->pixel(ceil(x)-1,0);
    174.                 rgb10=image->pixel(ceil(x),0);
    175.                 r=(ceil(x)-x)*qRed(rgb00)+(x-(ceil(x)-1))*qRed(rgb10);
    176.                 g=(ceil(x)-x)*qGreen(rgb00)+(x-(ceil(x)-1))*qGreen(rgb10);
    177.                 b=(ceil(x)-x)*qBlue(rgb00)+(x-(ceil(x)-1))*qBlue(rgb10);
    178.                 SouImage.setPixel(i,j,qRgb(r,g,b));
    179.             }

    180.             //(0,0)点特殊处理
    181.             if(ceil(y)==0&&ceil(y)==0)
    182.             {
    183.                 rgb00=image->pixel(0,0);
    184.                 SouImage.setPixel(i,j,rgb00);
    185.             }

    186.             //非边界采用双线性插值
    187.             if(ceil(x)!=0&&ceil(y)!=0)
    188.             {
    189.                 rgb00=image->pixel(ceil(x)-1,ceil(y)-1);
    190.                 rgb01=image->pixel(ceil(x)-1,ceil(y));
    191.                 rgb10=image->pixel(ceil(x),ceil(y)-1);
    192.                 rgb11=image->pixel(ceil(x),ceil(y));

    193.                 r1=(ceil(x)-x)*qRed(rgb00)+(x-(ceil(x)-1))*qRed(rgb10);
    194.                 r2=(ceil(x)-x)*qRed(rgb01)+(x-(ceil(x)-1))*qRed(rgb11);
    195.                 r=(int)((ceil(y)-y)*r1+(y-(ceil(y)-1))*r2);

    196.                 g1=(ceil(x)-x)*qGreen(rgb00)+(x-(ceil(x)-1))*qGreen(rgb10);
    197.                 g2=(ceil(x)-x)*qGreen(rgb01)+(x-(ceil(x)-1))*qGreen(rgb11);
    198.                 g=(int)((ceil(y)-y)*g1+(y-(ceil(y)-1))*g2);

    199.                 b1=(ceil(x)-x)*qBlue(rgb00)+(x-(ceil(x)-1))*qBlue(rgb10);
    200.                 b2=(ceil(x)-x)*qBlue(rgb01)+(x-(ceil(x)-1))*qBlue(rgb11);
    201.                 b=(int)((ceil(y)-y)*b1+(y-(ceil(y)-1))*b2);

    202.                 SouImage.setPixel(i,j,qRgb(r,g,b));
    203.             }
    204.         }
    205.     }
    206.     ui->label_2->resize(SouImage.width(),SouImage.height());
    207.     ui->label_2->setPixmap(QPixmap::fromImage(SouImage));
    208.     delete image;
    209.     delete dialog;
    210. }

    211. //设置图像锐化的阈值并触发图像锐化函数
    212. void MainWindow::SetBetterValue()
    213. {
    214.     dialog=new QDialog(this);
    215.     QLabel *WidthLabel=new QLabel(dialog);
    216.     WidthLabel->move(30,50);
    217.     WidthLabel->setText(tr(\"设置锐化的阈值\"));
    218.     setBetterValue=new QSpinBox(dialog);
    219.     setBetterValue->setMaximum(100);
    220.     setBetterValue->setMinimum(10);
    221.     setBetterValue->move(180,50);
    222.     QPushButton *button=new QPushButton(dialog);
    223.     button->move(180,70);
    224.     button->setText(tr(\"确定\"));
    225.     dialog->show();
    226.     connect(button,SIGNAL(clicked()),this,SLOT(MakePicBetter()));
    227. }
    228. //图像锐化
    229. void MainWindow::MakePicBetter()
    230. {
    231.     image=new QImage(fileName);
    232.     QImage ImageBetter;
    233.     ImageBetter=QImage(image->width(),image->height(),QImage::Format_ARGB32);
    234.     int i,j;
    235.     int r,g,b,tmpR,tmpG,tmpB;
    236.     QRgb rgb00,rgb01,rgb10;
    237.     int width=image->width(),height=image->height();
    238.     int betterValue=setBetterValue->value();
    239.     for(i=0;i<width;i++)
    240.     {
    241.         for(j=0;j<height;j++)
    242.         {
    243.             if(image->valid(i,j)&&image->valid(i+1,j)&&image->valid(i,j+1))
    244.             {
    245.                 rgb00=image->pixel(i,j);
    246.                 rgb01=image->pixel(i,j+1);
    247.                 rgb10=image->pixel(i+1,j);
    248.                 r=qRed(rgb00);
    249.                 g=qGreen(rgb00);
    250.                 b=qBlue(rgb00);
    251.                 tmpR=abs(qRed(rgb00)-qRed(rgb01))+abs(qRed(rgb00)-qRed(rgb10));
    252.                 tmpG=abs(qGreen(rgb00)-qGreen(rgb01))+abs(qGreen(rgb00)-qGreen(rgb10));
    253.                 tmpB=abs(qBlue(rgb00)-qBlue(rgb01))+abs(qBlue(rgb00)-qBlue(rgb10));
    254.                 if((tmpR+120)<255)
    255.                 {
    256.                     if(tmpR>betterValue)
    257.                     {
    258.                         r=tmpR+120;
    259.                     }
    260.                 }
    261.                 else
    262.                 {
    263.                     r=255;
    264.                 }

    265.                 if((tmpG+120)<255)
    266.                 {
    267.                     if(tmpG>betterValue)
    268.                     {
    269.                         g=tmpG+120;
    270.                     }
    271.                 }
    272.                 else
    273.                 {
    274.                     g=255;
    275.                 }

    276.                 if((tmpB+120)<255)
    277.                 {
    278.                     if(tmpB>betterValue)
    279.                     {
    280.                         b=tmpB+120;
    281.                     }
    282.                 }
    283.                 else
    284.                 {
    285.                     b=255;
    286.                 }
    287.                 ImageBetter.setPixel(i,j,qRgb(r,g,b));
    288.         }
    289.         }
    290.     }
    291.     ui->label_2->resize(ImageBetter.width(),ImageBetter.height());
    292.     ui->label_2->setPixmap(QPixmap::fromImage(ImageBetter));
    293.     delete image;
    294.     delete dialog;
    295. }
    296. //图像的直方图均衡化
    297. void MainWindow::MakePicAverage()
    298. {
    299.     image=new QImage(fileName);
    300.     QImage ImageAverage;
    301.     ImageAverage=QImage(image->width(),image->height(),QImage::Format_ARGB32);
    302.     int i,j;
    303.     int width,height;
    304.     width=image->width();
    305.     height=image->height();
    306.     QRgb rgb;
    307.     int r[256],g[256],b[256];//原图各个灰度数量的统计
    308.     int rtmp,gtmp,btmp,rj,gj,bj;
    309.     float rPro[256],gPro[256],bPro[256];//原图各个灰度级的概率
    310.     float rTemp[256],gTemp[256],bTemp[256];//均衡化后各个灰度级的概率
    311.     int rJun[256],gJun[256],bJun[256];//均衡化后对应像素的值
    312.     memset(r,0,sizeof(r));
    313.     memset(g,0,sizeof(g));
    314.     memset(b,0,sizeof(b));

    315.     //获取原图各个灰度的数量
    316.     for(i=0;i<width;i++)
    317.     {
    318.         for(j=0;j<height;j++)
    319.         {
    320.             rgb=image->pixel(i,j);
    321.             r[qRed(rgb)]++;
    322.             g[qGreen(rgb)]++;
    323.             b[qBlue(rgb)]++;
    324.         }
    325.     }

    326.     //获取原图各个灰度级的概率
    327.     for(i=0;i<256;i++)
    328.     {
    329.         rPro[i]=(r[i]*1.0)/(width*height);
    330.         gPro[i]=(g[i]*1.0)/(width*height);
    331.         bPro[i]=(b[i]*1.0)/(width*height);
    332.     }

    333.     //均衡化后各个灰度级的概率,同时获取均衡化后对应像素的值
    334.     for(i=0;i<256;i++)
    335.     {
    336.         if(i==0)
    337.         {
    338.             rTemp[0]=rPro[0];
    339.             gTemp[0]=gPro[0];
    340.             bTemp[0]=bPro[0];
    341.         }
    342.         else
    343.         {
    344.             rTemp[i]=rTemp[i-1]+rPro[i];
    345.             gTemp[i]=gTemp[i-1]+gPro[i];
    346.             bTemp[i]=bTemp[i-1]+bPro[i];
    347.         }
    348.         rJun[i]=(int)(255*rTemp[i]+0.5);
    349.         gJun[i]=(int)(255*gTemp[i]+0.5);
    350.         bJun[i]=(int)(255*bTemp[i]+0.5);
    351.     }

    352.     for(i=0;i<width;i++)
    353.     {
    354.         for(j=0;j<height;j++)
    355.         {
    356.             rgb=image->pixel(i,j);
    357.             rtmp=qRed(rgb);
    358.             gtmp=qGreen(rgb);
    359.             btmp=qBlue(rgb);
    360.             rj=rJun[rtmp];
    361.             gj=gJun[gtmp];
    362.             bj=bJun[btmp];
    363.             ImageAverage.setPixel(i,j,qRgb(rj,gj,bj));
    364.         }
    365.     }
    366.     ui->label_2->resize(ImageAverage.width(),ImageAverage.height());
    367.     ui->label_2->setPixmap(QPixmap::fromImage(ImageAverage));
    368.     delete image;
    369. }

    370. //Sobel算子提取图像边界
    371. void MainWindow::SobelGet()
    372. {
    373.     image=new QImage(fileName);
    374.     QImage SobelIma;
    375.     SobelIma=QImage(image->width(),image->height(),QImage::Format_ARGB32);
    376.     Template(SobelIma);
    377.     ui->label_2->resize(SobelIma.width(),SobelIma.height());
    378.     ui->label_2->setPixmap(QPixmap::fromImage(SobelIma));
    379. }
    380. //与算子进行卷积的函数
    381. void MainWindow::Template(QImage &SobelImage)
    382. {
    383.     int width=image->width(),height=image->height();
    384.     int pixelNum=width*height;
    385.     int i,j,k,l;
    386.     float rResult,gResult,bResult;
    387.     float sobel1[9]={1,2,1,0,0,0,-1,-2,-1},sobel2[9]={1,0,-1,2,0,-2,1,0,-1};
    388.     QRgb pixelOld[pixelNum],pixelTemp1[pixelNum],pixelTemp2[pixelNum];
    389.     int rtmp,gtmp,btmp;
    390.     memset(pixelTemp1,255,pixelNum);
    391.     memset(pixelTemp2,255,pixelNum);
    392.     QRgb tmpRgb;
    393.     for(j=0;j<height;j++)
    394.     {
    395.         for(i=0;i<width;i++)
    396.         {
    397.             tmpRgb=image->pixel(i,j);
    398.             pixelOld[j*width+i]=tmpRgb;
    399.         }
    400.     }
    401.     for(j=1;j<height-1;j++)
    402.     {
    403.         for(i=1;i<width-1;i++)
    404.         {
    405.             rResult=0;
    406.             gResult=0;
    407.             bResult=0;
    408.             for(k=0;k<3;k++)
    409.             {
    410.                 for(l=0;l<3;l++)
    411.                 {
    412.                     rResult+=qRed(pixelOld[(j-1+k)*width+(i-1+l)])*sobel1[k*3+l];
    413.                     gResult+=qGreen(pixelOld[(j-1+k)*width+(i-1+l)])*sobel1[k*3+l];
    414.                     bResult+=qBlue(pixelOld[(j-1+k)*width+(i-1+l)])*sobel1[k*3+l];
    415.                 }
    416.             }
    417.             rResult=(float)fabs(rResult);
    418.             gResult=(float)fabs(gResult);
    419.             bResult=(float)fabs(bResult);
    420.             if(rResult>255)
    421.             {
    422.                 rtmp=255;
    423.             }
    424.             else
    425.                 rtmp=(int)(rResult+0.5);
    426.             if(gResult>255)
    427.                 gtmp=255;
    428.             else
    429.                 gtmp=(int)(gResult+0.5);
    430.             if(bResult>255)
    431.                 btmp=255;
    432.             else
    433.                 btmp=(int)(bResult+0.5);
    434.             pixelTemp1[j*width+i]=qRgb(rtmp,gtmp,btmp);
    435.         }
    436.     }

    437.     for(j=1;j<height-1;j++)
    438.     {
    439.         for(i=1;i<width-1;i++)
    440.         {
    441.             rResult=0;
    442.             gResult=0;
    443.             bResult=0;
    444.             for(k=0;k<3;k++)
    445.             {
    446.                 for(l=0;l<3;l++)
    447.                 {
    448.                     rResult+=qRed(pixelOld[(j-1+k)*width+(i-1+l)])*sobel2[k*3+l];
    449.                     gResult+=qGreen(pixelOld[(j-1+k)*width+(i-1+l)])*sobel2[k*3+l];
    450.                     bResult+=qBlue(pixelOld[(j-1+k)*width+(i-1+l)])*sobel2[k*3+l];
    451.                 }
    452.             }
    453.             rResult=(float)fabs(rResult);
    454.             gResult=(float)fabs(gResult);
    455.             bResult=(float)fabs(bResult);
    456.             if(rResult>255)
    457.                 rtmp=255;
    458.             else
    459.                 rtmp=(int)(rResult+0.5);
    460.             if(gResult>255)
    461.                 gtmp=255;
    462.             else
    463.                 gtmp=(int)(gResult+0.5);
    464.             if(bResult>255)
    465.                 btmp=255;
    466.             else
    467.                 btmp=(int)(bResult+0.5);
    468.             pixelTemp2[j*width+i]=qRgb(rtmp,gtmp,btmp);
    469.         }
    470.     }

    471.     for(i=0;i<pixelNum;i++)
    472.     {
    473.         if(pixelTemp2[i]>pixelTemp1[i])
    474.             pixelTemp1[i]=pixelTemp2[i];
    475.     }
    476.     for(j=0;j<height;j++)
    477.     {
    478.         for(i=0;i<width;i++)
    479.         {
    480.             SobelImage.setPixel(i,j,pixelTemp1[j*width+i]);
    481.         }
    482.     }
    483.     delete[] pixelTemp1;
    484.     delete[] pixelTemp2;
    485.     delete image;
    486. }

    487. //设置图像平滑的方法
    488. void MainWindow::SelectYanKind()
    489. {
    490.     dialog=new QDialog(this);
    491.     QLabel *Label=new QLabel(dialog);
    492.     Label->move(45,20);
    493.     Label->setText(tr(\"设置图像平滑的方法\"));
    494.     QLabel *DescLabel=new QLabel(dialog);
    495.     DescLabel->move(60,45);
    496.     DescLabel->setText(tr(\" 1--邻域平均法\\n 2--加权平均法\\n 3--选择式掩膜平滑\\n\"));
    497.     setKind=new QSpinBox(dialog);
    498.     setKind->setMaximum(3);
    499.     setKind->setMinimum(1);
    500.     setKind->move(65,100);
    501.     QPushButton *button=new QPushButton(dialog);
    502.     button->move(65,130);
    503.     button->setText(tr(\"确定\"));
    504.     dialog->show();
    505.     connect(button,SIGNAL(clicked()),this,SLOT(DecreseVoice()));
    506. }
    507. //将图像的像素信息存在缓存中,并通过调用图像平滑函数更改缓存中的信息
    508. void MainWindow::DecreseVoice()
    509. {
    510.     image=new QImage(fileName);
    511.     int i,j,k,num;
    512.     int width=image->width(),height=image->height();
    513.     QImage MoreClear;
    514.     MoreClear=QImage(width,height,QImage::Format_ARGB32);
    515.     num=width*height;
    516.     QRgb tmpPixel[num];
    517.     int yanKind=setKind->value();
    518.     for(i=0;i<width;i++)
    519.     {
    520.         for(j=0;j<height;j++)
    521.         {
    522.             k=i*height+j;
    523.             tmpPixel[k]=image->pixel(i,j);
    524.         }
    525.     }
    526.     MoreClearPic(tmpPixel,yanKind,width,height);
    527.     for(i=0;i<width;i++)
    528.     {
    529.         for(j=0;j<height;j++)
    530.         {
    531.             k=i*height+j;
    532.             MoreClear.setPixel(i,j,tmpPixel[k]);
    533.         }
    534.     }
    535.     ui->label_2->resize(width,height);
    536.     ui->label_2->setPixmap(QPixmap::fromImage(MoreClear));
    537.     delete dialog;
    538. }
    539. //,图形平滑函数,它通过调用相应的平滑化函数实现图像的不同平滑化
    540. void MainWindow::MoreClearPic(QRgb *tmpPixel,int yanKind,int width,int height)
    541. {
    542.     int i,j,k;
    543.     int num=width*height;
    544.     int rtmpPixel[num],gtmpPixel[num],btmpPixel[num];
    545.     for(i=0;i<width;i++)
    546.     {
    547.        for(j=0;j<height;j++)
    548.        {
    549.            k=i*height+j;
    550.            rtmpPixel[k]=qRed(tmpPixel[k]);
    551.            gtmpPixel[k]=qGreen(tmpPixel[k]);
    552.            btmpPixel[k]=qBlue(tmpPixel[k]);
    553.        }
    554.     }
    555.     if(yanKind==1)
    556.     {
    557.         YanMo1(rtmpPixel,width,height);
    558.         YanMo1(gtmpPixel,width,height);
    559.         YanMo1(btmpPixel,width,height);
    560.     }
    561.     if(yanKind==2)
    562.     {
    563.         YanMo2(rtmpPixel,width,height);
    564.         YanMo2(gtmpPixel,width,height);
    565.         YanMo2(btmpPixel,width,height);
    566.     }
    567.     /*if(yanKind==3)
    568.     {
    569.         YanMo3(rtmpPixel,width,height);
    570.         YanMo3(gtmpPixel,width,height);
    571.         YanMo3(btmpPixel,width,height);
    572.     }*/
    573.     for(i=1;i<width-1;i++)
    574.     {
    575.         for(j=1;j<height-1;j++)
    576.         {
    577.             k=i*height+j;
    578.             tmpPixel[k]=qRgb(rtmpPixel[k],gtmpPixel[k],btmpPixel[k]);
    579.         }
    580.     }
    581. }
    582. //邻域平均法平滑化函数
    583. void MainWindow::YanMo1(int *tmpPixel, int width, int height)
    584. {
    585.     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};
    586.     int i,j;
    587.     for(i=1;i<width-1;i++)
    588.     {
    589.        for(j=1;j<height-1;j++)
    590.        {
    591.          tmpPixel[i*height+j]=tmpPixel[(i-1)*height+j-1]*Template[0]+tmpPixel[(i-1)*height+j]*Template[1]+
    592.          tmpPixel[(i-1)*height+j+1]*Template[2]+tmpPixel[i*height+j-1]*Template[3]+tmpPixel[i*height+j]*Template[4]
    593.          +tmpPixel[i*height+j+1]*Template[5]+tmpPixel[(i+1)*height+j-1]*Template[6]+tmpPixel[(i+1)*height+j]*Template[7]
    594.          +tmpPixel[(i+1)*height+j+1]*Template[8];
    595.        }
    596.     }
    597. }
    598. //加权平均法平滑化函数
    599. void MainWindow::YanMo2(int *tmpPixel, int width, int height)
    600. {
    601.     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};
    602.     int i,j;
    603.     for(i=1;i<width-1;i++)
    604.     {
    605.        for(j=1;j<height-1;j++)
    606.        {
    607.          tmpPixel[i*height+j]=tmpPixel[(i-1)*height+j-1]*Template[0]+tmpPixel[(i-1)*height+j]*Template[1]+
    608.          tmpPixel[(i-1)*height+j+1]*Template[2]+tmpPixel[i*height+j-1]*Template[3]+tmpPixel[i*height+j]*Template[4]
    609.          +tmpPixel[i*height+j+1]*Template[5]+tmpPixel[(i+1)*height+j-1]*Template[6]+tmpPixel[(i+1)*height+j]*Template[7]
    610.          +tmpPixel[(i+1)*height+j+1]*Template[8];
    611.        }
    612.     }
    613. }
    展开全文
  • 使用Qt实现一个图像处理软件0

    千次阅读 热门讨论 2019-06-05 22:08:08
    为了学习Qt界面编程和图像处理的基础算法,本人使用实现制作了一个简单的图像处理软件,实现了大部分的图像处理的基础算法,这里放出来与大家交流下,欢迎大家不吝指教。 项目源码地址...

    为了学习Qt界面编程和图像处理的基础算法,本人使用实现制作了一个简单的图像处理软件,实现了大部分的图像处理的基础算法,在这里放出来与大家交流下,欢迎大家不吝指教。

    项目源码地址 https://github.com/Aaron-Cai/ImageProcessTool.git

    本文是这个系列的第一篇文章,将首先先介绍一下软件最终的实现效果。软件组合要实现了一下一些基本的图像处理操作,包括:

    1、 二值化(手动二值化,Otsu二值化,和熵二值)

    2、卷积和基于卷积的操作(滤波、边缘提取)

    3、形态学操作(膨胀、腐蚀、开闭运算) 以及基于形态学的其他操作(边缘提取、区域提取、灰度重建等等)

     

    使用的开发环境:

    VS2008 +Qt 4

     

    先贴几张图

    二值化

     

     

    使用索贝尔算子提取边缘

     

    使用形态学操作对二值图像进行骨架提取:

     

    使用形态学操作提取特定区域(红色部分为提取结果)

     

    展开全文
  • QT+opencv的图像处理

    2020-07-30 09:51:19
    使用QT做界面下的采用opencv库编的图像处理软件,对于刚入门视觉学习,图像处理的人应该很有帮助,功能也比较全面,对于图像的基本处理都集成了,也可以根据自己需求添加相应功能;opencv为2.4.9其他版本的话可以...
  • 这是我做的一款图像处理的辅助程序,能够非常方便的实现雾化、刻蚀、晕染效果,方便UI、和图像的设计和处理。关于实现原理和源码请参考我的博客:http://blog.csdn.net/mahabharata_
  • QT+opencv实现简单的图像处理界面

    千次阅读 2017-12-14 09:35:59
    本来实现的功能是比较简单的,但在实现过程遇到不少问题,所以就写下来作为一个小结,也可以供大家参考: 实现的目标窗口如下: 1、其中菜单栏的文件里实现打开测试文件,打开自定义文件,还原图像,清除图像,...

    本来实现的功能是比较简单的,但在实现过程中遇到不少问题,所以就写下来作为一个小结,也可以供大家参考:

    实现的目标窗口如下:


    1、其中菜单栏的文件里实现打开测试文件,打开自定义文件,还原图像,清除图像,退出系统等功能,这些功能的实现可以参考《opencv编程案例》这本书。

    2、在实验过程中由于我所用的版本是QT5.7.1,所以按照书本打的代码中显示中文时出现乱码,对于该问题我参考了以下链接完成:

    http://blog.csdn.net/bitrain/article/details/51942965

    如下即可:


    3、对于菜单栏中各功能的实现:这里举个例子来说,比如我退出系统的objectName为exitSystem,在.h文件中则定义函数名为on_exitSystem_triggered(),再在cpp文件中实现功能即可实现该菜单项功能。

    4、在实验中还遇到一个问题,就是当我在ui 界面设计好后,点击保持后还需要编译一下工程,这样那个ui.h文件才会更新,而且在使用ui调用这些控件比如Label时如果无法自动提示,并且自己输入又提示错误的话,那就重新打开工程,如果还不行的话就重新开机吧,因为这个问题自己也搞了好久。


    展开全文
  • 最近小博甚是堕落,做深度学习好久没有啥进展,哎,人生最苦莫过于程序员啊,今天这篇文章就来和大家一起学学QT吧,下面我用QT实现摄像头的拍照,录像,以及打开视频文件,图像处理等操作 qt主要是用来做...
  • QT5.11,目前没有用opcv的库(估计写到后面就要用了) 介绍 目前实现的功能: smooth Gray Equal Sharpen Edge Detection Median Filter 以上除了灰度和均衡化,其实都是convolution(卷积)操作,因此对于实现不同的...
  • 基于qt与opencv实现常见的图像处理算法,编程语言为C++
  • qt图像处理

    千次阅读 2019-07-14 20:07:39
    文章目录一、菜单二、托盘信息三、托盘hover窗口 上一篇文章讲述了自定义Qt托盘,不过不是使用...文章的最后我也是提供了一个demo的下载链接,那是一个可以完全运行的demo,处理了鼠标hover事件,并模拟出了鼠标离...
  • QT进行图像处理-灰度直方图

    千次阅读 2018-02-05 00:20:27
     最近学习数字图像处理方面的知识,为了加深学习的效果,使用Qt进行处理处理程序的编写,Qt提供了QImage类,该类图像处理的相关函数,简化了编程。由于能了有限,此做记录,以便以后反思。首先进行了图像...
  • 制作一个基于QT的简单图像处理

    千次阅读 多人点赞 2018-04-19 00:29:32
    对于刚接触QT的我来说,其实很陌生,一开始就来输入输出都搞不懂,当明白了qt的原理后,就发现其实qt做起界面来还是挺方面,容易操作的,一下是一次简单的实验,可以改进的地方还是有多,我写的只是一个很基础的操作...
  • VS+QT+OpenCV图像处理输出

    千次阅读 2017-11-01 15:45:36
    使用VS+QT+OpenCV做图像处理的过程,对OpenCV的Mat类型的数据格式一直很头疼CV_8UC4,CV_32F等等格式的输出如果是使用namewindow+imshow的组合进行弹窗输出时确实是没有什么大问题,但是当需要把图片转成...
  • 基于Qt图像处理技术和算法

    万次阅读 多人点赞 2014-11-19 17:09:17
    原文链接: http://developer.nokia.com/community/wiki/Image_editing_techniques_and_algorithms_using_Qt
  • 基于Opencv3和Qt5的图像处理GUI

    千次阅读 2017-04-13 09:24:04
    最近做了一个基于Opencv3和Qt5的图像处理GUI,具有图像预处理、形态学操作、图像滤波、图像分割等四大功能模块. 图像预处理主要包括以下五个部分:  "①灰度化."  "②二值化."  "③对比度和亮度."  "④直方图...
  • QTQT从零入门教程(一):图像处理自编软件

    万次阅读 多人点赞 2018-08-23 12:51:00
    此前接触过OpenCV,学C++也有一段时间了,正好想从零入门学QT,于是思路打开,就做一个图像处理方向的软件。   这次QT自学,一改以往先看书看视频的习惯,构思了软件的大致界面和大体功能后,直接上手。不得不...
  • 采用QT5.0与openCV编程,调用摄像头获取动态图像,并可通过鼠标操作实现图像的颜色操作与轮廓识别,可用于视觉决策。
  • 介绍如何用Qt的Label控件显示OpenCV的Mat类图像
  • Qt实现图像旋转

    千次阅读 2017-05-18 21:13:40
    本节中将针对图像任意角度旋转事件处理介绍,先看一下效果图  30度 60度
1 2 3 4 5 ... 20
收藏数 13,326
精华内容 5,330
关键字:

在qt中怎么实现图像处理