L'essentiel de cette page

Traiter une image, c'est d'abord jouer sur les couleurs, la luminosité, le contraste. Dans un deuxième temps, c'est faire de la segmentation et utiliser le machine learning pour détecter des formes, des objets.

Installer PIL avec la commande pip :

pip install Pillow

• 1- Convertir l'image au format numpy et la décrire

import numpy as np

img = np.array(myimg)

plt.imshow(img) ; plt.show() # On peut continuer à utiliser la fonction imshow pour visualiser l'image même au format numpy

print("Dimensions de l'image : ",img.shape) # Dimensions x, y et nombre de couleurs

print("Pixel 500 sur 200 : ",img[200,500])

print("Composante rouge de ce dernier pixel :",img[200,500][0])

# Tous le rouge de tous les pixels

print("Rouge : ",img[:,:,0])

• 2- Convertir les composantes rouge, vert et bleu en dataframe

red = np.reshape(img[:,:,0],img.shape[0]*img.shape[1])

green = np.reshape(img[:,:,1],img.shape[0]*img.shape[1])

blue = np.reshape(img[:,:,2],img.shape[0]*img.shape[1])

from pandas import *

couleurs = DataFrame({"r":red,"g":green,"b":blue})

print(couleurs.head(10))

• 3- Réaliser des transformations sur ces composantes (exemples)

couleurs = couleurs + 30 # j'éclaircis tout de 30 niveau sur 255

couleurs.r = round(couleurs.r/3,0) # Je divise par 3 les valeurs de rouge

• 4- Fabriquer une nouvelle image à partir des composantes rouge, vert bleu retravaillée

img1 = img.copy()

red = np.reshape(np.array(couleurs.r),(img.shape[0],img.shape[1]))

green = np.reshape(np.array(couleurs.g),(img.shape[0],img.shape[1]))

blue = np.reshape(np.array(couleurs.b),(img.shape[0],img.shape[1]))

img1[:,:,0] = red

img1[:,:,1] = green

img1[:,:,2] = blue

• Une fonction pour faciliter l'affichage en basculant automatiquement en fonction du fait que l'image est en couleur ou en niveau de gris

def display(img,cmap='gray') :

if (len(img.shape) == 3) :

fig, ax = plt.subplots(figsize=(15, 12))

plt.imshow(img) ; plt.show()

else :

fig, ax = plt.subplots(figsize=(15, 12))

plt.imshow(img,cmap=cmap, vmin=0, vmax=255) ; plt.show()

• Une fonction pour convertir une image en niveau de gris

###############################

# NVEAU DE GRIS

###############################

def gray_scale_img(img) :

temp_img = img[:,:,1]

temp_img = temp_img.reshape(temp_img.shape[0],temp_img.shape[1])

temp_img[:,:] <- img[:,:,0]*0.2126+img[:,:,1]*0.7152+img[:,:,2]*0.0722

return(temp_img)

• Une fonction simple qui va réduire la taille d'une image (attention, pas de lissage = perte de signal plus accrue)

• coeff : est le coeff de réduction

def redim_img(img,coeff=3) :

colonnes = list(range(0,img.shape[1]))

colonnes = colonnes[0::coeff]

lignes = list(range(0,img.shape[0]))

lignes = lignes[0::coeff]

if len(img.shape)==3 :

img_temp = img[lignes,:,:]

img_temp = img_temp[:,colonnes,:]

else :

img_temp = img[lignes,:]

img_temp = img_temp[:,colonnes]

return(img_temp)

Liens externes pour redimensionner une image avec un lissage de l'information (éviter les pertes de signal) :

• Pour agrandir une image.

• Réduire une image en lissant avec skimage.transform import resize

Cette fonction est l'équivalent de la fonction de scipy, ndimage.convolve(), mais elle a l'avantage de s'adapter au format couleur ou niveau de gris automatiquement, tout en permettant de contrôler le code pas à pas. Cet équivalent :

from scipy import ndimage

# Travail sur une seule composante couleur de img à la fois

imgA = img[:,:,1]

imgA = imgA.reshape(imgA.shape[0],imgA.shape[1])

img2 = ndimage.convolve(imgA, contour, mode='constant', cval=0.0)

Il existe plusieurs méthode de k-means pour catégoriser automatiquement les points et les segmenter mais problème ! C'est en général tellement lourd que ça plante.

On pourrait très bien faire un k-means classique sur le tableau de composantes rgb de l'exemple ci-dessus (partie 2) mais la fonction de k-means a toutes les chances de planter à cause de la taille de la dataframe.

L'idéal est d'utiliser opencv, ce module permet d'implémenter de nombreuses fonctions très rapide de traitement d'images.

1) Défaire l'image pour la transformer dans une array

Z = img_red.reshape((-1,3))

Z = np.float32(Z)

2) Réaliser le K-means sur l'image déroulée

from sklearn.cluster import KMeans

nombre_de_categories = 5

kmeans = KMeans(n_clusters=nombre_de_categories).fit(Z)

groupes = kmeans.predict(Z)

img_groupes = groupes.reshape(img_red.shape[0],img_red.shape[1])

3) Récupérer les valeurs moyennes de couleurs de chaque catégorie

centers = kmeans.cluster_centers_

centers = centers.astype(np.uint8)

• 4) Attribuer à chaque pixel la valeur moyenne de couleur de sa catégorie (segmentation)

Zimg = Z.copy()

for i in range(0,centers.shape[0]) :

Zimg[np.where(groupes==i),:] = centers[i,:]

# recompiler une image segmentée

img_K = Zimg.reshape(img_red.shape[0],img_red.shape[1],img_red.shape[2])

img_K = img_K.astype(np.uint8)

• 1) Créons un tableau qui contient 3 colonnes, 2 qui détaillent les position des pixels (ligne et colonne) et la troisième le type (1- herbier ou 0- pas herbier)

# Créons une array contenant une colonne row, une colonne col, une colonne catégorie (herbier)

myrows = herbiers.copy()

myrows = myrows.reshape(herbiers2.shape[0],herbiers2.shape[1])

for i in range(0,myrows.shape[0]) :

myrows[i,:] = i

mycols = herbiers.copy()

mycols = mycols.reshape(herbiers2.shape[0],herbiers2.shape[1])

for i in range(0,mycols.shape[1]) :

mycols[:,i] = i

myrows = myrows.reshape((-1))

mycols = mycols.reshape((-1))

print(myrows.shape)

print(mycols.shape)

print(herbiers.shape)

• 2) Appliquons la méthode SVM pour entourer les zones à herbiers (paramétrage gamma et C à ajuster à son image)

# Regroupement SVM

from sklearn import svm

clf = svm.SVC(kernel='rbf', C=0.1, gamma=0.1)

# gamma : épaisseur du feutre, grossier ou petits traits

# C : inverse du coût => coefficient de lissage

clf.fit(DOC[:,0:2],DOC[:,2])

prediction = clf.predict(DOC[:,0:2])

prediction_img = prediction.reshape(img_red.shape[0],img_red.shape[1])

prediction_img = prediction_img.astype(np.uint8)

prediction_img.shape