Problème de BufferedImage

Bonjour,

je souhaitais faire quelques tests avec les bufferedImage, lorsque j'ai rencontré un problème que je n'explique pas.

J'ai tout d'abord créé des image en dégradé (la valeur d'un pixel est sa position dans l'image) :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

public static BufferedImage CreerBufferedImage(int w, int h) { int x ; int hauteur = h ; int largeur = w ; int[] pixels = new int[largeur*hauteur] ; BufferedImage buffer = new BufferedImage(largeur, hauteur, BufferedImage.TYPE_BYTE_GRAY) ; for (x=0 ; x < pixels.length ; x++) pixels[x] = x ; buffer.setRGB(0, 0, largeur, hauteur, pixels, 0, largeur) ; return buffer ; }

---

Mais lorsque j'ai appelé ma fonction pour une taille de 300*300, je n'ai pas eu le dégradé attendu :
http://guillaume.thibault.perso.esil...Degrade300.png
Je pensais qu'arrivé à 65536, la valeur des pixel repartirait à zéro. C'est bien le cas, mais le dégradé n'est pas continu.

Mais lorsque j'appelle pour 256*256, le dégradé est correct :
http://guillaume.thibault.perso.esil...Degrade256.png

Questions :
- Pourquoi ce problème ?
- Comment faire pour convertir mes valeurs entre 0..255 vers BufferedImage.TYPE_BYTE_GRAY, car multiplier par un coefficient de type 65536/255 ne fonctionne pas :(

Merci

Dans ton tableau, tu mets des valeurs exprimées en RGB. Les premieres valeurs sont :
0x00000000
0x00000001
0x00000002
...
0x000000FF
...

Ton objet BufferedImage etant de type TYPE_BYTE_GRAY, les seules couleurs disponibles dans la palette sont du genre :
0x00000000
0x00010101
0x00020202
..
0x00FFFFFF

A priori les 256 premiers pixels (de 0x00000000 à 0x000000FF) vont donc avoir comme approximation 0x00000000

Comme les changements se font tous les 256 couleurs, si ton image fait 256 couleurs de large, tu auras l'impression d'un gradient correct.
Avec une image de largeur 300, tu verras les approximations, qui vont se produire sur la ligne.

salut,
puisque les couleurs vont de 0 à 256 une image de taille 256*256 donnera una dégradé idéale.
mais pour une image 300 *300 tu as dépassé les 256 en ligne et en colonne ce qui explique la discontinuation du dégradé si j'ai bien raison. essaye avec une image 256*300 et 300*256 je crois que ça va beaucoup s'améliorer.
bon je pense.
tu peut amélirer ton code en essayant ceci

Code:

---

1 2 3 4 5

à la ligne i pour i = 0 ; i < ligne pour j = 0 ; j < colonne pixel(i,j) = i;

---

tu n'as pas besoin à chaque fois de déterminer la valeur de pixel, les pixels d'une seule ligne auront une seule valeur qui est la valeur de aligne.

Citation:

---

Envoyé par Sanguko

... Avec une image de largeur 300, tu verras les approximations, qui vont se produire sur la ligne.

---

L'oeil,a priori, n'étant sensible au maximum qu'à 64 nuances de gris, visuellement, tu ne devrais pas voir de saut.

Cordialement.

Pierre

Enfin bon, pour faire un dégradé en java, tu as quand même les GradientPaint (+LinearGradientPaint et RadialGradientPaint depuis java 6) qui sont là pour çà.

BOnjour,

merci pour ces réponses.

Mais ce que je souhaiterai vraiement savoir c'est comment convertir mon tableau de pixels 0..255 pour que les couleurs s'affichent correctement dans une BufferedImage.

J'ai essayé de réhausser de la façon suivante, mais ça reste toujours plus sombre que l'original :

Code:

---

1 2 3

BufferedImage buffer = new BufferedImage(largeur, hauteur, BufferedImage.TYPE_USHORT_GRAY/*TYPE_BYTE_GRAY*/) ; for (x=0 ; x < pixels.length ; x++) pixels[x] = 256*(pixels[x]+1)-1 ; buffer.setRGB(0, 0, largeur, hauteur, pixels, 0, largeur) ;

---

Merci...

Voila ce qu'il faut faire pour obtenir une valeur rgb en fonction du niveau de gris (entre 0 et 255):

Code:

---

1 2 3

int getRGBFromLevel(int level) { return 0xFF000000 | level<<16) | (level<<8) | (level); }

---

Pour du noir (level=0), le retour vaut : 0xFF000000
Pour du blanc (level=255), le retour vaut : 0xFFFFFFFF

NB : de facon rigoureuse, il faudrait passer par le ColorModel du BufferedImage pour rechercher les bonnes couleurs.

Bonjour,

merci pour ce petit morceau de code fort utile, mais il y a un souci.
Pour une image binaire (0 ou 255), cela fonctionne parfaitement. En revanche mon image en niveau de gris est encore sombre :(

Personne n'a fait ce genre de convertions ???

tu as essayé d " étaler " ??

( j'ai vu que oui mais comme il faut il me semble )

Etale ton degradé sur l'ensemble ..
J'explique :
Ton image fait 256 *256 ca marche parce que les couleurs vont de 0 à 256 donc c'est bon.

Maintenant si ton image fait 400*400 ca marche plus.

Fait un "rapport"
0 -> 0
256 -> 400
x -> x*400/256


( en gros tu associes à un point sa cordonnée * la taille de l'image / 256, ca devrait uniformiser ton dégradé)

Salut,

pour le côté "sombre" de ton image, vérifie que ton modèle est bien un dégradé linéaire et non un dégradé enjolivé.

Si tu veux créer un original utilise :

Code:

---

1 2 3 4

for (int x = 0 ; x < width ; x++) for (int y = 0 ; y < 256 ; y++) buffer.setRGB(x, y, getRGBFromLevel(y));

---

avec la méthode proposée par Sanguko.

Le même code, pour la taille que tu veux :

Code:

---

1 2 3 4

for (int x = 0 ; x < width ; x++) for (int y = 0 ; y < height ; y++) buffer.setRGB(x, y, getRGBFromLevel((int)Math.round(255d * (double)y / (double)height)));

---