Discussion :

[stocha]

Bonjour,
J'ai un petit problème avec la lecture des images Bitmap. Je vous explique le problème : je développe des algo de reconnaissance de formes sur scilab en travaillant sur des images Bitmap 8bits, et ma collègue développe sous Java un logiciel qui inclut ceux-ci. Sous scilab, il n'y a pas de problème, je peux directement travailler sur une matrice composée de valeurs comprises entre 0 et 255. Cependant, sous Java (avec imageIO.read), on a trois canaux tous identiques (Java croit donc avoir à faire à une image 24 bits), mais avec des niveaux de gris différents de ceux de scilab :
Sous Scilab : 0 1 2 3 4 5... 252 253 254 255
Java : 0 13 22 28 34 38...254 254 255 255.
Quelqu'un saurait ce que fait Java ? Comment obtenir les mêmes niveaux de gris que sous Scilab (les vrais en somme) ? (Si on génère une image sous Java et qu'on la lit avec scilab, tout va bien : il semble bien que c'est Java qui galère à lire le 8 bits)
Je ne sais pas si j'ai été clair. Merci d'avance de votre aide.

[bouye]

Fait une recherche dans le forum Interfaces graphiques et ses sous-forum, il me semble que qqun avait mentionné des problèmes avec le type BufferedImage.TYPE_BYTE_GRAY.

[zaboug]

Bonjour,

je suis la collègue de stocha. Je reprends le flambeau de ce post vu que c'est moi qui m'occupe de la partie Java...

Fait une recherche dans le forum Interfaces graphiques et ses sous-forum, il me semble que qqun avait mentionné des problèmes avec le type BufferedImage.TYPE_BYTE_GRAY.

j'ai suivi ton conseil et fait une recherche sur "TYPE_BYTE_GRAY". J'ai fini par tomber sur des posts très intéressant :
Savoir si une image est en couleur ou en niveaux de gris
[Bug] images TYPE_BYTE_GRAY / TYPE_BYTE_INDEXED

Le problème, c'est que je ne sais pas trop comment prendre en compte ces posts pour l'appliquer à mon propre code...

Voici comment je procédais jusqu'à présent :
On sait qu'on récupère toujours des images bmp codées sur 8bits en niveaux de gris.
J'ai utilisé la méthode ImageIO.read pour récupérer l'image dans un objet BufferedImage que je stocke dans ma propre classe Image :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public Image importerImage(String chemin)
	{
		BufferedImage buf_img = null;
 
		try
		{
			buf_img = ImageIO.read(new File(chemin));
		}
		catch(IOException e)
		{
			e.printStackTrace();
		}
 
		Image img = new Image(buf_img);
 
 
		return img;
	}

Pour traiter l'image, je ne peux pas directement utiliser la bufferedImage, donc je récupère la matrice dans une classe Matrice.
Comme l'a dit Stocha, la bufferedImage que je récupère n'est visiblement pas en niveau de gris sous Java. donc pour récupérer ma matrice, j'utilise la méthode extractionPixels() ci-dessous qui copie la valeur d'un seul des canaux (conseil que tu m'avais donné dans ce post):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class Image 
{
	BufferedImage img;
	int lignes;
	int colonnes;
 
	public Image(BufferedImage image)
	{
		this.img = image;
		this.lignes = img.getHeight();
		this.colonnes = img.getWidth();
	}
[...]
	/**
         * extractionPixels : recupere la bufferedImage de l'objet
         *  et renvoie la matrice contenant les pixels en niveaux de gris
         * @return Matrice de pixels en niveaux de gris 
         */
	public Matrice extractionPixels()
	{ 
		int nbLigne = this.getImage().getHeight();
		int nbCol = this.getImage().getWidth();
		Matrice matrice = new Matrice(nbLigne,nbCol); 
 
		for(int i=0; i<nbLigne; i++)
		{
			for(int j=0; j<nbCol; j++)
			{
				int rgb = this.getImage().getRGB(j,i);
				int gris = ((rgb >> 8 ) & 0xFF);
				matrice.setPixel(i, j, gris);
			}
		}
 
		return matrice;
	}

Enfin, quand j'ai effectué tous les traitements sur la matrice, je la reconvertie en BufferedImage de la façon suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
	/**
         * conversionMatrice : convertit une matrice en une bufferedImage (niveaux de gris)
         * @param matrice
         * @param nbLignes
         * @param nbCol
         * @return image obtenue a partir de la matrice
         */
	public BufferedImage conversionMatrice()
	{
		//Recuperation des dimensions de la matrice
		int nbLignes = this.getNbLigne();
		int nbCol = this.getNbCol();
 
		BufferedImage image = new BufferedImage(nbCol, nbLignes, BufferedImage.TYPE_INT_RGB);
 
		for (int i = 0; i < nbLignes; i++)
		{
			for (int j = 0; j < nbCol; j++)
			{
				int gray = this.getPixel(i, j);
				int rgb = (0xFF << 24) | ((gray & 0xFF) << 16) | ((gray & 0xFF) << 8) | ((gray & 0xFF) << 0);
 
				image.setRGB(j, i, rgb);
			}
		}	
 
		return image;
	}

à mon avis, c'est à une de ces deux étapes là que le problème de la valeur des pixels se situe...
Aurais-tu des conseils sur la marche à suivre pour régler ce problème de pixels Java qui n'ont pas la bonne valeur?

Sous Scilab : 0 1 2 3 4 5... 252 253 254 255
Java : 0 13 22 28 34 38...254 254 255 255.

[zaboug]

c'est bon, j'ai utilisé le workaround de pseudocode et ça marche.

Le bug est corrigé