Discussion :

[ToTo13]

Bonsoir,

je souhaiterai savoir comment est ce que l'on peut déterminer si une image (stockée dans un BufferedImage) est en couleur ou en niveau de gris.

J'ai trouvé cette discussion qui donne une réponse.
Malheureusement, dans mon cas j'ai lu avec JAI et ImageIO de nombreuses images (couleur et niveaux de gris) et le type a toujours été Image.TYPE_3BYTE_BGR (même pour des images binaires ).
Donc je souhaitai savoir s'il existait une solution facile pour connaître le type de couleur dont est composé l'image.
Sinon il y a bien évidemment la méthode bourine qui consiste à vérifier l'égalité entre les composantes des couleurs de chaque pixel (merci l'angoisse et la complexité).


Merci par avance

[bouye]

Je dirais que tu prends le problème par le mauvais bout :

1. Vérifie la source de tes images pour vérifier qu'elles soient produites dans le bon format (en niveau de gris quand elles ne contiennent que du gris), ce qui n'est visiblement pas le cas.
2. Après chargement vérifie le color model et s'il est bon tu n'as pas de boulot supplémentaire à faire.
3. S'il n'est pas bon, tu peux la rejeter en indiquant à l'utlisateur que son format n'est pas bon ou alors tu es parti pour vérifier un par un tous les pixels de l'image... pis après soit tu la conserves telle quelle soit tu la convertis en image en niveau de gris (avec le bon color model donc).

EDIt - évidement si l'image est grosse, utilise plutôt le JAI et charge là en PlanarImage et vérifie ses tiles un par un.

[ToTo13]

Bonjour,

merci, un des problèmes était bien sur les couleurs des images.

Malheureusement, j'ai un autre souci :-( à cause de ce de codage sRGB.
Lorsque je lis une image en 256 niveaux ce gris (Image.TYPE_GRAY), comment est ce que je dois faire pour passer la valeur d'un pixel à la méthode setRGB() et ensuite la récupérer avec getRGB() ?
Parce que si je ne fais aucune modification, la valeur en niveaux de gris que je passe n'est absolument pas celle que je récupère ;(

Connaîtrais tu un tutoriel sur le sujet ?

Merci



PS : j'ai essayé ce morceau de code pour gérer les valeurs des pixels des images en 256 niveaux de gris

Code java :

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

1
2
3
4
5
6
7
8
9
10
 
public int Pixel(int y, int x)
	{
	return getRGB(x, y) & 0xFF ;
	}
 
public void Pixel(int y, int x, int Value)
	{
	setRGB(x, y, 0xFF000000 | (Value<<16) | (Value<<8) | (Value)) ;
	}

Puis j'ai fait le test suivant

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Image image = new Image(256, 1, Image.TYPE_BYTE_GRAY) ;
 
for (int i=0 ; i < 256 ; i++) image.Pixel(0, i, i) ;
 
int nb = 0 ;
for (int i=0 ; i < 256 ; i++)
	if ( image.Pixel(0, i) != i )
		{
		nb++ ;
		System.err.println(i + " => " + image.Pixel(0, i)) ;
		}
System.out.flush() ;
System.out.println("nb = " + nb) ;

Le résultat est presque correcte, c'est le presque qui m'agace. Il y a 73 cas où les valeurs diffèrent légèrement. Sauf pour les valeurs faible où ça diffère beaucoup.

1 => 0
2 => 0
3 => 0
4 => 0
5 => 0
6 => 0
7 => 13
8 => 13
9 => 13
10 => 13
11 => 13
12 => 13
14 => 13
15 => 13
16 => 13
17 => 13
18 => 22
19 => 22
20 => 22
21 => 22
23 => 22
24 => 22
25 => 22
26 => 28
27 => 28
29 => 28
30 => 28
31 => 28
32 => 34
33 => 34
35 => 34
36 => 34
37 => 38
39 => 38
40 => 38
41 => 42
43 => 42
44 => 42
45 => 46
47 => 46
48 => 50
49 => 50
51 => 50
52 => 53
54 => 53
55 => 56
57 => 56
58 => 59
60 => 61
62 => 61
63 => 64
65 => 64
67 => 66
68 => 69
70 => 71
72 => 73
74 => 73
76 => 75
78 => 77
80 => 79
82 => 83
84 => 85
87 => 86
89 => 88
91 => 92
94 => 95
97 => 96
100 => 99
103 => 104
107 => 106
111 => 112
116 => 117
123 => 124
nb = 73

[pseudocode]

Malheureusement, j'ai un autre souci :-( à cause de ce de codage sRGB.
Lorsque je lis une image en 256 niveaux ce gris (Image.TYPE_GRAY), comment est ce que je dois faire pour passer la valeur d'un pixel à la méthode setRGB() et ensuite la récupérer avec getRGB() ?
Parce que si je ne fais aucune modification, la valeur en niveaux de gris que je passe n'est absolument pas celle que je récupère ;(

C'est un bug connu. Les valeurs dans une BufferedImage TYPE_BYTE_GRAY ne respecte pas les valeurs d'origine. Il faut construire soi-meme une palette de 256 niveaux de gris :

http://www.developpez.net/forums/d75..._byte_indexed/

[ToTo13]

Bonjour,

merci pour ce lien.
J'ai récupérer cette partie afin de construire ma table de couleur

Code java :

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

1
2
3
4
5
 
byte cmap[] = new byte[256];
for (int i = 0; i < 256; i++) cmap[i] = (byte)i;
IndexColorModel gray = new IndexColorModel(8, cmap.length, cmap, cmap, cmap);
BufferedImage bg = new BufferedImage(input.getWidth(), input.getHeight(), BufferedImage.TYPE_BYTE_INDEXED, gray);

Mais comment faire pour affecter et récupérer les valeurs correctement ?




EDIT : bon... j'ai apparemment résolu le problème comme ceci :

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
 
public int Pixel(int y, int x)
	{
	return getRaster().getPixel(x, y, (int[])null)[0] ;
	}
 
 
public void Pixel(int y, int x, int Value)
	{
	getRaster().setPixel(x, y, new int[]{Value}) ;
	}

Est ce que cela est lourd au niveau temps d'accés ? Si oui, comment aller plus vite ?

[ToTo13]

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
 
public int Pixel(int y, int x)
	{
	return getRaster().getPixel(x, y, (int[])null)[0] ;
	}
 
 
public void Pixel(int y, int x, int Value)
	{
	getRaster().setPixel(x, y, new int[]{Value}) ;
	}

En fait, en faisant cela pour tout ce qui est image en niveaux de gris ou binaires, je n'ai plus d'erreur .
La seule chose maintenant, c'est peut être un problème de complexité au niveau accès à l'information.

[ToTo13]

Bonjour,

ceci marche très bien et me permet de stocker/coder/gérer/etc. mes images en niveaux de gris (je ne gère que les 256 pour le moment).

J'ai récupérer cette partie afin de construire ma table de couleur

Code java :

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

1
2
3
4
5
 
byte cmap[] = new byte[256];
for (int i = 0; i < 256; i++) cmap[i] = (byte)i;
IndexColorModel gray = new IndexColorModel(8, cmap.length, cmap, cmap, cmap);
BufferedImage bg = new BufferedImage(input.getWidth(), input.getHeight(), BufferedImage.TYPE_BYTE_INDEXED, gray);

Malheureusement, au moment d'écrire, JAI considère que c'est une image couleur :-( En effet, le getColorModel().getColorSpace().getType() me renvoi que c'est un espace RGB et non pas GRAY :-(.
Y a t-il une solution pour lui imposer le fait que ce soit une image noir et blanc ? Que ce soit lors de la lecture (le mieux) ou de l'écriture ?