運動模糊濾波器

目錄

• 目標
• 理論
  • 運動模糊影像的 PSF 是什麼？
  • 如何恢復模糊影像？
• 原始碼
• 解釋
• 結果

上一個教程： 離焦去模糊濾鏡
下一個教程： 基於梯度結構張量的各向異性影像分割

原始作者	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 | input image name }"
"{LEN |125 | length of a motion }"
"{THETA |0 | angle of a motion in degrees }"
"{SNR |700 | signal to noise ratio }"
;
 
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()) //check whether the image is loaded or not
    {
cout << "ERROR : Image cannot be loaded..!!" << endl;
        return -1;
    }
 
    Mat imgOut;
 
    // it needs to process even image only
    Rect roi = Rect(0, 0, imgIn.cols & -2, imgIn.rows & -2);
 
    //Hw calculation (start)
    Mat Hw, h;
calcPSF(h, roi.size(), LEN, THETA);
calcWnrFilter(h, Hw, 1.0 / double(snr));
    //Hw calculation (stop)
 
imgIn.convertTo(imgIn, CV_32F);
edgetaper(imgIn, imgIn);
 
    // filtering (start)
filter2DFreq(imgIn(roi), imgOut, Hw);
    // filtering (stop)
 
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 << "You will learn how to recover an image with motion blur distortion using a Wiener filter" << 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_<float>(inputImg.clone()), Mat::zeros(inputImg.size(), CV_32F) };
    Mat complexI;
    merge(planes, 2, complexI);
    dft(complexI, complexI, DFT_SCALE);
 
    Mat planesH[2] = { Mat_<float>(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_<float>(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<float>(0);
    float* p2 = w2.ptr<float>(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);
}

解釋

運動模糊影像恢復演算法包括 PSF 生成、維納濾波器生成以及在頻域中對模糊影像進行濾波

    // it needs to process even image only
    Rect roi = Rect(0, 0, imgIn.cols & -2, imgIn.rows & -2);
 
    //Hw calculation (start)
    Mat Hw, h;
calcPSF(h, roi.size(), LEN, THETA);
calcWnrFilter(h, Hw, 1.0 / double(snr));
    //Hw calculation (stop)
 
imgIn.convertTo(imgIn, CV_32F);
edgetaper(imgIn, imgIn);
 
    // filtering (start)
filter2DFreq(imgIn(roi), imgOut, Hw);
    // filtering (stop)

函式 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<float>(0);
    float* p2 = w2.ptr<float>(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。