Java charge les images, affiche les images et les images en niveaux de gris

Le package de base Java fournit des classes d'images. Celles que nous utilisons couramment incluent java.awt.image.BufferedImage, javax.imageio.ImageIO, etc. En fait, ces deux classes suffisent. Le premier concerne les opérations de base sur les images, et le second concerne la lecture des images.

Charger l'image :

      BufferedImage img = null;  
        try{  
            img = ImageIO.read(new FileInputStream("/home/eple/DIP/o.jpg"));  
          
        }catch (IOException e) {  
            //e.printStackTrace();  
        }

Je suis sous Ubuntu, le chemin du fichier est donc légèrement différent de celui de Windows.

Afin de rendre le code plus polyvalent, j'ai créé une nouvelle classe de traitement d'image Imgae.

public class Image{
	
	public int h; //高
	public int w; //宽
	public int[] data; //像素
	public boolean gray; //是否为灰度图像
	
	public Image(BufferedImage img){
		
		this.h = img.getHeight();
		this.w = img.getWidth();
		
		this.data = img.getRGB(0, 0, w, h, null, 0, w);
		this.gray = false;
		toGray(); //灰度化
	}
	
	public Image(BufferedImage img,int gray){
		
		this.h = img.getHeight();
		this.w = img.getWidth();
		this.data = img.getRGB(0, 0, w, h, null, 0, w);
		this.gray = false;

	}

	public Image(int[] data,int h,int w){
		this.data = (data == null) ? new int[w*h]:data;
		this.h = h;
		this.w = w;
		this.gray = false;
	}
	
	public Image(int h,int w){
		this(null,h,w);
	}

        public BufferedImage toImage(){
               BufferedImage image = new BufferedImage(this.w, this.h, BufferedImage.TYPE_INT_ARGB);
               int[] d= new int[w*h];
               for(int i=0;i<this.h;i++){
               for(int j=0;j<this.w;j++){
                   if(this.gray){
                       d[j+i*this.w] = (255<<24)|(data[j+i*this.w]<<16)|(data[j+i*this.w]<<8)|(data[j+i*this.w]);
                   }else{
                       d[j+i*this.w] = data[j+i*this.w];
                   }
               }
         }
            image.setRGB( 0, 0, w, h, d, 0, w ); 
            return image;
     }

}

De cette façon, nous ne nous appuyons pas sur les méthodes fournies par Java lui-même. Il nous suffit de convertir l'image dans la classe que nous avons définie. Par exemple, sous Android, la lecture et la survie des pixels sont les suivantes, il suffit de remplacer les fonctions concernées.

 //android 中的获取方式RGB分量    
   pixelsA = Color.alpha(color);    
   pixelsR = Color.red(color);    
   pixelsG = Color.green(color);    
   pixelsB = Color.blue(color);  
                      
 // 根据新的RGB生成新像素    
   newPixels[i] = Color.argb(pixelsA, pixelsR, pixelsG, pixelsB);

D'accord, la classe ci-dessus contient des méthodes pour lire les informations sur les pixels de l'image, les enregistrer en tant que tableau int et convertir le tableau int en un Bufferedmage. Nous parlerons ensuite de la façon de décolorer les images, c'est-à-dire les niveaux de gris.

Comme nous l'avons mentionné dans l'article précédent, en ce qui concerne le traitement de l'image, nous nous préoccupons davantage des informations sur la luminosité de l'image, c'est-à-dire les niveaux de gris. Comment convertir une image couleur en une image en niveaux de gris ? C'est très simple, il suffit de rendre égales les trois valeurs de R, G et B. Alors, quelle est la relation entre cette valeur et les valeurs originales de R, G et B ?

Généralement, nous avons la formule empirique Gray=R×0,299 G×0,587 B×0,114, ou prenons simplement leur valeur moyenne directement. La formule empirique précédente est plus cohérente avec l’observation de l’œil humain. La fonction d'échelle de gris est la suivante :

public void toGray(){  
          
        if(!gray){  
            this.gray = true;  
            for (int y = 0; y < h; y++) {  
                       for (int x = 0; x < w; x++) {  
                          int c = this.data[x + y * w];  
                          int R = (c >> 16) & 0xFF;  
                          int G = (c >> 8) & 0xFF;  
                          int B = (c >> 0) & 0xFF;  
                          this.data[x + y * w] = (int)(0.3f*R + 0.59f*G + 0.11f*B); //to gray  
                }  
              }  
        }  
    }

L'effet de traitement est le suivant :

Ce qui précède est l'image de chargement Java, affiche les images et le contenu en niveaux de gris des images. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !