Programmation Java pour implémenter des solutions détaillées pour le flou gaussien et la convolution spatiale des images

Blur gaussien

Le flou gaussien, également connu sous le nom de lissage gaussien, est un effet de traitement largement utilisé dans les logiciels de traitement d'image tels qu'Adobe Photoshop, GIMP et Paint.net. Il est généralement utilisé pour réduire le bruit de l'image et réduire le niveau de détail. L'effet visuel de l'image généré par cette technologie floue est comme l'observation de l'image via un écran translucide, qui est considérablement différent de l'objectif d'effet d'imagerie à l'objectif et des ombres d'éclairage ordinaires. Le lissage gaussien est également utilisé dans les phases de prétraitement dans les algorithmes de vision par ordinateur pour améliorer les effets d'image des images à différentes échelles. D'un point de vue mathématique, le processus de flou gaussien d'une image est une convolution avec la distribution normale. Étant donné que la distribution normale est également appelée distribution gaussienne, cette technologie est appelée gaussienne floue. La convolution de l'image et le flou carré circulaire générera un effet d'imagerie à la fin plus précis. Étant donné que la transformée de Fourier de la fonction gaussienne est une autre fonction gaussienne, le flou gaussien est un filtre passe-bas pour l'image.

Le fuzzing gaussien utilise la fonction de densité de distribution normale de la gaussie pour calculer la transformation de chaque pixel dans l'image.

Sur la base de la fonction gaussienne unidimensionnelle, une fonction gaussienne bidimensionnelle peut être dérivée:

où r est le rayon flou, r ^ 2 = x ^ 2 + y ^ 2, et σ est l'écart type de la distribution normale. Dans l'espace bidimensionnel, les lignes de contour de la surface générées par cette formule sont des cercles concentriques qui sont normalement distribués à partir du centre. La matrice de convolution composée de pixels avec une distribution non nulle est transformée avec l'image d'origine. La valeur de chaque pixel est une moyenne pondérée des valeurs des pixels voisins autour. La valeur du pixel d'origine a la plus grande valeur de distribution gaussienne, il a donc le plus gros poids. Alors que les pixels adjacents s'éloignent de plus en plus du pixel d'origine, leurs poids deviennent de plus en plus petits. Ce processus de fuzzing préserve plus les effets de bord que les autres filtres flous à l'égalisation.

En fait, il est facile d'implémenter un flou gaussien sur iOS. Dès iOS 5.0, il y avait une API d'image de base et un grand nombre d'implémentations de filtre sont fournies dans la bibliothèque CoreImage.Framework.

 + (UiImage *) CoreBluriMage: (UiImage *) Image avecblurnumber: (cgfloat) Blur {CIContext * context = [CIContext contextWithOptions: nil]; CiImage * inputImage = [CiImage ImageWithCGImage: image.cgImage]; // SET FILTER CIFILTER * FILTER = [CIFILTER FILTERWITHNAME: @ "CigaussianBlur"]; [Filter setValue: InputImage forKey: kciInputImageKey]; [filter setValue: @ (blur) forkey: @ "inputradius"]; // blurimage ciimage * result = [filter valueforkey: kciOutputImageKey]; CGIMageRef OutImage = [Context CreateCgImage: Résultat de la résection: [Extension du résultat]]; UiImage * blurimage = [uiImage ImageWithCGImage: OutImage]; CGIMageRelease (Outimage); retour Blurimage;}

Vous pouvez également utiliser l'API native - Renderscript pour implémenter un flou gaussien sur Android, mais l'API d'Android est supérieure à 17, qui est Android version 4.2.

 /** * Algorithm for implementing Gaussian fuzzy using RenderScript* @param bitmap * @return */public Bitmap blur(Bitmap bitmap){//Let's create an empty bitmap with the same size of the bitmap we want to blurBitmap outBitmap = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Bitmap.config.argb_8888); // instanciera un nouveau renderscriptRenderscript rs = renderscript.create (getApplicationContext ()); // Créer un script de flou intrinsèque à l'aide du renderscriptScriptriTrintrinsicblur Blurscript = Scriptintrinsicblur.Create (Rs, élément.u8_4 (RS); (in / out) avec le Renderscript et le bitmapsallocation bitmapsallocation allin = allocation.createfrombitmap (RS, bitmap); allocation allowing = allocation.createfrombitmap (rs, outbitmap); // définir le rayon de la flor RenderscriptBlurscript.SetInput (ALLIN); Blurscript.ForEach (Allout); // Copiez le bitmap final créé par l'extraction de l'outrebitmapalout.copyto (Outbitmap); // recycler le bitmapbitmap.recle ();

Le cadre d'image CV4J que nous avons développé fournit également un filtre pour implémenter un flou gaussien.

 GaussianBlurFilter Filter = new GaussianBlurFilter (); filter.setsigma (10); rximageData.bitmap (bitmap) .addfilter (filtre) .into (image2);

On peut voir que la gaussienne floue implémentée dans CV4J est cohérente avec l'effet de la mise en œuvre de Renderscript.

Parmi eux, le code de GaussianBlurfilter est le suivant:

 classe publique GaussianBlurFilter implémente CommonFilter {Private Float [] Kernel; private Double Sigma = 2; ExecutorService MEXECUTOR; CompletionService <VOID> Service; public GaussianBlurFilter () {Kernel = New Float [0];} public Void SetSigma (Double A) {this.Sigma = a;} @ gouthage Public SetSigma (Final Filter (Final Filter (Final Imm ImageProcessor Src) {final int width = src.getWidth (); final int height = src.GetHeight (); final int size = width * height; int dims = src.getChannels (); MakeGaussianKernel (sigma, 0.002, (int) math.min (largeth, height)); mexecutor = TaskUtils.newFixeDThreadpool ("cv4j", dims); service = new EMMIROROCLETIONSERVICE <> (MEXECUTOR); // Enregistrer le résultat (int i = 0; i <dims; i ++) {final int temp = i; service.submit (new Callable <Void> () {public Veed Call () lacets exception {byte [] dans =) src.tobyte (temp); octet [] temp = new octet [size]; blur (inpixels, temp, largeur, hauteur); // h gaussianblur (temp, inpixels, hauteur, largeur); // v Gaussainreturn null;}});} pour (int i = 0; i <dims; i ++) {Try {Service.Take ();. (InterruptedException e) {E.PrintStackTrace ();}} mexecUtor.shutdown (); return src;} / ** * <p> voici 1D Gaussian, </p> * * @param inpixels * @param utpixels * @param width * @param height * / privil largeur, int hauteur) {int subcol = 0; int index = 0, index2 = 0; float sum = 0; int k = kernel.length-1; for (int row = 0; row <hight; row ++) {int c = 0; index = row; for (int col = 0; col <width; col ++) {sum = 0; for (int m = -K; m; if (subcol <0 || subcol> = width) {subcol = 0;} index2 = row * width + subcol; c = inpixels [index2] & 0xff; sum + = c * kernel [math.abs (m)];} sortpixels [index] = (byte) outils.clamp (sum); index + = height;}} MakegaussianKernel (Double Sigma final, double précision finale, int maxradius) {int kradius = (int) math.ceil (sigma * math.sqrt (-2 * math.log (précision))) + 1; if (maxradius <50) maxradius = 50; / trop petit maxradius kradius = maxradius; kernel = nouveau float [kradius]; pour (int i = 0; i <kradius; i ++) // gaussien functionkernel [i] = (float) (math.exp (-0.5 * i * i / sigma / sigma)); double sum; // sum sur tous les éléments de noyau pour la normalisationif (Kradius <maxradius) Kernel [0]; pour (int i = 1; i <kradius; i ++) sum + = 2 * kernel [i];} else sum = Sigma * math.sqrt (2 * math.pi); pour (int i = 0; i <kradius; i ++) {double v = (noyau [i] / sum); noyau [i] = (float) v;} return;}}

Convolution spatiale

La convolution bidimensionnelle est souvent rencontrée dans le traitement d'image, et la plupart des formes discrètes de convolution bidimensionnelle sont utilisées dans le traitement d'image.

Voici divers effets de convolution mis en œuvre par CV4J.

CV4J prend actuellement en charge les filtres de convolution spatiale suivants

CV4J est une bibliothèque de traitement d'image développée par Scaryfish et I, et est encore dans une première version.

Fonctions qui ont été implémentées à l'heure actuelle:

Cette semaine, nous avons fait des ajustements majeurs à CV4J et optimisé l'architecture globale. La fonction de convolution spatiale (amélioration de l'image, affûtage, flou, etc.) est également ajoutée. Ensuite, nous ferons une analyse d'image binaire (corrosion, expansion, opérations d'ouverture et de fermeture, extraction des contour, etc.)

Résumer

Ce qui précède est tout le contenu de cet article sur la programmation Java pour implémenter un flou gaussien et une convolution spatiale des images. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à ce site:

70 lignes de code Java pour implémenter le partage de l'algorithme de réseau neuronal profond

La langue java implémente l'exemple de code de l'algorithme de cruzkal basé sur des graphiques autorisés non dirigés

L'exemple de code complet de l'algorithme Java pour implémenter l'arbre rouge et noir

S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!