opencv简单图像处理工具（持续更新）

已于 2024-07-19 22:44:06 修改
阅读量231 收藏 4
点赞数 9
文章标签： opencv 图像处理 c++ 笔记
于 2024-07-19 22:06:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62612279/article/details/140560229
版权

资料

其它实现

页面切换

  • 利用`ui->stackedWidget->setCurrentIndex(0);``实现 欢迎与操作页面转换。
  • 利用stackedWidget的setCurrentWidget()实现最右侧算法执行栏切换

图片导入与保存

导入
void MainWindow::on_act_insert_pic_triggered()
{
    //打开图片文件，选择图片
    QString filename=QFileDialog::getOpenFileName(this,tr("Open Image"),QDir::homePath(),tr("(*.jpg)\n(*.bmp)\n(*.png)"));
    emit SignImagePath(filename);
}
  • work界面
void Work::SlotImagePath(QString path)
{
    if(path.isEmpty()){
            qDebug()<<"图片打开失败";
        return;
    }
    _path = path;
    QPixmap image(_path);
    // 利用opencv打开图片
    _mat = cv::imread(Lib::QStringToString(_path));
    //保存图片的内容用来保存  MatToQImage  mat与QImage转换。
    _exportImage = Lib::MatToQImage(_mat);
    // 显示图片
    ui->label_image->setPixmap(image);

}
图片的保存
void MainWindow::on_act_Export_pic_triggered()
{
    QString currentPath = QCoreApplication::applicationDirPath();
    QString path = QFileDialog::getSaveFileName(nullptr, QStringLiteral("保存文件"), currentPath, QStringLiteral("(*.jpg)\n(*.bmp)\n(*.png)"));
    emit this->SignSaveImagePath(path);
}


void Work::SlotSaveImagePath(QString path)
{
    _exportImage.save(path);
}

cv::Mat与QImage转换

cv::Mat Lib::QImageTocvMat(const QImage& image)
{
    switch(image.format())
    {
    // 8-bit, 4 channel
    case QImage::Format_ARGB32:
        break;
    case QImage::Format_ARGB32_Premultiplied:
    {
        cv::Mat mat(image.height(), image.width(),
                    CV_8UC4,
                    (void*)image.constBits(),
                    image.bytesPerLine());
        return mat.clone();
    }

    // 8-bit, 3 channel
    case QImage::Format_RGB32:
    {
        cv::Mat mat(image.height(),image.width(),
                    CV_8UC4,
                    (void*)image.constBits(),
                    image.bytesPerLine());

        // drop the all-white alpha channel
        cv::cvtColor(mat, mat, cv::COLOR_BGRA2BGR);
        return mat.clone();
    }
    case QImage::Format_RGB888:
    {
        QImage swapped = image.rgbSwapped();
        cv::Mat mat(swapped.height(), swapped.width(),
                    CV_8UC3,
                    (void*)image.constBits(),
                    image.bytesPerLine());
        return mat.clone();
    }

    // 8-bit, 1 channel
    case QImage::Format_Indexed8:
    {
        cv::Mat mat(image.height(),image.width(),
                    CV_8UC1,
                    (void*)image.constBits(),
                    image.bytesPerLine());
        return mat.clone();
    }

    // wrong
    default:
        qDebug() << "ERROR: QImage could not be converted to Mat.";
        break;
    }
    return cv::Mat();
}

QImage Lib::MatToQImage(const cv::Mat& mat)
{
    switch (mat.type())
    {
    // 8-bit, 4 channel
    case CV_8UC4:
    {
        QImage image(mat.data,
                     mat.cols, mat.rows,
                     static_cast<int>(mat.step),
                     QImage::Format_ARGB32);

        return image;
    }

        // 8-bit, 3 channel
    case CV_8UC3:
    {
        QImage image(mat.data,
                     mat.cols, mat.rows,
                     static_cast<int>(mat.step),
                     QImage::Format_RGB888);

        return image.rgbSwapped();
    }

        // 8-bit, 1 channel
    case CV_8UC1:
    {
#if QT_VERSION >= QT_VERSION_CHECK(5, 5, 0)
        QImage image(mat.data,
                     mat.cols, mat.rows,
                     static_cast<int>(mat.step),
                     QImage::Format_Grayscale8);
#else
        static QVector<QRgb>  sColorTable;

        // only create our color table the first time
        if (sColorTable.isEmpty())
        {
            sColorTable.resize( 256 );

            for ( int i = 0; i < 256; ++i )
            {
                sColorTable[i] = qRgb( i, i, i );
            }
        }

        QImage image(mat.data,
                     mat.cols, mat.rows,
                     static_cast<int>(mat.step),
                     QImage::Format_Indexed8 );

        image.setColorTable(sColorTable);
#endif

        return image;
    }

    // wrong
    default:
        qDebug() << "ERROR: Mat could not be converted to QImage.";
        break;
    }
    return QImage();
}

对于基础类的使用

图像变换即图像色彩空间修改

在这里插入图片描述

void Work::on_btn_transform_clicked()
{
    cv::Mat result;
    if(_mat.empty()){
        emit SignImageIsNull();
        return;
    }
    if(ui->RGB2HSV->isChecked()){
        cvtColor(_mat,result,cv::COLOR_RGB2HSV);
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("转换为HSV图像");
    }
    if(ui->BGR2GRAY->isChecked()){
        cvtColor(_mat, result, cv::COLOR_BGR2GRAY);
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("转换为灰度图像");

    }
    QImage image = Lib::MatToQImage(result);
    _exportImage = image;
    ui->label_image->setPixmap(QPixmap::fromImage(image));
}

图像平滑

在这里插入图片描述

	if(_mat.empty()){
        emit SignImageIsNull();
        return;
    }
    cv::Mat dst = cv::Mat(_mat.size(),_mat.type());
    cv::Size size = cv::Size(5,5);
    //选择滤波核
    if(ui->radio_size1->isChecked()){
        size = cv::Size(3,3);
    }
    if(ui->radio_size2->isChecked()){
        size = cv::Size(5,5);
    }
    //选择平滑算法
    //方框
    if(ui->radio_pane->isChecked()){
        cv::boxFilter(_mat,dst , -1, size, cv::Point(-1, -1), 1);
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("方框算法");
    }
    //均值
    if(ui->radio_mean->isChecked()){
        cv::blur(_mat, dst, size, cv::Point(-1, -1));
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("均值算法");
    }
    // 高斯
    if(ui->radio_gauss->isChecked()){
        cv::GaussianBlur(_mat, dst, size, 0);
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("高斯算法");
    }

    QImage image = Lib::MatToQImage(dst);
    _exportImage = image;
    ui->label_image->setPixmap(QPixmap::fromImage(image));

边缘检测

在这里插入图片描述

void Work::on_btn_edge_clicked()
{
    if(_mat.empty()){
        emit SignImageIsNull();
        return;
    }
    //创建与src同类型和同大小的矩阵
    cv::Mat dst = cv::Mat(_mat.size(),_mat.type());
    //边缘检测
    if(ui->radio_Canny->isChecked()){
        cv::Mat edge, grayImage;
        //将原始图转化为灰度图
        cv::cvtColor(_mat, grayImage, cv::COLOR_BGR2GRAY);
        //先使用3*3内核来降噪
        cv::blur(grayImage, edge, cv::Size(3, 3));
        //运行canny算子
        cv::Canny(edge, dst, 3, 9, 3);
        // Canny(edge, edge, 3, 9, 3);
        // imshow("边缘提取效果", edge);
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("Canny");
    }
    if(ui->radio_Sobel->isChecked()){
        cv::Mat grad_x, grad_y;
        cv::Mat abs_grad_x, abs_grad_y;

        //求x方向梯度
        cv::Sobel(_mat, grad_x, CV_16S, 1, 0, 3, 1, 1,cv::BORDER_DEFAULT);
        cv::convertScaleAbs(grad_x, abs_grad_x);
        // imshow("x方向soble", abs_grad_x);

        //求y方向梯度
        cv::Sobel(_mat, grad_y,CV_16S,0, 1,3, 1, 1, cv::BORDER_DEFAULT);
        cv::convertScaleAbs(grad_y,abs_grad_y);
        // imshow("y向soble", abs_grad_y);

        //合并梯度
        cv::addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, dst);
        // imshow("整体方向soble", dst);
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("Sobel");
    }
    if(ui->radio_Laplacian->isChecked()){
        cv::Mat gray, abs_dst;
        //高斯滤波消除噪声
        cv::GaussianBlur(_mat, dst, cv::Size(3, 3), 0, 0, cv::BORDER_DEFAULT);
        //转换为灰度图
        cv::cvtColor(dst, gray, cv::COLOR_RGB2GRAY);
        //使用Laplace函数
        //第三个参数：目标图像深度；第四个参数：滤波器孔径尺寸；第五个参数：比例因子；第六个参数：表示结果存入目标图
        cv::Laplacian(gray, dst, CV_16S, 3, 1, 0, cv::BORDER_DEFAULT);
        //计算绝对值，并将结果转为8位
        cv::convertScaleAbs(dst, abs_dst);
        dst = abs_dst.clone();
        // imshow("laplace效果图", abs_dst);
        ui->edit_algorithm->clear();
        ui->edit_algorithm->insertPlainText("Laplacian");

    }
    QImage image = Lib::MatToQImage(dst);
    _exportImage = image;
    ui->label_image->setPixmap(QPixmap::fromImage(image));
}

图像滤镜

点击滤镜按钮

void Work::on_pic_filter_clicked()
{
    ui->stackedWidget->setCurrentWidget(ui->page_filter);
    ui->edit_algorithm->clear();
    ui->edit_algorithm->insertPlainText("滤镜");
    QStringList strList;
    strList<<"原图"<<"浮雕"<<"素描"<<"怀旧"<<"轮廓"<<"模糊"<<"锐化"<<"美颜"<<"水彩";
    ui->filter_comboBox->addItems(strList);
}

点击执行算法

算法选择
void Work::on_btn_filter_clicked()
{
    if(_mat.empty()){
        emit SignImageIsNull();
        return;
    }
    QString algorithm_description = "滤镜";
    Mat dst(_mat.size(),_mat.type());
    int filter_data = ui->filter_comboBox->currentIndex();
    ImageFilter filter;
    // "原图", "浮雕", "素描", "怀旧", "轮廓", "模糊", "锐化", "美颜", "水彩";
    switch (filter_data) {
    // case FilterConfig::OriginalImage:
    //     qDebug()<<a;
    //     break;原图 设置为default
    case FilterConfig::ReliefImage:
        //浮雕
        dst = filter.relief(_mat,150);
        algorithm_description = "滤镜为：浮雕";
        break;
    case FilterConfig::SketchImage:
        //素描
        dst = filter.sketch(_mat);
        algorithm_description = "滤镜为：素描";
        break;
    case FilterConfig::NostalgiaImage:
        //怀旧
        dst = filter.nostalgia(_mat);
        algorithm_description = "滤镜为：怀旧";
        break;
    case FilterConfig::ContourImage:
        // 轮廓
        dst = filter.edge(_mat);
        algorithm_description = "滤镜为：轮廓";
        break;
    case FilterConfig::ObscureImage:
        // 模糊
        dst = filter.blur(_mat);
        algorithm_description = "滤镜为：模糊";
        break;
    case FilterConfig::SharpeningImage:
        // 锐化
        dst = filter.sharp(_mat);
        algorithm_description = "滤镜为：锐化";
        break;
    case FilterConfig::BeautyImage:
        // 美颜
        dst = filter.bifilter(_mat);
        algorithm_description = "滤镜为：美颜";
        break;
    case FilterConfig::WatercolorImage:
        // 水彩
        dst = filter.stylization(_mat);
        algorithm_description = "滤镜为：水彩";
        break;
    default://原图FilterConfig::OriginalImage
        dst = _mat.clone();
        algorithm_description = "设置为：原图";
        break;
    }
    ui->edit_algorithm->clear();
    ui->edit_algorithm->insertPlainText(algorithm_description);
    QImage image = Lib::MatToQImage(dst);
    _exportImage = image;
    ui->label_image->setPixmap(QPixmap::fromImage(image));
}
枚举
// "原图""浮雕", "素描", "怀旧", "轮廓", "模糊", "锐化", "美颜", "水彩";
enum FilterConfig{
    OriginalImage,
    ReliefImage,
    SketchImage,
    NostalgiaImage,
    ContourImage,
    ObscureImage,
    SharpeningImage,
    BeautyImage,
    WatercolorImage
};
算法内容
头
#ifndef IMAGEFILTER_H
#define IMAGEFILTER_H
// #include <QImage>
// #include <opencv2/core/core.hpp>
// #include <opencv2/highgui/highgui.hpp>
// #include <opencv2/imgproc/imgproc.hpp>
#include "opencv2/opencv.hpp"
using namespace cv;
class ImageFilter
{
public:
    ImageFilter();
public:
    //图像轮廓检测
    Mat edge(Mat image);
    //图像模糊处理
    Mat blur(Mat image);
    //图像锐化
    Mat sharp(Mat image);
    //图像双边滤波处理（美颜）
    Mat bifilter(Mat image);
    //图像浮雕处理
    Mat relief(Mat image,int Degree);
    //素描
    Mat sketch(Mat image);
    //怀旧
    Mat nostalgia(Mat image);
    //水彩
    Mat stylization(Mat image);
};

#endif // IMAGEFILTER_H
实现
#include "imagefilter.h"
ImageFilter::ImageFilter() {}

Mat ImageFilter::edge(Mat image)
{
    Mat dst(image.size(),image.type());
    cv::cvtColor(image,dst,cv::COLOR_BGR2GRAY);
    GaussianBlur(dst,dst,Size(5,5),0);
    Canny(dst,dst,100,200);
    // cv::cvtColor(image,dst,cv::COLOR_HSV2RGB);
    return dst;
}

Mat ImageFilter::blur(Mat image)
{
    Mat dst;
    cv::blur(image,dst,Size(15,15));
    return dst;
}

Mat ImageFilter::sharp(Mat image)
{
    Mat dst;
    // 定义卷积核
    Mat kernel = (Mat_<float>(3,3) << 0, -1, 0,
                  -1, 5, -1,
                  0, -1, 0);
    cv::filter2D(image,dst,-1,kernel);
    return dst;
}

Mat ImageFilter::bifilter(Mat image)
{
    Mat dst;
    cv::bilateralFilter(image,dst,0,30,15);
    return dst;
}

Mat ImageFilter::relief(Mat image, int Degree)
{
    Mat dst;
    cvtColor(image,dst,COLOR_BGR2GRAY);
    int w = dst.cols;
    int h = dst.rows;

    Mat img1 = Mat::zeros(dst.size(),dst.type());
    for(int i = 0;i<h;i++){
        for(int j=0;j<w-1;j++){
            // 前一个像素值
            int a = static_cast<int>(dst.at<uchar>(i, j));
            // 后一个像素值
            int b = static_cast<int>(dst.at<uchar>(i, j + 1));
            // 计算新的像素值，并确保在 0 到 255 之间
            int newValue = min(max(a - b + Degree, 0), 255);
            // 更新输出图像
            img1.at<uchar>(i, j) = static_cast<uchar>(newValue);
        }
    }
    return img1;
}

Mat ImageFilter::sketch(Mat image)
{
    Mat dst(image.size(),image.type());
    cv::cvtColor(image,dst,cv::COLOR_BGR2GRAY);
    GaussianBlur(dst,dst,Size(3,3),0);
    Canny(dst,dst,50,140);
    cv::threshold(dst,dst,90,255,THRESH_BINARY_INV);
    return dst;
}

Mat ImageFilter::nostalgia(Mat image)
{
    // 获取图像属性
    int h = image.rows;
    int w = image.cols;

    // 定义空白图像，存放怀旧处理后的图像
    Mat dst(h, w, CV_8UC3);

    // 遍历图像像素进行怀旧处理
    for (int i = 0; i < h; ++i) {
        for (int j = 0; j < w; ++j) {
            float B = 0.131 * image.at<Vec3b>(i, j)[0] + 0.534 * image.at<Vec3b>(i, j)[1] + 0.272 * image.at<Vec3b>(i, j)[2];
            float G = 0.168 * image.at<Vec3b>(i, j)[0] + 0.686 * image.at<Vec3b>(i, j)[1] + 0.349 * image.at<Vec3b>(i, j)[2];
            float R = 0.189 * image.at<Vec3b>(i, j)[0] + 0.769 * image.at<Vec3b>(i, j)[1] + 0.393 * image.at<Vec3b>(i, j)[2];

            // 防止图像溢出
            if (B > 255) B = 255;
            if (G > 255) G = 255;
            if (R > 255) R = 255;

            // 设置怀旧后的像素值
            dst.at<Vec3b>(i, j)[0] = static_cast<uchar>(B);
            dst.at<Vec3b>(i, j)[1] = static_cast<uchar>(G);
            dst.at<Vec3b>(i, j)[2] = static_cast<uchar>(R);
        }
    }

    return dst;
}

Mat ImageFilter::stylization(Mat image)
{
    Mat dst(image.size(),image.type());
    cv::stylization(image,dst,60,0.6);
    return dst;
}

```
懊恼王子
关注
  • 9
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OpenCV 概述和应用领域：图像处理的万能利器
小蓝枣的博客
07-08 876
OpenCV （ Open Source Computer Vision Library ）是一个广泛应用于计算机视觉和图像处理领域的开源库。它提供了丰富的图像处理算法和工具，能够处理图像和视频数据，实现诸如特征提取、目标检测、图像分割等功能。本文将介绍 OpenCV 的概述和应用领域，并通过具体实例展示其强大的功能和广泛应用。
图像处理-基于OpenCV实现的图像分割算法实现之RegionGrowing.zip
04-03
本压缩包“图像处理-基于OpenCV实现的图像分割算法实现之RegionGrowing.zip”专注于一种名为Region Growing的图像分割算法，这是一种基于像素相似性的区域生长方法。现在，我们将深入探讨Region Growing算法以及如何...
使用C++结合OpenCV进行图像处理与分类
忆_恒心的博客
06-05 2110
在当今数字化时代，图像处理技术在各个领域得到了广泛应用。无论是自动驾驶、医学影像分析，还是安防监控、虚拟现实，图像处理都扮演着重要角色。OpenCV（**Open Source Computer Vision Library**）作为一个开源的计算机视觉库，提供了丰富的图像处理函数和工具，使得图像处理变得更加简单和高效。本文将介绍如何使用C++结合OpenCV进行基础的图像处理操作。
数字图像处理c++ opencv（VS2019 opencv4.53）持续更新
刘燚的博客
07-27 3606
系列文章目录 文章目录系列文章目录前言一、基本操作1.图像的读取，显示，保存2. 前言 使用c++ opencv进行数字图像处理学习； 工具：VS2019, opencv4.53; 持续更新 一、基本操作 1.图像的读取，显示，保存 图像的读取，显示，保存 2. ...
Python图像处理指南：PIL与OpenCV的比较
一键难忘的博客
03-15 4397
图像处理在计算机视觉和图像识别等领域中扮演着至关重要的角色。Python作为一种功能强大且易于学习的编程语言，提供了多种库供图像处理使用。在本文中，我们将比较两个最流行的Python图像处理库：Python Imaging Library（PIL）和OpenCV。我们将探讨它们的功能、用法和性能，并通过代码实例进行演示。
halcon opencv 图像处理面试指南
weixin_39354845的博客
02-12 5703
跟随这位大神的步伐学，做补充图像处理-最常见面试题（必问）_聪哥965-CSDN博客_图像处理面试题 1.图像预处理有哪些方法？ 1 平均滤波 2 中值滤波 3 高斯滤波 4 高斯金字塔 5 拉普拉斯滤波 6 直方图均衡化 7 CHE 1.1 高斯滤波器原理介绍？ Opencv 笔记3 图像平滑_Σίσυφος1900的博客-CSDN博客 高斯滤波对于抑制服从正态分布的噪声效果非常好，其代价是使图像变得“模糊”。 高斯滤波器最重要的参数就是高斯分布的......
OpenCV图像处理基础（变换和去噪），2024年最新大厂面试题库
m0_61331491的博客
04-21 912
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
Opencv 图像处理：数字图像的必会知识
timerring的博客
10-24 4560
OpenCV 于 1999 年由 Intel 建立；开源发行的跨平台计算机视觉库；操作系统： Linux 、 Windows 、 Android 、 Mac OS构成： C 函数和少量 C++ 类；接口： Python 、 Java 、 MATLAB 等语言opencv 是数字图像处理和计算机视觉领域最常见的工具包，是学习，科研，企业项目开发的好帮手。
OpenCV-PyQT项目实战（4）OpenCV 与PyQt的图像转换
youcans的博客
02-05 3135
在OpenCV-PyQt的项目中，通常使用OpenCV读写和处理图像，使用PyQt进行显示和交互。但是，OpenCV与PyQt中的图像存储格式不同，需要进行转换。这里有不少坑，小心行驶。
OpenCV图像处理中的性能测试（持续更新）
lonelyrains的专栏
01-04 3400
OpenCV图像处理中的性能测试本文由 @lonelyrains 出品，转载请注明出处。 文章链接： http://blog.csdn.net/lonelyrains/article/details/50456266opencv中自带跨平台的计时代码实现。源码如下 int64 getTickCount(void) { #if defined WIN32 || defined _WIN32 ||
OpenCV图像处理助手3.4 有主要代码.zip
06-02
OpenCV图像处理助手3.4 有主要代码.zip Open Source Computer Vision Library。OpenCV是一个基于（开源）发行的跨平台计算机视觉库，可以运行在Linux、Windows和Mac OS操作系统上。它轻量级而且高效——由一系列 C ...
基于python和pyqt5，实现opencv图像处理
06-28
在本项目中，我们主要探讨如何使用Python和PyQt5结合OpenCV库来实现一系列的图像处理任务。OpenCV（开源计算机视觉库）是一个强大的工具，广泛用于图像和视频分析，而PyQt5则是一个Python版本的Qt界面库，允许我们...
opencv 数字图像处理.zip
04-05
高效性能：OpenCV代码经过高度优化，能够利用多核CPU、GPU以及特定硬件加速（如Intel IPP、OpenCL等），实现高速图像处理和实时计算机视觉应用。 多语言支持：尽管OpenCV主要使用C++编写，但它提供了丰富的API...
基于PyQt+OpenCV的图像处理软件.zip
04-05
高效性能：OpenCV代码经过高度优化，能够利用多核CPU、GPU以及特定硬件加速（如Intel IPP、OpenCL等），实现高速图像处理和实时计算机视觉应用。 多语言支持：尽管OpenCV主要使用C++编写，但它提供了丰富的API...
C++：opencv将彩色图转换为灰度图
Ethan_Rich的博客
07-15 470
但是，对于大多数来自相机或文件系统的图像，你可以安全地假设它们是BGR格式的（在OpenCV中）。：这种方法给了你更多的灵活性，因为你可以先对彩色图像进行一些处理（如裁剪、旋转等），然后再转换为灰度图。但是，它使用了更多的内存，因为你需要同时存储彩色和灰度图像（至少在转换过程中是这样）。对于将彩色图转换为灰度图，你通常会从BGR颜色空间（OpenCV中默认的彩色图像格式）转换到灰度颜色空间。请注意，如果原始图像不是彩色的（即，它是一个灰度图像或具有其他非BGR颜色空间的图像），但你仍然使用。
【Qt+opencv】基础的图像绘制
m0_62599305的博客
07-15 846
在计算机视觉和图像处理领域，OpenCV是一个强大的库，提供了丰富的功能和算法。而Qt是一个跨平台的C++图形用户界面应用程序开发框架，它为开发者提供了创建现代化的桌面应用程序的所有必要功能。结合这两者，我们可以创建一个强大的图像处理应用程序。本文将介绍如何使用Qt和OpenCV进行基础的图像绘制。我们将探讨如何在Qt应用程序中集成OpenCV库，以及如何使用OpenCV的函数在图像上进行基本的绘制操作。通过本文，我们了解了如何在Qt应用程序中集成OpenCV库，并使用其进行基础的图像绘制。
OpenCv 如何在 Java 中使用
最新发布
清汉_CSDN
07-18 398
OpenCV（开源计算机视觉库）是一个功能强大的计算机视觉和机器学习库。它提供了广泛的工具和算法，用于图像处理和计算机视觉任务。
OpenCV教程：cv2如何把两张图片的大小，设置成相同的宽高
我的Python教程
07-15 491
请注意，cv2.resize()函数的第一个参数是需要调整大小的图像，第二个参数是新的尺寸（宽度，高度），这是一个元组。你可以根据需要选择不同的插值方法，例如cv2.INTER_LINEAR（默认）、cv2.INTER_CUBIC或cv2.INTER_AREA，这可以通过添加第三个参数来实现，例如cv2.resize(image, size, interpolation=cv2.INTER_CUBIC)。-------------OpenCV教程集合-------------
OpenCV中的轮廓检测cv2.findContours()
qq_42591591的博客
07-12 2072
轮廓提取的前提，将背景置为黑色，目标为白色（利用二值化或Canny）边缘检测，例如Canny等，利用梯度变化，记录图像中的边缘像素点，返回和源图片一样尺寸和类型的边缘图。轮廓检测，则是将得到的每一个轮廓信息存储下来，记录的是轮廓之间和内部的信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值