Discussion :

[astragoth]

Bonjour,
Je suis en train de développez un soft pour trouver le centre de plusieurs taches dans une image.
Auriez vous des algorithmes si possible bien commenter, car google me sors du algo mais non commenté... pour trouver le centroid d'une tache de forme circulaire ou légérement ovale.
J'ai déjà un algo pour identifier des zones pour mes taches, donc il me reste juste à identifier le centre de chaque tache.

Merci d'avance
julien

[Matthieu Brucher]

Si tu as un masque de chaque tache, le plus simple est... une moyenne

[KINENVEU]

bonjour,
j'ai deja eu l'occasion de traiter un probleme de cet ordre.
Je travaillais en intensitee de gris [0, 256].
et je cherchais les zones de saturations.
Pour la detection des zones, j'utilisais les max par colonnes et lignes de memoire.
Puis pour le centroide, j'utilisais une moyenne ponderee.
eventuellement des subdivisions d'espace.
C'est assez simple a implementer, et ca ne marchait pas trop mal pour une estimation grossiere.
:-)

sinon, il doit exister des methodes plus evoluees dans la litterature du traitement d'image.

[astragoth]

Bonjour,
Aprés un léger acharnement, j'y suis arriver.
Pour ceux que ca interresse voici mon code:
Un premier balayage pour repérer le seuil max d'un motif 3*3
Puis rebalayage pour repérer les éléments ayant un niveau max/2
Aprés par un fit gaussien, j'identifie le centre de chaque tache.
Le seul probléme actuellement, plus la tache est grosse, puis le temps de calcul est long. car il me trouve beaucoup d'élément sur la meme tache.
Mais comme je travail sur des tache de 5 pixels, ca va trés bien.

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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
 
import sys
import numpy
import PIL
import string
import glob
import os.path
from scipy import optimize
from pylab import *
import random
astroterra_path = 'F:\\EVS\\DEV'
alt_astroterra_path = '\\\\140.94.169.102\\USER\\EVS\\DEV'
trouve = False
trouve = astroterra_path in sys.path
if not trouve:
    trouve = alt_astroterra_path in sys.path
    sys.path.append(alt_astroterra_path)
if not trouve:
    sys.path.append(astroterra_path)
else:
    print 'Chemin deje present'
import time
import PyQt4
from PyQt4 import QtCore, QtGui
from equipement.common.image.CGestionImage import CGestionImage as CImage
 
TailleObjet = 1
 
def maximum3x3_NOBJETS(img, seuil):
    #Recherche du macro pixel max
    data = img.donnees
    Smax = 0
    pixels_selec = []
    for l in range(0,img.largeur): #largeur
        for h in range(0,img.hauteur): #hauteur
            S = SommeArray(data[h-TailleObjet:h+TailleObjet+1,l-TailleObjet:l+TailleObjet+1])
            if(S>Smax):
                Smax = S
                pixels_selec.append([l,h,S])
    #recherche de tous les macro pixel superieur a Smax/2
    k = 0
    pixels_MAX = []
    for l in range(0,img.largeur): #largeur
        for h in range(0,img.hauteur): #hauteur
            S = SommeArray(data[h-TailleObjet:h+TailleObjet+1,l-TailleObjet:l+TailleObjet+1])
            if(S>Smax/2):
                pixels_MAX.append([l,h,S])
    #recherche de tous les objets differents
    for px_max in pixels_MAX:
        flag = 0
        for px_selec in pixels_selec: #tant que le macro pixel n appartient pas a un objet existant
            if(numpy.abs(int(px_max[0]) - int(px_selec[0])) < 10 and numpy.abs(int(px_max[1]) - int(px_selec[1])) < 10):
                flag = 1 #si le macro pixel appartient a un objet existant a une distance < 10 pixels
                if(int(px_max[2])> int(px_selec[2])):
                    px_selec = px_max
        if(flag == 0): #si le macro n appartient a aucun objet existant, alors creer l objet
            pixels_selec.append(px_max)
    #d?termination de la fenetre de calcul du barycentre
    px = []
    for px_selec in pixels_selec:
        seuil_s = seuil * px_selec[2]
        dim_haut = px_selec[0]
        i = px_selec[0]
        j = px_selec[1]
        S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        while(S > seuil_s):
            dim_haut = i
            i=i-1
            S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        dim_bas = px_selec[0]
        i = px_selec[0]
        j = px_selec[1]
        S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        while(S > seuil_s):
            dim_bas = i
            i=i+1
            S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        dim_gauche = px_selec[2]
        i = px_selec[0]
        j = px_selec[1]
        S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        while(S > seuil_s):
            dim_gauche = j
            j=j-1
            S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        dim_droit = px_selec[2]
        i = px_selec[0]
        j = px_selec[1]
        S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        while(S > seuil_s):
            dim_droit = j
            j=j+1
            S = SommeArray(img.donnees[j-2:j+3,i-2:i+3])
        px.append([px_selec[0], px_selec[1], px_selec[2], dim_haut-1, dim_bas+1, dim_gauche-1, dim_droit+1])
    #Recherche de la somme et la moyenne des sommes
    somme = []
    for p in px:
##        print p
        somme.append(p[2])
    return px, numpy.max(somme), numpy.mean(somme)
 
def barycentre_fenetre(img, px):
    #initialisation
    px_haut = int(px[3])
    px_bas = int(px[4])
    px_gauche = int(px[5])
    px_droit = int(px[6])
    poid_ligne = numpy.zeros(img.largeur)
    distance_ligne = numpy.zeros(img.largeur)
    Barycentre_ligne = 0
    somme_poid_ligne = 0
    poid_colonne = numpy.zeros(img.hauteur);
    distance_colonne = numpy.zeros(img.hauteur);
    Barycentre_colonne = 0;
    somme_poid_colonne = 0;
 
    #Balayage ligne
    for i in range(px_haut, px_bas+1):
        poid_ligne[i] = SommeArray1D(img.donnees[px_gauche:px_droit+1,i])
        distance_ligne[i]=i #centre du pixel est i
        Barycentre_ligne = poid_ligne[i] * distance_ligne[i] + Barycentre_ligne
        somme_poid_ligne = poid_ligne[i] + somme_poid_ligne
    Bar_ligne = Barycentre_ligne / somme_poid_ligne
 
    #Balayage colonne
    for j in range(px_gauche, px_droit+1):
        poid_colonne[j] = SommeArray1D(img.donnees[j,px_haut:px_bas+1])
        distance_colonne[j]=j #centre du pixel est j
        Barycentre_colonne = poid_colonne[j] * distance_colonne[j] + Barycentre_colonne
        somme_poid_colonne = poid_colonne[j] + somme_poid_colonne
    Bar_colonne = Barycentre_colonne / somme_poid_colonne
    return Bar_ligne, Bar_colonne
 
def gauss2D(px, data):
    params = fitgaussian(data[px[5]:px[6] +1, px[3]:px[4] +1])
    params[1] = params[1] + px[5]
    params[2] = params[2] + px[3]
##    print params
    fit = gaussian(*params)
 
    return fit, params
 
def SommeArray(tableau):
    somme = 0
    size=tableau.shape
    for Y in range(0, size[1]):
        for X    in range(0, size[0]):
            somme = somme+tableau[X,Y]
    return somme
def SommeArray1D(tableau):
    somme = 0
    size=tableau.shape
    for X in range(0, size[0]):
        somme = somme+tableau[X]
    return somme
 
def gaussian(height, center_x, center_y, width_x, width_y):
    """Returns a gaussian function with the given parameters"""
    width_x = float(width_x)
    width_y = float(width_y)
    return lambda x,y: height*exp(
                -(((center_x-x)/width_x)**2+((center_y-y)/width_y)**2)/2)
 
def moments(data):
    """Returns (height, x, y, width_x, width_y)
    the gaussian parameters of a 2D distribution by calculating its
    moments """
    total = data.sum()
    X, Y = indices(data.shape)
    x = (X*data).sum()/total
    y = (Y*data).sum()/total
    col = data[:, int(y)]
    width_x = sqrt(abs((arange(col.size)-y)**2*col).sum()/col.sum())
    row = data[int(x), :]
    width_y = sqrt(abs((arange(row.size)-x)**2*row).sum()/row.sum())
    height = data.max()
    return height, x, y, width_x, width_y
 
def fitgaussian(data):
    """Returns (height, x, y, width_x, width_y)
    the gaussian parameters of a 2D distribution found by a fit"""
    params = moments(data)
    errorfunction = lambda p: ravel(gaussian(*p)(*indices(data.shape)) -
                                 data)
    p, success = optimize.leastsq(errorfunction, params)
    return p
 
#Ouverture de l'image
PathImg = "F:\\EVS\\DEV\\julien\\AIM-4_PA.tif"
TraitementImage = CImage(None)
Img = TraitementImage.lire(PathImg)
data = Img.donnees
matshow(data, cmap=cm.gist_earth_r)
h = 80
l = 120
##print Img.donnees[h-1:h+2,l-1:l+2]
pixels, max, moy = maximum3x3_NOBJETS(Img, 0)
##print max
##print moy
bar = []
for px in pixels:
    lig, col = barycentre_fenetre(Img, px)
    bar.append([px[0],px[1],px[2],px[3],px[4],px[5],px[6],lig,col])
 
t = []
for b in bar:
    t.append(gauss2D(b, Img.donnees))
 
PrecX = -1
PrecY = -1
SommeX = 0
SommeY = 0
Nb = 0
centroide = {}
centre = 0
NameFileOut = 'I:/tmp/centroid.txt'
out = open(NameFileOut, 'w')
out.write('X\tY\tWidth_X\tWidth_Y\n')
for t1 in t:
##    print t1[0](*indices(data.shape))
    contour(t1[0](*indices(data.shape)), cmap=cm.copper)
    ax = gca()
    (height, x, y, width_x, width_y) = t1[1]
    print "x : " + str(x) + "\t Y : " + str(y) + "\t width_x : " + str(width_x) + "\t width_y : " + str(width_y)
    out.write(str(x) + "\t" + str(y) + "\t" + str(width_x) + "\t" + str(width_y) + "\n")
    if(numpy.abs(PrecX-x)<=10 and numpy.abs(PrecY-y)<=10):
        c = centroide[centre]
        centroide[centre][0].append(x)
        centroide[centre][1].append(y)
        centroide[centre][2].append(width_x)
        centroide[centre][3].append(width_y)
        PrecX = x
        PrecY = y
    else:
        centre = centre + 1
        centroide[centre] = {}
        centroide[centre][0] = []
        centroide[centre][0].append(x)
        centroide[centre][1] = []
        centroide[centre][1].append(y)
        centroide[centre][2] = []
        centroide[centre][2].append(width_x)
        centroide[centre][3] = []
        centroide[centre][3].append(width_y)
##        [x,y,width_x,width_y]
        PrecX = x
        PrecY = y
 
out.write("\n\n")
for cen in centroide:
    for c1 in centroide[cen]:
        out.write(str(numpy.mean(centroide[cen][c1])) + "\t" + str(numpy.std(centroide[cen][c1])) + "\t")
    out.write("\n")
out.close()
show()