Analyse de taches, comptage, et dissociation selon les couleurs

**thance** · 17/03/2007, 14h36

En suite à ce post ci http://www.developpez.net/forums/sho...d.php?t=285727

Et ou j'étais confronté à recommencer quasi depuis le départ mon système d'analyse d'image, je recommence donc un post pour essayer de résoudre mon problème.

En fait Voilà, je voudrais que l'image soit parcourue par un rond (virtuel), en fait se serait plutôt 2 lignes croisées qui parcourraient l'image, et dés que tous les pixels de ces 2 lignes seraient tous dans le même range "de couleur" on pourrait les considérer comme tache. Puis retenir leurs coordonées, et ensuite effectuer la dissociation selon que c'est du vert et du noir par exemple...

Cette image me sert d'image de départ à analyser :

Voilà, mon code qui s'est avéré foireux est en dernière page de l'autre taupic...

Donc en gros : taches de qques pixels vertes et noires, les compter et afficher le rapport.

Il faudrait que je fasse pour commencer 4 boucles je pense, avec une qui analyse le pixel du haut, l'autre celui du bas, et les deux autres gauches et droites.

Je ne sais pas si c'est le bonne méthode, ni comment la mettre concrètement en application. Car comme je le disais, je ne commence pas en progra, ni en analyse d'images (matlab), mais je ne connais pas encore le langage python.

Merci, et à +

**mchk0123** · 17/03/2007, 19h35

Ton problème est loin d'être simple et tu risques de perdre beaucoup de temps ; non pas à écrire un programme qui s'exécute mais à analyser sans erreurs ton image.

Depuis trés longtemps l'industrie et la recherche s'est penchée sur ce problème de détection automatique à partir d'images. Cela s'appèlle de la "vision industrielle" :

http://fr.wikipedia.org/wiki/Vision_industrielle

Je te conseilles de faire une recherche google sur la phrase "logiciels de vision industrielle" et tu verra que le sujet est trés vaste ... 1 million de pages trouvées ...

**thance** · 17/03/2007, 20h24

Je sais, mais j'ai le temps pour le faire et la motivation...

Je ne doit pas arriver a un résultat a 100% parfait, évidemment...

Mais j'aimerais qu'il aient une idée du rapport vert/noir.

Je pense y arriver, déjà ici j'ai pu arriver à quelque chose, en travaillant bien le sujet et en avançant pas à pas il y a moyen? non?

Tu crois que mon projet n'est pas viable?

Pourquoi?

Merci et à plus

**mchk0123** · 17/03/2007, 21h19

Tu vas trouver ça galère, mais ce que je te conseilles de faire c'est de t'impréigner de Python et apprendre à bien utiliser la librairie PIL.
Ensuite c'est de rechercher sur Internet et de lire des articles de recherche sur la vision industrielle.

Je ne penses pas qu'il existe de réponse toute faite à ton pb.

**thance** · 17/03/2007, 22h00

Envoyé par mchk0123

Je ne penses pas qu'il existe de réponse toute faite à ton pb.

Moi non plus, et ce n'est pas mon but!

J'aimerait vraiment construire un truc moi même... j'ai déjà exploré la librairie pil, et je commence a la cerner, ainsi que mon sujet et comment m'y attaquer...

Je veux juste un point de départ, des idées, comme j'ai eu sur l'autre topic...

J'ajoute que je ne veux pas un truc de précision industrielle, je veux juste leur faciliter la tâche, et montrer ce que je sais faire. Même si mon sujet s'en approche et que je m'y intéresse, d'ailleurs je vais me pencher dessus.

Je voulais savoir aussi si ma méthode était bonne et que je n'y vais pas par quatre chemins...

Merci, à +

**Guigui_** · 17/03/2007, 23h21

Ton objectif est simplement de compter les formes ?

Au vue de la qualité des images, ce n'est pas très compliqué pourtant (si toutes tes images se présentent de la même façon fond, couleur vert et noire de même nature sur toutes les images).

Mon algo qui m'a permis de trouver l'image des taches vertes et l'image des taches noires. j'ai travaillé en niveau de gris (je pense que c'est plus facile de travailler en couleur (mais vu que j'avais déjà développé des algos pour le niveau de gris, je m'en suis inspiré)).

Code python :

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

1
2
3
4
5
6
7
8
9
img = MonImage('dsc00001fd5.jpg') ## ouvre l'image en niveau de gris
img.Not()  ## pour chaque pixel: pixel = 255 - pixel
b = img.copy() ##  image finale contiendra les taches noires
c = img.copy() ##  image finale contiendra les taches vertes
 
b.SeuillageHysteresis(160, 220) ## où 160 est le seuilMin et 220 le seuilMax => j'obtiens les taches noires
c.Seuillage(150)  ## Un simple seuillage (qui me permet de récupérer les taches vertes et noires)
c ^= b  ## xor en binaire => permet d'éliminer les taches noires (il n'en restera plus que les contours plus ou moins gros)
c.Opening(1)  ## une ouverture morphologique (erosion puis dilatation de taille 1, la taille est a adapté en fonction de la qualité d'images) mais sur cet exemple, la taille 1 suffisait. => j'obtiens les taches vertes

Y'a plus qu'à les compter taches sur chaque image
Pour le seuillage à hysteresis, c'est simplement un seuillage sur le SeuilMax où tous les pixels voisins d'un pixel valide (pixel>SeuilMax ou validé) étant supérieur à SeuilMin est validé (donc mis à 255).
J'ai choisi les valeurs des seuillages pour que ca colle bien (donc c'est un peu biaisé) mais si tu as d'autres images qui ont les mêmes caractérisitiques, ces valeurs devraient convenir. Sinon cela ne fonctionnera pas.

Vu la qualité/propreté de tes images, il y a bien entendu plein d'algos possibles pour arriver à tes fins. Pour Python, en plus de PIL, tourne-toi aussi du côté de numpy/scipy pour le traitement matriciel (elles doivent mêmes fournir quelques fonctions de traitement d"image (notamment morphologique))

**Guigui_** · 18/03/2007, 08h47

Finalement, en travaillant sur les couleurs R, G, B, c'est encore plus simple

Code python :

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
# -*- coding: cp1252 -*-
import Image
import numpy
 
im = Image.open('dsc00001fd5.jpg').split()
im[0].save('r.png')  ##  juste pour voir ce que ca donne visuellement
im[1].save('g.png')  ## juste pour voir ce que ca donne visuellement
im[2].save('b.png')  ## juste pour voir ce que ca donne visuellement
 
r = numpy.array(list(im[0].getdata()))  ## création d'un tableau avec R
g = numpy.array(list(im[1].getdata()))  ## création d'un tableau avec G
b = numpy.array(list(im[2].getdata()))  ## création d'un tableau avec B
 
n = numpy.where(g<70, 255, 0)   ## seuillage sur G, on conserve les pixels en dessous de 70 => il ne reste que les noires
noire = Image.new('L', (640, 480))
noire.putdata(n)
noire.save('noir.png')
 
v = numpy.where(b<70, 255, 0) ## seuillage sur B, on conserve les pixels  en dessous de 70 => on obtient les noires et les vertes
n = 255-n ## on inverse l'image des taches noires
v &= n ## et binaire avec l'image sans les taches noires, permet de récupérer que les taches vertes
vert = Image.new('L', (640, 480))
vert.putdata(v)
vert.save('vert.png')

Et là, j'ai mes images vertes et noires nickel (il y a encore les 2 valeurs des seuillages à bien choisir)

**thance** · 18/03/2007, 15h03

Salut Guigui, et merci pour ton code je vais essayer de le comprendre.... Parce que c'est assez chaud pour mon niveau...

En fait, en théorie, le fond sera toujours clair (vert très clair).

Et il y aura toujours des taches vertes ou alors noires/vertes très très foncées... presque noires quoi...

Mais ton truc permet vraiment de compter, d'incrémenter un compteur plus exactement? (je suis encore aux vieilles boucles moi, php powaaa)

Merci à toi

**mchk0123** · 18/03/2007, 15h30

GuiGui tu pourrais nous mettre un lien d'explication vers le Seuillage par Hystéresis ?

Le plus complet possible au mieux, ou bien dans la doc PIL au pire ?

Merci, cela m'intéresse grandement.

**Guigui_** · 18/03/2007, 19h42

Envoyé par thance

Mais ton truc permet vraiment de compter, d'incrémenter un compteur plus exactement? (je suis encore aux vieilles boucles moi, php powaaa)

Merci à toi

Non, cet algo permet simplement de récupérer une image ne contenant que les taches vertes ou noires. Après il n'y a plus qu'à compter.
Pour compter, ce n'est pas très compliqué:
- il faut parcourir chaque pixel de ton image binarisée (représentant par exemple les taches noires).
- Dès que tu trouves un pixel valant 255, cela signifie que tu as une taches supplémentaire.
Alors tu mets ce pixel à 0 ainsi que tous ces voisins (valant 255) dans un 8-voisinnage (et les voisins des voisins ...), ainsi tu as mis à 0 tous les pixels de la tache.
Puis tu continue de parcourir ton image ainsi de suite

Code :

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

1
2
3
4
5
6
nbtache = 0
Pour i de 0 à NbLignes
    Pour j de 0 à NbColonnes
       if Pixel[i,j] == 255:
            nbtache += 1
            Mettre à 0 tous les pixels voisins (valant 255) de (i,j) et les voisins des voisins (cela se traite avec des piles ou listes)

**Guigui_** · 18/03/2007, 19h50

Envoyé par mchk0123

GuiGui tu pourrais nous mettre un lien d'explication vers le Seuillage par Hystéresis ?

Le plus complet possible au mieux, ou bien dans la doc PIL au pire ?

Merci, cela m'intéresse grandement.

PIL ne permet pas de faire du traitement d'images, mais plutôt de la manipulation d'images (en gros des trucs basiques). Pour faire du traitement, il faut passer par numpy et en général tout coder à la main dès que l'algo n'est pas simple.

Pour le seuillage par hysteresis, je ne crois pas que numpy le propose.
Le principe est simple: tu as 2 seuils: SeuilMin et SeuilMax
Tu seuilles ton image sur le SeuilMax et tu seuilles avec le SeuilMin tous les voisins (et les voisins des voisins) d'un pixel supérieur au SeuilMax.

Ainsi si tu as une images qui contient des taches ou les pixels varient de 50 à 150 et d'autres de 100 à 200 et que tu veux récupérer uniquement les taches 100-200 en conservant la tache la plus grosse possible, il suffit de faire un seuillage par hysteresis avec SeuilMin = 100 et SeuilMax = 180 alors qu'un Seuillage simple avec SeuilMin = 100, tu aurais aussi récupérer des bouts des taches 50-150

**parp1** · 19/03/2007, 10h01

Salut moi j'avais vu une autre facon de faire peut etre un peu plus ...bourin,cette facon de faire ne fonctionne que si la differences de taille entre tes points est assez grande.

Tu seuillage ton image afin d'extraires tes points du fond.(seuillage entropique par exemple)

Ensuite tu appliques une grosse erosion jusqu'a faire disparaitre tout les petits point.

Tu fais la soustraction entre ton seuillage initial, et ton image sans les petits points. Ainsi tu obtiens l'image des petits points.

tu as donc en stock, une image regroupant tes gros points, et une image avec tes petits points.

Il reste ensuite a faire (chose dont je ne suis pas sur qu'elle fonctionne) Une mulitplication d'une des images gros ou petits points avec l'image couleur originale(en fait mutliplication des trois canaux+reconstuction RGBtoColor.), le fond etant a 0 devrait rester etre mutliplier par zero, les points étant a 1 devrait maintenire les couleurs en leur état.

Je ne sais pas si j'ai été clair, et je ne sais meme pas si c'est fonctionnel... Mais peut etre a essayer.

**thance** · 24/03/2007, 13h43

Merci guigui pour tes réponses, et a parp aussi, je vais bien m'y mettre ce w-e...

Juste une question pour ceux qui connaissent matlab, il existe une fonction ressemblant a bwlabeln en python? Dans mes cours je me rapelles qu'en utilisant le labelling, on pouvait compter le nombre de taches en transformant préalablement l'image en binaire...

Pour guigui je crois commencer à capter ton système... C'est pas bête, mais le traitement ne sera pas lent? Mon idée est faisable ou c'est farfelu?

Sinon pour parp, c'est un peu trop chaud pour moi ta méthode, le python pour moi c'est assez neuf

A +

**thance** · 24/03/2007, 14h06

Pour les macs users qui veulent installer numpy : http://pythonmac.org/packages/py24-fat/

Voilà

**thance** · 24/03/2007, 17h32

Guigui j'ai un problème avec ton code... les images sont brouillées...

C'est un bizarre et je comprends pas pourquoi...

Comment je pourrais débuguer ça?

Et les piles et les listes jss pas doué

mais bon je vais essayer de compter par moi même...

A +

**thance** · 26/03/2007, 08h53

Voilà j'ai modifié et ça marche, sans doute qu'il fallait tout mettre pour que ça tourne...

Code python :

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
# -*- coding: cp1252 -*-
import Image
import numpy
im = Image.open('/Users/thomashance/Desktop/tfe/prog/DSC00001.JPG').split()
larg, haut = im[0].size ## long et largeur de l'image
im[0].save('/Users/thomashance/Desktop/tfe/prog/r.png')  ##  juste pour voir ce que ca donne visuellement
im[1].save('/Users/thomashance/Desktop/tfe/prog/g.png')  ## juste pour voir ce que ca donne visuellement
im[2].save('/Users/thomashance/Desktop/tfe/prog/b.png')  ## juste pour voir ce que ca donne visuellement
 
r = numpy.array(list(im[0].getdata()))  ## création d'un tableau avec R
g = numpy.array(list(im[1].getdata()))  ## création d'un tableau avec G
b = numpy.array(list(im[2].getdata()))  ## création d'un tableau avec B
 
 
 
n = numpy.where(g<70, 255, 0)   ## seuillage sur G, on conserve les pixels en dessous de 70 => il ne reste que les noires
matrix = numpy.reshape(n, (larg,haut))## mettre la matrice en forme, sinon bugs
noire = Image.new('L', (larg, haut))## création d'une instance d'image
noire.putdata(list(matrix.flat))## "transformation de la matric en image
noire.save('/Users/thomashance/Desktop/tfe/prog/noir.jpg')## on la sauve
noire.show() ## prévi.
 
 
 
v = numpy.where(b<70, 255, 0) ## seuillage sur B, on conserve les pixels  en dessous de 70 => on obtient les noires et les vertes
n = 255-n ## on inverse l'image des taches noires
v &= n ## et binaire avec l'image sans les taches noires, permet de rŽcupŽrer que les taches vertes
matrix2 = numpy.reshape(v, (larg,haut))
vert = Image.new('L', (larg, haut))
vert.putdata(list(matrix2.flat))
vert.save('/Users/thomashance/Desktop/tfe/prog/vert.tiff')
vert.show()

Pour le moment je suis en train de chercher des fonctions qui pourraient m'aider dans le comptage, avant de me mettre a faire mon propre algorithme... Il y a bien la fonction getbbox, mais ce n'est que pour les zones valant 0, et je ne pense pas qu'elle permette de réellement compter.

Sous matlab, en 3 étapes a partir d'une image en binaire, de regionprops, et de bwlabeln, on peut savoir combien de taches il y a..

++

**thance** · 16/04/2007, 20h43

Je relance mon topic, pour voir si qqun a une idée pour compter mes taches en noir et blanc...

J'ai essayé une méthode, mais je suis bloqué, car j'aimerait a partir de la coordonée de 4 points mettre un carré a noir un peu plus grand, et bon le carré noir, ça je sais, mais comment le placer?

Code python :

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
from PIL import Image
vert = Image.open("/Users/thomashance/Desktop/tfe/prog/vert.png")
noir = Image.open("/Users/thomashance/Desktop/tfe/prog/noir.png")
x, y = vert.size
compt = 0
k = 0
s = 0
fin = 1
a=0
## fais la collecte de tous les pixels avec leur couleurs respectives
for i in range(x):
    for j in range(y):
        pixel = vert.getpixel((i, j))
        if pixel == 255:
            if vert.getpixel((i, j+8))==255 and vert.getpixel((i, j-8))==255 and vert.getpixel((i+8, j))==255 and vert.getpixel((i-8, j))==255:## à paramètrer selon la taille
                    compt=compt + 1
                    print "ok"
vert.show()
print compt

Voilà, ça fonctionne, mais pas dans le cas ou certains points sont plus grands que les autres...

Il faudrait pouvoir initialiser la croix a la tache la plus petite, et masquer avec une tache plus importante... Mais je vois pas trop comment faire en fait...

Svp aidez moi...

Merci

**ol9245** · 20/04/2007, 19h15

tu comptes les pixels qui sont verts ET qui ont du nor à une distance de 8 pixels. Je crois pas que ça marche. En tous cas c'est pas la méthode académique.

Tu dois labelliser. cherche labelisation pour avoir les algos : c'est pas caché. Après tu compte le nombre de labels que tu as distribués.

**thance** · 20/04/2007, 19h31

Oui je sais, le label, mais franchement j'ai bien cherché et je trouve pas en python...

Sinon ici je pars des images noir et blanc pour compter, donc pas de vert...

En fait le prob avec ma boucle c'est que si ça rentre 2 fois dans une tache il le compte 2 fois...

+++

**ol9245** · 21/04/2007, 03h08

C'est pas trop difficile d'écrire un algo de label sur une page blanche. C'est peut être pour ca qu'il n'y a pas beaucoup de pages web qui lui sont dédiées

Tu peux utiliser la forme récursive pour que ça soit plus simple.

Toujours pour faire simple, tu a deux images : l'image d'origine et celle des labels. l'image label est initialisée à zéro doc séro n'st pas un label

un truc comme (j'écris comme je pense. A vérifier)

set_label prend 4 paramètres :
image = l'image de départ
label_image = la carte des labels
i = le pixel i a labelliser
n = le label à poser si possible

Code :

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

1
2
3
4
5
6
7
8
fonction set_label (image, label_image, i, n)
si i a un label
    sortir
sinon
    label_image(i) = n
pour tous les voisins j de i, 
    si appartient_à_la_meme_région(image, i, j)
          set_label (image, label_image, j)

La fonction appartient_à_la_meme_région compare deux pixels voisins et décide si le deuxième et bon ou pas
% a priori tu fais un simple gradient donc, pour des taches sombres sur fond clair

Code :

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

1
2
3
4
5
fonction appartient_à_la_meme_région(image, i, j)
    si image(j) - image(i) > mon_seuil
        return faux
    else
        return vrai

reste à labelliser une image
La fonction labeliser_image prend une image en entrée et te donne la carte des labels correspondants en sortie.
Noter que la variable interne n contiendra en sortie le nombre de labels posés

Code :

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

1
2
3
4
5
6
7
fonction label = labeliser_image(image)
    label = image * 0 %%% je crée une image de même taille remplie de zéros
    n = 0 ; % le numéro du dernier label posé
    pour tout i dans image  
        si label(i) == 0    
             n=n+1
             set_label (image, label_image, i, n)

Voilà. Tu vois, c'est pas compliqué. ya pas de quoi en faire une page web, comme je disais ! Ca devrait marcher après traduction en Python. Désolé, je ne connais pas ce langage.

OL

Analyse de taches, comptage, et dissociation selon les couleurs

Traitement d'images

Discussions similaires

Partager

Partager