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()
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()
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.
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 :
- on la ramène entre 0 et 1 en la divisant par 255 ;
- 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 ;
- 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.
À 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
intetmin.
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 !
Éditeur Python