Retoucher la photo

Léa passe aux choses sérieuses : comme dans un vrai logiciel de retouche, elle veut transformer sa photo en noir et blanc, puis en régler la luminosité. Chaque retouche suit le même principe que les canaux de la page précédente : on parcourt les pixels, on calcule un nouveau triplet à partir de (r, g, b), et on l'écrit dans une image de sortie. Les exercices utilisent de nouveau la photo réduite papillon-petit.jpg.

Passer en niveaux de gris

Un pixel est gris lorsque ses trois composantes sont égales : (0, 0, 0) est noir, (255, 255, 255) est blanc, et (128, 128, 128) un gris moyen. Pour passer une photo en niveaux de gris, on remplace donc chaque pixel (r, g, b) par un pixel (m, m, m), où m mesure la luminosité du pixel d'origine.

La moyenne des composantes

L'idée la plus simple consiste à prendre pour m la moyenne des trois composantes, en valeur entière : m = (r + g + b) // 3.

À faire vous-même

Exercice 11.1. Complétez le programme pour obtenir la photo en niveaux de gris par la moyenne des composantes.

Correction
from PIL import Image

image = Image.open("papillon-petit.jpg")
sortie = Image.new("RGB", (image.width, image.height))

for x in range(image.width):
    for y in range(image.height):
        r, g, b = image.getpixel((x, y))
        m = (r + g + b) // 3
        sortie.putpixel((x, y), (m, m, m))

sortie.show()
Le papillon en niveaux de gris
Niveaux de gris par la moyenne

Tenir compte de l'œil humain

Le résultat est correct, mais un peu terne. En effet, notre œil ne perçoit pas les trois couleurs de la même façon : il est beaucoup plus sensible au vert qu'au rouge, et beaucoup moins au bleu. On obtient un gris plus fidèle en donnant un poids différent à chaque composante : 30 % de rouge, 60 % de vert et seulement 10 % de bleu.

\( m = 0{,}3 \times r + 0{,}6 \times g + 0{,}1 \times b \)

Ce calcul donne un nombre décimal : il faut le convertir en entier avec int avant de l'écrire dans un pixel.

À faire vous-même

Exercice 11.2. Reprenez le programme précédent avec ce mélange pondéré, et comparez les deux images obtenues.

Correction
from PIL import Image

image = Image.open("papillon-petit.jpg")
sortie = Image.new("RGB", (image.width, image.height))

for x in range(image.width):
    for y in range(image.height):
        r, g, b = image.getpixel((x, y))
        m = int(0.3 * r + 0.6 * g + 0.1 * b)
        sortie.putpixel((x, y), (m, m, m))

sortie.show()
Le papillon en niveaux de gris pondérés
Niveaux de gris pondérés

Modifier la luminosité

Multiplier les composantes

Pour éclaircir une photo, on peut multiplier chaque composante par un même nombre m : si m est plus grand que 1, l'image s'éclaircit ; s'il est plus petit que 1, elle s'assombrit. Deux précautions : une composante ne doit pas dépasser 255, d'où l'emploi de min, et elle doit rester entière, d'où l'emploi de int.

Comme à la page 6, Léa écrit d'abord une fonction qui reçoit un pixel et renvoie un nouveau pixel ; il suffit ensuite de l'appliquer à chaque pixel de l'image.

À faire vous-même

Exercice 11.3. Écrivez la fonction luminosite(pixel, m), puis utilisez-la pour éclaircir la photo avec m = 1.4. Essayez ensuite m = 0.7.

Correction
from PIL import Image


def luminosite(pixel, m):
    r, g, b = pixel
    return int(min(r * m, 255)), int(min(g * m, 255)), int(min(b * m, 255))


print(luminosite((100, 200, 50), 1.4))   # (140, 255, 70)

image = Image.open("papillon-petit.jpg")
sortie = Image.new("RGB", (image.width, image.height))

for x in range(image.width):
    for y in range(image.height):
        pixel = image.getpixel((x, y))
        sortie.putpixel((x, y), luminosite(pixel, 1.4))

sortie.show()

Avec m = 1.4, les zones déjà claires atteignent toutes 255 : elles deviennent uniformément blanches, on dit qu'elles sont saturées. Avec m = 0.7, ce sont les zones sombres qui se « bouchent » et deviennent presque noires.

Le papillon éclairci
Luminosité multipliée par 1,4

La correction gamma

Pour éviter de saturer ou de boucher l'image, les logiciels de retouche utilisent plutôt une correction gamma. Elle s'appuie sur une propriété des puissances : pour tout exposant \( p \) positif, on a \( 0^p = 0 \) et \( 1^p = 1 \). Le noir et le blanc ne bougent donc pas ; seules les valeurs intermédiaires sont modifiées. Pour chaque composante :

  1. on la ramène entre 0 et 1 en la divisant par 255 ;
  2. on l'élève à une puissance \( p \) : si \( p \) est plus petit que 1, l'image s'éclaircit ; s'il est plus grand que 1, elle s'assombrit ;
  3. on multiplie le résultat par 255 pour revenir entre 0 et 255.

\( \displaystyle r' = 255 \times \left( \frac{r}{255} \right)^p \)

En Python, la puissance s'écrit ** : int((r / 255) ** p * 255).

À faire vous-même

Exercice 11.4. Écrivez la fonction gamma(pixel, p), puis appliquez-la à la photo avec p = 0.6, puis p = 1.5. Comparez avec la méthode précédente.

Correction
from PIL import Image


def gamma(pixel, p):
    r, g, b = pixel
    return int((r / 255) ** p * 255), int((g / 255) ** p * 255), int((b / 255) ** p * 255)


print(gamma((0, 128, 255), 0.6))   # (0, 168, 255)

image = Image.open("papillon-petit.jpg")
sortie = Image.new("RGB", (image.width, image.height))

for x in range(image.width):
    for y in range(image.height):
        pixel = image.getpixel((x, y))
        sortie.putpixel((x, y), gamma(pixel, 0.6))

sortie.show()

Le test le montre : le noir (0) et le blanc (255) sont conservés, tandis que la valeur intermédiaire 128 passe à 168. L'image est éclaircie sans que les zones claires ne saturent.

Le papillon après correction gamma
Correction gamma avec p = 0,6
À retenir
  • Un pixel est gris lorsque ses trois composantes sont égales.
  • Une retouche se programme en calculant, pour chaque pixel (r, g, b), un nouveau triplet écrit dans une image de sortie.
  • Une fonction qui reçoit un pixel et renvoie un nouveau pixel rend le programme plus lisible : la double boucle se contente de l'appliquer.
  • Les composantes doivent rester des entiers entre 0 et 255 : on utilise int et min.

Léa a terminé son petit logiciel de retouche, entièrement construit sur des tuples : dimensions, coordonnées et couleurs. Bravo, vous savez maintenant manipuler ces « paquets » de valeurs, que vous retrouverez partout en Python !