Utilisation de Python - Traitement d'images

Python est un langage de haut niveau doté qui peut être augmenté de nombreuses fonctions de calcul scientifique et de traitement d’images. Dans ces TP, vous utiliserez des notebooks qui permettent de faire de la « programmation lettrée », mélangeant ainsi du code (Python) et des éléments de texte.

Pour commencer, allumez votre ordinateur et ouvrez Jupyter Lab ou VSCodium.

Jupyter Lab s’exécute dans un navigateur web.

Ouvrez un terminal en tapant terminal dans le menu principal ou en utilisant le raccourci clavier Ctrl + Alt + T.
Sur les ordinateurs de TPS, vous devez activer l’environnement Python dédié aux TP en tapant dans le terminal :
```
mm-activate python_base
```
Lancez Jupyter Lab en tapant :
```
jupyter lab
```
ou
```
jupyter-lab
```

Écrire un notebook¶

Un notebook est un fichier contenant du code, mais aussi des commentaires pour expliquer ce code ou les résultats qu’il a produit. Un notebook est divisé en cellules, qui sont de deux types :

les cellules de type « Code » ne contiennent que du code (Python par exemple) ;
les cellules de type « Markdown » contiennent du texte mis en forme. En appuyant sur Ctrl+Entrée sur une cellule, le code de cette cellule (et uniquement celle-ci !) est exécuté.

Cellules « Code »¶

Par défaut, les cellules sont sensées contenir du code. Elles sont divisées en une entrée (les instructions Python) et une sortie (le résultat).

Par exemple, l’entrée suivante :

a = 21
b = 42
c = a + b
print("La valeur est " + str(c))

La valeur est 63

Renvoie cette sortie :

La valeur est 63

Cellules « Markdown »¶

Vous pouvez changer le type d’une cellule en choisissant Markdown dans la liste déroulante de la barre d’outils (Jupyter Lab) ou en cliquant sur Python dans l’angle en bas à droite de la cellule (VSCodium). Markdown est un langage très simple pour formater du texte (par exemple, écrire des titres, des listes ou des équations).

Par exemple :

La _convolution_ entre **deux** images $f$ et $g$ est définie comme suit :

$$
(f*g)(m,n) = \sum_u \sum_v f(u,v) g(u-m,v-n)
$$

donne :

La convolution entre deux images $f$ et $g$ est définie comme suit :

(f*g)(m,n) = \sum_u \sum_v f(u,v) g(u-m,v-n)

Veuillez consulter cette aide pour apprendre la syntaxe Markdown.

Écrire du code¶

Pour faire du calcul scientifique avec Python, il faut importer des modules. En général, nous utiliserons les trois modules suivants :

numpy, qui fournit des fonctions pour le calcul scientifique général ;
scikit-image qui est un ensemble d’algorithmes pour le traitement d’images ;
matplotlib, qui permet d’afficher des images.

Les modules Python sont importés dans votre code à l’aide de l’instruction import.

Par exemple, le code suivant ouvre une image, la convertit en niveaux de gris et affiche les deux versions :

# Ceci est un commentaire et n'est donc pas exécuté
# Les commentaires commencent avec un #

# Importe le sous-module 'io' du module 'skimage' (scikit-image),
# et le renomme 'io' (pour éviter de taper 'skimage.io'
# à chaque fois qu'on en a besoin)
import skimage.io as io

# Importe le sous-module 'color' du module 'skimage' et le renomme 'clr'
import skimage.color as clr

# Importe le sous-module 'pyplot' du module 'matplotlib' et le renomme 'plt'
import matplotlib.pyplot as plt

# La fonction 'imread' qui est dans 'skimage.io' charge une image
# à partir de son nom de fichier
f = io.imread("data/peppers.png")

# Convertit l'image couleur f en image à niveau de gris g
g = clr.rgb2gray(f)

# Crée une figure et la divise en 1 ligne et 2 colonnes :
# chaque division ainsi constituée est un axe où seront affichées les images
fig, axs = plt.subplots(1,2)

# Affiche l'image couleur f avec la fonction 'imshow' (de 'matplotlib.pyplot')
# dans le premier axe (indice 0)
axs[0].imshow(f)

# Affiche l'image à niveaux de gris g dans le deuxième axe (indice 1)
axs[1].imshow(g, cmap="gray")

# Affiche l'image g
plt.show()

Pour les utilisateurs de Matlab¶

Python, grâce au module Numpy, est très similaire à Matlab. Ces deux langages fonctionnent avec des scripts et leurs fonctions sont très similaires. Il existe cependant des différences majeures, listées ci-après.

Modules¶

Python est conçu pour être un langage de programmation généraliste. Contrairement à Matlab, il ne contient que très peu de fonctions scientifiques de base. Il faut donc le compléter avec des modules comme Matplotlib ou Numpy. Par exemple, Numpy est chargé avec :

import numpy as np

Les fonctions dans Numpy sont ensuite accessibles avec np.nom_de_la_fonction.

Vecteurs et matrices¶

Alors que Matlab utilise des parenthèses pour les vecteurs et les matrices, Python utilise des crochets. De plus, le premier élément dans Matlab est à l’indice 1, tandis qu’en Python, il est à l’indice 0.

Matlab	Python
`a(1)`	`a[0]`
`B(3,5)`	`B[2,4]`

Point-virgule¶

En Python, il n’y a pas de point-virgule (;) à la fin des instructions.

Pour aller plus loin…¶

Pour aller plus loin, vous pouvez consulter cet aide-mémoire ou cet article sur Numpy.