Qt C++ 数据预处理笔记(4)——高通滤波

已于 2023-12-27 10:16:53 修改
阅读量1k 收藏 7
点赞数 6
文章标签： qt c++ 笔记
于 2023-12-27 10:14:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tadpole_java/article/details/135238540
版权
文章详细描述了一个使用C++编写的HighPassFilter类，该类用于对文件中的数据进行高通滤波处理，包括读取文件、数据过滤、进度更新和结果输出。同时，文中还提及了与Qt库的集成，如QThread、QRunnable和QCustomPlot等工具。
摘要由CSDN通过智能技术生成 

#include "HighPassFilter.h"

HighPassFilter::HighPassFilter(int iRow, QString oStrFileName, int iStart, int iEnd, QObject* parent)
    : QObject{parent}, iRow(iRow), oStrFileName(oStrFileName), iStart(iStart), iEnd(iEnd)
{
    oHead = PF::readHead(oStrFileName);

    times = pow(2, log10(iEnd - iStart));
}

void HighPassFilter::run()
{
    QElapsedTimer time;
    time.start();

    QFile oFile(oStrFileName);

    if( !oFile.open(QIODevice::ReadOnly) )
    {
        return;
    }

    QDataStream oStream(&oFile);

    oStream.setByteOrder(QDataStream::BigEndian);
    oStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
    oStream.skipRawData(LENGTH_178_BYTE);//作者是靠占位符来占据首行的。

    for(int i = 0; i < iStart; ++i)
    {
        oStream.skipRawData(oHead.uiFS * LENGTH_4_BYTE);
    }

    oStream.startTransaction();

    double value = 0;

    QVector<double> adSegmentX(HIGH_PASS_FILTERED_LENGTH);
    QVector<double> in(HIGH_PASS_FILTERED_LENGTH);
    QVector<double> out(HIGH_PASS_FILTERED_LENGTH);

    in.clear();
    out.clear();
    adSegmentX.clear();

    in.squeeze();
    out.squeeze();
    adSegmentX.squeeze();

    quint32 uiPercentage = PROGRESS_STEP;


    for(quint64 i = oHead.uiFS * iStart; i < oHead.uiFS * iEnd; i++)
    {
        oStream >> value;

        adSegmentX.append(oHead.iStartTimestamp + (double)i / (double)oHead.uiFS);

        in.append(value);

        if(in.size() == HIGH_PASS_FILTERED_LENGTH)
        {
            out = this->filter(in, HIGH_PASS_FILTERED_LENGTH);

            this->dilution(adSegmentX, in, out);

            adSegmentX.clear();
            adSegmentX.squeeze();

            in.clear();
            in.squeeze();

            out.clear();
            out.squeeze();
        }

        float fProgress = ((float)(i) / ((float)oHead.uiFS * (iEnd - iStart))) * 100;

        if(fProgress >= uiPercentage)
        {
            emit sigProgress(iRow, "处理中~ ", fProgress);

            uiPercentage = uiPercentage + PROGRESS_STEP;
        }

    }
    oStream.commitTransaction();

    oFile.close();
    emit sigProgress(iRow, "处理完毕!", 100.00);

    qint64 milsec = time.elapsed();

    emit sigMsg(QString("行号：%1\t加载采样点个数：%2\t耗时：%3s\t高通滤波")
                .arg(iRow + 1)
                .arg(oHead.uiFS * (iEnd - iStart))
                .arg(QString::number(milsec / 1000.00, 'f', 3)));
}


QVector<double> HighPassFilter::filter(QVector<double> TestData, int DataCnt)
{
    QVector<double> HPData(DataCnt);

    for(int i = 0; i < TestData.size(); i++)  //TestData是读取的原始数据,注意读取的时候的数据类型需要是duble不然会因为fLoat类型丢失精度
    {
        double testb = 0.0;
        double testa = 0.0;

        if(i < sizeB - 1)
        {
            for(int j = i; j >= 0; j--)
            {
                testb += HPcoeffB[i - j] * TestData[j];
            }
        }
        else //作为测试，这里是写死的因为这样速度更快，暂时认为高通滤波系数为提供的固定值，后续需要更改
        {
            testb = HPcoeffB[0] * TestData[i] +
                    HPcoeffB[1] * TestData[i - 1] +
                    HPcoeffB[2] * TestData[i - 2] +
                    HPcoeffB[3] * TestData[i - 3] +
                    HPcoeffB[4] * TestData[i - 4] +
                    HPcoeffB[5] * TestData[i - 5] +
                    HPcoeffB[6] * TestData[i - 6] +
                    HPcoeffB[7] * TestData[i - 7] +
                    HPcoeffB[8] * TestData[i - 8] +
                    HPcoeffB[9] * TestData[i - 9];
        }

        if(i > 0)
        {
            if(i < sizeA - 1)
            {
                for(int j = i - 1; j >= 0; j--)
                {
                    testa += HPcoeffA[i - j] * HPData[j];
                }
            }
            else  //作为测试，这里是写死的因为这样速度更快,暂时认为高通滤波系数为提供的固定值,后续需要更改
            {
                testa = HPcoeffA[1] * HPData[i - 1] +
                        HPcoeffA[2] * HPData[i - 2] +
                        HPcoeffA[3] * HPData[i - 3] +
                        HPcoeffA[4] * HPData[i - 4] +
                        HPcoeffA[5] * HPData[i - 5] +
                        HPcoeffA[6] * HPData[i - 6] +
                        HPcoeffA[7] * HPData[i - 7] +
                        HPcoeffA[8] * HPData[i - 8] +
                        HPcoeffA[9] * HPData[i - 9];
            }
        }

        HPData[i] = testb - testa;
    }
    return HPData;
}

void HighPassFilter::dilution(QVector<double> adX, QVector<double> adY_in, QVector<double> adY_out)
{
    int length = (HIGH_PASS_FILTERED_LENGTH / 1024);

    for(int i = 0; i < 1024; ++i )
    {
        extremum( DATA_RAW,
                  adX.mid(i * length, length),
                  adY_in.mid(i * length, length));

        extremum( DATA_FILTERED,
                  adX.mid(i * length, length),
                  adY_out.mid(i * length, length));
    }

    if(adX_raw.count() >= 1024)
    {
        emit sigData(iRow, DATA_RAW, adX_raw, adY_raw);
        emit sigData(iRow, DATA_FILTERED, adX_hpf, adY_hpf);

        adX_raw.clear();
        adY_raw.clear();
        adX_hpf.clear();
        adY_hpf.clear();

        adX_raw.squeeze();
        adY_raw.squeeze();
        adX_hpf.squeeze();
        adY_hpf.squeeze();
    }
}

void HighPassFilter::extremum(DATA_TYPE eDataType, QVector<double> x, QVector<double> y)
{
    if(x.count() <= 2)
    {
        switch (eDataType)
        {
            case DATA_RAW:
                adX_raw.append(x);
                adY_raw.append(y);
                break;
            case DATA_FILTERED:
                adX_hpf.append(x);
                adY_hpf.append(y);
                break;
            default:
                break;
        }
    }
    else
    {
        auto max = std::max_element(std::begin(y), std::end(y));
        auto min = std::min_element(std::begin(y), std::end(y));

        auto positionmax = std::distance(std::begin(y), max);
        auto positionmin = std::distance(std::begin(y), min);

        int posmax = positionmax;
        int posmin = positionmin;

        if(posmin < posmax)
        {
            switch (eDataType)
            {
                case DATA_RAW:
                    adX_raw.append(x.at(posmin));
                    adY_raw.append(y.at(posmin));

                    adX_raw.append(x.at(posmax));
                    adY_raw.append(y.at(posmax));
                    break;
                case DATA_FILTERED:
                    adX_hpf.append(x.at(posmin));
                    adY_hpf.append(y.at(posmin));

                    adX_hpf.append(x.at(posmax));
                    adY_hpf.append(y.at(posmax));
                    break;
                default:
                    break;
            }
        }
        else
        {
            switch (eDataType)
            {
                case DATA_RAW:
                    adX_raw.append(x.at(posmax));
                    adY_raw.append(y.at(posmax));

                    adX_raw.append(x.at(posmin));
                    adY_raw.append(y.at(posmin));
                    break;
                case DATA_FILTERED:
                    adX_hpf.append(x.at(posmax));
                    adY_hpf.append(y.at(posmax));

                    adX_hpf.append(x.at(posmin));
                    adY_hpf.append(y.at(posmin));
                    break;
                default:
                    break;
            }
        }
    }
}


#ifndef HIGHPASSFILTER_H
#define HIGHPASSFILTER_H

#include "PF.h"
#include <QObject>

#include <QRunnable>

class HighPassFilter : public QObject, public QRunnable
{
    Q_OBJECT
public:
    explicit HighPassFilter(int iRow, QString oStrFileName, int iStart, int iEnd,  QObject* parent = nullptr);

    void run() override;

    QVector<double> filter(QVector<double> TestData, int DataCnt);

    void dilution(QVector<double> adX, QVector<double> adY_in, QVector<double> adY_out);

    /* 给定的x, y数组; 返回的是一对最小值和一对最大值 */
    void extremum(DATA_TYPE eDataType, QVector<double> x, QVector<double> y);

signals:
    void sigData(int iRow, DATA_TYPE, QVector<double> x, QVector<double> y);

    void sigProgress(int, QString, float);

    void sigMsg(QString);

private:
    // 使用你提供的系数
    QVector<double> HPcoeffA = {1, -7.869418904996362, 27.586910329781470, -56.537228014951000, 74.643630533230250, -65.831482420294930, 38.781248457435920, -14.713983344295070, 3.262353900872095, -0.322030283384344};
    QVector<double> HPcoeffB = {0.567477121463362, -5.107294093170260, 20.429176372681038, -47.668078202922420, 71.502117304383630, -71.502117304383630, 47.668078202922420, -20.429176372681038, 5.107294093170260, -0.567477121463362};

    int sizeA = HPcoeffA.size();
    int sizeB = HPcoeffB.size();

    int iRow;
    QString oStrFileName;

    int iStart;//秒序列，
    int iEnd;

    HEAD oHead;

    QVector<double> adX_raw, adY_raw;
    QVector<double> adX_hpf, adY_hpf;

    int times = 1;
};

#endif // HIGHPASSFILTER_H

这个有界面：

#include "FilterWidget.h"
#include "ui_FilterWidget.h"

FilterWidget::FilterWidget(int iRow, QString oStrFileName, int iStart, int iEnd, QWidget* parent) :
    QWidget(parent),  ui(new Ui::FilterWidget), iRow(iRow), oStrFileName(oStrFileName), iStart(iStart), iEnd(iEnd)
{
    ui->setupUi(this);

    ui->plot->showTracer(false);

    //ui->plot->xAxis->setLabel("时间");            //X轴文字显示
    ui->plot->yAxis->setLabel("振幅(mV)");        //Y轴文字显示

    QSharedPointer<QCPAxisTickerDateTime> dateTicker(new QCPAxisTickerDateTime);//日期做X轴
    dateTicker->setDateTimeFormat("yyyy年MM月dd日\nHH:mm:ss");//日期格式(可参考QDateTime::fromString()函数)
    ui->plot->xAxis->setTicker(dateTicker);//设置X轴为时间轴

    ui->plot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables | QCP::iSelectLegend | QCP::iSelectAxes);

    QList<QCPAxis*> axes;
    axes << ui->plot->xAxis2 << ui->plot->xAxis;
    ui->plot->axisRect()->setRangeZoomAxes(axes);
    ui->plot->setZoomAxis(ZOOM_X);

    ui->plot->xAxis->grid()->setZeroLinePen(QPen(Qt::red));   //设置刻度为0时的网格线的画笔
    ui->plot->yAxis->grid()->setZeroLinePen(QPen(Qt::red));

    ui->plot->legend->setVisible(true);
    ui->plot->legend->setFont(QFont("Helvetica", 12));

    poGraperTD_raw = ui->plot->addGraph( ui->plot->xAxis,  ui->plot->yAxis);
    poGraperTD_raw->setName("Original");

    QThread* poThreadRaw = new QThread;

    poGraperTD_raw->setParent(nullptr);
    poGraperTD_raw->moveToThread(poThreadRaw);

    poGraperTD_fld =  ui->plot->addGraph( ui->plot->xAxis,  ui->plot->yAxis);
    poGraperTD_fld->setName("High pass filtered");

    QThread* poThreadFld = new QThread;

    poGraperTD_fld->setParent(nullptr);
    poGraperTD_fld->moveToThread(poThreadFld);

    poGraperTD_fld->setPen(QPen(Qt::red, 2));

    oHead = PF::readHead(oStrFileName);

    ui->plot->xAxis->setRange(oHead.iStartTimestamp + iStart, oHead.iStartTimestamp + iEnd);

    ui->plot->plotLayout()->insertRow(0);
    QCPTextElement* m_title = new QCPTextElement(ui->plot, oStrFileName, QFont("Times", 16, QFont::Bold));

    ui->plot->plotLayout()->addElement(0, 0, m_title);
}

FilterWidget::~FilterWidget()
{
    delete ui;
}

void FilterWidget::recvData(int iRow, DATA_TYPE eDataType, QVector<double> x, QVector<double> y)
{
    //qDebugV0() << iRow << x << y;

    if(iRow != this->iRow)
    {
        return;
    }

    switch (eDataType)
    {
        case DATA_RAW:
            poGraperTD_raw->addData(x, y);
            //poGraperTD_raw->rescaleValueAxis();

            break;
        case DATA_FILTERED:
            poGraperTD_fld->addData(x, y);
            poGraperTD_fld->rescaleValueAxis();
            break;
        default:
            break;
    }

    ui->plot->replot();
}

#ifndef FILTERWIDGET_H
#define FILTERWIDGET_H

#include "PF.h"
#include "QCustomPlot/qcustomplot.h"
#include <QWidget>

namespace Ui
{
    class FilterWidget;
}

class FilterWidget : public QWidget
{
    Q_OBJECT

public:
    explicit FilterWidget(int iRow, QString oStrFileName, int iStart, int iEnd, QWidget* parent = nullptr);
    ~FilterWidget();

    void recvData(int iRow, DATA_TYPE, QVector<double> x, QVector<double> y);

private:
    Ui::FilterWidget* ui;

    int iRow;
    QString oStrFileName;

    int iStart;
    int iEnd;


    HEAD oHead;

    QCPGraph* poGraperTD_raw;
    QCPGraph* poGraperTD_fld;
};

#endif // FILTERWIDGET_H

//高通滤波
void MainWindow::on_pushButtonHighPassFilter_clicked()
{
    QList<int> aiRow = PF::getSelectedRows(ui->tableWidget);

    if(aiRow.isEmpty())
    {
        return;
    }

    QTabWidget* poTabWidget = new QTabWidget;

    poTabWidget->setMinimumSize(1024, 633);

    poTabWidget->setWindowTitle("高通滤波");

    for(int i = 0; i < aiRow.count(); ++i)
    {
        QString oStrFileName = ui->tableWidget->item(aiRow.at(i), TABLE_HEADER_FILE_NAME)->data(Qt::DisplayRole).toString();

        QSpinBox* poSpinBoxStart = (QSpinBox*)ui->tableWidget->cellWidget(aiRow.at(i), TABLE_HEADER_START_SECOND);
        QSpinBox* poSpinBoxEnd   = (QSpinBox*)ui->tableWidget->cellWidget(aiRow.at(i), TABLE_HEADER_END_SECOND);

        FilterWidget* poWidget = new FilterWidget(aiRow.at(i), oStrFileName, poSpinBoxStart->value(), poSpinBoxEnd->value());

        poTabWidget->insertTab(i, poWidget, QString("第%1行").arg(aiRow.at(i) + 1));

        HighPassFilter* poWorker = new HighPassFilter(aiRow.at(i),
            oStrFileName,
            poSpinBoxStart->value(),
            poSpinBoxEnd->value());

        poWorker->setParent(nullptr);

        connect(poWorker, &HighPassFilter::sigData,  poWidget, &FilterWidget::recvData);
        connect(poWorker, &HighPassFilter::sigProgress, this, &MainWindow::recvProgress);
        connect(poWorker, &HighPassFilter::sigMsg,      this, &MainWindow::recvMsg);

        QThreadPool::globalInstance()->start(poWorker);
    }

    poTabWidget->show();

    PF::scrollToRigth(ui->tableWidget);
}

关键代码来源于小周老师。有个问题，不同的长度，结果有差异。

QQ_278397935
关注
使用C++设计滤波器(低通滤波器，高通滤波器，带通滤波器)
Q_Linfeng的博客
02-20 1万+
使用C++设计滤波器(低通滤波器，带通滤波器)，包含普通滤波器，FIR滤波器和IIR滤波器的实现
OpenCV C++使用高通滤波和阈值法增强指纹图像
cyf15238622067的博客
03-08 5004
《数字图像处理》冈萨雷斯 第三版中，P179有一个指纹增强的例子； 先用opencv模拟实现： 处理这个指纹图像 ，其污染是很明显的。自动指纹识别的关键一步是增强指纹的脊线并减小污染。使用高通滤波实现； 脊线增强使用脊线包含高频这样一个事实来完成，而高通滤波不会改变高频；另一方面，滤掉了低频，而低频分量对应图像中慢变化的灰度，例如背景和污染。 这样增强就可以同时减少高频外的所有特征来达到，...
qt界面化实现各种滤波函数
05-25
开发环境是基于qt+opencv+vs2013能实现方框滤波，均值滤波等滤波函数，已验证，均能运行，如若需要后续资料，尽可私信我，大家互相学习
探索数字信号处理的奇妙世界：基于QT的滤波器设计
最新发布
gitblog_09761的博客
09-24 402
探索数字信号处理的奇妙世界：基于QT的滤波器设计 基于QT的滤波器设计FFTIIRFIR 此资源是专为那些希望通过实际编程来加深对信号处理理解的学习者准备的。它不仅包括了核心的滤波算法实现，还展示了如何在现代GUI应用中有效地展示这些概念。适合电子工程、计算机科学以及其他相关领域的学生和专业人士。- **信号合成**：示...
（完美运行）基于QT的滤波器设计（含信号合成、FFT、FIR滤波、IIR滤波）
qq_45362665的博客
12-11 6358
学习QT的UI界面操作和IIR、FIR滤波器设计及滤波，FFT频谱分析。详细代码和完整工程文件，下载即可运行，适合QT新手以及学习IIR、FIR滤波、FFT的C语言算法实现，受益绝对匪浅。 （1）在上位机，使用QT软件编写完成两种或三种频率信号的合成，在图形界面上显示合成的时域波形； （2）使用FFT计算合成信号的频率，在界面上绘制频谱图； （3）使用matlab的Filter Designer设计FIR和IIR滤波器，分别完成一种频率成分的去除，并且在界面上显示滤除后的信号时域波形。
Qt - FIR滤波器
J 的博客
02-28 2938
原文：http://beself.top/2020/02/28/qt-firter/ 由于公司开发需要，用Qt做了一个FIR滤波，虽然网上资料也还是挺多的，过程也是比较艰辛，花了好几天研究出来，还有有之前研发的人打下了夯实的基础。 个人邮箱：lijiangjun931026@outlook.com 动图展示 介绍 图中用到的数据文件是根据公司特定的数据文件格式 可以根据动图看到软件采用窗...
c++ opencv数字图像处理：频率域滤波--低通滤波--巴特沃斯低通滤波
刘燚的博客
11-30 2172
文章目录前言一、巴特沃斯低通滤波器（BLPF）二、代码三、说明 前言 数字图像处理c++ opencv（VS2019 opencv4.53）持续更新 一、巴特沃斯低通滤波器（BLPF） D2(u,v)为距离中心点的距离平方，D0为设置半径，通过n的值来调整滤波器D^2(u,v)为距离中心点的距离平方，D_0为设置半径，通过n的值来调整滤波器D2(u,v)为距离中心点的距离平方，D0​为设置半径，通过n的值来调整滤波器 二、代码 主代码： #include<iostream> #inc.
数据预处理软件源代码(QT C++).zip
04-02
这个名为“数据预处理软件源代码(QT C++)”的压缩包包含了一款使用QT框架和C++编程语言开发的数据预处理工具的源代码。QT是一个跨平台的应用程序开发框架，广泛用于创建图形用户界面和其他桌面应用。 在数据预处理...
基于Qt+C++开发的前视声纳数据显示与预处理软件+图像处理算法+源码（毕业设计&课程设计&项目开发）
07-13
基于Qt+C++开发的前视声纳数据显示与预处理软件+图像处理算法+源码，适合毕业设计、课程设计、项目开发。项目源码已经过严格测试，可以放心参考并在此基础上延申使用~ 基于Qt+C++开发的前视声纳数据显示与预处理...
qt图像均值滤波 c++_图像处理之滤波（下）
weixin_39557813的博客
12-09 2193
[toc]目录一、常规滤波低通高通带通带阻二、非局部均值滤波三、维纳滤波四、卡尔曼滤波前言所谓滤波，其实就是从混合在一起的诸多信号中提取出所需要的信号。信号的分类：确定型信号，可以表示为确定的时间函数，可确定其在任何时刻的量值。（具有确定的频谱）；一般可通过低通、高通、带通、带阻等模拟滤波器或其他常规滤波算法实现。随机信号，不能用确定的数学关系式描述，不能预测其未来任何瞬时值，其值的变化服从统计规...
基于QT的数据结构课设——图书管理系统.zip
12-31
QT，C++使用技巧，实战应用开发小系统参考资料，源码参考。 详细介绍了一些Qt框架的各种功能和模块，以及如何使用Qt进行GUI开发、网络编程和跨平台应用开发等。 适用于初学者和有经验的开发者，能够帮助你快速上手Qt...
高通滤波（2）
dss875914213的博客
09-02 1574
之前的滤波，截止频率设为100Hz很完美。但是要将截止频率设为1Hz，系统变得不稳定，引入杂波。 通过改滤波器的阶数，效果不理想。 改变滤波器类型，效果也不理想，感觉iir的butterworth效果最好，用不同模型，导出方式是一样的（只要转换方法设为一样就好了，点击Edit-&gt;Convert Structure）。fir不会用，调了一下，看不太懂，没继续深究。 在讲参数导到ARM中用...
数字滤波器的C语言实现，包括高通、低通、带通滤波器
05-03
数字滤波器的C语言实现，包括高通、低通、带通滤波器
高斯滤波的c++代码实现
01-19
分别利用一阶高斯与二阶高斯实现了图像的滤波算法，总体来说一阶高斯滤波会更加的快速
高通滤波代码
jialeheyeshu的博客
10-30 1795
%高通滤波 I=imread('lv.jpg'); I=rgb2gray(I); [f1,f2]=freqspace(size(I),'meshgrid');  %分割频率空间 Hd=ones(size(I)); r=sqrt(f1.^2+f2.^2);   %计算到原点的r Hd(r Y=fft2(I); Y=fftshift(Y); Ya=Y.*Hd; Ya=ifftshi
c++ opencv数字图像处理：频率域滤波--高通滤波--巴特沃斯高通滤波
刘燚的博客
11-30 4720
文章目录前言一、巴特沃斯高通滤波器（BHPF）二、代码 前言 数字图像处理c++ opencv（VS2019 opencv4.53）持续更新 一、巴特沃斯高通滤波器（BHPF） D2(u,v)为距离中心点的距离平方，D0为设置半径，通过n的值来调整滤波器D^2(u,v)为距离中心点的距离平方，D_0为设置半径，通过n的值来调整滤波器D2(u,v)为距离中心点的距离平方，D0​为设置半径，通过n的值来调整滤波器 二、代码 主代码： #include<iostream> #include&.
mfc高通滤波器
05-06
mfc制作高通滤波器 滤波算法 double c=0.098531; y[0]=c*x[0]; y[1]=c*x[1]-3*c*x[0]-0.486441*y[0]; y[2]=c*x[2]-3*c*x[1]+3*c*x[0]-0.486441*y[1]-0.421787*y[0]; for(i=3;i<N;i++) { y[i]=c*x[i]-3*c*x[i-1]+3*c*x[i-2]-c*x[i-3]-0.486441*y[i-1]-0.421787*y[i-2]-0.056297*y[i-3]; }
利用Qt框架和C++开发了一款符合前视声纳成像特点的前视声纳数据显示与预处理软件。集成了经典的图形处理算法.zip
12-29
利用Qt框架和C++开发了一款符合前视声纳成像特点的前视声纳数据显示与预处理软件。集成了经典的图形处理算法.zip 利用Qt框架和C++开发了一款符合前视声纳成像特点的前视声纳数据显示与预处理软件。集成了经典的图形...
qt图像均值滤波 c++_数字图像处理：Parametric Wiener Filter
weixin_39924307的博客
12-03 815
【欢迎关注、点赞、收藏、私信、交流】共同学习进步摘 要：本实验主要通过维纳滤波法（也称最小均方误差滤波法）对图像进行恢复与重建，维纳滤波器没有逆滤波中的退化函数为零的问题，更容易把噪声与有用信息的图像分离出来。首先给图像中添加高斯噪声和运动污损滤波，然后从噪声中提取恢复图像，并与原图像进行对比。图像复原的大部分过程是一个客观的过程，是利用退化现象的某种先验知识来重建或复原被退化的图像。一、实验...
C++低频和高频滤波（.rar
08-28
源程序，直接拿来跑，基于C++编写的高频和低频滤波，（一阶，二阶和三阶）。稍稍修改可以对声音信号和图像进行滤波。一个程序解决所有滤波问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值