图像处理实验3:空域滤波

要求

1. 利用均值模板平滑灰度图像。
   具体内容:利用 OpenCV 对图像像素进行操作,分别利用 33. 55 和 9*9
   尺寸的均值模板平滑灰度图像
2. 利用高斯模板平滑灰度图像。
   具体内容:利用 OpenCV 对图像像素进行操作,分别利用 33. 55 和 9*9
   尺寸的高斯模板平滑灰度图像
3. 利用 Laplacian. Robert. Sobel 模板锐化灰度图像。
   具体内容:利用 OpenCV 对图像像素进行操作,分别利用 Laplacian. Robert.
   Sobel 模板锐化灰度图像
4. 利用高提升滤波算法增强灰度图像。
   具体内容:利用 OpenCV 对图像像素进行操作,设计高提升滤波算法增
   强图像
5. 利用均值模板平滑彩色图像。
   具体内容:利用 OpenCV 分别对图像像素的 RGB 三个通道进行操作,利
   用 33. 55 和 9*9 尺寸的均值模板平滑彩色图像
6. 利用高斯模板平滑彩色图像。
   具体内容:利用 OpenCV 分别对图像像素的 RGB 三个通道进行操作,分
   别利用 33. 55 和 9*9 尺寸的高斯模板平滑彩色图像
7. 利用 Laplacian. Robert. Sobel 模板锐化灰度图像。
   具体内容:利用 OpenCV 分别对图像像素的 RGB 三个通道进行操作,分
   别利用 Laplacian. Robert. Sobel 模板锐化彩色图像

过程

我没有严格按照要求做，事实上，我增加了些。

向量

可使用vector存储要使用的参数。

在使用vector存储函数时，遇到了些麻烦。gaussian_kernel有3个参数，而vector被我设置成元素为function<void(Mat&, int)>>，使用bind将gaussian_kernel转化成符合要求的函数对象（仿函数）即可。

我之前错误的做法是，又另外实现了满足条件的只需要接受Mat&,int两个参数的gaussian_kernel函数，函数重载。但编译器似乎不知道该使用哪一个gaussian_kernel函数了

opencv的矩阵运算

opencv的矩阵运算支持多通道Mat，所以我之前将彩色图像split后处理再merge的做法反而多余了。

当需要对不同通道做不同处理时，这时就需要split–>process–>merge处理流程了。

Robert算子

一般见到的Robert算子是2×2的，但一般卷积核大小为奇数，所以可把2*2的卷积核放到3×3的右下方。

解耦

在实验1时，我把公共部分抽象成一个公共函数，供各个函数调用。

在此次实验中，我把参数和处理函数（回调函数）分别放到不同的vector。将公共处理部分在主函数的for循环中，主动调用vector中的函数和参数。

代码

#include <opencv2/core.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>

#include <iostream>
#include <vector>
#include <map>
#include <functional>
#include <string>

using namespace cv;
using namespace std;

void mean_kernel(Mat &kernel, int ksize);
void gaussian_kernel(Mat &kernel, int ksize, double sigma=0.849);

vector<int> ksizes {3, 5, 9};
vector<string> smooth_kernel_names {"Mean", "Gauss"};
vector<function<void(Mat&, int)>> smooth_kernel_fun {mean_kernel, bind(gaussian_kernel, placeholders::_1, placeholders::_2, 1.)};

vector<string> diff_kernel_names {"Laplace", "Sobel", "Robert",};
vector<vector<char>> kernel_weights0 {{0,-1,0,-1,4,-1,0,-1,0}, {-1,-2,-1,0,0,0,1,2,1}, {0,0,0,0,-1,0,0,0,1}};
vector<vector<char>> kernel_weights1 {{0,-1,0,-1,4,-1,0,-1,0}, {-1,0,1,-2,0,2,-1,0,1}, {0,0,0,0,0,-1,0,1,0}};

void mean_kernel(Mat &kernel, int ksize)
{
    kernel = Mat::ones(ksize, ksize, CV_32F) / (float)(ksize * ksize);
}

void gaussian_kernel(Mat &kernel, int ksize, double sigma)
{
    kernel.create(ksize, ksize, CV_32F);
    auto fun = [=](float x, float y) -> float {
        return exp((-x*x-y*y) / (2*sigma*sigma))/ (2 * CV_PI * sigma * sigma);};

    for (int i = 0; i < ksize; ++i) {
        auto p = kernel.ptr<float>(i);
        for (int j = 0; j < ksize; ++j) {
            p[j] = fun(j-(ksize-1)/2, i-(ksize-1)/2);
            // p[j] = fun(j-ksize/2, i-ksize/2);
        }
    }

    auto weight_sum = cv::sum(kernel);
    cv::divide(kernel, Mat(ksize, ksize, kernel.type(), weight_sum), kernel);
}

int main(int argc, char const *argv[])
{
    const char *image_path = (argc > 1) ? argv[1] : "img_test.jpg";
    Mat img, image_color, image_gray, image_dst;
    img = imread(image_path, IMREAD_COLOR);
    if (img.empty()) {
        cout << "Cannot read image: " << image_path << std::endl;
        return -1;
    }

    namedWindow("image", CV_WINDOW_AUTOSIZE);

    image_color = img;
    cvtColor(image_color, image_gray, CV_BGR2GRAY);

    map<string, Mat> images {{"image_gray", image_gray}, {"image_color", image_color}};


    for (auto &item : images) {
        auto image_name = item.first;
        auto image = item.second;

        cout << endl << endl;
        cout << image_name << endl;
        imshow("image", image);
        waitKey();

        cout << endl;
        for (size_t i = 0; i < smooth_kernel_names.size(); ++i) {
            cout << smooth_kernel_names[i] << endl;

            for (size_t j = 0; j < ksizes.size(); ++j) {
                Mat kernel, image_diff;

                smooth_kernel_fun[i](kernel, ksizes[j]);

                cout << smooth_kernel_names[i] << "\tsize:" << ksizes[j] << "\tsmooth" << endl;
                filter2D(image, image_dst, image.depth(), kernel);
                imshow("image", image_dst);
                waitKey();

                cout << smooth_kernel_names[i] << "\tsize:" << ksizes[j] << "\tdiff" << endl;
                subtract(image, image_dst, image_diff);
                imshow("image", image_diff);
                waitKey();

                cout << smooth_kernel_names[i] << "\tsize:" << ksizes[j] << "\tsharpen" << endl;
                add(image, image_diff, image_dst);
                imshow("image", image_dst);
                waitKey();
            }
        }

        cout << endl;
        for (size_t i = 0; i < diff_kernel_names.size(); ++i) {
            cout << diff_kernel_names[i] << endl;

            Mat diff, diff0, diff1, abs_diff0, abs_diff1;

            filter2D(image, diff0, image.depth(), Mat(3,3,CV_8S,kernel_weights0[i].data()));
            filter2D(image, diff1, image.depth(), Mat(3,3,CV_8S,kernel_weights1[i].data()));
            convertScaleAbs(diff0, abs_diff0);
            convertScaleAbs(diff1, abs_diff1);
            addWeighted(abs_diff0, 0.5, abs_diff1, 0.5, 0, diff);

            cout << diff_kernel_names[i] + "\tdiff" << endl;
            imshow("image", diff);
            waitKey();

            cout << diff_kernel_names[i] + "\tsharpen" << endl;
            add(image, diff, image_dst);
            imshow("image", image_dst);
            waitKey();
        }
    }

    return 0;
}