OpenCV 4.11.0
开源计算机视觉库
加载中...
搜索中...
未找到匹配项
运动模糊滤波器

目录

上一篇教程： 散焦去模糊滤波器
下一篇教程： 基于梯度结构张量的各向异性图像分割

原作者Karpushin Vladislav
兼容性OpenCV >= 3.0

目标

在本教程中，您将学习

  • 运动模糊图像的PSF是什么
  • 如何恢复运动模糊图像

理论

关于图像退化模型理论和维纳滤波器理论，您可以参考教程 散焦去模糊滤波器。本页只考虑线性运动模糊失真。本页的运动模糊图像是真实世界的图像。模糊是由运动的物体引起的。

运动模糊图像的PSF是什么？

线性运动模糊失真的点扩散函数 (PSF) 是线段。这种 PSF 由两个参数指定：\(LEN\) 是模糊的长度，\(THETA\) 是运动的角度。

线性运动模糊失真的点扩散函数

如何恢复模糊图像？

在本页中，维纳滤波器用作恢复滤波器，详情请参考教程 散焦去模糊滤波器。为了合成运动模糊情况下的维纳滤波器，需要指定信噪比 ( \(SNR\))、PSF 的 \(LEN\) 和 \(THETA\)。

源代码

您可以在 OpenCV 源代码库的 samples/cpp/tutorial_code/ImgProc/motion_deblur_filter/motion_deblur_filter.cpp 中找到源代码。

#include <iostream>
#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
using namespace cv;
using namespace std;
void help();
void calcPSF(Mat& outputImg, Size filterSize, int len, double theta);
void fftshift(const Mat& inputImg, Mat& outputImg);
void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H);
void calcWnrFilter(const Mat& input_h_PSF, Mat& output_G, double nsr);
void edgetaper(const Mat& inputImg, Mat& outputImg, double gamma = 5.0, double beta = 0.2);
const String keys =
"{help h usage ? | | 打印此消息 }"
"{image |input.png | 输入图像名称 }"
"{LEN |125 | 运动长度 }"
"{THETA |0 | 运动角度（度） }"
"{SNR |700 | 信噪比 }"
;
int main(int argc, char *argv[])
{
help();
CommandLineParser parser(argc, argv, keys);
if (parser.has("help"))
{
parser.printMessage();
return 0;
}
int LEN = parser.get<int>("LEN");
double THETA = parser.get<double>("THETA");
int snr = parser.get<int>("SNR");
string strInFileName = parser.get<String>("image");
if (!parser.check())
{
parser.printErrors();
return 0;
}
Mat imgIn;
imgIn = imread(strInFileName, IMREAD_GRAYSCALE);
if (imgIn.empty()) // 检查图像是否加载
{
cout << "错误：无法加载图像！!" << endl;
return -1;
}
Mat imgOut;
// 只需要处理偶数图像
Rect roi = Rect(0, 0, imgIn.cols & -2, imgIn.rows & -2);
// Hw 计算 (开始)
Mat Hw, h;
calcPSF(h, roi.size(), LEN, THETA);
calcWnrFilter(h, Hw, 1.0 / double(snr));
// Hw 计算 (结束)
imgIn.convertTo(imgIn, CV_32F);
edgetaper(imgIn, imgIn);
// 滤波 (开始)
filter2DFreq(imgIn(roi), imgOut, Hw);
// 滤波 (结束)
imgOut.convertTo(imgOut, CV_8U);
normalize(imgOut, imgOut, 0, 255, NORM_MINMAX);
imwrite("result.jpg", imgOut);
return 0;
}
void help()
{
cout << "2018-08-14" << endl;
cout << "Motion_deblur_v2" << endl;
cout << "您将学习如何使用维纳滤波器恢复具有运动模糊失真的图像" << endl;
}
void calcPSF(Mat& outputImg, Size filterSize, int len, double theta)
{
Mat h(filterSize, CV_32F, Scalar(0));
Point point(filterSize.width / 2, filterSize.height / 2);
ellipse(h, point, Size(0, cvRound(float(len) / 2.0)), 90.0 - theta, 0, 360, Scalar(255), FILLED);
Scalar summa = sum(h);
outputImg = h / summa[0];
}
void fftshift(const Mat& inputImg, Mat& outputImg)
{
outputImg = inputImg.clone();
int cx = outputImg.cols / 2;
int cy = outputImg.rows / 2;
Mat q0(outputImg, Rect(0, 0, cx, cy));
Mat q1(outputImg, Rect(cx, 0, cx, cy));
Mat q2(outputImg, Rect(0, cy, cx, cy));
Mat q3(outputImg, Rect(cx, cy, cx, cy));
Mat tmp;
q0.copyTo(tmp);
q3.copyTo(q0);
tmp.copyTo(q3);
q1.copyTo(tmp);
q2.copyTo(q1);
tmp.copyTo(q2);
}
void filter2DFreq(const Mat& inputImg, Mat& outputImg, const Mat& H)
{
Mat planes[2] = { Mat_(inputImg.clone()), Mat::zeros(inputImg.size(), CV_32F) };
Mat complexI;
merge(planes, 2, complexI);
dft(complexI, complexI, DFT_SCALE);
Mat planesH[2] = { Mat_(H.clone()), Mat::zeros(H.size(), CV_32F) };
Mat complexH;
merge(planesH, 2, complexH);
Mat complexIH;
mulSpectrums(complexI, complexH, complexIH, 0);
idft(complexIH, complexIH);
split(complexIH, planes);
outputImg = planes[0];
}
void calcWnrFilter(const Mat& input_h_PSF, Mat& output_G, double nsr)
{
Mat h_PSF_shifted;
fftshift(input_h_PSF, h_PSF_shifted);
Mat planes[2] = { Mat_(h_PSF_shifted.clone()), Mat::zeros(h_PSF_shifted.size(), CV_32F) };
Mat complexI;
merge(planes, 2, complexI);
dft(complexI, complexI);
split(complexI, planes);
Mat denom;
pow(abs(planes[0]), 2, denom);
denom += nsr;
divide(planes[0], denom, output_G);
}
void edgetaper(const Mat& inputImg, Mat& outputImg, double gamma, double beta)
{
int Nx = inputImg.cols;
int Ny = inputImg.rows;
Mat w1(1, Nx, CV_32F, Scalar(0));
Mat w2(Ny, 1, CV_32F, Scalar(0));
float* p1 = w1.ptr(0);
float* p2 = w2.ptr(0);
float dx = float(2.0 * CV_PI / Nx);
float x = float(-CV_PI);
for (int i = 0; i < Nx; i++)
{
p1[i] = float(0.5 * (tanh((x + gamma / 2) / beta) - tanh((x - gamma / 2) / beta)));
x += dx;
}
float dy = float(2.0 * CV_PI / Ny);
float y = float(-CV_PI);
for (int i = 0; i < Ny; i++)
{
p2[i] = float(0.5 * (tanh((y + gamma / 2) / beta) - tanh((y - gamma / 2) / beta)));
y += dy;
}
Mat w = w2 * w1;
multiply(inputImg, w, outputImg);
}
cv::CommandLineParser
用于命令行解析。
**定义:** utility.hpp:890
cv::Mat_
派生自Mat的模板矩阵类。
**定义:** mat.hpp:2247
cv::Mat
n维密集数组类
**定义:** mat.hpp:829
cv::Mat::clone
CV_NODISCARD_STD Mat clone() const
创建数组和底层数据的完整副本。
cv::Mat::size
MatSize size
**定义:** mat.hpp:2177
cv::Mat::copyTo
void copyTo(OutputArray m) const
将矩阵复制到另一个矩阵。
cv::Mat::cols
int cols
**定义:** mat.hpp:2155
cv::Mat::empty
bool empty() const
如果数组没有元素，则返回true。
cv::Mat::rows
int rows
行和列的数量，当矩阵具有超过2维时为(-1, -1)
**定义:** mat.hpp:2155
cv::Mat::convertTo
void convertTo(OutputArray m, int rtype, double alpha=1, double beta=0) const
将数组转换为另一种数据类型，并可以选择缩放。
cv::Point_
cv::Rect_
二维矩形的模板类。
**定义:** types.hpp:444
cv::Rect_::size
Size_< _Tp > size() const
矩形的尺寸 (宽度，高度)
cv::Scalar_< double >
cv::Size_
用于指定图像或矩形大小的模板类。
定义 types.hpp:335
cv::Size_::height
_Tp height
高度
定义 types.hpp:363
cv::Size_::width
_Tp width
宽度
定义 types.hpp:362
cv::split
void split(const Mat &src, Mat *mvbegin)
将多通道数组分割成多个单通道数组。
cv::mulSpectrums
void mulSpectrums(InputArray a, InputArray b, OutputArray c, int flags, bool conjB=false)
执行两个傅里叶频谱的逐元素相乘。
cv::divide
void divide(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
执行两个数组或标量与数组的逐元素相除。
cv::sum
Scalar sum(InputArray src)
计算数组元素的总和。
cv::merge
void merge(const Mat *mv, size_t count, OutputArray dst)
由多个单通道数组创建一个多通道数组。
cv::multiply
void multiply(InputArray src1, InputArray src2, OutputArray dst, double scale=1, int dtype=-1)
计算两个数组的逐元素比例乘积。
cv::idft
void idft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
计算一维或二维数组的逆离散傅里叶变换。
cv::dft
void dft(InputArray src, OutputArray dst, int flags=0, int nonzeroRows=0)
对一维或二维浮点数组执行正向或逆向离散傅里叶变换。
cv::String
std::string String
定义 cvstd.hpp:151
CV_8U
#define CV_8U
定义 interface.h:73
CV_32F
#define CV_32F
定义 interface.h:78
cv::tanh
Quat< T > tanh(const Quat< T > &q)
cvRound
int cvRound(double value)
将浮点数四舍五入到最接近的整数。
定义 fast_math.hpp:200
CV_PI
#define CV_PI
定义 cvdef.h:380
cv::ellipse
void ellipse(InputOutputArray img, Point center, Size axes, double angle, double startAngle, double endAngle, const Scalar &color, int thickness=1, int lineType=LINE_8, int shift=0)
绘制简单的或粗的椭圆弧或填充椭圆扇区。
main
int main(int argc, char *argv[])
定义 highgui_qt.cpp:3
cv
定义 core.hpp:107
std
STL 命名空间。

解释

运动模糊图像恢复算法包括 PSF 生成、维纳滤波器生成和在频域中滤波模糊图像。

// 只需要处理偶数图像
Rect roi = Rect(0, 0, imgIn.cols & -2, imgIn.rows & -2);
// Hw 计算 (开始)
Mat Hw, h;
calcPSF(h, roi.size(), LEN, THETA);
calcWnrFilter(h, Hw, 1.0 / double(snr));
// Hw 计算 (结束)
imgIn.convertTo(imgIn, CV_32F);
edgetaper(imgIn, imgIn);
// 滤波 (开始)
filter2DFreq(imgIn(roi), imgOut, Hw);
// 滤波 (结束)

函数 calcPSF() 根据输入参数\(LEN\)和\(THETA\)（以度为单位）形成PSF。

void calcPSF(Mat& outputImg, Size filterSize, int len, double theta)
{
Mat h(filterSize, CV_32F, Scalar(0));
Point point(filterSize.width / 2, filterSize.height / 2);
ellipse(h, point, Size(0, cvRound(float(len) / 2.0)), 90.0 - theta, 0, 360, Scalar(255), FILLED);
Scalar summa = sum(h);
outputImg = h / summa[0];
}

函数 edgetaper() 对输入图像的边缘进行锥化处理，以减少恢复图像中的振铃效应。

void edgetaper(const Mat& inputImg, Mat& outputImg, double gamma, double beta)
{
int Nx = inputImg.cols;
int Ny = inputImg.rows;
Mat w1(1, Nx, CV_32F, Scalar(0));
Mat w2(Ny, 1, CV_32F, Scalar(0));
float* p1 = w1.ptr(0);
float* p2 = w2.ptr(0);
float dx = float(2.0 * CV_PI / Nx);
float x = float(-CV_PI);
for (int i = 0; i < Nx; i++)
{
p1[i] = float(0.5 * (tanh((x + gamma / 2) / beta) - tanh((x - gamma / 2) / beta)));
x += dx;
}
float dy = float(2.0 * CV_PI / Ny);
float y = float(-CV_PI);
for (int i = 0; i < Ny; i++)
{
p2[i] = float(0.5 * (tanh((y + gamma / 2) / beta) - tanh((y - gamma / 2) / beta)));
y += dy;
}
Mat w = w2 * w1;
multiply(inputImg, w, outputImg);
}

函数 calcWnrFilter()、fftshift() 和 filter2DFreq() 通过指定的PSF在频域中实现图像滤波。这些函数是从教程散焦去模糊滤波器中复制的。

结果

下面您可以看到具有运动模糊失真的真实世界图像。两辆车的车牌都无法辨认。红色标记显示汽车车牌的位置。

下面您可以看到黑色汽车车牌的恢复结果。结果是使用\(LEN\) = 125，\(THETA\) = 0，\(SNR\) = 700 计算的。

下面您可以看到白色汽车车牌的恢复结果。结果是使用\(LEN\) = 78，\(THETA\) = 15，\(SNR\) = 300 计算的。

手动选择\(SNR\)、\(LEN\)和\(THETA\)的值以获得最佳视觉效果。\(THETA\)参数与汽车的运动方向一致，\(LEN\)参数取决于汽车的运动速度。结果并不完美，但至少它给了我们图像内容的提示。经过一番努力，现在可以辨认出汽车的车牌了。

注意
参数\(LEN\)和\(THETA\)是最重要的。您应该先调整\(LEN\)和\(THETA\)，然后再调整\(SNR\) 。

您还可以找到车牌恢复方法的快速视频演示 YouTube。

2025年1月8日星期三16:06:35 为OpenCV生成的 doxygen 1.12.0