AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

OpenCV-巴特沃斯低通&高通滤波器（C++）

2023-10-16 390
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： OpenCV-巴特沃斯低通&高通滤波器（C++）

场景需求

      做图像处理，滤波是家常便饭，今天给大家分享巴特沃斯滤波器实现。


      众所周知，在频谱中，低频主要对应图像在平滑区域的总体灰度级分布，高频对应图像细节部分，如边缘和噪声。巴特沃斯滤波器被称作最大平坦滤波器。其特点是通频带内的频率响应曲线最大限度平坦，没有纹波，而在阻频带则逐渐下降为零，公式和具体原理就不再罗列了，百度一下全都有，接下来是硬货——C++&OpenCV代码实现。

相关功能函数的C++实现代码

// 巴特沃斯低通滤波核函数
cv::Mat butterworth_low_kernel(cv::Mat &scr, float sigma, int n)
{
  cv::Mat butterworth_low_pass(scr.size(), CV_32FC1); //，CV_32FC1
  float D0 = sigma;//半径D0越小，模糊越大；半径D0越大，模糊越小
  for (int i = 0; i < scr.rows; i++) {
    for (int j = 0; j < scr.cols; j++) {
      float d = sqrt(pow(float(i - scr.rows / 2), 2) + pow(float(j - scr.cols / 2), 2));//分子,计算pow必须为float型
      butterworth_low_pass.at<float>(i, j) = 1.0f / (1.0f + pow(d / D0, 2 * n));
    }
  }
  return butterworth_low_pass;
}
// 巴特沃斯低通滤波
cv::Mat butterworth_low_pass_filter(cv::Mat &src, float d0, int n)
{
  // H = 1 / (1+(D/D0)^2n)   n表示巴特沃斯滤波器的次数
  // 阶数n=1 无振铃和负值    阶数n=2 轻微振铃和负值  阶数n=5 明显振铃和负值   阶数n=20 与ILPF相似
  cv::Mat padded = image_make_border(src);
  cv::Mat butterworth_kernel = butterworth_low_kernel(padded, d0, n);
  cv::Mat result = frequency_filter(padded, butterworth_kernel);
  return result;
}
// 巴特沃斯高通滤波核函数
cv::Mat butterworth_high_kernel(cv::Mat &scr, float sigma, int n)
{
  cv::Mat butterworth_high_pass(scr.size(), CV_32FC1); //，CV_32FC1
  float D0 = (float)sigma;  // 半径D0越小，模糊越大；半径D0越大，模糊越小
  for (int i = 0; i < scr.rows; i++) {
    for (int j = 0; j < scr.cols; j++) {
      float d = sqrt(pow(float(i - scr.rows / 2), 2) + pow(float(j - scr.cols / 2), 2));//分子,计算pow必须为float型
      butterworth_high_pass.at<float>(i, j) =1.0f-1.0f / (1.0f + pow(d / D0, 2 * n));
    }
  }
  return butterworth_high_pass;
}
// 巴特沃斯高通滤波
cv::Mat butterworth_high_pass_filter(cv::Mat &src, float d0, int n)
{
  cv::Mat padded = image_make_border(src);
  cv::Mat butterworth_kernel = butterworth_high_kernel(padded, d0, n);
  cv::Mat result = frequency_filter(padded, butterworth_kernel);
  return result;
}
// 频率域滤波
cv::Mat frequency_filter(cv::Mat &scr, cv::Mat &blur)
{
  cv::Mat mask = scr == scr;
  scr.setTo(0.0f, ~mask);
  //创建通道，存储dft后的实部与虚部（CV_32F，必须为单通道数）
  cv::Mat plane[] = { scr.clone(), cv::Mat::zeros(scr.size() , CV_32FC1) };
  cv::Mat complexIm;
  cv::merge(plane, 2, complexIm); // 合并通道 （把两个矩阵合并为一个2通道的Mat类容器）
  cv::dft(complexIm, complexIm); // 进行傅立叶变换，结果保存在自身
  // 分离通道（数组分离）
  cv::split(complexIm, plane);
  // 以下的操作是频域迁移
  fftshift(plane[0], plane[1]);
  // *****************滤波器函数与DFT结果的乘积****************
  cv::Mat blur_r, blur_i, BLUR;
  cv::multiply(plane[0], blur, blur_r);  // 滤波（实部与滤波器模板对应元素相乘）
  cv::multiply(plane[1], blur, blur_i);  // 滤波（虚部与滤波器模板对应元素相乘）
  cv::Mat plane1[] = { blur_r, blur_i };
  // 再次搬移回来进行逆变换
  fftshift(plane1[0], plane1[1]);
  cv::merge(plane1, 2, BLUR); // 实部与虚部合并
  cv::idft(BLUR, BLUR);       // idft结果也为复数
  BLUR = BLUR / BLUR.rows / BLUR.cols;
  cv::split(BLUR, plane);//分离通道，主要获取通道
  return plane[0];
}
// 图像边界处理
cv::Mat image_make_border(cv::Mat &src)
{
  int w = cv::getOptimalDFTSize(src.cols); // 获取DFT变换的最佳宽度
  int h = cv::getOptimalDFTSize(src.rows); // 获取DFT变换的最佳高度
  cv::Mat padded;
  // 常量法扩充图像边界，常量 = 0
  cv::copyMakeBorder(src, padded, 0, h - src.rows, 0, w - src.cols, cv::BORDER_CONSTANT, cv::Scalar::all(0));
  padded.convertTo(padded, CV_32FC1);
  return padded;
}
// 实现频域滤波器的网格函数
void getcart(int rows, int cols, cv::Mat &x, cv::Mat &y) {
  x.create(rows, cols, CV_32FC1);
  y.create(rows, cols, CV_32FC1);
  //设置边界
  //计算其他位置的值
  for (int i = 0; i < rows; ++i) {
    if (i <= rows / 2) {
      x.row(i) = i;
    }
    else {
      x.row(i) = i - rows;
    }
  }
  for (int i = 0; i < cols; ++i) {
    if (i <= cols / 2) {
      y.col(i) = i;
    }
    else {
      y.col(i) = i - cols;
    }
  }
}
// fft变换后进行频谱搬移
void fftshift(cv::Mat &plane0, cv::Mat &plane1)
{
  // 以下的操作是移动图像  (零频移到中心)
  int cx = plane0.cols / 2;
  int cy = plane0.rows / 2;
  cv::Mat part1_r(plane0, cv::Rect(0, 0, cx, cy));  // 元素坐标表示为(cx, cy)
  cv::Mat part2_r(plane0, cv::Rect(cx, 0, cx, cy));
  cv::Mat part3_r(plane0, cv::Rect(0, cy, cx, cy));
  cv::Mat part4_r(plane0, cv::Rect(cx, cy, cx, cy));
  cv::Mat temp;
  part1_r.copyTo(temp);  //左上与右下交换位置(实部)
  part4_r.copyTo(part1_r);
  temp.copyTo(part4_r);
  part2_r.copyTo(temp);  //右上与左下交换位置(实部)
  part3_r.copyTo(part2_r);
  temp.copyTo(part3_r);
  cv::Mat part1_i(plane1, cv::Rect(0, 0, cx, cy));  //元素坐标(cx,cy)
  cv::Mat part2_i(plane1, cv::Rect(cx, 0, cx, cy));
  cv::Mat part3_i(plane1, cv::Rect(0, cy, cx, cy));
  cv::Mat part4_i(plane1, cv::Rect(cx, cy, cx, cy));
  part1_i.copyTo(temp);  //左上与右下交换位置(虚部)
  part4_i.copyTo(part1_i);
  temp.copyTo(part4_i);
  part2_i.copyTo(temp);  //右上与左下交换位置(虚部)
  part3_i.copyTo(part2_i);
  temp.copyTo(part3_i);
}

测试代码

#include<iostream>
#include<opencv2/opencv.hpp>
#include<ctime>
using namespace std;
using namespace cv;
cv::Mat butterworth_low_kernel(cv::Mat &scr, float sigma, int n);
cv::Mat butterworth_low_pass_filter(cv::Mat &src, float d0, int n);
cv::Mat butterworth_high_kernel(cv::Mat &scr, float sigma, int n);
cv::Mat butterworth_high_pass_filter(cv::Mat &src, float d0, int n);
cv::Mat frequency_filter(cv::Mat &scr, cv::Mat &blur);
cv::Mat image_make_border(cv::Mat &src);
void fftshift(cv::Mat &plane0, cv::Mat &plane1);
void getcart(int rows, int cols, cv::Mat &x, cv::Mat &y);
Mat powZ(cv::InputArray src, double power);
Mat sqrtZ(cv::InputArray src);
int main(void)
{
  Mat test = imread("tangsan.jpg", 0);
  float D0 = 50.0f;
  float D1 = 5.0f;
  Mat lowpass = butterworth_low_pass_filter(test, D0,2);
  Mat highpass = butterworth_high_pass_filter(test, D1, 2);
  imshow("original", test);
  imshow("low pass", lowpass / 255);     // lowpass的数据都比较大，0-255，imshow对于float型Mat显示需要除以255
  imshow("high pass", highpass / 255);   // highpass的数据都比较大，0-255，imshow对于float型Mat显示需要除以255
  waitKey(0);
  system("pause");
  return 0;
}
// 巴特沃斯低通滤波核函数
cv::Mat butterworth_low_kernel(cv::Mat &scr, float sigma, int n)
{
  cv::Mat butterworth_low_pass(scr.size(), CV_32FC1); //，CV_32FC1
  float D0 = sigma;//半径D0越小，模糊越大；半径D0越大，模糊越小
  for (int i = 0; i < scr.rows; i++) {
    for (int j = 0; j < scr.cols; j++) {
      float d = sqrt(pow(float(i - scr.rows / 2), 2) + pow(float(j - scr.cols / 2), 2));//分子,计算pow必须为float型
      butterworth_low_pass.at<float>(i, j) = 1.0f / (1.0f + pow(d / D0, 2 * n));
    }
  }
  return butterworth_low_pass;
}
// 巴特沃斯低通滤波
cv::Mat butterworth_low_pass_filter(cv::Mat &src, float d0, int n)
{
  // H = 1 / (1+(D/D0)^2n)   n表示巴特沃斯滤波器的次数
  // 阶数n=1 无振铃和负值    阶数n=2 轻微振铃和负值  阶数n=5 明显振铃和负值   阶数n=20 与ILPF相似
  cv::Mat padded = image_make_border(src);
  cv::Mat butterworth_kernel = butterworth_low_kernel(padded, d0, n);
  cv::Mat result = frequency_filter(padded, butterworth_kernel);
  return result;
}
// 巴特沃斯高通滤波核函数
cv::Mat butterworth_high_kernel(cv::Mat &scr, float sigma, int n)
{
  cv::Mat butterworth_high_pass(scr.size(), CV_32FC1); //，CV_32FC1
  float D0 = (float)sigma;  // 半径D0越小，模糊越大；半径D0越大，模糊越小
  for (int i = 0; i < scr.rows; i++) {
    for (int j = 0; j < scr.cols; j++) {
      float d = sqrt(pow(float(i - scr.rows / 2), 2) + pow(float(j - scr.cols / 2), 2));//分子,计算pow必须为float型
      butterworth_high_pass.at<float>(i, j) =1.0f-1.0f / (1.0f + pow(d / D0, 2 * n));
    }
  }
  return butterworth_high_pass;
}
// 巴特沃斯高通滤波
cv::Mat butterworth_high_pass_filter(cv::Mat &src, float d0, int n)
{
  cv::Mat padded = image_make_border(src);
  cv::Mat butterworth_kernel = butterworth_high_kernel(padded, d0, n);
  cv::Mat result = frequency_filter(padded, butterworth_kernel);
  return result;
}
// 频率域滤波
cv::Mat frequency_filter(cv::Mat &scr, cv::Mat &blur)
{
  cv::Mat mask = scr == scr;
  scr.setTo(0.0f, ~mask);
  //创建通道，存储dft后的实部与虚部（CV_32F，必须为单通道数）
  cv::Mat plane[] = { scr.clone(), cv::Mat::zeros(scr.size() , CV_32FC1) };
  cv::Mat complexIm;
  cv::merge(plane, 2, complexIm); // 合并通道 （把两个矩阵合并为一个2通道的Mat类容器）
  cv::dft(complexIm, complexIm); // 进行傅立叶变换，结果保存在自身
  // 分离通道（数组分离）
  cv::split(complexIm, plane);
  // 以下的操作是频域迁移
  fftshift(plane[0], plane[1]);
  // *****************滤波器函数与DFT结果的乘积****************
  cv::Mat blur_r, blur_i, BLUR;
  cv::multiply(plane[0], blur, blur_r);  // 滤波（实部与滤波器模板对应元素相乘）
  cv::multiply(plane[1], blur, blur_i);  // 滤波（虚部与滤波器模板对应元素相乘）
  cv::Mat plane1[] = { blur_r, blur_i };
  // 再次搬移回来进行逆变换
  fftshift(plane1[0], plane1[1]);
  cv::merge(plane1, 2, BLUR); // 实部与虚部合并
  cv::idft(BLUR, BLUR);       // idft结果也为复数
  BLUR = BLUR / BLUR.rows / BLUR.cols;
  cv::split(BLUR, plane);//分离通道，主要获取通道
  return plane[0];
}
// 图像边界处理
cv::Mat image_make_border(cv::Mat &src)
{
  int w = cv::getOptimalDFTSize(src.cols); // 获取DFT变换的最佳宽度
  int h = cv::getOptimalDFTSize(src.rows); // 获取DFT变换的最佳高度
  cv::Mat padded;
  // 常量法扩充图像边界，常量 = 0
  cv::copyMakeBorder(src, padded, 0, h - src.rows, 0, w - src.cols, cv::BORDER_CONSTANT, cv::Scalar::all(0));
  padded.convertTo(padded, CV_32FC1);
  return padded;
}
// 实现频域滤波器的网格函数
void getcart(int rows, int cols, cv::Mat &x, cv::Mat &y) {
  x.create(rows, cols, CV_32FC1);
  y.create(rows, cols, CV_32FC1);
  //设置边界
  //计算其他位置的值
  for (int i = 0; i < rows; ++i) {
    if (i <= rows / 2) {
      x.row(i) = i;
    }
    else {
      x.row(i) = i - rows;
    }
  }
  for (int i = 0; i < cols; ++i) {
    if (i <= cols / 2) {
      y.col(i) = i;
    }
    else {
      y.col(i) = i - cols;
    }
  }
}
// fft变换后进行频谱搬移
void fftshift(cv::Mat &plane0, cv::Mat &plane1)
{
  // 以下的操作是移动图像  (零频移到中心)
  int cx = plane0.cols / 2;
  int cy = plane0.rows / 2;
  cv::Mat part1_r(plane0, cv::Rect(0, 0, cx, cy));  // 元素坐标表示为(cx, cy)
  cv::Mat part2_r(plane0, cv::Rect(cx, 0, cx, cy));
  cv::Mat part3_r(plane0, cv::Rect(0, cy, cx, cy));
  cv::Mat part4_r(plane0, cv::Rect(cx, cy, cx, cy));
  cv::Mat temp;
  part1_r.copyTo(temp);  //左上与右下交换位置(实部)
  part4_r.copyTo(part1_r);
  temp.copyTo(part4_r);
  part2_r.copyTo(temp);  //右上与左下交换位置(实部)
  part3_r.copyTo(part2_r);
  temp.copyTo(part3_r);
  cv::Mat part1_i(plane1, cv::Rect(0, 0, cx, cy));  //元素坐标(cx,cy)
  cv::Mat part2_i(plane1, cv::Rect(cx, 0, cx, cy));
  cv::Mat part3_i(plane1, cv::Rect(0, cy, cx, cy));
  cv::Mat part4_i(plane1, cv::Rect(cx, cy, cx, cy));
  part1_i.copyTo(temp);  //左上与右下交换位置(虚部)
  part4_i.copyTo(part1_i);
  temp.copyTo(part4_i);
  part2_i.copyTo(temp);  //右上与左下交换位置(虚部)
  part3_i.copyTo(part2_i);
  temp.copyTo(part3_i);
}
Mat powZ(cv::InputArray src, double power) {
  cv::Mat dst;
  cv::pow(src, power, dst);
  return dst;
}
Mat sqrtZ(cv::InputArray src) {
  cv::Mat dst;
  cv::sqrt(src, dst);
  return dst;
}

测试效果

图1 效果图

   不同的滤波参数导致的滤波器尺寸大小不一，得到的结果也就不一样~

      另外，如果我的代码有什么问题，欢迎大家提出异议批评指正，一同进步~

      如果文章帮助到你了，可以点个赞让我知道，我会很快乐~加油！

文章标签：
C++
计算机视觉
关键词：
OpenCV c++
OpenCV滤波器
opencv高通滤波器C++
OpenCV高通
OpenCV低通高通滤波器
翟天保Steven
目录
相关文章
SarPro
|
9月前
|
存储 算法 Linux
【实战项目】网络编程：在Linux环境下基于opencv和socket的人脸识别系统--C++实现
【实战项目】网络编程：在Linux环境下基于opencv和socket的人脸识别系统--C++实现
SarPro
295 7
opencv学堂
|
8月前
|
算法 开发工具 计算机视觉
【零代码研发】OpenCV实验大师工作流引擎C++ SDK演示
【零代码研发】OpenCV实验大师工作流引擎C++ SDK演示
opencv学堂
115 1
蓝易云
|
4月前
|
Ubuntu Linux 编译器
Linux/Ubuntu下使用VS Code配置C/C++项目环境调用OpenCV
通过以上步骤，您已经成功在Ubuntu系统下的VS Code中配置了C/C++项目环境，并能够调用OpenCV库进行开发。请确保每一步都按照您的系统实际情况进行适当调整。
蓝易云
1015 3
蓝易云
|
5月前
|
存储 计算机视觉 C++
在C++中实现Armadillo库与OpenCV库之间的数据格式转换
在C++中实现Armadillo库与OpenCV库之间的数据格式转换是一项常见且实用的技能。上述步骤提供了一种标准的方法来进行这种转换，可以帮助开发者在两个库之间高效地转移和处理数据。虽然转换过程相对直接，但开发者应留意数据类型匹配和性能优化等关键细节。
蓝易云
84 11
蓝易云
|
5月前
|
存储 计算机视觉 C++
在C++中实现Armadillo库与OpenCV库之间的数据格式转换
在C++中实现Armadillo库与OpenCV库之间的数据格式转换是一项常见且实用的技能。上述步骤提供了一种标准的方法来进行这种转换，可以帮助开发者在两个库之间高效地转移和处理数据。虽然转换过程相对直接，但开发者应留意数据类型匹配和性能优化等关键细节。
蓝易云
49 3
opencv学堂
|
8月前
|
计算机视觉 C++
【见微知著】OpenCV中C++11 lambda方式急速像素遍历
【见微知著】OpenCV中C++11 lambda方式急速像素遍历
opencv学堂
82 0
米码收割机
|
9月前
|
人工智能 机器人 Linux
【C++】Linux下如何查看opencv的版本
【C++】Linux下如何查看opencv的版本
米码收割机
195 0
大花爱编程
|
9月前
|
算法 C++ 计算机视觉
Opencv（C++）学习系列---Laplacian拉普拉斯边缘检测算法
Opencv（C++）学习系列---Laplacian拉普拉斯边缘检测算法
大花爱编程
405 0
大花爱编程
|
9月前
|
算法 计算机视觉 C++
Opencv(C++)学习系列---Sobel索贝尔算子边缘检测
Opencv(C++)学习系列---Sobel索贝尔算子边缘检测
大花爱编程
254 0
大花爱编程
|
9月前
|
算法 C++ 计算机视觉
Opencv(C++)学习系列---Canny边缘检测算法
Opencv(C++)学习系列---Canny边缘检测算法
大花爱编程
214 0

热门文章

最新文章

  • 1
    嵌入式C++、STM32、MySQL、GPS、InfluxDB和MQTT协议数据可视化
  • 2
    【c++丨STL】stack和queue的使用及模拟实现
  • 3
    为什么C/C++编译腰要先完成汇编
  • 4
    c++ linux通过实现独立进程之间的通信和传递字符串 demo
  • 5
    类和对象的简述（c++篇）
  • 6
    模拟实现c++中的vector模版
  • 7
    【01】opencv项目实践第一步opencv是什么-opencv项目实践-opencv完整入门以及项目实践介绍-opencv以土壤和水滴分离的项目实践-人工智能AI项目优雅草卓伊凡
  • 8
    模拟实现c++中的list模版
  • 9
    使用 OpenCV 和 Python 轻松实现人脸检测
  • 10
    模拟实现c++中的string
  • 1
    基于OpenCV的车牌识别系统源码分享
    36
  • 2
    【01】opencv项目实践第一步opencv是什么-opencv项目实践-opencv完整入门以及项目实践介绍-opencv以土壤和水滴分离的项目实践-人工智能AI项目优雅草卓伊凡
    105
  • 3
    使用 OpenCV 和 Python 轻松实现人脸检测
    60
  • 4
    Ubuntu系统下编译OpenCV4.8源码
    70
  • 5
    Ubuntu系统下编译OpenCV4.8源码
    79
  • 6
    Ubuntu系统下编译OpenCV4.8源码
    37
  • 7
    Ubuntu系统编译OpenCV4.8源码
    56
  • 8
    基于opencv与mediapipe的民族舞舞蹈动作识别
    98
  • 9
    基于计算机视觉（opencv)的运动计数（运动辅助）系统-源码+注释+报告
    113
  • 10
    基于Python_opencv人脸录入、识别系统（应用dlib机器学习库）（下）
    62

    • 相关课程

    更多
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce

    • 相关实验场景

    更多
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车巡线
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车跟车
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车识别路牌停车
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车多车跟随
  • Gazebo环境下基于ROS和OpenCV的阿克曼小车综合实验
    • 下一篇
    PAI Model Gallery 支持云上一键部署 DeepSeek-V3、DeepSeek-R1 系列模型