C++ Qt数字图像处理作业（无Opencv）

最新推荐文章于 2023-04-01 11:20:44 发布
最新推荐文章于 2023-04-01 11:20:44 发布
阅读量2.6k 收藏 67
点赞数 8
文章标签： opencv qt c++ 图像处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47564581/article/details/120075774
版权

C++ Qt数字图像处理作业（无Opencv）

1.界面

数字图像处理老师不让用opencv来实现直方图均衡化、中值滤波、锐化、边缘检测、直方图阈值分割。各个处理模块有参考csdn上大佬的算法。本着分享的精神，上传上来。代码和结构还有很大的优化空间，希望看客么也能给一些建议。

主界面图片
在这里插入图片描述
每一次图片处理的直方图
在这里插入图片描述
边缘检测效果
在这里插入图片描述

2.代码结构

1.pro配置
在这里插入图片描述
在这里插入图片描述
2.代码
代码结构很简单，有打开图片，直方图的显示公共函数，代码中重复的内容很多，还可以进行优化。

在这里插入图片描述
mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <QtCharts>
QT_CHARTS_USE_NAMESPACE
namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
   QImage *SmoothMedianRGB(QImage* image);
    QImage* SmoothMedianRGB_ShiZi(QImage* image);
    QImage* SmoothMedianRGB5X5(QImage* image);
    QImage* SmoothMedianRGB_7X7(QImage* image);
    QImage * sharpen(QImage * image);
    QImage *border_detection (QImage *image);
    QImage *roberts_border_detection (QImage *image);
    QImage *sober_border_detection (QImage *image);
    QImage *gradesharpen(QImage * image);
    QImage toGray( QImage *image );
    QImage *MakePicAverage(QImage *image);
   int Sort(int a1[],int n);
private slots:
    void on_pushButton_median_filter_clicked();
    void Zhifangtu(QImage grayimage,QString strname);
    void on_pushButton_median_filter_shizi_clicked();

    void on_pushButton_median_filter_ruihua_clicked();

    void on_pushButton_median_filter_2_clicked();

    void on_pushButton_median_filter_7x7_clicked();

    void on_pushButton_histogram_equ_clicked();

    void on_pushButton_median_filter_ruihua_2_clicked();

    void on_pushButton_median_filter_ruihua_3_clicked();


    void on_pushButton_sobel_clicked();

    void on_pushButton_sobel_2_clicked();



private:
    void File_open();                           // 打开
    Ui::MainWindow *ui;
    QString currentPath;                        // 当前图像的路径
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
     ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    connect(ui->action_open, &QAction::triggered, this, &MainWindow::File_open);
    connect(ui->horizontalSlider,SIGNAL(valueChanged(int)),ui->spinBox,SLOT(setValue(int)));
    connect(ui->spinBox,SIGNAL(valueChanged(int)),ui->horizontalSlider,SLOT(setValue(int)));

}
MainWindow::~MainWindow()
{
    delete ui;
}
//*********************************打开图片****************************************
void MainWindow::File_open()
{
    /* 文件选择框 */
    QString path = QFileDialog::getOpenFileName
            (this,"打开文件","C:\\Users\\ming\\Desktop");
    if (!path.isEmpty())                                    // 判断当前路径是否正确
    {
        QImage* img = new QImage();
        if (!(img->load(path))
                )
        {
            QMessageBox::information(this, tr("错误"), tr("打开图像失败"));
            delete img;
            return;
        }
        qDebug() << "打开图片成功";                           // 仅用于检测是否进入if判断
        ui->label->setPixmap(QPixmap::fromImage(*img));
        ui->label->resize(img->size());
        currentPath = path;
        QImage img1;
        img1.load (currentPath);
        Zhifangtu(img1,"直方图 ");
    }
}
//******************************直方图显示****************************************
void MainWindow::Zhifangtu(QImage grayimage, QString strname)
{
    int data[256]{0};
    int yRange = 0;
    int width  = grayimage.width();
    int height = grayimage.height();
    for(int i = 0; i <width; i++)
    {
        for(int j = 0; j < height; j++)
        {
            int index = grayimage.pixelIndex(i, j);
            ++data[index];
        }
    }

    //设置每个“柱”的颜色，值，宽度等
    QBarSet *set = new QBarSet("灰度值 ");
    for (int i=0;i<256;i++) {
       set->append(data[i]);
       if(yRange<data[i]) yRange = data[i];
       set->setColor(QColor::Rgb);
    }
    QBarSeries *series = new QBarSeries();
    series->append(set);
    series->setBarWidth(1.2);

    //QFont fontText("SimHei");
    //fontText.setPixelSize(12);
    //设置横坐标
//    QStringList categories;
//    for(int i=0; i<256; i++)
//        categories.push_back(QString::number(i));
//    QBarCategoryAxis *axisX = new QBarCategoryAxis();
//    axisX->append(categories);
//    axisX->setGridLineColor("transparent");    //参考线颜色透明
//    axisX->setLinePenColor("#5da4f2");         //标尺 线颜色
//    axisX->setLabelsColor("#5da4f2");          //文本颜色
//    axisX->setLabelsFont(fontText);
//    axisX->setTitleText(QStringLiteral("pix value"));
//    axisX->setTitleFont(QFont("宋体"));
//    QBrush brush;
//    brush.setStyle(Qt::SolidPattern);
//    brush.setColor(Qt::red);
//    axisX->setTitleBrush(brush);
    QValueAxis *axisX = new QValueAxis;//数值类型轴（用作Y轴）
    axisX->setLabelFormat("%d");
    axisX->setRange(0,255);

    //设置纵坐标
    QValueAxis *axisY = new QValueAxis;//数值类型轴（用作Y轴）
    axisY->setLabelFormat("%d");
    axisY->setRange(0,yRange);


    //建表
    QChart *chart = new QChart();
    chart->addSeries(series);
    chart->createDefaultAxes();
    chart->setAxisX(axisX);
    chart->setAxisY(axisY);
    chart->setTitle("直方");
    chart->setAnimationOptions(QChart::SeriesAnimations);
    chart->legend()->setVisible(false);

    //表的容器
   ui->chartview = new QChartView();
   ui->chartview->setObjectName(QStringLiteral("widget"));
   ui->chartview->setGeometry(QRect(20, 40, 611, 391));
   ui->chartview->setChart(chart);
   ui->chartview->setRenderHint(QPainter::Antialiasing);
   ui->chartview->setVisible(true);
   ui->chartview->setWindowTitle(strname);

}
//*******************************转为灰度图*****************************************
QImage MainWindow::toGray( QImage *image )
{
    int height = image->height();
    int width = image->width();
    QImage ret(width, height, QImage::Format_Indexed8);
    ret.setColorCount(256);
    for(int i = 0; i < 256; i++)
    {
        ret.setColor(i, qRgb(i, i, i));
    }
    switch(image->format())
    {
    case QImage::Format_Indexed8:
        for(int i = 0; i < height; i ++)
        {
            const uchar *pSrc = (uchar *)image->constScanLine(i);
            uchar *pDest = (uchar *)ret.scanLine(i);
            memcpy(pDest, pSrc, width);
        }
        break;
    case QImage::Format_RGB32:
    case QImage::Format_ARGB32:
    case QImage::Format_ARGB32_Premultiplied:
        for(int i = 0; i < height; i ++)
        {
            const QRgb *pSrc = (QRgb *)image->constScanLine(i);
            uchar *pDest = (uchar *)ret.scanLine(i);

            for( int j = 0; j < width; j ++)
            {
                 pDest[j] = qGray(pSrc[j]);
            }
        }
        break;
    }
    return ret;
}
//************************************锐化**********************************************************
//拉普拉斯
QImage * MainWindow::sharpen(QImage * image)
{
    QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    int kernel [3][3]= {{0,-1,0},
                        {-1,5,-1},
                        {0,-1,0}};
    int kernelSize = 3;
    int sumKernel = 1;
    int r,g,b;
    QColor color;

    for(int x=kernelSize/2; x<newImage->width()-(kernelSize/2); x++){
        for(int y=kernelSize/2; y<newImage->height()-(kernelSize/2); y++){

            r = 0;
            g = 0;
            b = 0;

            for(int i = -kernelSize/2; i<= kernelSize/2; i++){
                for(int j = -kernelSize/2; j<= kernelSize/2; j++){
                    color = QColor(image->pixel(x+i, y+j));
                    r += color.red()*kernel[kernelSize/2+i][kernelSize/2+j];
                    g += color.green()*kernel[kernelSize/2+i][kernelSize/2+j];
                    b += color.blue()*kernel[kernelSize/2+i][kernelSize/2+j];
                }
            }

            r = qBound(0, r/sumKernel, 255);
            g = qBound(0, g/sumKernel, 255);
            b = qBound(0, b/sumKernel, 255);

            newImage->setPixel(x,y, qRgb(r,g,b));
        }
    }

    QImage image2 =  toGray(newImage);
    ui->label_ruihuashow->setPixmap(QPixmap::fromImage(image2));         // 显示图像
    ui->label_ruihuashow->resize(image2.width(), image2.height());
    Zhifangtu(image2,"拉普拉斯锐化直方 ");
    return newImage;
}
void MainWindow::on_pushButton_median_filter_ruihua_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
    sharpen(img1);
    delete img1;
}
//梯度
QImage * MainWindow::gradesharpen(QImage * image)
{
    QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
        QColor color0;
        QColor color1;
        QColor color2;
        int  r = 0;
        int g = 0;
        int b = 0;

        int r1 = 0;
        int g1 = 0;
        int b1 = 0;

        int r2 = 0;
        int g2 = 0;
        int b2 = 0;

        for( int y = 0; y < image->height() - 1; y++)
           {
               for(int x = 0; x < image->width() - 1; x++){

           color0 =   QColor ( image->pixel(x,y));
           color1 =   QColor ( image->pixel(x + 1,y));
           color2 =   QColor ( image->pixel(x,y + 1));

           r = color0.red();
           g = color0.green();
           b = color0.blue();


           r2 = abs(color0.red() - color1.red());
           g2 = abs(color0.green() - color1.green());
           b2 = abs(color0.blue() - color1.blue());

           r1 = abs(color0.red() - color2.red());
           g1= abs(color0.green() - color2.green());
           b1 = abs(color0.blue() - color2.blue());

            r= r+r1+r2;
            g =g+g1+g2;
            b= b+b1+b2;

           newImage->setPixel(x,y,qRgb(r,g,b));
        }
    }

    QImage image2 =  toGray(newImage);
    ui->label_ruihuashow_2->setPixmap(QPixmap::fromImage(image2));         // 显示图像
    ui->label_ruihuashow_2->resize(image2.width(), image2.height());
    Zhifangtu(image2,"梯度锐化直方 ");
    return newImage;
}
void MainWindow::on_pushButton_median_filter_ruihua_2_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
    gradesharpen(img1);
    delete img1;
}
//************************************中值滤波**********************************************************
//中值滤波排序
int MainWindow::Sort(int a1[],int n)
{
    int k;
    int j;
    int c;
    for (int i = 0;i<n;i++)
    {
        k = i;
        for(j = k +1;j<n;j++)
        {
        if (a1[i]>a1[j])
        {
            c = a1[j];
            a1[j] = a1[i];
            a1[i] = c;
        }
        }
    }
    return a1[n/2];
}
//3x3 窗口中值滤波
void MainWindow::on_pushButton_median_filter_clicked()
{
   QImage *img1 = new QImage;
   img1->load (currentPath);
   SmoothMedianRGB(img1);
   delete img1;
}
QImage *MainWindow::SmoothMedianRGB(QImage* image)
{
    QImage *newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    int kernel [3][3] = {
        {1,1,1},
        {1,1,1},
        {1,1,1}};

//    {1,1,1,1,1},
//     {1,1,1,1,1},
//         {1,1,1,1,1},
//         {1,1,1,1,1},
//         {1,1,1,1,1}};

    int sizeKernel = 3;
    int sizeKernel1= sizeKernel* sizeKernel;
    int sumKernel = 1;
    QColor color;
     for(int x = sizeKernel/2;x<image->width() - sizeKernel/2;x++)
    {
       for(int y= sizeKernel/2;y<image->height() - sizeKernel/2;y++)
        {
           int * rgb1 = new int [sizeKernel1];
           int * rgb2 = new int [sizeKernel1];
           int * rgb3 = new int [sizeKernel1];
           int rgb = 0;
            int r = 0;
            int g = 0;
            int b = 0;
            for(int i = -sizeKernel/2;i<=sizeKernel/2;i++)
            {
               for(int j = -sizeKernel/2;j<=sizeKernel/2;j++)
                {
                 color = QColor(image->pixel(x+i,y+j));
                 rgb1[rgb]=color.red()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb2[rgb]=color.green()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb3[rgb]=color.blue()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb ++;
                 if (rgb == sizeKernel1)
                 {
                     r = Sort(rgb1,sizeKernel1);
                     g = Sort(rgb2,sizeKernel1);
                     b = Sort(rgb3,sizeKernel1);
                 }
                }
            }
            r = qBound(0,r/sumKernel,255);
            g = qBound(0,g/sumKernel,255);
            b = qBound(0,b/sumKernel,255);
            newImage->setPixel(x,y,qRgb( r,g,b));
            delete [] rgb1;
            delete [] rgb2;
            delete [] rgb3;
        }
    }
       QImage image2 =  toGray(newImage);
         ui->label_2->setPixmap(QPixmap::fromImage(image2));         // 显示图像
         ui->label_2->resize(image2.width(), image2.height());
         Zhifangtu(image2,"矩形3X3");
    return newImage;

}
//3x3 十字 中值滤波
void MainWindow::on_pushButton_median_filter_shizi_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
    QImage *newImage =  SmoothMedianRGB_ShiZi(img1);
    QImage image2 =  toGray(newImage);
     ui->label_shizishow->setPixmap(QPixmap::fromImage(image2));         // 显示图像
     ui->label_shizishow->resize(image2.width(), image2.height());
    Zhifangtu(image2,"十字窗口直方");
    delete img1;
}
QImage* MainWindow::SmoothMedianRGB_ShiZi(QImage* image)
{
    QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    int kernel [3][3] = {
    {1,1,1},
    {1,1,1},
    {1,1,1}};
    int sizeKernel = 3;
    int sizeKernel1= 5;
    int sumKernel = 1;
    QColor color;
     for(int x = sizeKernel/2;x<image->width() - sizeKernel/2;x++)
    {
       for(int y= sizeKernel/2;y<image->height() - sizeKernel/2;y++)
        {
           int * rgb1 = new int [sizeKernel1];
           int * rgb2 = new int [sizeKernel1];
           int * rgb3 = new int [sizeKernel1];
           int rgb = 0;
            int r = 0;
            int g = 0;
            int b = 0;
            for(int i = -sizeKernel/2;i<=sizeKernel/2;i++)
            {
             int j=0;
                 color = QColor(image->pixel(x+i,y+j));
                 rgb1[rgb]=color.red()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb2[rgb]=color.green()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb3[rgb]=color.blue()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb ++;
            }
            for(int j = -sizeKernel/2;j<=sizeKernel/2;j++)
            {
             int i=0;
                 color = QColor(image->pixel(x+i,y+j));
                 rgb1[rgb]=color.red()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb2[rgb]=color.green()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb3[rgb]=color.blue()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb ++;
            }

             if (rgb == sizeKernel1+1)
             {
                 r = Sort(rgb1,sizeKernel1);
                 g = Sort(rgb2,sizeKernel1);
                 b = Sort(rgb3,sizeKernel1);
             }


            r = qBound(0,r/sumKernel,255);
            g = qBound(0,g/sumKernel,255);
            b = qBound(0,b/sumKernel,255);
            newImage->setPixel(x,y,qRgb( r,g,b));
            delete [] rgb1;
            delete [] rgb2;
            delete [] rgb3;
      }
  }
    return newImage;

}

//5x5 矩形窗口中值滤波
QImage* MainWindow::SmoothMedianRGB5X5(QImage* image)
{
    QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    int kernel [5][5] = {
//        {1,1,1},
//        {1,1,1},
//        {1,1,1}};

         {1,1,1,1,1},
         {1,1,1,1,1},
         {1,1,1,1,1},
         {1,1,1,1,1},
         {1,1,1,1,1}};

    int sizeKernel = 5;
    int sizeKernel1= sizeKernel* sizeKernel;
    int sumKernel = 1;
    QColor color;
     for(int x = sizeKernel/2;x<image->width() - sizeKernel/2;x++)
    {
       for(int y= sizeKernel/2;y<image->height() - sizeKernel/2;y++)
        {
           int * rgb1 = new int [sizeKernel1];
           int * rgb2 = new int [sizeKernel1];
           int * rgb3 = new int [sizeKernel1];
           int rgb = 0;
            int r = 0;
            int g = 0;
            int b = 0;
            for(int i = -sizeKernel/2;i<=sizeKernel/2;i++)
            {
               for(int j = -sizeKernel/2;j<=sizeKernel/2;j++)
                {
                 color = QColor(image->pixel(x+i,y+j));
                 rgb1[rgb]=color.red()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb2[rgb]=color.green()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb3[rgb]=color.blue()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb ++;
                 if (rgb == sizeKernel1)
                 {
                     r = Sort(rgb1,sizeKernel1);
                     g = Sort(rgb2,sizeKernel1);
                     b = Sort(rgb3,sizeKernel1);
                 }
                }
            }
            r = qBound(0,r/sumKernel,255);
            g = qBound(0,g/sumKernel,255);
            b = qBound(0,b/sumKernel,255);
            newImage->setPixel(x,y,qRgb( r,g,b));
            delete [] rgb1;
            delete [] rgb2;
            delete [] rgb3;
        }
    }


         QImage image2 =  toGray(newImage);
         ui->label_5x5->setPixmap(QPixmap::fromImage(image2));         // 显示图像
         ui->label_5x5->resize(image2.width(), image2.height());
         Zhifangtu(image2,"矩形5X5");
    return newImage;
}
void MainWindow::on_pushButton_median_filter_2_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
    SmoothMedianRGB5X5(img1);
    delete img1;
}
//7x7 矩形窗口中值滤波
QImage* MainWindow::SmoothMedianRGB_7X7(QImage* image)
{
    QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    int kernel [7][7] = {
//        {1,1,1},
//        {1,1,1},
//        {1,1,1}};

         {1,1,1,1,1,1,1},
         {1,1,1,1,1,1,1},
         {1,1,1,1,1,1,1},
         {1,1,1,1,1,1,1},
         {1,1,1,1,1,1,1},
         {1,1,1,1,1,1,1},
         {1,1,1,1,1,1,1}};


    int sizeKernel = 7;
    int sizeKernel1= sizeKernel* sizeKernel;
    int sumKernel = 1;
    QColor color;
     for(int x = sizeKernel/2;x<image->width() - sizeKernel/2;x++)
    {
       for(int y= sizeKernel/2;y<image->height() - sizeKernel/2;y++)
        {
           int * rgb1 = new int [sizeKernel1];
           int * rgb2 = new int [sizeKernel1];
           int * rgb3 = new int [sizeKernel1];
           int rgb = 0;
            int r = 0;
            int g = 0;
            int b = 0;
            for(int i = -sizeKernel/2;i<=sizeKernel/2;i++)
            {
               for(int j = -sizeKernel/2;j<=sizeKernel/2;j++)
                {
                 color = QColor(image->pixel(x+i,y+j));
                 rgb1[rgb]=color.red()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb2[rgb]=color.green()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb3[rgb]=color.blue()*kernel[sizeKernel/2+i][sizeKernel/2+j];
                 rgb ++;
                 if (rgb == sizeKernel1)
                 {
                     r = Sort(rgb1,sizeKernel1);
                     g = Sort(rgb2,sizeKernel1);
                     b = Sort(rgb3,sizeKernel1);
                 }
                }
            }
            r = qBound(0,r/sumKernel,255);
            g = qBound(0,g/sumKernel,255);
            b = qBound(0,b/sumKernel,255);
            newImage->setPixel(x,y,qRgb( r,g,b));
            delete [] rgb1;
            delete [] rgb2;
            delete [] rgb3;
        }
    }

         QImage image2 =  toGray(newImage);
         ui->label_7x7->setPixmap(QPixmap::fromImage(image2));         // 显示图像
         ui->label_7x7->resize(image2.width(), image2.height());
         Zhifangtu(image2,"矩形7X7");
    return newImage;
}
void MainWindow::on_pushButton_median_filter_7x7_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
    SmoothMedianRGB_7X7(img1);
            delete img1;
}
//************************************直方图均衡化*********************************************************
QImage *MainWindow::MakePicAverage(QImage *image)
{
     QImage *ImageAverage= new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    int i,j;
    int width,height;
    width=image->width();
    height=image->height();
    QRgb rgb;
    int r[256],g[256],b[256];//原图各个灰度数量的统计
    int rtmp,gtmp,btmp,rj,gj,bj;
    float rPro[256],gPro[256],bPro[256];//原图各个灰度级的概率
    float rTemp[256],gTemp[256],bTemp[256];//均衡化后各个灰度级的概率
    int rJun[256],gJun[256],bJun[256];//均衡化后对应像素的值
    memset(r,0,sizeof(r));
    memset(g,0,sizeof(g));
    memset(b,0,sizeof(b));

    //获取原图各个灰度的数量
    for(i=0;i<width;i++)
    {
        for(j=0;j<height;j++)
        {
            rgb=image->pixel(i,j);
            r[qRed(rgb)]++;
            g[qGreen(rgb)]++;
            b[qBlue(rgb)]++;
        }
    }

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

    //均衡化后各个灰度级的概率，同时获取均衡化后对应像素的值
    for(i=0;i<256;i++)
    {
        if(i==0)
        {
            rTemp[0]=rPro[0];
            gTemp[0]=gPro[0];
            bTemp[0]=bPro[0];
        }
        else
        {
            rTemp[i]=rTemp[i-1]+rPro[i];
            gTemp[i]=gTemp[i-1]+gPro[i];
            bTemp[i]=bTemp[i-1]+bPro[i];
        }
        rJun[i]=(int)(255*rTemp[i]+0.5);
        gJun[i]=(int)(255*gTemp[i]+0.5);
        bJun[i]=(int)(255*bTemp[i]+0.5);
    }

    for(i=0;i<width;i++)
    {
        for(j=0;j<height;j++)
        {
            rgb=image->pixel(i,j);
            rtmp=qRed(rgb);
            gtmp=qGreen(rgb);
            btmp=qBlue(rgb);
            rj=rJun[rtmp];
            gj=gJun[gtmp];
            bj=bJun[btmp];
            ImageAverage->setPixel(i,j,qRgb(rj,gj,bj));
        }
    }
    QImage image2 =  toGray(ImageAverage);
    ui->label_histogram_equ->resize(image2.width(),image2.height());
    ui->label_histogram_equ->setPixmap(QPixmap::fromImage(image2));
    Zhifangtu(image2,"均衡化后 ");
    return ImageAverage;
}
void MainWindow::on_pushButton_histogram_equ_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
    MakePicAverage(img1);
    delete img1;
}
//************************************边缘检测*********************************************************
//梯度算子边缘检测
QImage *MainWindow::border_detection (QImage *image)
{

    QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    QColor color0;
    QColor color1;
    QColor color2;
    int  r = 0;
    int g = 0;
    int b = 0;
    int rgb = 0;
    int r1 = 0;
    int g1 = 0;
    int b1 = 0;
    int rgb1 = 0;
    int a = 0;
    for( int y = 0; y < image->height() - 1; y++)
    {
        for(int x = 0; x < image->width() - 1; x++)
        {
            color0 =   QColor ( image->pixel(x,y));
            color1 =   QColor ( image->pixel(x + 1,y));
            color2 =   QColor ( image->pixel(x,y + 1));
            r = abs(color0.red() - color1.red());
            g = abs(color0.green() - color1.green());
            b = abs(color0.blue() - color1.blue());
            rgb = r + g + b;

            r1 = abs(color0.red() - color2.red());
            g1= abs(color0.green() - color2.green());
            b1 = abs(color0.blue() - color2.blue());
            rgb1 = r1 + g1 + b1;

            a = rgb + rgb1;
            a = a * 2;
            a = a>255?255:a;

            newImage->setPixel(x,y,qRgb(a,a,a));
        }
    }
    QImage image2 =  toGray(newImage);
    ui->label_ruihuashow_3->setPixmap(QPixmap::fromImage(image2));         // 显示图像
    ui->label_ruihuashow_3->resize(image2.width(), image2.height());
    Zhifangtu(image2,"梯度算子边缘检测直方 ");
    return newImage;

}
void MainWindow::on_pushButton_median_filter_ruihua_3_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
   border_detection(img1);
    delete img1;
}
//Roberts边缘检测
QImage *MainWindow::roberts_border_detection (QImage *image)
{
    QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
    QColor color0;
    QColor color1;
    QColor color2;
    QColor color3;
    int  r = 0;
    int g = 0;
    int b = 0;
    int rgb = 0;
    int r1 = 0;
    int g1 = 0;
    int b1 = 0;
    int rgb1 = 0;
    int a = 0;
    for( int y = 0; y < image->height() - 1; y++)
    {
        for(int x = 0; x < image->width() - 1; x++)
        {
            color0 =   QColor ( image->pixel(x,y));
            color1 =   QColor ( image->pixel(x + 1,y));
            color2 =   QColor ( image->pixel(x,y + 1));
            color3 =   QColor ( image->pixel(x + 1,y + 1));
            r = abs(color0.red() - color3.red());
            g = abs(color0.green() - color3.green());
            b = abs(color0.blue() - color3.blue());
            rgb = r + g + b;

            r1 = abs(color1.red() - color2.red());
            g1= abs(color1.green() - color2.green());
            b1 = abs(color1.blue() - color2.blue());
            rgb1 = r1 + g1 + b1;

            a = rgb + rgb1;
            a = a * 1;
            a = a>255?255:a;

            newImage->setPixel(x,y,qRgb(a,a,a));
        }
    }
    QImage image2 =  toGray(newImage);
    ui->label_ruihuashow_4->setPixmap(QPixmap::fromImage(image2));         // 显示图像
    ui->label_ruihuashow_4->resize(image2.width(), image2.height());
    Zhifangtu(image2,"roberts算子边缘检测直方 ");
    return newImage;
  }
void MainWindow::on_pushButton_sobel_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
    roberts_border_detection(img1);
    delete img1;
}
//soberts边缘检测
QImage * MainWindow::sober_border_detection(QImage *image)
{
QImage* newImage = new QImage(image->width(),image->height(),QImage::Format_ARGB32);
  QColor color0;
  QColor color1;
  QColor color2;
  QColor color3;
  QColor color4;
  QColor color5;
  QColor color6;
  QColor color7;
  QColor color8;
  int  r = 0;
  int g = 0;
  int b = 0;
  int rgb = 0;
  int r1 = 0;
  int g1 = 0;
  int b1 = 0;
  int rgb1 = 0;
  int a = 0;
  for( int y = 1; y < image->height() - 1; y++)
  {
      for(int x = 1; x < image->width() - 1; x++)
      {
          color0 =   QColor ( image->pixel(x,y));

          color1=   QColor ( image->pixel(x-1,y-1));
          color2 =   QColor ( image->pixel(x,y-1));
          color3 =   QColor ( image->pixel(x+1,y));

          color4 =   QColor ( image->pixel(x-1,y));
          color5 =   QColor ( image->pixel(x+1,y));

          color6 =   QColor ( image->pixel(x-1,y+1));
          color7=   QColor ( image->pixel(x,y+1));
          color8 =   QColor ( image->pixel(x+1,y+1));
          r = abs(color1.red() + color2.red() * 2 + color3.red() - color6.red() - color7.red() * 2 - color8.red());
          g = abs(color1.green() + color2.green() * 2 + color3.green() - color6.green() - color7.green() * 2 - color8.green());
          b = abs(color1.blue() + color2.blue() * 2 + color3.blue() - color6.blue() - color7.blue() * 2 - color8.blue());
          rgb = r + g + b;

          r1 = abs(color1.red() + color4.red() * 2 + color6.red() - color3.red() - color5.red() * 2 - color8.red());
          g1= abs(color1.green() + color4.green() * 2 + color6.green() - color3.green() - color5.green() * 2 - color8.green());
          b1 = abs(color1.blue() + color4.blue() * 2 + color6.blue() - color3.blue() - color5.blue() * 2 - color8.blue());
          rgb1 = r1 + g1 + b1;

          a = (rgb + rgb1)/2;

          a = a>255?255:a;

          newImage->setPixel(x,y,qRgb(a,a,a));
      }
  }

  QImage image2 =  toGray(newImage);
  ui->label_ruihuashow_5->setPixmap(QPixmap::fromImage(image2));         // 显示图像
  ui->label_ruihuashow_5->resize(image2.width(), image2.height());
  Zhifangtu(image2,"sober算子边缘检测直方 ");

  return newImage;
  }
void MainWindow::on_pushButton_sobel_2_clicked()
{
    QImage *img1 = new QImage;
    img1->load (currentPath);
   sober_border_detection(img1);
    delete img1;
}
四维碎片
关注
  • 8
    点赞
  • 踩
  • 67
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
数字图像处理-基于Qt 5.8.0(C++)
05-30
数字图像处理——基于Qt 5.8.0(C++) ImageQt Image viewer powered by Qt 5.8.0 功能（按完成时间排序） 基本的图像查看 图像缩放、旋转、翻转 灰度图像 调节色温 调节亮度 添加相框 金属纹理 语言切换（中/英）支持（已删除） 直方图（包括灰度直方图和各通道直方图） 线性灰度变换 函数图像绘制 指数灰度变换 幂次灰度变换 对数灰度变换 拉伸灰度变换 简单平滑 高斯平滑 中值滤波 Laplace锐化 Sobel边缘检测
C++数字图像处理（不用opencv）
tongjingqi_的博客
09-28 4195
转载：https://www.lavenderdh.cn/2020/11/09/%E6%95%B0%E5%AD%97%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86%EF%BC%9ABMP%E5%9B%BE%E5%83%8F%E5%A4%84%E7%90%86%EF%BC%88%E6%8E%A7%E5%88%B6%E5%8F%B0%E7%A8%8B%E5%BA%8F%EF%BC%89/ 本文作者： Lavender @lavender 本文链接： https://www.lavend
图像处理-高斯滤波和升级版Side Window版高斯滤波（C++实现，无需opencv）
风轻云淡的博客
12-20 741
图像处理绕不开的一个环节就是去燥，去掉各式各样的噪声来保证图像的质量。今天将高斯滤波实现了下，在此稍作记录。以往惯例，先上图： 原图： 高斯滤波： Side Window版高斯滤波： 仔细看蓝色的山，和图像右侧下中部的倒影，还是能看出些许增强的，在一些特别注重细节的领域或应用中，可能就会发挥很大的作用。 滤波原理简单的理解就是通过一个模板，去与图像的每一个像素进行卷积，通过...
C++ 视频转换成图片
02-28 3694
#include #include #include "opencv2\highgui\highgui.hpp" using namespace std; using namespace cv; void video2image(string video,string path) { VideoCapture capture(video); if(!capture.isOpened()
C++/MFC工程[5]——绘制矩形与椭圆
舟舟的博客
04-01 4789
本文包含绘制矩形的两种方法、椭圆的绘制以及在绘制中，透明画刷的使用。
基于Qt的图像处理技术和算法
热门推荐
爱冒险的技术宅
11-19 2万+
原文链接： http://developer.nokia.com/community/wiki/Image_editing_techniques_and_algorithms_using_Qt
C++毕业设计项目基于Opencv+QT完成的数字图像处理系统源码（高分项目）.zip
03-24
C++毕业设计项目基于Opencv+QT完成的数字图像处理系统源码（高分项目）.zip本资源中的源码都是经过本地编译过可运行的。资源项目的难度比较适中，内容都是经过助教老师审定过的能够满足学习、使用需求，如果有需要的...
基于OpenCV+QT5开发的数字图像处理系统c++源码.zip
01-14
基于OpenCV+QT5开发的数字图像处理系统c++源码.zip基于OpenCV+QT5开发的数字图像处理系统c++源码.zip基于OpenCV+QT5开发的数字图像处理系统c++源码.zip基于OpenCV+QT5开发的数字图像处理系统c++源码.zip xml：使用到...
ex01_01Qt+OpenCV数字图像处理初步_
09-30
在本项目"ex01_01Qt+OpenCV数字图像处理初步_"中，我们将探讨如何结合Qt框架和OpenCV库进行数字图像处理的初步实践。这个实验是学习这一领域的一个重要起点，它将帮助我们理解这两个强大的工具如何协同工作以实现...
基于C++ QT+OpenCV的数字图像处理大作业源码+使用文档+全部资料（优秀项目）.zip
最新发布
04-19
基于C++ QT+OpenCV的数字图像处理大作业源码+使用文档+全部资料（优秀项目）.zip基于C++ QT+OpenCV的数字图像处理大作业源码+使用文档+全部资料（优秀项目）.zip 【备注】 1、该项目是个人高分毕业设计项目源码，已...
QT与OPENCV进行数字图像处理
06-08
QT与OPENCV进行数字图像处理
Qt编写的数字图像处理软件
08-21
用Qt编写（非OpenCV）纯C++，数字图象处理。含采样，旋转，平移，平滑，锐化 压缩，直方图，反色，窗口，均值，折线等图像处理。
Qt5数字图像处理演示程序
02-27
利用Qt5、Opencv2写的图像处理程序，包含边缘检测（Sobel、Prewitt、Roberts、Canny.LOG等算法）和图像分割算法（结合直方图手动设置阈值、大津法、最大熵、灰度平均法、双峰法、迭代法、最小误差、模糊集合、聚类等分割算法），源代码与可独立运行的exe文件。
基于OpenCV+QT5开发的数字图像处理系统c++源码
10-16
在本项目中，开发者利用了OpenCV库和QT5框架创建了一个数字图像处理系统，主要应用于C++编程环境。OpenCV（开源计算机视觉库）是一个强大的工具，它提供了丰富的图像处理和计算机视觉功能，而QT5则是一个跨平台的GUI...
【Qt】一篇全面的关于Qt对图像数据的操作总结
iriczhao的博客
03-03 1万+
文章目录一、简介二、QImage类（2-1）QImage简介（2-2）使用QImage读取图像文件（2-3）使用QImage进行图像写入（2-4）获取图像信息（2-4-1）获取```Geometry```信息（2-4-2）获取颜色信息（2-4-3）获取文本信息（2-4-4）获取图像底层信息（2-5）操作图像像素（2-6）图像格式三、QPixmap类（3-1）QPixmap简介（3-2）使用QPixmap读取图像文件（3-3）使用QPixmap进行图像数据写入（3-4）获取图像信息（3-4-1）获取Geome
C&C++图形图像处理开源库
墙角里的光线
10-30 2万+
Google三维APIO3D O3D 是一个开源的 WebAPI 用来在浏览器上创建界面丰富的交互式的 3D 应用程序。这是一种基于网页的可控3D标准。此格式期望真正的基于浏览器，独立于操作系统之外，并且支持主流的3D显卡，这样就可以在网页中实现效果逼真的3D动画。 绘图引擎RRDtoo 简单的说，RRDtool (RoundRobin Database Tool)就是一个强大的绘图的引擎，
图像处理5-边缘检测
Qt学视觉
02-21 411
边缘检测 这在实战中经常用到
C++读取图片
weixin_45851904的博客
04-04 915
C++读取图片 以C++风格（文件流）而不是C风格（FILE）读取图片。 补充：也可以使用opencv的cv::imread()函数读取图片，这个函数返回的是cv:Mat类型，在计算机视觉(CV)领域用的比较多。 头文件 使用到的头文件主要是fstream 参考链接 http://www.cplusplus.com/reference/istream/istream/read/ http://ww...
QT不用OPENCV 读取图片并显示
邮箱：feboreigns001@163.com
05-17 462
这是摄像头的一部分程序　如果摄像头没打开给他一张默认图片，从文件目录中获取，也可以从资源文件找那个读取 //默认图片 QImageReader reader("miku4.jpg"); reader.setAutoTransform(true); QImage newImage = reader.read(); image_viewer->SetImage(newImage); ImageViewer　是我自己搞得， image_viewer->SetImage(newImag
基于C++的数字图像处理系统：车牌定位实践与OpenCV应用
"本文主要探讨了利用Qt集成开发环境，结合C++编程语言和OpenCV库，开发一个数字图像处理系统的过程，特别是车牌定位的应用。文章详细阐述了系统设计、需求分析、算法实现以及结果分析，旨在为图像处理研究者提供一个...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值