Traitement d'image en java

**fifi2** · 31/05/2009, 23h55

Bonsoir à tous!

Pour un projet en java, je dois proposer une palette de contraste; j'ai donc utiliser les filtres avec l'opération LookUpOp sur une image BufferedImage.
J'ai donc pu faire plusieurs fonctions de traitement : récupération de la composante rouge, récupération de la composante bleu, récupération de la composante vert, inversion des couleurs.
Voici le code correspondant :

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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
 
package loupe;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.ShortLookupTable;
import java.awt.image.LookupOp;
 
 
/**
 * Classe permettant de faire une conversion de couleur d'une image.<br><br>
 * Conversion Possible :<br>
 * - Noir et Blanc<br>
 * - Couleur inversée<br>
 * - Rouge prédominant<br>
 * - Vert prédominant<br>
 * - Bleu prédominant<br>
 *
 */
public class SelectionCouleur 
{
	private short inversion[] = new short[256];
	private short[][] vert;
	private short[][] rouge;
	private short[][] bleu;
	private short[][] renduCouleur1;
	private short[][] renduCouleur2;
	private short[] table;
	private short[] normal;
	private Image image;
	private static SelectionCouleur selectCouleurInstance;
 
 
	private SelectionCouleur()
	{
		table = new short[256];
		normal = new short[256];
 
		short [] inverseCouleur = new short[256];
		for (int i = 0; i < 256; i++)
		{
			normal[i] = (short)i;
			table[i] = 0; 
			inverseCouleur[i] = (short)(255 - i);	
		}
 
		this.vert = new short [][]{ table, normal, table};
		this.rouge = new short [][]{ normal, table, table};
		this.bleu = new short [][]{ table, table, normal};
		renduCouleur1 = new short [][]{normal, normal, inverseCouleur};
		renduCouleur2 = new short [][] {inverseCouleur, normal, normal};
	}
 
	public static SelectionCouleur getSelectionCouleurInstance(){
		if (selectCouleurInstance == null){
			selectCouleurInstance = new SelectionCouleur();
		}
		return selectCouleurInstance;
	}
 
	/**
         * Cette fonction a pour but d'inverser les couleurs de l'image passée
         * en paramètre.
         * 
         * @param img Image dont les couleurs vont changer
         * @param width Largeur de l'image
         * @param height Hauteur de l'image
         */
	private Image inversionCouleur(Image img, int width, int height)
	{
		//création d'une instance de shortLookUpTable pour une table de conversion de short
		ShortLookupTable table = new ShortLookupTable(0, inversion);
		LookupOp op = new LookupOp(table, null);
 
		BufferedImage filteredImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
 
		op.filter((BufferedImage)img, filteredImage); //application de l'opération op sur l'image source image à l'image destination filteredImage
		return filteredImage;
	}
 
	/**
         * Cette fonction a pour but de mettre l'image passée en paramètre en 
         * noir et blanc.
         * 
         * @param img Image source
         */
	private Image noirEtBlanc(Image img, int width, int height)
	{
		BufferedImage filteredImage = new BufferedImage(width,height,BufferedImage.TYPE_BYTE_GRAY);
		Graphics g = filteredImage.createGraphics();
		g.drawImage(img,0,0,null);
		g.dispose();
		return filteredImage;
	}
 
	/**
         * Cette fonction a pour but de mettre l'image passée en paramètre avec 
         * une couleur verte prédominante.
         * 
         * @param img Image source
         * @param width Largeur de l'image
         * @param height Hauteur de l'image
         */
	private Image vertPredomine(Image img, int width, int height)
	{
 
		ShortLookupTable invertTable = new ShortLookupTable(0, vert);
		//System.out.println("table du vert chargée");
 
		LookupOp op = new LookupOp(invertTable, null);
		BufferedImage filteredImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
		//application de l'opération op sur l'image source image à l'image destination filteredImage
		image = img;
		op.filter((BufferedImage)image, filteredImage); 
		return filteredImage;
	}
 
	/**
         * Cette fonction a pour but de mettre l'image passée en paramètre avec 
         * une couleur rouge prédominante.
         * 
         * @param img Image source
         * @param width Largeur de l'image
         * @param height Hauteur de l'image
         */
	private Image rougePredomine(Image img, int width, int height)
	{
		ShortLookupTable invertTable = new ShortLookupTable(0, rouge);
		//System.out.println("table du rouge chargée");
 
		LookupOp op = new LookupOp(invertTable, null);
		BufferedImage filteredImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
		//application de l'opération op sur l'image source image à l'image destination filteredImage
		op.filter((BufferedImage)img, filteredImage); 
		return filteredImage;
	}
 
	/**
         * Cette fonction a pour but de mettre l'image passée en paramètre avec 
         * une couleur bleu prédominante.
         * 
         * @param img Image source
         * @param width Largeur de l'image
         * @param height Hauteur de l'image
         */
	private Image bleuPredomine(Image img, int width, int height)
	{
		ShortLookupTable invertTable = new ShortLookupTable(0, bleu);
		//System.out.println("table du bleu chargée");
 
		LookupOp op = new LookupOp(invertTable, null);
		BufferedImage filteredImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
		//image = img;
 
		//application de l'opération op sur l'image source image à l'image destination filteredImage
		op.filter((BufferedImage)img, filteredImage); 
		return filteredImage;
	}
 
	/**
         * Cette fonction a pour but de mettre l'image passée en paramètre avec 
         * un rendu de couleurs (type 1).
         * 
         * @param img Image source
         * @param width Largeur de l'image
         * @param height Hauteur de l'image
         */
	private Image inverseCouleur1(Image img, int width, int height)
	{
		ShortLookupTable invertTable = new ShortLookupTable(0, renduCouleur1);
 
		LookupOp op = new LookupOp(invertTable, null);
		BufferedImage filteredImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
		//application de l'opération op sur l'image source image à l'image destination filteredImage
		op.filter((BufferedImage)img, filteredImage); 
		return filteredImage;
	}
 
	/**
         * Cette fonction a pour but de mettre l'image passée en paramètre avec 
         * un rendu de couleurs (type 2).
         * 
         * @param img Image source
         * @param width Largeur de l'image
         * @param height Hauteur de l'image
         */
	private Image inverseCouleur2(Image img, int width, int height)
	{
		ShortLookupTable invertTable = new ShortLookupTable(0, renduCouleur2);
 
		LookupOp op = new LookupOp(invertTable, null);
		BufferedImage filteredImage = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
		//application de l'opération op sur l'image source image à l'image destination filteredImage
		op.filter((BufferedImage)img, filteredImage); 
		return filteredImage;
	}
 
	/**
         * 
         * @param img Image à modifier
         * @param width Largeur de l'image
         * @param height Hauteur de l'image
         * @param choix Choix disant comment modifier l'image
         * @return Image modifiée (bleu prédominant ou vert prédominant ou...)
         */
	public Image getImageModifiee(Image img, int width,int height,int choix)
	{
		if(choix == PaletteCouleurs.COULEUR_INVERSEE)
			return inversionCouleur(img, width, height);
		if(choix == PaletteCouleurs.BLEU_PREDOMINANT) 
			return bleuPredomine(img, width, height);
		if(choix == PaletteCouleurs.NOIR_ET_BLANC)
			return noirEtBlanc(img,width,height);
		if(choix == PaletteCouleurs.RENDU_COULEUR_1)
			return inverseCouleur1(img, width, height);
		if(choix == PaletteCouleurs.RENDU_COULEUR_2)
			return inverseCouleur2(img, width, height);
		if(choix == PaletteCouleurs.ROUGE_PREDOMINANT)
			return rougePredomine(img, width, height);
		if(choix == PaletteCouleurs.NORMAL)
			return img;
 
		return vertPredomine(img, width, height);
	}

Le problème qui se pose est que si le filtre avec la composante rouge est appliqué sur une image à composante bleu ou verte alors l'image rendue devient noire. Le problème se pose aussi sur le filtre avec composante verte, sur des images à composante bleu et à composante rouge, et composante bleu, sur des images a composante rouge et à composante verte.
Mais sur des images normales ces différents filtres fonctionnent bien.
J'ai donc chercher à modifier la valeur de la composante mise à 0 en fonction d'un curseur déplacer par l'utilisateur, ceci se passe dans la fonction setColor(int c). Mais rien n'y change.

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public void setColor(int c)
	{
		for (int i = 0; i < 256; i++)
		{
			table[i] = (byte)c;
		}
		this.vert = new short [][]{ table, normal, table};
		this.rouge = new short [][]{ normal, table, table};
		this.bleu = new short [][]{ table, table, normal};	
	}
 
}

Est ce la bonne solution pour que les images ne soient plus noires?
Et si non, comment puis je y remédier?

Merci d'avance!

**pseudocode** · 01/06/2009, 09h48

Envoyé par fifi2

Pour un projet en java, je dois proposer une palette de contraste; j'ai donc utiliser les filtres avec l'opération LookUpOp sur une image BufferedImage.

Qu'est ce que tu appelles une "palette de contraste" ?

Tu cherches à augmenter le contraste sur une image ?

**fifi2** · 01/06/2009, 13h14

Bonjour,
en fait mon projet est destiné à des malvoyants.Afin de faciliter la lecture d'un document, nous devons leur proposer une palette de couleur pour le contraste police/fond mais nous avons étendu le sujet en leur offrant une palette de contraste aussi bien pour lire un document que pour visualiser l'espace de travail de l'ordinateur (bureau, navigateur web, etc...).
Voila ce que je veux dire par palette de contraste.

**pseudocode** · 01/06/2009, 22h52

Envoyé par fifi2

Voila ce que je veux dire par palette de contraste.

Bon, je vais reformuler ma question.

Une palette est une liste de couleurs indexées par un numéro (par exemple une palette de 8, 16 ou 256 couleurs).

Quelle est ta définition de palette de contraste ?
- Chaque couleur de la palette présente un fort contraste avec toutes les autres couleurs de la palette ?
- Chaque couleur de la palette présente un fort contraste avec une couleur donnée (le fond), mais elles peuvent être "proches" entre-ellles ?
- autre chose ?

**fifi2** · 02/06/2009, 19h33

Salut, peut être que je n'aurais pas dû utiliser le mot palette.
En fait, en terme de programmation, je propose à l'utilisateur plusieurs filtres, quelques uns avec des prédominance. Et le problème se pose sur ces filtres là.

**pseudocode** · 02/06/2009, 22h52

Envoyé par fifi2

Salut, peut être que je n'aurais pas dû utiliser le mot palette.
En fait, en terme de programmation, je propose à l'utilisateur plusieurs filtres, quelques uns avec des prédominance. Et le problème se pose sur ces filtres là.

Ah. Bon je comprends mieux. Donc tu utilises l'opérateur de Lookup pour modifier les couleurs d'une image.

Le problème qui se pose est que si le filtre avec la composante rouge est appliqué sur une image à composante bleu ou verte alors l'image rendue devient noire.

Ca c'est normal. Ton filtre "composante rouge" force les composantes bleue et verte a zero. Donc si ton image de départ n'avait que des composantes bleues ou vertes, le résultat c'est une image avec toutes les composantes a zero => noir.

**millie** · 02/06/2009, 23h07

Je tiens à préciser que le LookupOp a tendance à déconner avec une image dont le colorModel est de type IndexColorModel (autant dire que ça marche pas !).

Il y a également quelques trucs à faire attention quand il y a un canal alpha dans l'image.

**fifi2** · 03/06/2009, 01h03

D'accord je comprend mieux, ce rendu noir. Je pense que je vais complètement changé mes filtres pour ne plus avoir ces problèmes.

Merci à vous pour ces explications!

Traitement d'image en java

Traitement d'images

Discussions similaires

Partager

Partager