Java -Programmierung zur Implementierung detaillierter Lösungen für Gaußsche Unschärfe und räumliche Faltung von Bildern

Gaußsche Unschärfe

Gaußsche Blur, auch als Gaußsche Glättung bekannt, ist ein Verarbeitungseffekt, der in der Bildverarbeitungssoftware wie Adobe Photoshop, GIMP und Paint.net weit verbreitet ist. Es wird normalerweise verwendet, um das Bildrauschen zu reduzieren und den Detailpegel zu verringern. Der visuelle Effekt des Bildes, das durch diese Unschärfe-Technologie erzeugt wird, ist wie das Beobachten des Bildes durch einen durchscheinenden Bildschirm, der sich erheblich von dem Out-of-Focus-Bildgebungseffekt Bokeh und gewöhnliche Beleuchtungsschatten unterscheidet. Die Gaußsche Glättung wird auch bei der Vorverarbeitungsphasen in Computer-Vision-Algorithmen verwendet, um die Bildeffekte von Bildern in verschiedenen Maßstäben zu verbessern. Aus mathematischer Sicht ist der Gaußsche Blur -Prozess eines Bildes mit der Normalverteilung die Faltung. Da die Normalverteilung auch als Gaußsche Verteilung bezeichnet wird, wird diese Technologie als Gaußsche Fuzzy bezeichnet. Die Faltung des Bildes und der kreisförmigen Quadratmilde erzeugt einen genaueren Out-of-Focus-Bildgebungseffekt. Da die Fourier-Transformation der Gaußschen Funktion eine weitere Gaußsche Funktion ist, ist Gaußsche Unschärfe ein Tiefpassfilter für das Bild.

Gaußsche Fuzzing verwendet die Normalverteilungsdichtefunktion von Gaußschen, um die Transformation jedes Pixels im Bild zu berechnen.

Basierend auf der eindimensionalen Gaußschen Funktion kann eine zweidimensionale Gaußsche Funktion abgeleitet werden:

wobei R der Fuzzy -Radius ist, r^2 = x^2 + y^2, und σ ist die Standardabweichung der Normalverteilung. Im zweidimensionalen Raum sind die durch diese Formel erzeugten Konturlinien der Oberfläche konzentrische Kreise, die normal aus der Mitte verteilt sind. Die Faltungsmatrix, die aus Pixeln mit ungleich Null-Verteilung besteht, wird mit dem Originalbild transformiert. Der Wert jedes Pixels ist ein gewichteter Durchschnitt der Werte benachbarter Pixel. Der Wert des ursprünglichen Pixels hat den größten Gaußschen Verteilungswert und hat daher das größte Gewicht. Wenn die angrenzenden Pixel immer weiter vom ursprünglichen Pixel entfernt sind, werden ihre Gewichte immer kleiner. Dieser Fuzzing -Prozess bewahrt Kanteneffekte mehr als andere Fuzzy -Filter.

Tatsächlich ist es einfach, Gaußsche Unschärfe auf iOS zu implementieren. Bereits iOS 5.0 gab es eine Kernbild -API, und in der CoreImage.Framework -Bibliothek sind eine große Anzahl von Filterimplementierungen bereitgestellt.

 +(UIImage *) CoreBlurimage: (UIImage *) Image Withblurnumber: (cgfloat) Blur {cicontext *context = [cicontext contextwithOptions: nil]; Ciimage *inputImage = [ciimage Bild miteinander: Image.cgimage]; // 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: result from rect: [resultecent]]; UIImage *BluRimage = [UIImage ImageWithCGImage: Outimage]; CGImagerelease (Outimage); Blurimage zurückgeben;}

Sie können auch die native API -RenderScript verwenden, um Gaußsche Unschärfe auf Android zu implementieren, aber die API von Android liegt über 17, der Android -Version 4.2.

 /** * Algorithmus zur Implementierung von Gaußschen Fuzzy mit Renderscript * @param bitmap * @return */public bitmap Blur (Bitmap Bitmap) {// Lassen Sie uns eine leere Bitmap mit der gleichen Größe des Bitmaps erstellen. Bitmap.config.argb_8888); // Ein neues RenderscripTrenderscript rs = renderscript.create (GetApplicationContext (); // Erstellen Sie ein intrinsisches Blur -Skript mit dem RenderscriptScriptintrintrintrinScript = scriptintrinScrinsicblur. (in/out) mit dem Renderscript und dem In/Out Bitmapsalloclocation Allin = Allocation.createFrombitmap (RS, Bitmap); Allocout = Allocation RenderscriptBlurscript.setInput (Allin); Blurscript.foreach (lega); // Die endgültige Bitmap kopieren, die durch die Outallokation in die Outbitmaphallout.CopyTo (OutbitMap) erstellt wurde; // Recycle des ursprünglichen Bitmapbitmap.Recycle () // Nach Abschluss der Renderscript.rscript.rscript.

Der von uns entwickelte Bildrahmen CV4J bietet auch einen Filter zur Implementierung von Gaußschen Unschärfe.

 Gaußsianblurfilter filter = new Gaußsianblurfilfilter (); filter.setsigma (10);

Es ist ersichtlich, dass der in CV4J implementierte Gaußsche Fuzzy mit der Auswirkung der Implementierung der Renderschriften übereinstimmt.

Unter ihnen lautet der Code von Gaußsianblurfilter wie folgt:

 public class gausussianblurfilter implementiert Commonfilter {privat float [] kernel; privat doppelt sigma = 2; Executorservice Mexecutor; CompletionService <void> Service; public Gaußsianblurfilter () {kernel = new float [0]; ImageProcessor src) {endgültig int width = src.getwidth (); endgültige inthage = src.getheight (); endgültige int size = width*Höhe; int dims = src.getchannels (); makegaussiankernel (Sigma, 0,002, (int) math.min (width, height); TaskUtils.newFixedThreadPool("cv4j",dims);service = new ExecutorCompletionService<>(mExecutor);// save resultfor (int i=0; i<dims; i++) {final int temp = i;service.submit(new Callable<Void>() {public Void call() throws Exception {byte[] inPixels = src.tobyte (temp); byte [] temp = new Byte [Größe]; Blur (Inpixel, Temp, Breite, Höhe); // H Gaußsianblur (Temp, Inpixel, Höhe, Breite); // v Gaußainreturn null;}});}; (InterruptedException e) {e.printStackTrace();}}mExecutor.shutdown();return src;}/** * <p> here is 1D Gaussian , </p> * * @param inPixels * @param outPixels * @param width * @param height */private void blur(byte[] inPixels, byte[] outPixels, int width, int height) {int subCol = 0;int index = 0, index2 = 0;float sum = 0;int k = kernel.length-1;for (int row=0; row<height; row++) {int c = 0;index = row;for (int col=0; col<width; col++) {sum = 0;for (int m = -k; m< kernel.length; m++) {subCol = col + m; if (subcol <0 || subcol> = width) {subcol = 0;} index2 = row * width +subcol; c = inpixel [index2] & 0xff; makegaussiankernel (endgültiges Doppel-Sigma, endgültige Doppelgenauigkeit, int maxradius) {int kradius = (int) math.ceil (sigma*math.sqrt (-2*math.log (Genauigkeit)))+1; Wenn (maxradius <50) maxradius = 50; // // zu kleiner maxradius u. maxradius) kradius = maxradius; kernel = neuer float [kradius]; für (int i = 0; i <kradius; i ++) // Gaußsische FunktionKernel [i] = (float) (math.exp (-0,5*i*i/Sigma/sigma/sigma/sigma); {sum = kernel [0]; für (int i = 1; i <kradius; i ++) sum+= 2*kernel [i];} else sum = sigma*math.sqrt (2*math.pi); für (int i = 0; i <kradius; i ++) {double v = (kernel [i]/sum); kernel [i] = (float) v;} return;}}

Raumverarbeitung

Zweidimensionale Faltung wird häufig in der Bildverarbeitung auftreten, und die meisten diskreten Formen der zweidimensionalen Faltung werden in der Bildverarbeitung verwendet.

Im Folgenden sind verschiedene Faltungseffekte von CV4J implementiert.

CV4J unterstützt derzeit die folgenden räumlichen Faltungsfilter

CV4J ist eine Bildverarbeitungsbibliothek, die von Düsterfisch und mir entwickelt wurde, und befindet sich noch in einer frühen Version.

Funktionen, die derzeit implementiert wurden:

Diese Woche haben wir große Anpassungen an CV4J vorgenommen und die Gesamtarchitektur optimiert. Die räumliche Faltungsfunktion (Bildverstärkung, Schärfen, Unschärfen usw.) wird ebenfalls hinzugefügt. Als nächstes werden wir eine binäre Bildanalyse (Korrosion, Expansion, Öffnungs- und Schließvorgänge, Konturentnahme usw.) durchführen

Zusammenfassen

Das obige ist der gesamte Inhalt dieses Artikels über Java -Programmierung zur Implementierung von Gaußschen Unschärfe und räumliche Faltung von Bildern. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf diese Seite verweisen:

70 Zeilen Java -Code zur Implementierung des tiefen neuronalen Netzwerk -Algorithmusfreigabe

Java Language implementiert das Codebeispiel des Cruzkal -Algorithmus basierend auf ungerichteten autorisierten Graphen

Das vollständige Codebeispiel des Java -Algorithmus zur Implementierung des roten und schwarzen Baumes

Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!