Discussion :

[Panthère Bleue]

Bonjour,

Eh bien je crois que presque tout est dans le titre! Je programme en Python depuis un petit mois, donc je m'autoproclame "initié". Hop!

Quelques détails : il s'agit de créer une image à partir d'un array d'entiers 16 bits (signés ou pas), dérivé de numarray. Mais je pense qu'avec numpy ou Numeric c'est la même...

J'ai bien essayé avec le module Image mais je ne crois pas avoir trouvé le bon mode de conversion. Les valeurs de l'array (qui seront donc le niveau des pixels) sont majoritairement entre 500 et 800, ce qui ne colle pas avec du 8 bits... J'ai obtenu entre autre des résultats avec une image blanche, donc tout à 255. Pour le contraste, c'est pas génial

Quelqu'un sait comment faire ...? Merci!

[Panthère Bleue]

Dites moi si la question est trop simple, trop compliquée, mal formulée...

J'ai vu que quelques-uns font du traitement d'images, personne n'a jamais bloqué sur un problème du genre?

[Guigui_]

Tu cherches a avoir quoi au final ? une image en niveau de gris, une image couleur ? (en gros à quoi correspond la valeur d'un pixel) parce que typiquement en niveau de gris c'est du 8 bits et en RGB, c'est du 24 bits (ou 32)

Edit: oups j'avais pas lu le titre. Donc c'est bien du niveau de gris.

Donc je modifie:
Si j'ai bien compris, tes nombres sont compris entre -32768 et +32768
- Une première approche est de linéairement remettre l'échelle entre 0 et 255 c'est à dire de considérer que -32768 correspond au pixel 0 et +32768 au pixel 255. Pour cela il suffit pour chaque pixel de faire :
newpixel = (ancienpixel + 32768) * 255 / 65536
- Après si tes valeurs ne parcourent pas l'ensemble du spectre -32768 -> +32768, tu peux tout d'abord chercher le min et le max puis pour chaque pixel :
newpixel = (ancienpixel - min) * 255 / (max-min)

[Panthère Bleue]

Merci pour la réponse!

Je vois ce que tu veux dire, j'y avais pensé sans essayer de le mettre en application parce qu'a priori... le problème n'est qu'à moitié résolu.

J'aurais bien une image contrastée en faisant comme ça, par contre je ne conserverai pas l'info sur les valeurs de mes pixels (qui sont en Int16 donc entre -32768 et 32768, comme tu dis). Et c'est embêtant, parce que les valeurs de 500, 600... correspondent à des microns! Et comme l'image est destinée à être analysée (histo, seuillage, profil...), y'a comme qui dirait "une couille".

Donc l'idéal serait de faire du niveaux de gris 16 bits. Et je sais que c'est possible, j'en ai déjà vu !

[Guigui_]

en fait, mettre l'image entre 0 et 255, cela sert juste pour avoir un aspect visuel pour l'humain. Sinon pour faire de l'analyse, tu continues de travailler toujours avec tes matrices (en fait ce n'est plus une image) en int16

[Panthère Bleue]

Ouaip c'est une solution mais j'aimerais pouvoir exporter une image niveaux de gris 16 bits pour l'exploiter facilement avec un logiciel approprié. Si tu connais une librairie python qui permet de le faire, pourquoi pas!

Mais pour le moment, j'ai peur que mes compétences en programmation (et surtout le temps) ne m'obligent à exporter l'image vers un logiciel tout fait, tout propre, par exemple photoshop, ou dans mon cas plutôt aphelion, si tu connais.

Aaaaarg, j'ai peur d'en demander trop là... pourtant ça doit bien être faisable! La librairie Image de Python a bien plusieurs modes de conversion mais je n'ai pas l'impression d'avoir trouvé le bon... et je n'ai pas trouvé d'aide détaillée là dessus. Est ce que le problème ne peut pas venir du fait que Image ouvre automatiquement une nouvelle image créée, en Bitmap avec Paint (en tout cas sur l'ordi que j'utilise)?

[parp1]

Salut Tu connais Aphelion??? ...
Moi je connais... comment ca se fait que tu connaisse ce "logiciel" .... je dirais boite a outils.

[Panthère Bleue]

Ouip je connais vaguement Aphelion parce que ça permet justement un traitement d'iamges complet. Mais la version que j'ai est assez vieillote, et ne propose que des macros en basic lourdeau... d'où python pour traiter les données d'acquisition et fournir à aphelion une image propre et moins volumineuse.

[Panthère Bleue]

Je pense avoir réussi mais avec une magouille qui me parait bizarre, je ne comprend toujours pas qu'on doive passer par là pour arriver à créer du 65536 niveaux de gris... c'est pas si exceptionnel que ça quand même?

Pour résumer:
- je passe mes données en array Float32 (anciennement UInt16 ou Int16)
- je peux alors créer une image avec le mode de conversion 'F'
- je la convertis en entiers avec 65536 niveaux de gris

Il y a peut être une erreur dans tout ça... je viens de trouver (mais depuis le début du post, j'ai fait autre chose, rassurez vous! ).

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
import Image
from pylab import *

## Chemin d'accès aux données en array Float32
file = 'C:/donnees'  

## ouverture en binaire
f = open(file, 'rb')

data = f.read()
f.close()

## 'F' correspond au mode de conversion : F pour Float, bien sûr
## [667,800] est la taille de l'image à créer, dans mon cas
img = Image.fromstring('F', [667,800], data)

tiff = 'E:/partage/103/Face A/103A_final'
fim = open(tiff, 'wb')

## Et conversion en entiers, en précisant le nombre de couleurs...
img = img.convert('I', colors=65536)

## Sauvegarde au format TIFF. BMP, JPEG, PNG ne sont pas compatibles
## avec le format des données
img.save(fim, 'tiff')

fim.close()

[airod]

petite intervention, pour dire que je suis confronté au même problème mais en RGB.
Je suis en train de créer une appli de correction chromatique pour les fichiers numériques.
J'utilise le mode 16 bits car cela permet une meilleure correction.

Au stade ou j'en suis , je m'appuie sur LCMS pour générer des images en 16 bits (tif uniquement)
puis je les converti (enfin normalement), dans un autre format (si besoin) en passant par PIL.

LCMS, permet de faire de la convertion de profil a profil.

ca peut peut être t'aider.