Binarisierung von Java-Bildern und Otsu-Schwellenwertmethode

Dieser Artikel konzentriert sich hauptsächlich auf die Binarisierung von Bildern, also die Schwellenwertsegmentierung basierend auf Graustufen. Es gibt viele Methoden zur Binarisierung. Wenn der Zielbereich während der Bildverarbeitung perfekt segmentiert werden kann, wird mehr als die Hälfte des Erfolgs erzielt, was die Bedeutung der Binarisierung zeigt. In diesem Artikel werden hauptsächlich drei Binarisierungsmethoden vorgestellt.

1. Feste Schwellenwertmethode, legen Sie den Schwellenwert fest und setzen Sie die Pixel, die größer als der Schwellenwert sind, auf 255, andernfalls ist er 0. Dies ist der einfachste und instabilste Effekt.

<span style="font-size:14px;"><span style="font-size:10px;">public void SimBinary(){
		toGray();//灰度化
		int Threshold = 128;
		for (int y = 0; y < h; y++) {
                   for (int x = 0; x < w; x++) {
            	      if(data[x + y * w] < Threshold){
            		 data[x + y * w] = 0;

            	      }else{
            		data[x + y * w] = 255;
            	      }
                  }
	       }
					
	}</span></span>

Der Operationseffekt ist wie folgt:

2. Schleifenmethode (Referenz: Gemeinsame Binärwerte ​​der Bildverarbeitung (Zusammenfassung der Methoden)

1. Ein Initialisierungsschwellenwert T, der von Ihnen selbst festgelegt oder basierend auf einer Zufallsmethode generiert werden kann.

2. Gemäß der Schwellenwertkarte werden alle Pixeldaten P(n,m) in Objektpixeldaten G1 und Hintergrundpixeldaten G2 unterteilt. (n ist

Zeilen, m ist Spalte)

3 Der Durchschnitt von G1 ist m1, der Durchschnitt von G2 ist m2

4 (m1 + m2)/2

5. Kehren Sie zum zweiten Schritt zurück, verwenden Sie den neuen Schwellenwert, um die Pixeldaten weiterhin in Objekte und Peking-Pixeldaten zu unterteilen, und fahren Sie mit den Schritten 2 bis 4 fort,

bis Der berechnete neue Schwellenwert ist gleich dem vorherigen Schwellenwert.

Der Code lautet wie folgt:

<span   style="max-width:90%">	public void IterBinary(){
		toGray();
		
		int Threshold = 128;
		int preThreshold = 256;
		
		while (Math.abs(Threshold-preThreshold) > 4){
			int s1 = 0;
			int s2 = 0;
			int f1 = 0;
			int f2 = 0;
			
			for (int y = 0; y < h; y++) {
	                  for (int x = 0; x < w; x++) {
	            	    if(data[x + y * w] < Threshold){
	            		s1 += data[x + y * w];
	            		f1++;
	            	      }else{
	            		s2 += data[x + y * w];
	            		f2++;
	            	      }
	                 }
		       }
			
			preThreshold = Threshold;
			Threshold = (int)((s1/f1+s2/f2)/2);
		 }
		
		for (int y = 0; y < h; y++) {
                   for (int x = 0; x < w; x++) {
            	     if(data[x + y * w] < Threshold){
            		data[x + y * w] = 0;

            	     }else{
            		data[x + y * w] = 255;
            	     }
                  }
	       }
					
	}</span>

Der Effekt ist wie folgt:

3. Adaptiver Schwellenwertalgorithmus (Otsu-Schwellenwertmethode))

Die Methode der maximalen Varianz zwischen Klassen wurde 1979 vom japanischen Gelehrten Otsu vorgeschlagen. Es handelt sich um eine adaptive Schwellenwertbestimmungsmethode, auch Otsu-Methode oder kurz OTSU genannt. Es unterteilt das Bild in zwei Teile: Hintergrund und Ziel entsprechend den Graustufeneigenschaften des Bildes. Je größer die klassenübergreifende Varianz zwischen dem Hintergrund und dem Ziel ist, desto größer ist der Unterschied zwischen den beiden Teilen, aus denen das Bild besteht. Wenn ein Teil des Ziels fälschlicherweise als Hintergrund oder ein Teil des Hintergrunds fälschlicherweise als Ziel klassifiziert wird, wird der Der Unterschied zwischen den beiden Teilen wird kleiner. Daher bedeutet die Segmentierung, die die Varianz zwischen den Klassen maximiert, die geringste Wahrscheinlichkeit einer Fehlklassifizierung. Für Bild I (x, y) wird der Segmentierungsschwellenwert des Vordergrunds (d. h. des Ziels) und des Hintergrunds als T bezeichnet, der Anteil der Anzahl der zum Vordergrund gehörenden Pixel am gesamten Bild wird als ω0 und sein durchschnittliches Grau bezeichnet Ebene μ0; die Anzahl der Hintergrundpixel für das gesamte Bild wird angegeben. Der Maßstab des Bildes ist ω1 und seine durchschnittliche Graustufe beträgt μ1. Die gesamte durchschnittliche

Graustufe des Bildes wird als μ bezeichnet, und die Varianz zwischen den Klassen wird als g bezeichnet. Angenommen, der Hintergrund des Bildes ist dunkel und die Größe des Bildes beträgt M×N. Die Anzahl der Pixel im Bild, deren Grauwert unter dem Schwellenwert T liegt, wird als N0 aufgezeichnet, und die Anzahl der Pixel, deren Grauwert beträgt größer als der Schwellenwert T wird als N1 aufgezeichnet, dann gilt:

　ω0=N0/ M×N (1)

　ω1=N1/ M×N (2)

N0+N1=M×N (3)

　ω0+ω1=1 (4)

μ=ω0*μ0+ω1*μ1 (5)

g=ω0(μ0-μ)^2+ω1( μ1-μ)^2 (6)

Durch Einsetzen von Gleichung (5) in Gleichung (6) erhält man die äquivalente Formel:

g=ω0ω1(μ0-μ1)^2 (7)

Verwenden Sie die Traversal-Methode, um den Schwellenwert T zu erhalten, der die Varianz zwischen Klassen maximiert, was Sie wollen.

Der Code lautet wie folgt:

<span   style="max-width:90%">public void Otsu(){
		toGray();
		int num = h*w;
		int[] hist = hist();
		int sum = math.sum(hist);
		double[] res = new double[256];
		double m1=0,m2=0,w1=0,w2=0;
		
		for(int k=0;k<256;k++){
			for(int i=0;i<k;i++){
				m1 +=hist[i];
			}
			w1 = m1/num;
			w2 = 1-w1;
			m2 = (sum-m1)/(255-k);
			m1 = m1/(k+1);
			res[k] = w1*w2*Math.abs(m1 - m2)*Math.abs(m1 - m2);
		}
		
		int Threshold = math.maxIndex(res); //获得最大值的下标
		
		for (int y = 0; y < h; y++) {
                  for (int x = 0; x < w; x++) {
            	    if(data[x + y * w] < Threshold){
            		data[x + y * w] = 0;

            	    }else{
            		data[x + y * w] = 255;
            	    }
                }
		}
	}</span>

Der Laufeffekt ist wie folgt:

Das Obige ist die Binarisierung von Java Bilder und der Inhalt der Otsu-Schwellenwertmethode. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn)!