Analyse automatique image

[CedC]

Bonjour,

Les physiciens utilisent souvent des techniques automatiques; peut-être l'un de vous aurais donc connaissance d'un outil me permettant de calculer (en gros), la densité des boule sur des images comme celle mis en lien. Mes images initiales sont en .tif, mais le forum ne les acceptent pas, et j'ai de toute façon de quoi les convertir. Si vous avez connaissance d'outils permettant de faire ce type d'opérations, je suis preneur.
Je travail aussi bien sous windows que linux, un soft libre (et donc modifiable) serait préférable mais pas indispensable.

(Si c'est facilement faisable sois-même, et qu'on me décrit la façon dý arriver, je peux peut-être également arriver à quelque-chose, mais si j'ai des base en programmation, je n'ai jamais fais de traitement d'image. J'ai bien vu que le format tif n'est au final qu'une matrice de pixel, chacun possèdent ici un niveau de gris, mais pour détecter le contour des cercles et les compter, je ne suis pas sur du moyen. La première étape serait surement une augmentation du contraste afin mais ensuite...)

Merci d'avance

CedC
-----

[LPFR]

Bonjour.
Le seul format qui soit vraiment un tableau de pixels et le format BMP (le plus volumineux).
Le format TIF est presque la même chose mais avec un peu de compression pour les pixels identiques qui se suivent.
Vous trouverez les descriptions des « headers » sur le WEB.

Compter le nombre de taches grises de votre image est faisable mais demande de la programmation. Il faut séparer les pixels noirs (ou suffisamment gris) en groupes contigus. C’est un très bon exercice (que je donnais à mes étudiants) de programmation en C d’utilisation de listes de pointeurs sur des listes de pointeurs. Car il faut souvent fusionner des listes de pixels qui semblaient au départ non contigus et qui s’avèrent appartenir au même objet.

Pour ce qui est du traitement de l’image elle-même, des logiciels existent pour augmenter le contraste, binariser l’image, etc. Par exemple, Photoshop si vous avez les moyens, ou GIMP, qui fait presque la même chose mais qui est gratuit.
Au revoir.

[CedC]

Merci pour votre réponse,
J'ai effectivement eu recourt a Gimp pour diminuer la luminosité et augmenter le contraste afin de me rapprocher du noir et blanc, (est-ce de cela dont vous parlez en écrivant binariser l'image? ). Je comprend bien l'idée de faire des groupes mais j'ai alors deux questions: Vous mentionnez le c, est-ce réellement le langage qui se prête le plus à cet usage? Je n'ai rien contre le c que j'ai déjà utiliser plus d'une fois, mais il me semble que python permettrais de développer plus facilement ce genre de choses, ou peut-être avec imageJ et ses macros...
Comment définir assez gris et trouver une limite au contour, ou meme pour commencer, automatiser la modification de luminosité et de contraste que pour l'instant je fais à la main.

[LPFR]

Re.
Oui. C’est bien cela que j’entends par binariser l’image.
Je ne peux rien vous dire sur Python. Je ne le connais pas. Mais pour le peux que j’ai vu sur Wikipedia, je ne crois pas que ça fasse beaucoup de différence avec C.
Même chose pour imageJ Mais d’après Wikipedia il semble mieux adapté pour ce que vous voulez faire.
Faites-le avec le langage que vous dominez.
Le langage de programmation utilisé ne change pas grand-chose. Ce qui est vraiment important est d’avoir bien compris le problème et savoir ce que vous voulez faire. Notamment, compter des objets.

Je ne pense pas que ce soit possible d’automatiser la binarisation de l’image. Cela risque d’être différent d’une image à une autre. Mais c’est une impression personnelle.

A+

[A voir en vidéo sur Futura]

[azad]

Bonsoir.
Mathematica possède une bibliothèque très riche en matière d'analyse graphique. Par exemple
ImageData suivi par votre image glissée entre deux crochets [ image] et quelques paramètres, vous retourne un tableau contenant la valeur de chacun des pixels de votre image.
Le résultat peut ensuite être traité (tout cela dans un seul NoteBook) via les outils d'analyse de données de Mathematica encore. Par exemple avec l'image que vous avez posté et en se limitant aux 100 premiers pixels ….
ImageData[mon_image][[1,1;;100]] renvoie le tableau :
{{0.862745, 0.862745, 0.862745}, {0.854902, 0.854902,
0.854902}, {0.85098, 0.85098, 0.85098}, {0.847059, 0.847059,
0.847059}, {0.839216, 0.839216, 0.839216}, {0.831373, 0.831373,
0.831373}, {0.831373, 0.831373, 0.831373}, {0.831373, 0.831373,
0.831373}, {0.831373, 0.831373, 0.831373}, {0.819608, 0.819608,
0.819608}, {0.819608, 0.819608, 0.819608}, {0.823529, 0.823529,
0.823529}, {0.815686, 0.815686, 0.815686}, {0.792157, 0.792157,
0.792157}, {0.8, 0.8, 0.8}, {0.823529, 0.823529,
0.823529}, {0.819608, 0.819608, 0.819608}, {0.827451, 0.827451,
0.827451}, {0.835294, 0.835294, 0.835294}, {0.823529, 0.823529,
0.823529}, {0.819608, 0.819608, 0.819608}, {0.843137, 0.843137,
0.843137}, {0.85098, 0.85098, 0.85098}, {0.831373, 0.831373,
0.831373}, {0.827451, 0.827451, 0.827451}, {0.823529, 0.823529,
0.823529}, {0.811765, 0.811765, 0.811765}, {0.803922, 0.803922,
0.803922}, {0.815686, 0.815686, 0.815686}, {0.827451, 0.827451,
0.827451}, {0.819608, 0.819608, 0.819608}, {0.8, 0.8,
0.8}, {0.796078, 0.796078, 0.796078}, {0.811765, 0.811765,
0.811765}, {0.807843, 0.807843, 0.807843}, {0.792157, 0.792157,
0.792157}, {0.796078, 0.796078, 0.796078}, {0.819608, 0.819608,
0.819608}, {0.823529, 0.823529, 0.823529}, {0.807843, 0.807843,
0.807843}, {0.803922, 0.803922, 0.803922}, {0.807843, 0.807843,
0.807843}, {0.807843, 0.807843, 0.807843}, {0.803922, 0.803922,
0.803922}, {0.807843, 0.807843, 0.807843}, {0.807843, 0.807843,
0.807843}, {0.807843, 0.807843, 0.807843}, {0.8, 0.8,
0.8}, {0.807843, 0.807843, 0.807843}, {0.819608, 0.819608,
0.819608}, {0.839216, 0.839216, 0.839216}, {0.843137, 0.843137,
0.843137}, {0.827451, 0.827451, 0.827451}, {0.803922, 0.803922,
0.803922}, {0.803922, 0.803922, 0.803922}, {0.815686, 0.815686,
0.815686}, {0.819608, 0.819608, 0.819608}, {0.819608, 0.819608,
0.819608}, {0.811765, 0.811765, 0.811765}, {0.803922, 0.803922,
0.803922}, {0.807843, 0.807843, 0.807843}, {0.819608, 0.819608,
0.819608}, {0.839216, 0.839216, 0.839216}, {0.85098, 0.85098,
0.85098}, {0.835294, 0.835294, 0.835294}, {0.792157, 0.792157,
0.792157}, {0.764706, 0.764706, 0.764706}, {0.772549, 0.772549,
0.772549}, {0.788235, 0.788235, 0.788235}, {0.780392, 0.780392,
0.780392}, {0.768627, 0.768627, 0.768627}, {0.764706, 0.764706,
0.764706}, {0.756863, 0.756863, 0.756863}, {0.768627, 0.768627,
0.768627}, {0.768627, 0.768627, 0.768627}, {0.752941, 0.752941,
0.752941}, {0.74902, 0.74902, 0.74902}, {0.760784, 0.760784,
0.760784}, {0.772549, 0.772549, 0.772549}, {0.776471, 0.776471,
0.776471}, {0.776471, 0.776471, 0.776471}, {0.768627, 0.768627,
0.768627}, {0.760784, 0.760784, 0.760784}, {0.760784, 0.760784,
0.760784}, {0.756863, 0.756863, 0.756863}, {0.752941, 0.752941,
0.752941}, {0.760784, 0.760784, 0.760784}, {0.768627, 0.768627,
0.768627}, {0.764706, 0.764706, 0.764706}, {0.752941, 0.752941,
0.752941}, {0.760784, 0.760784, 0.760784}, {0.772549, 0.772549,
0.772549}, {0.760784, 0.760784, 0.760784}, {0.737255, 0.737255,
0.737255}, {0.74902, 0.74902, 0.74902}, {0.792157, 0.792157,
0.792157}, {0.784314, 0.784314, 0.784314}, {0.764706, 0.764706,
0.764706}, {0.760784, 0.760784, 0.760784}, {0.780392, 0.780392,
0.780392}}
pardon pour la longueur du message.
En remplaçant 100 par All les tableau serait la description complète de l'image, mais les modérateurs pourraient bien sévir.
Voir la doc de Mathematica pour ensuite voir quelles commandes sont adaptées à vos désirs, mais des choses comme "ContourPlot, DensityPlot, DensityHistogram" sont courantes en analyse. Et comme l'opération inverse est également possible, une modification du tableau ci dessus via une commande de traitement numérique ou statistique de tableau peut vous retourner le résultat graphique de l'image modifiée.
Il suffit d'écrire Image[ {{ le_tableau}}, "Byte"] pour voir le résultat.
pas très clair ? Allez sur le site dédié à Mathematica.

[azad]

On voit à la lecture du tableau que votre image n'est pas colorée, ou plutôt que chaque composante couleur à la même valeur que les deux autres. Typique d'un niveau de gris donc.

[obi76]

Bonjour,

comme le disait LPFR : avec une binarisation, on peut ensuite compter la quantité de blanc et de noir, sachant que pour chaque boule on semble avoir un ratio à peu près constant.

Un calcul sur matlab se fera en 5 minutes. Et si vous bossez en bmp, personnellement je le ferai en fortran90 : la lecture du fichier se fait en 5 lignes, le calcul en 2.

[LPFR]

Bonjour Obi76.
Le problème est que ce qu’il faut compter n’est pas le nombre de pixels noirs, mais le nombre de groupes de pixels noirs contigus. C’est beaucoup plus difficile.

Et ce qui est encore plus difficile c’est de savoir si deux groupes de pixels noirs contigus proches correspondent à un même objet ou à deux objets différents. Et ça change avec le critère de binarisation.
Cordialement,

[Gilgamesh]

Et pour rajouter mon grain de sel, il me semble que la bonne stratégie ce serait plutôt de compter les groupes contigus blanc purs (le sommet des bosses) au milieu d'un océan en niveau de gris. Y'a un réglage du contraste qui à mon sens ne peut être fait que manuellement et dans l'algo de comptage il faut paramétrer la largeur des bosses pour tenir compte que certaines sont fusionnées sur l'image.

Bref, à mon sens après un paramétrage correcte ça peut donner qqchose de relativement simple à coder, mais le problème en soi est intrinsèquement complexe.

[iori]

Je pense que ce n'est pas la peine de réinventer la roue, il y a des tonnes de plugins tout faits sous imageJ.

Je ne suis pas sur d'avoir bien comprit ce qu'il fallait détecter sur l'image, mais si c'est ce que je pense.
Découper une partie de l'image bien nette, et lancer un "find maxima" ou un "watershed" devrait lui détecter les bosses.

[azad]

Il suffit de rechercher dans le tableau obtenu le plus petit des triplets, et de le définir comme niveau des noirs, ou inversement le plus grand, qui lui sera le niveau des blancs. Ensuite en alignant les valeurs du tableau sur l'une ou l'autre de ces définitions un "ContourPlot" donne le résultat souhaité. On peut aussi si l'on définit le niveau des noirs comme {0,0,0} et celui des blancs comme {1,1,1} augmenter notablement la résolution grâce à une transposition (pas nécessairement linéaire) de la valeur de chacun triplets sur ces nouvelles définitions. Et si Matlab fait très bien cela, Mathematica le fait aussi. Avec pour ce dernier l'avantage d'un apprentissage bien plus rapide à mon sens.

[obi76]

Re-,

Bonjour Obi76.
Le problème est que ce qu’il faut compter n’est pas le nombre de pixels noirs, mais le nombre de groupes de pixels noirs contigus. C’est beaucoup plus difficile.

Pourquoi nécessairement vouloir les noirs contigus ? Ce que je propose n'est pas un traitement de compter les boules, mais de compter la quantité de noir, puisque le schéma semble quasi-identique pour toutes les boules... et donc connaître la quantité de noir pour une permet de remonter à son nombre, grosso modo)...

[LPFR]

Re-bonjour Obi76.
D’après iori, qui semble avoir côtoyé imageJ, le logiciel a des fonctionnalités faites pour compter ce type de choses.
Je commencerais par là. Surtout vu le prix.
Cordialement,

[lucas.gautheron]

Bonsoir,

Re-,



Pourquoi nécessairement vouloir les noirs contigus ? Ce que je propose n'est pas un traitement de compter les boules, mais de compter la quantité de noir, puisque le schéma semble quasi-identique pour toutes les boules... et donc connaître la quantité de noir pour une permet de remonter à son nombre, grosso modo)...

Cette méthode risque d'être trop sensible au seuil "noir-blanc" non ?
Je recommanderais plutôt, dans l'ordre :
1) voir si les outils existants (il y en a forcément) font l'affaire
2) sinon, faire comme gilgamesh l'a suggéré, compter les blancs, après binarisation. Puisque le seuil est arbitraire c'est bien de balayer toutes les valeurs possibles et de visualiser le nombre de boules en fonction de ce seuil et j'imagine que la bonne valeur est celle pour laquelle le résultat dépend peu du seuil

A+

[obi76]

Effectivement si des logiciels tout fait existent déjà, pourquoi s'emm****beter

[iori]

j'ai mentionné imageJ parce que c'est gratuit mais matlab avec la toolbox image processing doit aussi avoir des fonctions assez puissantes qui doivent convenir