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))## cration 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') |
Partager