画像のフィルタリング機能-opencv

 

関数原型

方框滤波

無効 boxFilter（InputArray SRC、OutputArray DST、int型 ddepth、サイズksize、ポイントアンカー=ポイント（ - 1、 - 1 ）、 
     BOOLノーマライズ= 真、int型 borderType = BORDER_DEFAULT）
均值滤波

無効ぼかし（インプットSRC、OutputArray DST 、サイズksize、ポイントアンカー=ポイント（ - 1、 - 1 ）、 
     int型 borderType = BORDER_DEFAULT）
高斯滤波

無効 GaussianBlur（InputArray SRC、OutputArray DST、サイズksize、ダブル SIGMAX、ダブル sigmaY = 0 、 
    int型 borderType = BORDER_DEFAULT）
中值滤波

無効 medianBlur（InputArray SRC、OutputArray DST、int型ksize）
双边滤波

無効 bilateralFilter（InputArray SRC、OutputArray DST、int型の D、ダブル sigmaColor、ダブルsigmaSpace、 
     int型 borderType = BORDER_DEFAULT）

特定のパラメータの解析

InputArray SRC：
    入力画像（元画像）、マット型オブジェクト、画像深度はCV_8U、CV_16U、CV_16S、CV_32F一CV_64Fなければなりません。
    ksizeは3または5である場合、細孔サイズは、唯一CV_8U大きい場合メディアンフィルタリングのために、画像の深さは、CV_8U、CV_16U一CV_32Fなければなりません。
OutputArray DST：
    出力画像（対象画像）、及びソース画像のサイズと種類は同じです。
INTのddepth：
    出力画像の深さ、 - 1は、オリジナル画像（すなわちsrc.depth（））の深さを表しています。
サイズksize：
    カーネルサイズ、サイズによって（H、W）を示すためには、wとhはそれぞれ幅と高さを表します。
ポイントアンカー：
    （アンカー、すなわち平滑化点、負の値は、中心点座標を示す場合は、核を採取するので、デフォルトされる - 1 - 。1 ）コアにおけるアンカーの中心を示します。
BOOL 正規：
    識別子が、trueの場合、コアの残りの領域は、（正規化された）正規化されていることを示しています。
INT borderType：
    画像モード外のいくつかの境界画素が導出されます。
ダブルSIGMAX： 
    X方向のガウスカーネル関数の標準偏差を表します。
ダブルsigmaY：
    Y方向のガウシアンカーネルの標準偏差を表します。
    sigmaYが0である場合、それはSIGMAXに設定され、両方が0である場合、及びksize.withのksize.heightによって算出さ、
    そうガウシアンフィルタリング機能、wとhのksizeは、正の奇数でなければなりませんまたは0、異なる場合があります。
int型のksize：
    線形空間の開口部は、1より大きい奇数でなければなりません。
INT D：
    その値が正でない場合、フィルタ処理画素近傍の直径は、値がsigmaSpaceから算出します。
二重sigmaColor：
    シグマフィルタの色空間値は、このパラメータの値が大きいほど、画素近傍が広い色を有する大きな色領域を等しい半分を生成するために一緒に混合されることを示しています。
ダブルsigmaSpace：
    マーク分散シグマ値は、座標空間の空間フィルタの座標。同じ色取得十分に類似した色の大きな領域ように大きく、その値、遠い画素は、互いに影響を意味します。
    dのときとき> 0、dが近所のsigmaSpaceの大きさとは独立して開発しました。それ以外の場合は、dがsigmaSpaceに比例しています。

代码如下：

書式#include <iostreamの> 
書式#include <opencv2 \コア\ core.hpp> 
の#include <opencv2 \のHighGUI \ highgui.hpp> 
の#include <opencv2 \ imgproc \ imgproc.hpp> 

使用して、名前空間STD; 
使用して名前空間CV; 

マットg_srcImage; / /グローバルソース画像
					//グローバルブロックフィルタリングを対応する出力画像は、フィルタリング、ガウシアンフィルタリング、メディアンフィルタリング、バイラテラルフィルタカーネル値/パラメータ値平均
マットg_dstImgBox、g_dstImgBlur、g_dstImgGaussian、g_dstImgMedian、g_dstImgBilateralと、
INT = g_BoxFilterVal 。5; 
INT g_BlurVal = 12である
。INT g_GaussianBlurVal = 5; 
INT g_MedianBlurVal = 12である。
INT g_BilateralFilterVal = 12であり、

静的ボイドon_BoxFilter（INT、ボイド*）; 
静的ボイドon_Blur（INT、ボイド*）; 
静的ボイドon_GaussianBlur（INT、ボイド* ）; 
静的な無効on_MedianBlur（int型）*無効。
無効on_BilateralFilter静的（int型、void *型）; 
	namedWindow（ "フィルタブロック[]"、1）;

メインINTは（）
{ 
	// g_srcImageに画像を読み取る
	g_srcImage関数imread =（ "E：\\ \\ vs2015 VS2015Opencvプロジェクト\\ \\ \\ 06.jpgピクチャー"）; 
	IF（g_srcImage.data！）{ 
		のprintf（ " 、読み取った画像は、......の\ n「）が存在しない
		偽に戻る; 
	} 

	//所望のアートワーク画像フィルタ5にクローニングし、あるマットタイプ
	g_dstImgBox g_srcImage.clone =（）; 
	g_dstImgBlur = g_srcImage.clone （）; 
	g_dstImgGaussian g_srcImage.clone =（）; 
	g_dstImgMedian g_srcImage.clone =（）; 
	g_dstImgBilateral g_srcImage.clone =（）; 

	//表示画像
	namedWindow（ "[画像]" ,. 1）; 
	関数imshow（「[ピクチャー] "g_srcImage）; 

	//ブロックフィルタ ）。
	on_BoxFilter（g_BoxFilterVal、0）;
	createTrackbar（ "コア値"、 "[ブロックフィルタ]"、＆g_BoxFilterVal、30、on_BoxFilter）; ）。
	on_BilateralFilter（g_BilateralFilterValは、0）; 
	COUTは<< Q "キー、プログラムが終了......の\ n" "押し";

	namedWindow（ "[フィルタを意味する]"、1）; 
	createTrackbar（ "コア値"、 "[フィルタを意味する]"、＆g_BlurVal、30、on_Blur）; 
	on_Blur（g_BlurVal、0）; 

	namedWindow（ "[ガウシアンフィルタ]"、1 ）; 
	createTrackbar（ "コア値"、 "[ガウシアンフィルタ]"、＆g_GaussianBlurVal、30、on_GaussianBlur）; 
	on_GaussianBlur（g_GaussianBlurVal、0）; 

	namedWindow（ "[メディアンフィルタ]" ,. 1）; 
	createTrackbar（ "コア値"、 "[メディアンフィルタ]"、＆g_MedianBlurVal、30、on_MedianBlur）; 
	on_MedianBlur（g_MedianBlurVal、0）; 

	namedWindow（ "[バイラテラルフィルタリング]" ,. 1）; 
	createTrackbar（ "コア値"、 "[バイラテラルフィルタリング]"、＆g_BilateralFilterVal、 30、on_BilateralFilter）; 
静的ボイドon_BoxFilter（INT、ボイド*）
{

	一方、（CHAR（waitKey（1））= 'Q'！）{} 

	戻り0。
} 

	boxFilter（g_srcImage、g_dstImgBox、-1、サイズ（g_BoxFilterVal + 1、g_BoxFilterVal + 1））。
	関数imshow（ "【方框滤波】"、g_dstImgBox）。
} 

静的ボイドon_Blur（INT、ボイド*）
{ 
	ブラー（g_srcImage、g_dstImgBlur、サイズ（g_BlurVal + 1、g_BlurVal + 1）、
		点（-1、-1））。
	関数imshow（ "【均值滤波】"、g_dstImgBlur）。
} 

静的ボイドon_GaussianBlur（INT、ボイド*）
{ 
	GaussianBlur（g_srcImage、g_dstImgGaussian、サイズ（g_GaussianBlurVal * 2 + 1、
		g_GaussianBlurVal * 2 + 1）、0、0）; 
	関数imshow（ "【高斯滤波】"、g_dstImgGaussian）。
} 

静的ボイドon_MedianBlur（INT、ボイド*）
{
	medianBlur（g_srcImage、g_dstImgMedian、g_MedianBlurVal * 2 + 1）; 
	関数imshow（ "[メディアンフィルタ]"、g_dstImgMedian）;
} 

静的ボイドon_BilateralFilter（INT、ボイド*）
{ 
	bilateralFilter（g_srcImage、g_dstImgBilateral、g_BilateralFilterVal、
		g_BilateralFilterVal * 2、g_BilateralFilterVal / 2）; 
	関数imshow（ "[]バイラテラルフィルタリング"、g_dstImgBilateral）; 
}

ノイズを追加します

 

#include <iostream>
#include <opencv2\core\core.hpp>
#include <opencv2\highgui\highgui.hpp>
#include <opencv2\imgproc\imgproc.hpp>
#include<ctime>

using namespace std;
using namespace cv;

Mat g_srcImage;     // 全局的源图像
                    // 分别对应全局的方框滤波、均值滤波、高斯滤波、中值滤波、双边滤波的输出图像以及内核值/参数值
Mat g_dstImgBox, g_dstImgBlur, g_dstImgGaussian, g_dstImgMedian, g_dstImgBilateral;
int g_BoxFilterVal = 5;
int g_BlurVal = 12;
int g_GaussianBlurVal = 5;
int g_MedianBlurVal = 12;
int g_BilateralFilterVal = 12;

static void on_BoxFilter(int, void *);
static void on_Blur(int, void *);
static void on_GaussianBlur(int, void *);
static void on_MedianBlur(int, void *);
static void on_BilateralFilter(int, void*);

//图像椒盐化
void salt(Mat &image, int num) {
    if (!image.data) return;//防止传入空图
    int i, j;
    srand(time(NULL));
    for (int x = 0; x < num; ++x) {
        i = rand() % image.rows;
        j = rand() % image.cols;
        image.at<Vec3b>(i, j)[0] = 255;
        image.at<Vec3b>(i, j)[1] = 255;
        image.at<Vec3b>(i, j)[2] = 255;
    }
}


int main()
{
    // 读取图像到g_srcImage
    Mat image = imread("E:\\VS2015Opencv\\vs2015\\project\\picture\\06.jpg");
    if (!image.data) {
        printf("读取的图片不存在…… \n");
        return false;
    }

    image.copyTo(g_srcImage);
    salt(g_srcImage, 3000);

    // 分别克隆原图到5中滤波所需的图像中，均为Mat类型
    g_dstImgBox = g_srcImage.clone();
    g_dstImgBlur = g_srcImage.clone();
    g_dstImgGaussian = g_srcImage.clone();
    g_dstImgMedian = g_srcImage.clone();
    g_dstImgBilateral = g_srcImage.clone();

    // 显示原图
    namedWindow("【原图】", 1);
    imshow("【原图】", g_srcImage);

    // 方框滤波
    namedWindow("【方框滤波】", 1);
    createTrackbar("内核值", "【方框滤波】", &g_BoxFilterVal, 30, on_BoxFilter);
    on_BoxFilter(g_BoxFilterVal, 0);

    namedWindow("【均值滤波】", 1);
    createTrackbar("内核值", "【均值滤波】", &g_BlurVal, 30, on_Blur);
    on_Blur(g_BlurVal, 0);

    namedWindow("【高斯滤波】", 1);
    createTrackbar("内核值", "【高斯滤波】", &g_GaussianBlurVal, 30, on_GaussianBlur);
    on_GaussianBlur(g_GaussianBlurVal, 0);

    namedWindow("【中值滤波】", 1);
    createTrackbar("内核值", "【中值滤波】", &g_MedianBlurVal, 30, on_MedianBlur);
    on_MedianBlur(g_MedianBlurVal, 0);

    namedWindow("【双边滤波】", 1);
    createTrackbar("内核值", "【双边滤波】", &g_BilateralFilterVal, 30, on_BilateralFilter);
    on_BilateralFilter(g_BilateralFilterVal, 0);

    cout << "按下“q”键时，程序退出……\n";
    while (char(waitKey(1)) != 'q') {}

    return 0;
}

static void on_BoxFilter(int, void *)
{
    boxFilter(g_srcImage, g_dstImgBox, -1, Size(g_BoxFilterVal + 1, g_BoxFilterVal + 1));
    imshow("【方框滤波】", g_dstImgBox);
}

static void on_Blur(int, void *)
{
    blur(g_srcImage, g_dstImgBlur, Size(g_BlurVal + 1, g_BlurVal + 1),
        Point(-1, -1));
    imshow("【均值滤波】", g_dstImgBlur);
}

static void on_GaussianBlur(int, void *)
{
    GaussianBlur(g_srcImage, g_dstImgGaussian, Size(g_GaussianBlurVal * 2 + 1,
        g_GaussianBlurVal * 2 + 1), 0, 0);
    imshow("【高斯滤波】", g_dstImgGaussian);
}

static void on_MedianBlur(int, void *)
{
    medianBlur(g_srcImage, g_dstImgMedian, g_MedianBlurVal * 2 + 1);
    imshow("【中值滤波】", g_dstImgMedian);
}

static void on_BilateralFilter(int, void*)
{
    bilateralFilter(g_srcImage, g_dstImgBilateral, g_BilateralFilterVal,
        g_BilateralFilterVal * 2, g_BilateralFilterVal / 2);
    imshow("【双边滤波】", g_dstImgBilateral);
}

 

 

 参考博文：https://blog.csdn.net/i_chaoren/article/details/54562502