Apprentissage OpenCV: manipulation d'image de base (5): Smooth and Blur

Filtres communs

Filtrage moyen

Le filtrage moyen est également appelé filtrage linéaire, et sa méthode principale est la moyenne de voisinage. Le principe de base du filtrage linéaire est de remplacer chaque valeur de pixel de l'image d'origine par la valeur moyenne, c'est-à-dire le pixel actuel (x, y) à traiter, de sélectionner un modèle, qui est composé de plusieurs pixels voisins, et de trouver la valeur de tous les pixels du modèle Valeur moyenne, puis attribuez la valeur moyenne au pixel actuel (x, y), qui peut être exprimée par la formule suivante:

Caractéristiques: Le filtrage moyen lui-même a des défauts inhérents, c'est-à-dire qu'il ne peut pas bien protéger les détails de l'image . Il détruit également les détails de l'image tout en réduisant le bruit de l'image, de sorte que l'image devient floue et que le bruit ne peut pas être supprimé correctement.

Filtre médian

Le filtrage médian est une technologie de traitement de signal non linéaire qui peut supprimer efficacement le bruit en se basant sur la théorie statistique du classement. Le principe de base du filtrage médian consiste à utiliser la valeur d'un point dans une image numérique ou une séquence numérique avec la valeur de chaque point dans un voisinage de ce point. Au lieu de la valeur médiane, les valeurs des pixels environnants sont proches de la valeur réelle, éliminant ainsi les points de bruit isolés.

Caractéristiques: Le filtre médian a un bon effet de filtrage sur le bruit impulsionnel, en particulier lors du filtrage du bruit, il peut protéger le bord du signal et l'empêcher d'être flou. Ces excellentes caractéristiques ne sont pas disponibles dans les méthodes de filtrage linéaire.

Filtrage gaussien

Distribution gaussienne bidimensionnelle

Le filtrage gaussien est un filtre de lissage linéaire, qui convient pour éliminer le bruit gaussien et est largement utilisé dans le processus de réduction du bruit du traitement d'image. En termes simples, le filtrage gaussien est le processus moyen pondéré de l'image entière. La valeur de chaque pixel est obtenue par moyenne pondérée de lui-même et des autres valeurs de pixels du voisinage. Le poids pondéré provient de la distribution gaussienne bidimensionnelle générée en fonction des paramètres d'entrée.

Caractéristiques: La plupart du bruit de l'image est un bruit gaussien, les filtres gaussiens sont donc également largement utilisés. Le filtrage gaussien est un filtre de lissage linéaire, qui convient pour éliminer le bruit gaussien et est largement utilisé dans le débruitage d'image.

Filtrage bilatéral

Le filtre bilatéral est une méthode de filtrage non linéaire qui combine la proximité spatiale de l' image et la similitude de la valeur du pixel. Il prend également en compte les informations spatiales et la similitude des niveaux de gris pour obtenir la préservation des contours et le débruitage. objectif.

Domaine spatial S

Domaine de plage de pixels (domaine de plage R)

En général, lorsque la différence de pixels est supérieure au seuil (c'est-à-dire qu'il y a un bord), le filtrage est divisé en deux parties, sans affecter les bords pour effectuer un filtrage gaussien. Structuré comme la formule suivante:

Caractéristiques: Le filtre bilatéral, comme son nom l'indique, a une variance gaussienne de plus que le filtre gaussien . Il s'agit d'une fonction de filtre gaussien basée sur la distribution spatiale. Ainsi, près du bord, les pixels plus éloignés n'affecteront pas trop la valeur du pixel sur le bord. Assurer la préservation des valeurs de pixels près du bord. Cependant, en raison de la préservation d'une trop grande quantité d'informations à haute fréquence, le filtre bilatéral ne peut pas filtrer proprement le bruit à haute fréquence dans l'image couleur et ne peut que filtrer correctement les informations à basse fréquence. Le filtrage bilatéral est souvent utilisé dans des applications telles que la belle dermabrasion.

Introduction à l'API

• Filtrage moyen

• blur(src, dst, Size(5, 5));
  //源图片，生成图片，卷积核大小
  //卷积核大小长选用正方形的奇数边长，也可选用奇数长和宽的矩形，但不常用可根据实际情况选定

• Filtre médian

• medianBlur(src, dst, ksize / 2 * 2 + 1);
  //源图片，生成图片，卷积核大小(默认为方形)

• Filtrage gaussien

• GaussianBlur(src, dst, Size(wkernelSize / 2 * 2 + 1, hkernelSize / 2 * 2 + 1), wsigma, hsigma);
  //源图片，生成图片，核大小(长、宽)，长上分布的标准差，宽上分布的标准差
  //同样可以根据需要改变卷积核的长宽，及对应维度上的分布
  

• Filtrage bilatéral

• bilateralFilter(src, dst, kernelSize / 2 * 2 + 1, sigmaColor, sigmaSpace);
  //源图片，生成图片，卷积核大小，高斯分布标准差，保护边缘阈值

  Plus le seuil du bord de protection est bas, plus les détails sont conservés et plus le paramètre est grand, plus le degré de flou est élevé.

Pratique du code

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

using namespace std;
using namespace cv;

typedef struct _imgPair {
	Mat* src;
	Mat* dst;
	void* Param;
	string winName;
}ImgPair;

typedef struct _gaussianParam {
	int kernelSize;
	int sigma;
}GaussianParam;

typedef struct _bilateralParam {
	int kernelSize;
	int sigmaColor;
	int sigmaSpace;
}BilateralParam;

void on_gaussiankernelBar(int ksize, void* userdata)
{
	ImgPair* pImgPair = (ImgPair*)userdata;
	GaussianParam* gPair = (GaussianParam*)(pImgPair->Param);
	gPair->kernelSize = ksize;

	GaussianBlur(*(pImgPair->src), *(pImgPair->dst), Size(gPair->kernelSize / 2 * 2 + 1, gPair->kernelSize / 2 * 2 + 1), gPair->sigma, gPair->sigma);
	imshow(pImgPair->winName, *(pImgPair->dst));
}


void on_gaussianSigmaBar(int sigma, void* userdata)
{
	ImgPair* pImgPair = (ImgPair*)userdata;
	GaussianParam* gPair = (GaussianParam*)(pImgPair->Param);
	gPair->sigma = double(sigma);

	GaussianBlur(*(pImgPair->src), *(pImgPair->dst), Size(gPair->kernelSize / 2 * 2 + 1, gPair->kernelSize / 2 * 2 + 1), gPair->sigma, gPair->sigma);
	imshow(pImgPair->winName, *(pImgPair->dst));
}




void on_medianSigmaBar(int ksize, void* userdata)
{
	ImgPair* pImgPair = (ImgPair*)userdata;

	medianBlur(*(pImgPair->src), *(pImgPair->dst), ksize / 2 * 2 + 1);
	imshow(pImgPair->winName, *(pImgPair->dst));

}


void on_bilateralDBar(int ksize, void* userdata)
{
	ImgPair* pImgPair = (ImgPair*)userdata;
	BilateralParam* param = (BilateralParam*)(pImgPair->Param);
	bilateralFilter(*(pImgPair->src), *(pImgPair->dst), ksize / 2 * 2 + 1, param->sigmaColor, param->sigmaSpace);
	param->kernelSize = ksize;
	imshow(pImgPair->winName, *(pImgPair->dst));

}



void on_bilateralSigmaSpaceBar(int sigmaSpace, void* userdata)
{
	ImgPair* pImgPair = (ImgPair*)userdata;
	BilateralParam* param = (BilateralParam*)(pImgPair->Param);
	bilateralFilter(*(pImgPair->src), *(pImgPair->dst), param->kernelSize / 2 * 2 + 1, param->sigmaColor, sigmaSpace);
	param->sigmaSpace = sigmaSpace;
	imshow(pImgPair->winName, *(pImgPair->dst));
}

void on_bilateralSigmaColorBar(int sigmaColor, void* userdata)
{
	ImgPair* pImgPair = (ImgPair*)userdata;
	BilateralParam* param = (BilateralParam*)(pImgPair->Param);
	bilateralFilter(*(pImgPair->src), *(pImgPair->dst), param->kernelSize / 2 * 2 + 1, sigmaColor, param->sigmaSpace);
	param->sigmaColor = sigmaColor;
	imshow(pImgPair->winName, *(pImgPair->dst));
}


int main()
{
	Mat src = imread("4.jpg");

	namedWindow("src");
	imshow("src", src);


	/*-------GaussianBlur-----------*/
	Mat GaussianBlurImg;
	namedWindow("GaussianBlurImg");
	GaussianParam gaussianParam = { 5, 1.0 };
	GaussianBlur(src, GaussianBlurImg, Size(5, 5), 1, 1);
	GaussianParam gparam = { 5, 1.0 };
	ImgPair  gaussianPair = { &src, &GaussianBlurImg, &gparam,  "GaussianBlurImg" };

	imshow("GaussianBlurImg", GaussianBlurImg);
	createTrackbar("kernelsize", "GaussianBlurImg", &(gparam.kernelSize), 30, on_gaussiankernelBar, &gaussianPair);
	createTrackbar("sigma", "GaussianBlurImg", &(gparam.kernelSize), 10, on_gaussianSigmaBar, &gaussianPair);

	/*-------medianBlur-----------*/
	Mat MedianBlurImg;
	int kernelSize = 5;
	ImgPair  medianPair = { &src, &MedianBlurImg, nullptr,  "MedianBlurImg" };
	medianBlur(src, MedianBlurImg, 5);
	imshow("MedianBlurImg", MedianBlurImg);
	createTrackbar("kernelsize", "MedianBlurImg", &(kernelSize), 30, on_medianSigmaBar, &medianPair);


	/*---Bilateral-----------------*/
	Mat BilateralFilterImg;
	bilateralFilter(src, BilateralFilterImg, 5, 2, 2);
	BilateralParam bparam = { 5,1,1 };
	ImgPair  bilateralPair = { &src, &BilateralFilterImg, &bparam,  "BilateralFilterImg" };
	imshow("BilateralFilterImg", BilateralFilterImg);
	createTrackbar("kernelsize", "BilateralFilterImg", &(bparam.kernelSize), 30, on_bilateralDBar, &bilateralPair);
	createTrackbar("sigmaspace", "BilateralFilterImg", &(bparam.sigmaSpace), 30, on_bilateralSigmaSpaceBar, &bilateralPair);
	createTrackbar("sigmacolor", "BilateralFilterImg", &(bparam.sigmaColor), 30, on_bilateralSigmaColorBar, &bilateralPair);
	waitKey(0);
}