Binarisation d'images Java et méthode de seuil Otsu

Cet article se concentre principalement sur la binarisation des images, c'est-à-dire la segmentation par seuil basée sur les niveaux de gris. Il existe de nombreuses méthodes de binarisation. En fait, si la zone cible peut être parfaitement segmentée lors du traitement de l'image, alors plus de la moitié du succès est obtenu, ce qui montre l'importance de la binarisation. Cet article présente principalement trois méthodes de binarisation.

1. Méthode de seuil fixe, définissez le seuil et définissez les pixels supérieurs au seuil à 255, sinon il est 0. C'est l'effet le plus simple et le plus instable.

<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>

L'effet de l'opération est le suivant :

2. Méthode de boucle (référence : valeurs binaires communes ​​de traitement d'image Résumé des méthodes)

1. Un seuil d'initialisation T, qui peut être défini par vous-même ou généré sur la base d'une méthode aléatoire.

2. Selon la carte de seuil, chaque donnée de pixel P(n,m) est divisée en données de pixel d'objet G1 et données de pixel d'arrière-plan G2. (n est

lignes, m est colonne)

3. La moyenne de G1 est m1, la moyenne de G2 est m2

4 Un nouveau seuil T' =. (m1 m2)/2

5. Revenez à la deuxième étape, utilisez le nouveau seuil pour continuer à diviser les données de pixels en objets et données de pixels de Pékin, continuez les étapes 2 à 4,

jusqu'à ce que le calcul La nouvelle valeur seuil qui ressort est égale à la valeur seuil précédente.

Le code est le suivant :

<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>

L'effet est le suivant :

3. Algorithme de seuil adaptatif (méthode du seuil Otsu))

La méthode de variance inter-classes maximale a été proposée par le chercheur japonais Otsu en 1979. Il s'agit d'une méthode de détermination de seuil adaptatif, également appelée méthode Otsu, ou OTSU en abrégé. Il divise l'image en deux parties : l'arrière-plan et la cible en fonction des caractéristiques des niveaux de gris de l'image. Plus la variance interclasse entre l'arrière-plan et la cible est grande, plus la différence entre les deux parties qui composent l'image est grande. Lorsqu'une partie de la cible est classée par erreur comme arrière-plan ou qu'une partie de l'arrière-plan est classée par erreur comme cible, la différence est grande. la différence entre les deux parties deviendra plus petite. Par conséquent, la segmentation qui maximise la variance entre les classes signifie la plus petite probabilité d’erreur de classification. Pour l'image I (x, y), le seuil de segmentation du premier plan (c'est-à-dire la cible) et de l'arrière-plan est noté T, la proportion du nombre de pixels appartenant au premier plan par rapport à l'image entière est notée ω0, et son gris moyen le niveau est μ0 ; le nombre de pixels d’arrière-plan représente l’ensemble de l’image. L’échelle de l’image est ω1 et son niveau de gris moyen est μ1. La moyenne globale

niveaux de gris de l'image est notée μ, et la variance inter-classes est notée g. Supposons que l'arrière-plan de l'image soit sombre et que la taille de l'image soit M×N. Le nombre de pixels dans l'image dont la valeur de gris est inférieure au seuil T est enregistré comme N0, et le nombre de pixels dont la valeur de gris est. supérieur au seuil T est enregistré comme N1, alors il y a :

　ω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)

Remplacez l'équation (5) par l'équation (6) pour obtenir la formule équivalente :

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

Utilisez la méthode de parcours pour obtenir le seuil T qui maximise la variance entre les classes, ce que vous souhaitez.

Le code est le suivant :

<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>

L'effet d'exécution est le suivant :

Ce qui précède est la binarisation de Java images et méthode de seuil Otsu Contenu, veuillez faire attention au site Web PHP chinois (www.php.cn) pour plus de contenu connexe !