Discussion :

[BoNux83]

Bonjour.

Je me permet de créer se topic car cela fait plus d'une dizaine de jours que j'essaye de trouver une solution pour récupérer la valeur de grayscale d'une image PNG externe 16 bits.

Pour cela, j'ai essayé plusieurs choses ... premièrement d'appliquer un mask sur la valeur du pixel pour faire sauter le bit de signe (même si ca fausse forcément le résultat vu que la valeur perd une donnée).
Ensuite j'ai essayé de dupliquer le bitmap dans un objet "Picture" mais là c'est pareil ...

Le soucis est que la valeur donner est une valeur négative (merci le non signé en JAVA) et donc me fausse le résultat que je désire (le système marche avec d'autre langages) et il me faut absolument une valeur "non signée".

J'espère que vous pourrez m'aider à me donner une piste ou même trouver une solution à mon problème.
Les ressources que j'ai trouvé sur le net ne me permettais que d'appliquer un effet de grayscale avec les ColorFilter mais en aucun cas de récupérer la valeur exacte.

Merci d'avance.

Cordialement,
BoNux83.

[hwoarang]

Avec un petit bout de code, ca devrait etre possible de t'aider

Je te propose de poster la recuperation du pixel, comment tu appliques ton masque, la valeur que tu trouves ainsi que la valeur attendue

[BoNux83]

Je ne peux pas vous montrer tout le code mais j'ai fait un petit bench histoire de comparer les valeurs attendu (et renvoyer en ObjectifC ainsi qu'avec un script CGI)

Là je ne vous affiche que les 100 premières valeurs pour vous montrer un peu les fluctuations attendues:

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
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
 
0: 0
1: 0
2: 0
3: 0
4: 0
5: 0
6: 0
7: 0
8: 0
9: 0
10: 0
11: 0
12: 0
13: 0
14: 0
15: 0
16: 0
17: 0
18: 0
19: 0
20: 0
21: 0
22: 0
23: 0
24: 0
25: 0
26: 0
27: 0
28: 0
29: 0
30: 0
31: 0
32: 0
33: 0
34: 6
35: 21
36: 59
37: 72
38: 96
39: 95
40: 103
41: 116
42: 134
43: 159
44: 179
45: 184
46: 161
47: 135
48: 116
49: 90
50: 62
51: 45
52: 42
53: 47
54: 54
55: 62
56: 54
57: 55
58: 57
59: 60
60: 63
61: 67
62: 69
63: 70
64: 74
65: 75
66: 78
67: 80
68: 82
69: 85
70: 88
71: 90
72: 94
73: 96
74: 101
75: 104
76: 107
77: 108
78: 107
79: 107
80: 109
81: 109
82: 111
83: 114
84: 115
85: 117
86: 118
87: 119
88: 120
89: 122
90: 124
91: 126
92: 126
93: 127
94: 127
95: 127
96: 127
97: 130
98: 134
99: 137
100: 135

Ces valeurs peuvent monter beaucoup plus haut (quelques milliers).
Avec JAVA il me renvoit tout à 0 avec un masque "0xEFFF".

Voici un aperçu du traitement:

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
 
img = BitmapFactory.decodeStream(instream, null, opt);
 
int picw = img.getWidth();
pixel = new int[img.getWidth() * img.getHeight()];
img.getPixels(pixel, 0, picw, 0, 0, img.getWidth(), img.getHeight());
 
 
j=0;
dj=256;
 
while (dj != 0)
{
 
    di=256;
    while ( di !=0)
    {
 
        dy = (int) ((pixel[j] &  0xEfff )* coeff ;
        j++;
        di--;
 
     }
     dj--;
 }

Quand j'affiche dy dans la boucle je me retrouve pour ce PNG là qu'avec des dy = 0. (mais sinon ca arrive que j'ai des paliers à 344 ou d'autres valeurs "récurantes".
J'ai afficher la valeur en binaire et j'ai remarquer que Bitmap stocker ca sous forme de ARGB. J'ai testé en précisant en option du decodeStream un RGB_565 mais rien n'y fait ...
J'ai essayé aussi de faire le calcule du grayscale en récuperant le pseudo RGB que me génère la classe Bitmap mais pas concluant du tout (des valeurs ne dépassant pas 10).
Le soucis ne vient pas du coeff non plus car différent de 0 (mais c'est une petite valeur).

Merci en tout cas de prêter attention à mon problème

Cordialement,
BoNux83.

[hwoarang]

Dans ce code, tu utilises un coef qui n'est pas déclaré (dans le code posté). Le masque semble bizarre (pourquoi 0xEFFF ?).

Tu dis que avec java, apres le masque, c'est tout à 0. Peux tu poster 1 exemple avec la valeur avant masque, la valeur apres et la valeur attendue ?

[BoNux83]

Oui le masque ne correspond à rien, j'ai tout essayé désespérément à vrai dire.

Pour le coeff c'est un ensemble de variable que j'ai appelé coeff (c'était plus rapide)

J'ai changer radicalement de méthode et j'ai enfin décidé de me baser non pas sur un objet Bitmap mais sur le buffer InputStream directement et de décompresser le PNG.
Au final ca marche impeccablement avec la librairie PNGJ (http://code.google.com/p/pngj/).

Merci quand même de ton aide hwoarang