Les niveaux de gris avec Python

Conversions en niveaux de gris avec Python

En page de niveaux de gris, nous vous montrons sept images associées à une seule photo en couleurs. Ici, nous vous proposons trois programmes en langage Python que vous pourrez facilement adapter afin d’obtenir les nuances de gris qui vous conviennent à partir d’une même image en couleurs (sans compter que vous pouvez aussi agir sur les couleurs avant de passer au gris).

L'image à travailler est la suivante :

pirate couleurs

Pour cela, vous devez bien entendu avoir accès à un éditeur Python mais aussi disposer de Pillow.

 

Pillow

Pillow est une bibliothèque de traitement d’image pour Python. Elle remplace PIL depuis 2010. Pour réécrire les algorithmes ci-dessous, vous devez donc la télécharger. Pillow est gratuit.

https://pillow.readthedocs.io/en/stable/

Bien sûr, nous ne détaillerons pas toutes ses fonctions. Ce n’est pas l’objet de cette page. Mais examinons tout de même quelques attributs.

Le mode de l’image définit sa profondeur et son code couleur. Quelques exemples :

  • 1 : codage sur un bit (noir et blanc, sans nuance de gris)
  • L : codage sur 8 bits (nuances de gris). C’est ce code que l’on trouvera dans les programmes ci-dessous. Voir aussi l'utilisation de P (8 bits aussi mais 256 couleurs) en page de seuillage pour réaliser une image en rouge et blanc.
  • RGB : codage sur 24 bits (couleurs). À utiliser pour modifier les couleurs d’une photo, par exemple (voir le système RVB).
  • RBGA : codage sur 32 bits (couleurs et transparence). Rappelons que le format PNG gère la transparence, contrairement au JPG.

La taille (size) : l’image sera balayée horizontalement et verticalement (une ligne de pixels, puis la suivante…). On peut définir la taille de l’image par le nombre de pixels en colonnes puis en lignes ou, comme ci-dessous, par des variables.

Vous verrez comment ouvrir une image puis en créer une nouvelle de mêmes dimensions, comment la modifier pixel par pixel, puis comment sauvegarder et afficher votre création.

 

Programme 1

Dans ce premier programme, l’intensité du gris est tout simplement celle du vert.

from PIL import Image

# L'image "pirate" se trouve dans le même dossier que le programme

img1 = Image.open("pirate.jpg")

# On relève les dimensions de l'image. Il est inutile de les connaître

largeur,hauteur = img1.size

# On crée une seconde image de mêmes dimensions que la première, codée sur 8 bits

img2 = Image.new('L',(largeur,hauteur))

# L'image est balayée en hauteur et en largeur, de pixel en pixel

for y in range(hauteur):

    for x in range(largeur):

# Pour chaque pixel on récupère le triplet rouge, vert, bleu

        r,v,b = img1.getpixel((x,y))

# La variable pixel2 reprend la luminosité du vert de chaque pixel

        pixel2 = v

# Une seconde image est créée, chacun de ses pixels ayant l'intensité de vert de l'image d'origine

        img2.putpixel((x, y), pixel2)

# L'image est sauvegardée et elle apparaît à l'écran avec le logiciel que vous avez défini par défaut pour ouvrir les fichiers JPG

img2.save("pirate_2.jpg")
img2.show("pirate_2.jpg")

 

Programme 2

Ce programme ressemble au précédent mais la luminosité est celle de la moyenne non pondérée des canaux rouge, vert et bleu.

from PIL import Image
img1=Image.open("pirate.jpg")
largeur,hauteur = img1.size
img3 = Image.new('L',(largeur,hauteur))
for y in range(hauteur):
    for x in range(largeur):
        r,v,b = img1.getpixel((x,y))

# La variable pixel3 reprend la luminosité de la moyenne entre le rouge, le vert et le bleu de chaque pixel

        pixel3 = int((r + v + b)/3)
        Img3.putpixel((x, y), pixel3)
Img3.save("pirate_3.jpg")
Img3.show("pirate_3.jpg")

 

Programme 3

Selon l’UIT (Union Internationale des Télécommunications), la pondération des trois canaux doit être la suivante :

\(0,2126\,R + 0,7152\,V + 0,0722\,B\)

Le vert reste dominant, le rouge compte pour \(21\%\) tandis que le rôle du bleu est anecdotique.

Il ne vous sera pas difficile de réécrire le programme avec cette pondération.

 

pirate gris