Développer la photo

Jusqu'ici, Léa a travaillé sur des pixels qu'elle écrivait elle-même. Il est temps de passer à ses vraies photos. Pour cela, elle utilise Pillow, une bibliothèque Python qui permet d'ouvrir, de modifier et d'enregistrer des images. Son module s'appelle PIL (Python Imaging Library).

Une bibliothèque construite sur les tuples

Une image manipule sans cesse des informations faites de plusieurs nombres qui vont ensemble : les deux dimensions de l'image, les deux coordonnées d'un pixel, les trois composantes de sa couleur. Ce sont exactement des valeurs composées : leur nombre d'éléments est fixe, et c'est la position de chaque élément qui lui donne son sens. Pillow les représente donc toutes par des tuples :

InformationTupleExempleSens de chaque position
Dimensions de l'imageun couple(1600, 1065) largeur, puis hauteur (en pixels)
Position d'un pixelun couple(10, 20) abscisse x, puis ordonnée y
Couleur d'un pixelun triplet(255, 128, 0) composantes rouge, verte, bleue (canaux de couleur)

Toutes les fonctions de Pillow que nous allons utiliser reçoivent ou renvoient ces tuples :

  • image.size est le couple des dimensions ;
  • image.resize((largeur, hauteur)) et Image.new("RGB", (largeur, hauteur)) reçoivent un couple de dimensions ;
  • image.getpixel((x, y)) reçoit un couple de coordonnées et renvoie un triplet de couleur ;
  • image.putpixel((x, y), (r, g, b)) reçoit un couple de coordonnées et un triplet de couleur.

Tout ce que nous avons appris sur les tuples va donc servir : les créer, lire leurs éléments par indice, les déballer avec r, g, b = …, et calculer de nouveaux tuples. Attention aux doubles parenthèses que l'on rencontrera souvent : dans image.getpixel((x, y)), les parenthèses extérieures sont celles de l'appel de la fonction, les parenthèses intérieures construisent le couple (x, y), qui est l'unique argument.

Le fichier de la photo

Lorsque vous ouvrez l'éditeur Python d'un exercice de cette page, la photo papillon.jpg est automatiquement copiée à côté de votre programme : on peut l'ouvrir simplement par son nom. Les images affichées par le programme apparaissent dans l'onglet Graphisme de l'éditeur.

Ouvrir et afficher une image

On importe d'abord Image depuis le module PIL. La fonction Image.open ouvre un fichier image, et la méthode show affiche l'image obtenue :

from PIL import Image

image = Image.open("papillon.jpg")
image.show()
Le papillon de Léa
La photo papillon.jpg

Les dimensions : un couple

Les dimensions d'une image sont rangées dans image.size. C'est un couple (largeur, hauteur), exprimé en pixels : on peut donc le « déballer » en deux variables. Les attributs image.width et image.height donnent aussi directement la largeur et la hauteur.

largeur, hauteur = image.size
print("Cette image mesure", largeur, "x", hauteur, "pixels")

Affichage :

Cette image mesure 1600 x 1065 pixels

Redimensionner une image

La méthode resize reçoit les nouvelles dimensions sous la forme d'un couple (largeur, hauteur). Elle ne modifie pas l'image : elle renvoie une nouvelle image, aux dimensions demandées. Pour conserver le résultat, il faut donc l'associer à un nom, par exemple en réaffectant le nom image.

À faire vous-même

Exercice 9.1. Remplacez image par une image deux fois moins large et deux fois moins haute, puis vérifiez ses nouvelles dimensions. Attention : les dimensions doivent être des nombres entiers.

Correction
from PIL import Image

image = Image.open("papillon.jpg")
print(image.size)      # (1600, 1065)

image = image.resize((image.width // 2, image.height // 2))

print(image.size)      # (800, 532)
image.show()

On utilise la division entière //, car une dimension est un nombre entier de pixels. Les doubles parenthèses sont indispensables : resize reçoit un seul argument, le couple des nouvelles dimensions.

Lire un pixel

Chaque pixel est repéré par ses coordonnées (x, y), encore un couple. Attention, l'origine (0, 0) est le coin en haut à gauche de l'image : x augmente vers la droite, et y augmente vers le bas.

La méthode getpixel reçoit le couple des coordonnées et renvoie la couleur du pixel sous la forme d'un triplet (r, g, b) :

pixel = image.getpixel((0, 0))
print(pixel)

Affichage :

(23, 41, 0)

Le pixel du coin en haut à gauche est vert sombre : peu de rouge, un peu de vert, pas de bleu.

À faire vous-même

Exercice 9.2. Dans l'image papillon.jpg d'origine :

  1. affichez séparément les composantes rouge, verte et bleue du pixel de coordonnées (400, 250) ;
  2. affichez le pixel situé tout en bas à droite de l'image. Quelles sont ses coordonnées ?
Correction
from PIL import Image

image = Image.open("papillon.jpg")

r, g, b = image.getpixel((400, 250))
print("rouge :", r, "vert :", g, "bleu :", b)    # rouge : 63 vert : 80 bleu : 25

largeur, hauteur = image.size
print(image.getpixel((largeur - 1, hauteur - 1)))  # (43, 64, 5)

Les abscisses vont de 0 à largeur - 1 et les ordonnées de 0 à hauteur - 1 : le pixel en bas à droite a donc pour coordonnées (1599, 1064).

Créer une image et écrire des pixels

Créer une image

Image.new("RGB", (largeur, hauteur)) crée une nouvelle image, aux dimensions données par le couple (largeur, hauteur). Le texte "RGB" indique que chaque pixel aura trois composantes rouge, verte et bleue. Tous les pixels de cette nouvelle image sont noirs, c'est-à-dire (0, 0, 0).

sortie = Image.new("RGB", (200, 100))
print(sortie.size)
print(sortie.getpixel((10, 20)))

Affichage :

(200, 100)
(0, 0, 0)

Écrire un pixel : putpixel

La méthode putpixel change la couleur d'un pixel d'une image. Elle s'utilise ainsi :

image.putpixel((x, y), (r, g, b))

Elle reçoit deux arguments, qui sont tous les deux des tuples :

  • le couple des coordonnées (x, y) du pixel à modifier ;
  • le triplet de la nouvelle couleur (r, g, b), dont les trois composantes sont des entiers entre 0 et 255.

putpixel ne renvoie rien : elle modifie l'image elle-même. Contrairement à un tuple, une image Pillow est donc modifiable. On le vérifie en relisant le pixel avec getpixel :

sortie = Image.new("RGB", (200, 100))
print(sortie.getpixel((10, 20)))
sortie.putpixel((10, 20), (255, 0, 0))
print(sortie.getpixel((10, 20)))

Affichage :

(0, 0, 0)
(255, 0, 0)

Le pixel de coordonnées (10, 20), noir au départ, est devenu rouge. Pour colorier plusieurs pixels, on appelle putpixel dans une boucle. Ce programme trace par exemple une ligne horizontale rouge au milieu d'une image noire : seule l'abscisse x change, l'ordonnée reste 50.

sortie = Image.new("RGB", (200, 100))
for x in range(200):
    sortie.putpixel((x, 50), (255, 0, 0))
sortie.show()
Attention !

Les coordonnées doivent désigner un pixel de l'image (x entre 0 et largeur - 1, y entre 0 et hauteur - 1), sinon Python signale une erreur IndexError. Et les composantes de la couleur doivent être des entiers : (127.5, 0, 0) provoque une erreur.

Remarque

Cette façon de modifier une image pixel par pixel est lente, mais elle est facile à comprendre : c'est celle que nous utiliserons dans les pages suivantes.

À faire vous-même

Exercice 9.3. Dessinez le drapeau français dans une image de 300 × 200 pixels : trois bandes verticales de même largeur, bleue (0, 85, 164), blanche (255, 255, 255) et rouge (239, 65, 53). Il faudra parcourir tous les pixels avec deux boucles imbriquées.

Correction
from PIL import Image

bleu = (0, 85, 164)
blanc = (255, 255, 255)
rouge = (239, 65, 53)

drapeau = Image.new("RGB", (300, 200))
for x in range(300):
    for y in range(200):
        if x < 100:
            drapeau.putpixel((x, y), bleu)
        elif x < 200:
            drapeau.putpixel((x, y), blanc)
        else:
            drapeau.putpixel((x, y), rouge)

drapeau.show()

La couleur ne dépend que de l'abscisse x. Chaque couleur est un tuple, que l'on nomme une fois pour toutes et que l'on passe directement à putpixel.

À retenir
  • Pillow représente les dimensions, les coordonnées et les couleurs par des tuples : (largeur, hauteur), (x, y), (r, g, b).
  • Image.open("fichier.jpg") ouvre une image ; image.show() l'affiche.
  • image.size est le couple (largeur, hauteur) ; image.resize((l, h)) renvoie une nouvelle image.
  • Un pixel est repéré par le couple (x, y), avec l'origine en haut à gauche et y vers le bas.
  • image.getpixel((x, y)) renvoie le triplet (r, g, b) ; image.putpixel((x, y), (r, g, b)) change la couleur d'un pixel (l'image est modifiée).
  • Image.new("RGB", (largeur, hauteur)) crée une image noire.

Léa sait maintenant lire et écrire chacun des pixels de sa photo. Elle va pouvoir s'amuser avec ses couleurs : direction la page suivante, et Andy Warhol !