Manipuler des images

Dans cette feuille, vous allez apprendre à effectuer quelques manipulations et traitements simples sur les images. Nous allons commencer par nous entrainer sur une image riche en couleurs (source: wikimedia).

../../_images/apple4.png

Pour cela, nous la chargeons avec la bibliothèque PIL (Python Imaging Library) en précisant le nom du fichier la contenant, puis l’affectons à une variable img pour pouvoir la manipuler par la suite:

from PIL import Image
img = Image.open("media/apple.png")

Voici cette image:

img

Pour l’afficher avec des axes et – lorsque l’image a une basse résolution – mieux repérer les pixels individuels, on peut utiliser matplotlib:

import matplotlib.pyplot as plt
plt.imshow(img);

Pourquoi un ; à la fin de la commande précédente? Parce que plt.imshow ne renvoie pas une image, mais l’affiche par effet de bord. Le ; évite l’affichage de ce que renvoie vraiment plt.imshow (un objet de type figure).

Cette approche quelque peu datée est traditionnelle dans des systèmes comme Matlab. La bibliothèque matplotlib.pyplot l’a reproduit pour faciliter la migration d’utilisateurs de ces systèmes. Par habitude beaucoup d’exemples sur internet utilisent encore cette approche; cela peut rester pratique comme raccourci dans des exemples en une ligne comme ci-dessus.

Mais on sait depuis – et c’est ce que nous vous enseignons depuis le début de l’année – que l’on obtient du code beaucoup plus modulaire si l’on sépare proprement les traitements et calculs (par exemple construire une figure) des entrées et sorties (par exemple afficher la figure).

De ce fait, pour tout usage non trivial, il est préférable d’utiliser l’interface objet de matplotlib, comme dans l’exemple suivant:

from matplotlib.figure import Figure
fig = Figure()              # Construction d'une nouvelle figure
subplot = fig.add_subplot() # Ajout d'une zone de dessin (appelée «axes» dans matplotlib) à la figure
subplot.imshow(img)         # Ajout d'une image à la zone de dessin
fig                         # Affichage de la figure

Consultez la documentation de PIL Image sur internet, pour trouver comment obtenir la largeur et la hauteur de cette image. Stockez le résultat dans des variables width et height et vérifiez la cohérence avec la figure ci-dessus.

### BEGIN SOLUTION
width, height = img.size
### END SOLUTION
assert width == 256
assert height == 256

Images comme tableaux

On souhaite maintenant pouvoir accéder au contenu de l’image pour pouvoir calculer avec. Pour cela, nous allons convertir l’image en un tableau de nombres NumPy, tels ceux que nous avons manipulés dans la fiche précédente.

Voici le tableau associé à l’image:

import numpy as np
M = np.array(img)

En vous référant éventuellement au cours, combien de lignes, de colonnes et de couches devrait avoir ce tableau?

BEGIN SOLUTION

Il devrait y avoir 256 lignes, 256 colonnes et quatre couches.

END SOLUTION

Vérifier avec l’attribut shape:

### BEGIN SOLUTION
M.shape
### END SOLUTION

Pourquoi quatre couches? Rouge, Vert, Bleu, … et transparence!

Comprendre les couches de couleurs

Comme toujours, pour mieux comprendre des données, il faut les visualiser ! Voici une figure représentant notre image et ses trois couches rouge, vert, bleu. Observez comment les couleurs de l’image de départ (blanc, vert, noir, rouge) se décomposent dans les différentes couches.

# Échelles de couleur (colormap) allant du noir à la couleur primaire correspondante
from matplotlib.colors import LinearSegmentedColormap
black_red_cmap   = LinearSegmentedColormap.from_list('black_red_cmap',   ["black", "red"])
black_green_cmap = LinearSegmentedColormap.from_list('black_green_cmap', ["black", "green"])
black_blue_cmap  = LinearSegmentedColormap.from_list('black_blue_cmap',  ["black", "blue"])

fig = Figure(figsize=(30, 5));
(subplot, subplotr, subplotg, subplotb) = fig.subplots(1, 4)  # Quatre zones de dessin
# Dessin de l'image et de ses trois couches
subplot.imshow(M)
imgr = subplotr.imshow(M[:,:,0], cmap=black_red_cmap,   vmin=0, vmax=255)
imgg = subplotg.imshow(M[:,:,1], cmap=black_green_cmap, vmin=0, vmax=255)
imgb = subplotb.imshow(M[:,:,2], cmap=black_blue_cmap,  vmin=0, vmax=255)
# Ajout des barres d'échelle de couleur aux images
fig.colorbar(imgr, ax=subplotr);
fig.colorbar(imgg, ax=subplotg);
fig.colorbar(imgb, ax=subplotb);
fig

Par la suite, nous visualiserons de même de nombreuses images. Il est donc temps d’automatiser la construction de la figure ci-dessus. Ouvrez le fichier utilities.py et complétez-y la fonction show_color_channels à partir du code ci-dessus.

# Automatically reload code when changes are made
%load_ext autoreload
%autoreload 2
from intro_science_donnees import show_source, load_images, image_grid
from utilities import *
show_source(show_color_channels)
show_color_channels(img)

Vérification: show_color_channels renvoie bien une figure

assert isinstance(show_color_channels(img), Figure)

Étudions maintenant les images du jeu de données de la semaine dernière:

from intro_science_donnees import data
import os.path
dataset_dir = os.path.join(data.dir, 'ApplesAndBananasSimple')
images = load_images(dataset_dir, "*.png")
image_grid(images, titles=images.index)

Observez l’image suivante et ses couches. Expliquez ce que vous voyez. Essayez d’autres exemples.

BEGIN SOLUTION

On remarque que les pixels noirs sont à zéro dans les trois couches et les pixels blancs à 255 dans les trois couches. Le jaune étant la couleur complémentaire du bleu est à 255 en rouge et en vert et 0 en bleu.

END SOLUTION

img = images[10]
show_color_channels(img)

Nous allons maintenant observer l”histogramme des couleurs apparaissant dans une image, en utilisant l’utilitaire color_histogram (vous pouvez comme d’habitude en consulter la documentation et le code par introspection avec color_histogram? et color_histogram??):

color_histogram(img)

Observez les histogrammes ci-dessous de la dixième et la troisième image, et interprétez-les.

BEGIN SOLUTION

Image 10 : on remarque que de les pixels verts et rouges se situent très majoritairement dans des valeurs supérieures à 150, tandis que de nombreux pixels bleus se situent dans des valeurs inférieures. C’est logique étant donné la couleur jaune de la pomme (jaune étant la couleur complémentaire du bleu).

Image 3 : on remarque qu’il y a davantage de pixels rouges ayant la valeur 256 ; bleus et verts ayant dans l’ensemble des valeurs plus faibles que les pixels rouges. Cohérent, puisque la pomme de l’image est rouge.

END SOLUTION

img = images[9]
show_color_channels(img)
color_histogram(img)
img = images[2]
show_color_channels(img)
color_histogram(img)

Séparation des couleurs

Nous allons maintenant extraire les trois canaux, rouge, vert, bleu. Pour le canal des rouges, on extrait le sous-tableau à deux dimensions de toutes les cases d’indice \((i,j,k)\) avec \(k=0\). Le * 1.0 sert à convertir les valeurs en nombres à virgule.

R = M[:,:,0] * 1.0

Regarder le résultat directement n’est pas très informatif :

R

Comme d’habitude, il vaut mieux le visualiser :

fig = Figure(figsize=(5,5))
ax, axr = fig.subplots(1,2)
ax.imshow(M)
axr.imshow(R, cmap='Greys_r', vmin=0, vmax=255)
fig
  1. Extrayez de même le canal des verts et des bleus de la première image dans les variables G et B. N’hésitez pas à les visualiser !

### BEGIN SOLUTION
G = M[:,:,1] * 1.0

fig = Figure(figsize=(5,5))
ax, axr = fig.subplots(1,2)
ax.imshow(M)
axr.imshow(G, cmap='Greys_r', vmin=0, vmax=255)
fig
### END SOLUTION
assert G.shape == (256, 256)
assert abs(G.mean() - 158.27) < 0.1
### BEGIN SOLUTION
B = M[:,:,2] * 1.0

fig = Figure(figsize=(5,5))
ax, axr = fig.subplots(1,2)
ax.imshow(M)
axr.imshow(B, cmap='Greys_r', vmin=0, vmax=255)
fig
### END SOLUTION
assert B.shape == (256, 256)
assert abs(B.mean() - 148.39) < 0.1

Il est maintenant facile de faire de l’arithmétique sur tous les pixels. Par exemple la somme des intensités en vert et rouge s’écrit:

G + R

Exercice

  1. Calculez et visualisez la luminosité de tous les pixels de l’image, la luminosité d’un pixel \((r,g,b)\) étant définie comme la moyenne \(v=\frac{r+g+b}{3}\):

### BEGIN SOLUTION
V = (R+G+B)/3

fig = Figure(figsize=(5,5))
ax, axr = fig.subplots(1,2)
ax.imshow(M)
axr.imshow(V, cmap='Greys_r', vmin=0, vmax=255)
fig
### END SOLUTION
assert V.shape == (256, 256)
assert abs(V.mean() - 172.44) < 0.1

Vous venez de transformer l’image en niveaux de gris! Pour que cela colle au mieux avec notre perception visuelle, il faudrait en fait utiliser une moyenne légèrement pondérée; voir par exemple la Wikipedia.

Conclusion

Vous avons vu dans cette feuille comment charger une image dans Python et effectuer quelques manipulations, visualisations et calculs simples dessus. Cela a été l’occasion de mieux comprendre la décomposition d’une image en couches de couleur.

Exercice : Mettez à jour votre rapport, et notamment la section « revue de code » pour vérifier vos utilitaires dans utilities.py.

Vous pouvez maintenant passer à l”extraction d’attributs