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
| # -*- coding: cp1252 -*-
import Image
import numpy
import scipy
def imgtoseuil():
im = Image.open('/Users/thomashance/Desktop/tfe/prog/P52505912+vert2.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())) ## creation d'un tableau avec R
g = numpy.array(list(im[1].getdata())) ## creation d'un tableau avec G
b = numpy.array(list(im[2].getdata())) ## creation 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.tiff')## on la sauve
noire.show() ## prévisualise.
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()
return matrix, matrix2
def fromdatatodata_colors(datamatrice):
# Cette fonction prend en argument une matrice n*m de données et retourne une matrice image RGB de ces données.
img_shape = scipy.shape(datamatrice[0])
img_nb_ligne = img_shape[0]
img_nb_collonne = img_shape[1]
img_ligne = scipy.arange(0, img_nb_ligne, 1)
img_collonne = scipy.arange(0, img_nb_collonne, 1)
rgb = scipy.arange(0, 3, 1)
niveaux = scipy.arange(0, 255, 1)
zones = scipy.arange(0, 16581376, 1)
CO = 16581376 / (datamatrice[1]*1000) # Color offset, permet de répartir les zones le long des 16000000 de couleurs.
img = datamatrice[0] * CO
index = 0
colormap = scipy.ones([1, len(zones), len(rgb)]) # Index des couleurs RGB en fonction des numéros de zones.
for r in niveaux:
for g in niveaux:
for b in niveaux:
colormap[0, index, 0] = r
colormap[0, index, 1] = g
colormap[0, index, 2] = b
index = index + 1
data_colors = scipy.ones([img_shape[0] + 2, img_shape[1] + 2, len(rgb)])
for l in img_ligne: # Parcours des image rgb et data.
for c in img_collonne:
for n in rgb:
if img[l, c] != 0:
data_colors[l, c, n] = colormap[0, img[l, c], n]
return data_colors
def fromimgtoimg_edge(img, img_ligne, img_collonne, nblc, offset):
# Cette fonction retourne une matrice qui gère les effets de bords en fonction de la matrice binaire d'origine.
img_edge = scipy.zeros([nblc, nblc])
for l in img_ligne:
for c in img_collonne:
img_edge[l + offset, c + offset] = img[l, c]
return img_edge
def fromdata_edgetodata(data_edge, img_shape, img_ligne, img_collonne, offset):
# Cette fonction retourne une matrice emputé des bords qui servaient à gérer les effets de bords.
data = scipy.zeros([img_shape[0], img_shape[1]])
for l in img_ligne:
for c in img_collonne:
data[l, c] = data_edge[l + offset, c + offset]
return data
def neighbors(img_edge, data_edge, l, c, x, next_region):
# cette fonction parcours l'image de façon concentrique à partir d'un point à la recherche d'éléments consécutifs.
empty = 0
neighbors_row = scipy.arange(- x, x + 1, 1)
for n in neighbors_row:
for m in neighbors_row:
if abs(n) == x or abs(m) == x:
if img_edge[l + n, c + m] == 255:
if data_edge[l + n - 1, c + m - 1] == next_region or data_edge[l + n - 1, c + m] == next_region or data_edge[l + n - 1, c + m + 1] == next_region or data_edge[l + n, c + m - 1] == next_region or data_edge[l + n, c + m + 1] == next_region or data_edge[l + n + 1, c + m - 1] == next_region or data_edge[l + n + 1, c + m] == next_region or data_edge[l + n +1, c + m + 1] == next_region:
empty = 1
img_edge[l + n, c + m] = 0
data_edge[l + n, c + m] = next_region
return empty
def fromimgtodata(img):
# Cette fonction prend en argument la matrice binaire d'origine et renvoie une matrice de données.
img_shape = scipy.shape(img)
img_nb_ligne = img_shape[0]
img_nb_collonne = img_shape[1]
img_ligne = scipy.arange(0, img_nb_ligne, 1)
img_collonne = scipy.arange(0, img_nb_collonne, 1)
nbmaxlc = max([img_shape[0], img_shape[1]]) # donne la dimention de la matrice la plus grande (largeur ou hauteur).
offset = nbmaxlc - 1 # grandeur de la zone de gestion de bords.
nblc = nbmaxlc * 3 -2 # Longueur et grandeur de la matrice.
neighbors_row_max = scipy.arange(1, nbmaxlc, 1)
data_edge = scipy.zeros([nblc, nblc]) # Matrice de data avec gestion de bords.
img_edge = fromimgtoimg_edge(img, img_ligne, img_collonne, nblc, offset)
data_edge_shape = scipy.shape(data_edge)
data_edge_nb_ligne = data_edge_shape[0]
data_edge_nb_collonne = data_edge_shape[1]
next_region = 1
for l in img_ligne:
for c in img_collonne:
if img_edge[l + offset, c + offset] == 255:
img_edge[l + offset, c + offset] = 0
data_edge[l + offset, c + offset] = next_region
for x in neighbors_row_max:
if neighbors(img_edge, data_edge, l + offset, c + offset, x, next_region) == 0:
break # Si tous les voisins sont = 0 rien ne sert de regarder les adjacents suivant.
next_region = next_region + 1
data = fromdata_edgetodata(data_edge, img_shape, img_ligne, img_collonne, offset)
nbregion = next_region - 1
return data, nbregion
# How to use fromimgtodata
#erosion
def Erosion(img):##ok
Erode=[0]*(img.shape[1]-2)*(img.shape[0]-2)
h=0
for i in range(1,img.shape[0]-1):
for j in range(1,img.shape[1]-1):
Erode[h]=min([img[i-1][j-1],img[i][j-1],img[i+1][j-1],img[i-1][j],img[i][j],img[i+1][j],img[i-1][j+1],img[i][j+1],img[i+1][j+1]])
#Mise de la valeur max du voisinage 3x3 au point(x,y)
h+=1
Erode=numpy.array(Erode)
Erode=numpy.reshape(Erode,(img.shape[0]-2,img.shape[1]-2))
RebuildImg(Erode,'/Users/thomashance/Desktop/tfe/prog/erode.tiff')
def RebuildImg(data,path): #data de limage a reconstruire, plus chemin de sortie.
Copie = Image.new("L",(data.shape[1],data.shape[0]))
Copie.putdata(list(data.flat))
Copie.save(fp=str(path))
img = imgtoseuil()
img = scipy.misc.pilutil.imread('/Users/thomashance/Desktop/tfe/prog/noir.tiff')
img2 = scipy.misc.pilutil.imread('/Users/thomashance/Desktop/tfe/prog/vert.tiff')
img2 = Erosion(img2)
img2 = scipy.misc.pilutil.imread('/Users/thomashance/Desktop/tfe/prog/erode.tiff')
datamatrice = fromimgtodata(img)
print "Nombre de zones noires: " + str(datamatrice[1])
datamatrice2 = fromimgtodata(img2)
print "Nombre de zones vertes: " + str(datamatrice2[1])
# Colors
#datacolors = fromdatatodata_colors(datamatrice)
#scipy.misc.pilutil.imshow(datacolors)
#datacolors2 = fromdatatodata_colors(datamatrice2)
#scipy.misc.pilutil.imshow(datacolors2)
#RebuildImg(datacolors2,'/Users/thomashance/Desktop/tfe/prog/datacolors2.tiff') |
