L'objectif de cette activité est d'illustrer le rôle du calcul matriciel (applications linéaires, transformations) en traitement numérique des images. Chaque exercice consiste à créer un filtre modifiant le contenu d'un fichier image.

Elle comporte trois parties, et se termine par une section facultative présentant des ouvertures possibles :

1. Introduction : les images numériques en python
2. Manipulation des couleurs
3. Transformations géométriques
4. Pour aller plus loin (bonus)

Les images qui seront utilisées dans les trois premières parties sont les suivantes :

• Solo version LEGO (256px)
• Logo STAR WARS (256px)

Vous devez les télécharger (localement) puis les « téléverser » dans un répertoire images que vous aurez créé.

Pour pouvez aussi effectuer cette opération grâce aux instructions suivantes, depuis votre notebook jupyter :

import urllib.request,os
# Creation eventuelle du répertoire
try:
   os.mkdir('images')
except:
    print('Le répertoire existe déjà')
# Téléchargement des images
urllib.request.urlretrieve("https://iut-info.univ-reims.fr/users/coutant/img/solo-256px.png", "images/solo-256px.png")
urllib.request.urlretrieve("https://iut-info.univ-reims.fr/users/coutant/img/logo-starwars-256px.png", "images/logo-starwars-256px.png")

Le répertoire images devrait maintenant contenir les deux images suivantes :

Attention

Si vous travaillez avec votre distribution de python, il vaut mieux utiliser le module requests :

import requests,os

def download(url, destination):
  response = requests.get(url, verify=True)
  open(destination, 'wb').write(response.content)

# Creation eventuelle du répertoire
try:
   os.mkdir('images')
except:
    print('Le répertoire existe déjà')

# Téléchargement des images
download('https://iut-info.univ-reims.fr/users/coutant/img/solo-256px.png', 'images/solo-256px.png')
download('https://iut-info.univ-reims.fr/users/coutant/img/logo-starwars-256px.png', 'images/logo-starwars-256px.png')

Il est aussi nécessaire de charger les modules suivants :

# Modules
from math import *
import random
import numpy as np
import matplotlib.pyplot as plt

Il existe de nombreux formats d'images numériques. On distingue deux catégories :

• les images matricielles (formats jpeg, png, bmp, ou encore tiff)
• des images vectorielles (formats svg, emf par exemple)

Celles qui nous intéressent ici sont les images matricielles (ou images bitmap).

Les images matricielles sont des tableaux de points, appelés pixels. Chaque pixel est caractérisé par :

• sa position dans l'image (ligne puis colonne, par convention)
• et un vecteur contenant autant de valeurs que l'image possède de canaux (qu'on appelle aussi composantes)

Dans une image en niveaux de gris, le vecteur qui représente le pixel n'a qu'une composante.

Dans le cas d'une image en couleurs, il y a au moins trois canaux. Généralement, il s'agit des canaux associés au Rouge, au Vert et au Bleu. En utilisant le principe de synthèse additive la superposition de ces canaux lumineux permet d'obtenir les autres couleurs (nous en reparlerons dan la partie suivante). On peut représenter le tableau de pixels comme un tableau à trois dimensions (dont la profondeur représente le nombre de canaux spectraux). Dans ce cas, un pixel p est un vecteur à trois composantes p=(r_p,g_p, b_p) où :

• r_p quantifie l'intensité de la lumière rouge du pixel p,
• g_p quantifie l'intensité de la lumière verte du pixel p,
• et b_p quantifie l'intensité de la lumière bleue du pixel p.

Ainsi par exemple :

• dans une image en niveaux de gris, encodés à l'aide de valeurs réelles comprises dans [0;1],
  • un pixel noir est représenté par la valeur réelle 0.0
  • un pixel blanc par la valeur réelle 1.0
  • un pixel gris clair par la valeur 0.75 (par exemple)
  • et un pixel gris foncé par 0.25 (par exemple)
• dans une image en couleurs, encodées en RGB à l'aide de triplets de valeurs réelles (de [0;1]\times [0;1] \times [0;1]),
  • un pixel noir est représenté par le triplet (0.0, 0.0, 0.0),
  • un pixel blanc par le triplet (1.0, 1.0, 1.0)
  • un pixel rouge (primaire) par (1.0, 0.0, 0.0)
  • un pixel orange par (1.0, 0.52, 0.0), par exemple (ce qui signifie que l'intensité de la lumière rouge est de 100%, celle du vert de 52% et celle du bleu de 0%)

Ainsi ces pixels sont de couleurs respectives :

La structure de données pythontypiquement utilisée pour représenter ces tableaux est l'array de numpy. Les valeurs sont généralement de type float64.

• Une image est donc un array (2D) de pixels.
• Un pixel en niveaux de gris est un float.
• Un pixel en couleurs est un array de float (un floatpar composante chromatique).

Affichage facile

Pour afficher les images, nous vous proposons d'utiliser la fonction display(img_list, size, shape) ci-dessous, qui affiche une série d'images stockées dans une liste img_list. La taille de l'affichage d'une image est fixée à size pouces. Le booléen shape permet d'afficher ou non les dimensions du tableau au dessus de l'image.

def display(imglist,size=5, shape=True):
    cols = len(imglist)
    fig = plt.figure(figsize=(size*cols,size*cols))
    for i in range(0,cols):
        a = fig.add_subplot(1, cols, i+1)
        if len(imglist[i].shape) > 2 :
            subfig = plt.imshow(imglist[i], vmin=0.0, vmax=1.0)
        else :
            subfig = plt.imshow(imglist[i],cmap="gray",vmin=0.0, vmax=1.0)
        subfig.axes.get_xaxis().set_visible(False)
        subfig.axes.get_yaxis().set_visible(False)
        if shape == True:
            a.set_title(str(imglist[i].shape))
    plt.show()

Nous allons maintenant créer une image de 4 pixels (2 \times 2) avec les niveaux de gris suivants :

• pixel en haut à gauche : 0.98
• pixel en haut à droite : 0.43
• pixel en bas à gauche : 0.11
• pixel en bas à droite : 0.79

img = np.array([[0.98, 0.43],
                [0.11, 0.79]])

display([img])

puis une image de 4 pixels (2 \times 2) avec les couleurs suivantes :

• pixel en haut à gauche : (0.98, 0.06, 0.18)
• pixel en haut à droite : (0.78, 0.29, 0.91)
• pixel en bas à gauche : (0.49, 0.51, 0.37)
• pixel en bas à droite : (0.53, 0.81, 0.55)

img = np.array([[[0.98, 0.06, 0.18], [0.78, 0.29, 0.91]],
                [[0.49, 0.51, 0.37], [0.53, 0.81, 0.55]]])

display([img])

Pour accéder, en lecture, comme en écriture, à un pixel, il suffit d'utiliser les [ ].

Exemple

img[0,1]

array([0.78, 0.29, 0.91])

# Accès en modification
img[0,1] = [0.0,1.0,0.0]

# Visualisation de l'image modifiée
display([img])

Le module matplotlib dispose de deux fonctions imread et imsave (dans le sous-module pyplot) qui permettent respectivement :

• de lire un fichier image et de retourner le tableau correspondant,
• d'écrire un fichier image en utilisant les valeurs contenues dans un tableau.

# Lecture de l'image téléchargée au début du TP
img = plt.imread("images/solo-256px.png")

#  Sauvegarde de l'image img dans un fichier
plt.imsave("images/solo-256px-copie.png", img)

Il existe aussi une fonction imshow, qui permet d'afficher une image contenue dans un tableau :

plt.imshow(img)

<matplotlib.image.AxesImage at 0x7fef4ac7d3d0>

...mais on lui préférera notre fonction display qui en simplifie l'usage.

Pour accéder au pixel situé à la i-ème ligne et à la j-ème colonne de l'image on utilise donc simplement img[i,j]. Par exemple, le pixel situé sur la ligne 78 et la colonne 95 de l'image précédente correspond au vecteur :

p = img[78,95]
print(p)

[0.7411765 0.6627451 0.5803922]

Les composantes R, G et B de ce pixel p sont :

print("Rouge : ", p[0])
print("Vert : ", p[1])
print("Bleu : ", p[2])

Rouge :  0.7411765
Vert :  0.6627451
Bleu :  0.5803922

Remarque

On peut naturellement accéder directement à une composante d'un pixel en spécifiant son indice :

img[78, 95 ,0]

0.7411765

Vérification avec Gimp

Vous pouvez vérifier -ici avec Gimp, mais tout autre logiciel d'imagerie fera l'affaire- que ces valeurs numériques sont cohérentes.

Attention : dans Gimp, les pixels sont repérés de la façon suivante

(colonne,ligne) contrairement à notre représentation.

Exemple

display([img,inverse(img)],5)

Exemple :

display([keep_red(img),keep_green(img),keep_blue(img)],5)

Écrire une fonction extract(img, l1, c1, l2, c2) qui retourne une nouvelle image avec les pixels de img situés entre les lignes l1 et l2 et les colonnes c1 et c2.

Exemple :

img2 = extract(img, 23, 57, 95, 111)
display([img2],5)

Indication : la fonction random.random() du module random (ne pas oublier de l'importer avec import random) permettent de générer aléatoirement uniformément un réel compris entre 0 et 1.

Exemples :

display([randimg_gsc(256,256), randimg_rgb(256,256)],5)

display([im1, im2, im3, im4, im5],4)

Les exercices qui suivent sont facultatifs. Ne les faites qui si vous avez une avance suffisante. La suite est encore longue !

Construire les tableaux permettant de reproduire à peu près les images suivantes :

display([im5,im6],5)

Remarque : sur l'image de gauche, le motif artefactuel est dû à un phénomène appelé moiré

def count_histo_gsc(img):
    [height, width] = np.shape(img)
    lcount = [0] * 256
    for i in range(height):
        for j in range(width):
            int_gsv = int(round(img[i,j] * 255))
            lcount[int_gsv] += 1
    return lcount

Ensuite, la fonction draw_histo construit une image de l'histogramme des fréquences. Grosso modo, on dessine une ligne verticale proportionnelle au nombre de fois où le niveau de gris correspondant apparaît dans l'image.

def draw_histo(img):
    [height, width] = np.shape(img)
    counth = count_histo_gsc(img)
    # Attention cascade ; on transforme les comptages 
    # en hauteurs de barres en pixels (le max est à 255) :
    ch = [int(i * 255 / max(counth)) for i in counth]
    img_histo = np.zeros((256,256),dtype='float32')
    for g in range(256):
        if ch[g] > 0:
            for k in range(255-ch[g],256):
                img_histo[k,g] = 1.0
    return img_histo

Exemple d'utilisation :

img = plt.imread("https://upload.wikimedia.org/wikipedia/commons/f/fa/Grayscale_8bits_palette_sample_image.png")
display([draw_histo(img), img], 5)

Écrire la fonction draw_histo_rgb(img) qui retourne une liste des trois images des histogrammes des composantes chromatiques : rouge, vert, bleu.

img = plt.imread("./images/solo-256px.png")

display(draw_histo(img),5)

Voilà. Cette introduction à l'image en python est terminée. Mais... quel rapport avec l'algèbre linéaire ? On y vient. Dans la partie suivante, on utilise les outils de l'algèbre linéaire pour transformer les couleurs d'une image.