Utiliser des algorithmes pour modifier une Thème 4 TP2

image Image Numérique

"Le monde va mal, très mal on ne se met pas à la place des autres. Et si on inventait un dispositif qui
permettait de voir le monde à travers les yeux d'un autre comme un daltonien, un bébé, un chat…"

Pour mieux comprendre de quoi il s'agit, visionnez la vidéo :

http://www.lumni.fr/video/photographie-numerique-du-reel-aux-pixels

Vous allez petit à petit en arriver à créer un programme, en Python, qui ouvrira une image et en
modifiera les couleurs des pixels pour qu'elle corresponde à ce que voit un chat puis un daltonien.

Activité 1 : Afficher les quantités de Rouge, Vert et Bleu d'un pixel

1. A partir du code ci-dessous et des commentaires, essayez de deviner ce que va faire le programme 1.
Programme 1
from PIL import Image
mon_image = Image.open("pomme.jpg")
r,v,b=mon_image.getpixel((100,250))
print("rouge :",r,"vert :",v,"bleu :",b)
Commentaires
On importe les outils Image (avec un grand I) de la
bibliothèque PIL.
On crée une variable mon_image contenant les données
des pixels de l'image "pomme.jpg"
r, v, b, sont trois variables contenant la quantité de rouge,
de vert et de bleu du pixel de coordonnées (100,250).
On affiche à l'écran du texte et la valeur contenue dans
r, dans v et dans b.

2. Vous allez maintenant écrire ce programme dans un navigateur :

Dans Chrome, saisir l’adresse https://repl.it/
Une fois sur le site, cliquez sur puis saisir les codes d’accès ci-contre :
puis cliquez sur puis .
Suivez les étapes 1 à 5 ci-dessous pour obtenir l'affichage suivant :

1 : zone dans laquelle vous devez écrire le programme,

2 : bouton permettant de lancer l'exécution du programme,
3 : zone d'affichage des résultats, si le programme doit afficher quelque chose. C'est ici aussi que
peuvent apparaître des messages d'erreur.
Dans votre cas, un message rouge doit apparaître indiquant, à la fin :
FileNotFoundError: [Errno 2] No such file or directory: 'pomme.jpg'.
Que signifie ce message à votre avis ?

4 : zone contenant le programme (c'est le fichier main.py) et les fichiers utilisés par le programme.
Mais c'est bien sûr, il manque le fichier pomme.jpg.
5 : bouton à utiliser pour télécharger (upload file) un fichier.
Cliquer sur le bouton de la zone 5 pour télécharger le fichier pomme.jpg. Ce fichier se trouve dans le
dossier de votre classe : 2nde/document en consultation/SNT/theme4.

Reste à cliquer sur RUN, pour voir apparaître le message : " rouge : 133 vert : 168 bleu : 3 "
Ce programme affiche donc les quantités de rouge, de vert et de bleu du pixel de coordonnées (100, 250).
1
 Remarque : L’origine du repère est située en haut à gauche de l’image. Les
coordonnées augmentent en allant vers la droite et le bas.
Voir ci-contre un exemple pour une image de 800 par 600 pixels.
Attention, dans notre cas, l'image fait 500 par 500 pixels.

3. Modifiez le programme pour qu'il affiche les valeurs du rouge, du vert et du bleu du pixel de
coordonnées (250,300).

Activité 2 : Modifier les quantités de Rouge, Vert et Bleu d'un pixel

1. A partir du code ci-dessous et des commentaires, essayez de deviner ce que va faire le programme 2.
Programme 2 Commentaires
from PIL import Image
mon_image = Image.open("pomme.jpg")

mon_image.putpixel((250,250),(255,0,0)) On sélectionne le pixel de coordonnées (250,250) et on

change les quantités de Rouge (255), Vert (0) et Bleu (0).
mon_image.save("pommepixelr.bmp") On sauvegarde la nouvelle image.

2. Dans repl.it, effacez votre ancien programme, puis saisissez le programme n°2. Enfin testez-le avec RUN.

Un nouveau fichier va apparaître dans la colonne de gauche, nommé pommepixelr.bmp . Cliquez

dessus pour afficher son contenu à l’écran. Puis cliquez sur Click here to download (au dessus de
l’image) pour télécharger l'image pommepixelr.bmp.
Ouvrez l'image avec Paint et faites un zoom. Vous devriez voir un pixel rouge au milieu de la pomme.
Remarque : (255, 0, 0) est le code correspondant au rouge.

Ce programme a donc permis de modifier la couleur du pixel de coordonnées (250,250).

3. Cliquez sur main.py, pour revenir au code du programme.

Puis, modifiez le programme afin de colorier le pixel de coordonnées (100,250) en bleu.

4. A partir du code ci-dessous et des commentaires, essayez de deviner ce que va faire le programme 3.

Programme 3 Commentaires
from PIL import Image
mon_image = Image.open("pomme.jpg")
On crée une boucle dans laquelle la variable i va prendre
for i in range (0,500): les valeurs entières de l'intervalle [0; 500[ c'est à dire de 0
mon_image.putpixel((i,250),(0,255,0)) à 499.
Dans la boucle, on colorie en vert les pixels de
mon_image.save("pommepixelv.bmp") coordonnées (i, 250).

5. Dans repl.it, effacez votre ancien programme, puis saisissez le programme n°3, enfin testez-le avec RUN.
Affichez le fichier pommepixelv.bmp pour voir les modifications apportées par votre programme.

6. Modifier votre programme pour qu'il ajoute un cadre vert (133, 168,3) à 10 pixels des bords de
l'image pomme.jpg, comme ci-contre.

2
 Activité 3 : Utiliser une double boucle ( ou boucles imbriquées)

1. A partir du code ci-dessous et des commentaires, essayez de deviner ce que va faire le

programme 4.
Programme 4 Commentaires
from PIL import Image
img = Image.open("pomme.jpg")
largeur_image=500 On crée 2 variables contenant la largeur et la hauteur de
hauteur_image=500 l'image.
for y in range(hauteur_image): Pour chaque valeur entière de y de 0 à 499 :
for x in range(largeur_image): Pour chaque valeur entière de x de 0 à 499 :
On récupère les quantités de R, V et B du pixel (x,y)
r,v,b=img.getpixel((x,y))
Puis on affiche les coordonnées du pixel et les valeurs
print("pixel :",(x,y),"rouge :
r,v et b.
",r,"vert : ",v,"bleu : ",b)
Ceci n’est qu’une même phrase, à écrire sans retour à la ligne.

2. Dans repl.it, effacez votre ancien programme, puis saisissez le programme n°4. Enfin testez-le avec RUN.
ATTENTION : l'exécution complète de ce programme n'est pas très intéressante en soi, vous pouvez
l'arrêter à tout moment en cliquant sur

A votre avis, combien de couples de valeur r, v et b seront affichées ? Dit autrement, combien de
lignes le programme devrait-il afficher ? Les compter une par une n'est pas vraiment une bonne
idée… (réponse dans un coin de la page)

Ce programme contient une double boucle. On pourrait la décrire de la manière suivante :

Pour y=0 (ligne du haut), et pour toutes les valeurs de x allant de 0 à 499 (donc de gauche à droite
sur l'image), on récupère les valeurs R, V et B du pixel et on les affiche à l'écran.
Puis on recommence avec y=1, puis 2…
On balaie ainsi tous les pixels de l'image comme si on lisait un texte, du coin en haut à gauche au coin
en bas à droite, et pour chaque pixel on affiche ses valeurs r, v et b.

Activité 4 : Négatif
1. A partir du code ci-dessous et des commentaires, essayez de deviner ce que va faire le programme 5.
Programme 5 Commentaires
from PIL import Image
img = Image.open("pomme.jpg")
largeur_image=500
hauteur_image=500
for y in range(hauteur_image): Pour chaque ligne :
for x in range(largeur_image): Pour chaque colonne de cette ligne :
On récupère les quantités de rouge, vert et bleu
r,v,b=img.getpixel((x,y))
On calcule de nouvelles quantités de rouge, vert, bleu.
n_r=255-r
n_v=v
n_b=b
On insère ces nouvelles valeurs pour le pixel considéré.
img.putpixel((x,y),(n_r,n_v,n_b)) On sauvegarde l'image
img.save("pommenegatif.bmp")

2. Dans repl.it, effacez votre ancien programme, puis saisissez le programme n°5. Enfin testez-le avec RUN.
Dans ce programme, la quantité de rouge de chaque pixel a été modifiée, inversée. Faites de même pour
la quantité de vert et la quantité de bleu.
Testez votre programme. Quel est l’effet de ce programme sur votre image ?
500x500

3
 Activité 5 : Le chat
Les chats ne possèdent que deux types de cônes; S (Small) et M (Medium), dont 80 à 90% de cônes
M et 10 à 20% de cônes S.
  -Les cônes S possèdent un photopigment sensible aux courtes longueurs d'ondes et ont un
maximum de sensibilité aux alentours de 447 nm; les chats sont donc sensibles à la couleur bleue.
  -Les cônes M possèdent eux un photopigment sensible aux moyennes longueurs d'ondes et ont un
maximun de sensibilité aux alentours de 554 nm; les chats sont donc sensibles également à la couleur
verte.
  Le chat ne possède pas le troisième type de cône L (Large) qui est chez l'homme pour la couleur
rouge. Ainsi, leurs palettes de couleur tourne autour du bleu et du vert avec des couleurs plutôt
pastels.

 le spectre félin                             le spectre humain

1. Compléter le code ci-dessous de manière à ce que la couleur rouge n'apparaisse plus sur l'image.
L'image obtenue sera alors proche de ce que verrait un chat.

Programme 6 Commentaires
from PIL import Image
img = Image.open("pomme.jpg")
largeur_image=500 On crée 2 variables contenant la largeur et la hauteur de
hauteur_image=500 l'image.
for y in range(hauteur_image): Pour chaque valeur entière de y de 0 à 499 :
for x in range(largeur_image): Pour chaque valeur entière de x de 0 à 499 :
On récupère les quantités de R, V et B du pixel (x,y)
r,v,b=img.getpixel((x,y))
Puis on affiche les coordonnées du pixel et les valeurs
n_r=
r,v et b.
n_v=v
n_b=b
img.putpixel((x,y),(n_r,n_v,n_b))
img.save("pommechat.bmp")

Aide : Pour que la couleur rouge n'apparaisse plus, il faut la retirer. C’est-à-dire la mettre à zéro.

2. Si vous le souhaitez, vous pouvez tester ce programme avec une de vos photos. Attention, plus elle
contiendra de pixels et plus il faudra de temps au programme pour aboutir au résultat.

Remarque : Les smartphones arrivent à prendre des photos de plus en plus perfectionnées dans des
temps réduits. C'est pour cela que les smartphones intègrent des processeurs toujours plus
puissants. En comparaison, afficher une vidéo ou un jeu vidéo ne coûte pas grand-chose en termes
de calculs.

Pour aller plus loin :

Procéder de la même manière pour obtenir une image n’affichant que du rouge et du vert, ou que du
rouge et du bleu. On se rapproche ainsi de ce que voient certains daltoniens.

4
 Activité 6 : Le daltonien
Source : https://www.futura-sciences.com/sante/questions-reponses/maladie-daltoniens-voient-ils-monde-12647/

Dans le monde, on estime à environ 300 millions le nombre de personnes atteintes de daltonisme.
Une maladie qui affecte la manière dont une personne perçoit les couleurs. Et ainsi, la façon dont elle
voit le monde. Le daltonisme est une maladie essentiellement génétique. Ce qui explique pourquoi
elle touche plus les hommes que les femmes. Environ un homme sur douze est daltonien contre
seulement une femme sur deux cents.
Il existe différents types de daltonisme, en fonction des types de cônes défectueux. Certains
daltoniens ne voient pas le rouge, ou pas le bleu (rare), ou pas le vert (le plus fréquent), ou une
combinaison de tout cela.
Avec l'activité du chat, nous avons un programme qui permet également d'afficher ce que verrait un
daltonien dont tous les cônes rouges seraient défectueux. Si c'étaient les cônes verts qui étaient
complètement défectueux on mettrait à 0 la valeur v. Et même chose pour le bleu.
Dans le monde, une personne sur 33.000 souffrirait de ce que les spécialistes qualifient de
monochromatisme, c'est-à-dire une incapacité totale à voir les couleurs. Leur rétine ne comporte
aucun cône et leur monde se joue donc dans des nuances de gris.

Voyons cela…

On peut calculer une image en niveaux de gris à partir d’une image couleur en moyennant les trois
r + v+ b
canaux : g= .
3
Chaque canal r,v et b recevrait la quantité g de lumière : (r,v,b) deviendrait (g,g,g,)

Exemple : la couleur (20, 160, 120) donnerait la couleur (100, 100, 100) .

Si on avait eu (19,160,120) on aurait eu (99.66666, 99.66666,99.66666). Or 99.666666 n’est pas un

nombre entier et cela poserait problème. Pour que cela fonctionne, le résultat du calcul de moyenne
doit ensuite être associé à un nombre entier compris entre 0 et 255 (pour pouvoir être enregistré
dans un octet). Heureusement, Python sait parfaitement récupérer la partie entière d’un nombre
réel tout seul. Au lieu de diviser avec / on utilise // .

Compléter le programme ci-dessous en remplaçant les xxx et yyy de manière à ce que le

programme affiche une image en niveaux de gris. Puis testez-le.

Programme 6
from PIL import Image
img = Image.open("pomme.jpg")
largeur_image=500
hauteur_image=500
for y in range(hauteur_image):
for x in range(largeur_image):
r,v,b=img.getpixel((x,y))
g=xxx
img.putpixel((x,y),( yyy, yyy, yyy))
img.save("pommedaltonien.bmp")

5
En pratique, nos yeux ne contiennent pas la même quantité de cônes rouges, verts ou bleus. Ils contiennent
environ 70% de cônes vert, 21% de cônes rouges et 9% de cônes bleus. Pour obtenir des niveaux de gris plus
vrai semblant, pour nos yeux, utilisez la formule suivante : g=int(0.21*r+0.7*v+0.09*b).

6
 Activité 7 : Symétrie

Dans cette activité, vous allez programmer une fonction qui permet d’obtenir une image symétrique.
Pour cela, il suffit de déplacer chaque pixel judicieusement.

Le code ci-dessous permet de réaliser une symétrie.

Programme 7 Commentaires
from PIL import Image
img = Image.open("pomme.jpg")
largeur_image =500 On crée 2 variables contenant la largeur et la
hauteur_image=500 hauteur de l'image.
new_img=Image.new('RGB', On crée une nouvelle image, de la même
(largeur_image,hauteur_image)) dimension que celle de départ.

Pour chaque valeur entière de y de 0 à 499 :

for y in range(hauteur_image):
Pour chaque valeur entière de x de 0 à 499 :
for x in range(largeur_image):
On récupère les quantités de R, V et B du
r,v,b=img.getpixel((x,y))
pixel (x,y)
new_img.putpixel((499-x,y),( r, v, b)) On affecte ces quantités R, V, B au pixel
(499-x, y ).
new_img.save("pomme_symetrie.bmp") On sauvegarde la nouvelle image dans un fichier.

Pour mieux percevoir ce que fait ce programme, compléter les phrases suivantes :
Pour y=250 et x=10, le pixel de coordonnées (10, 250) de l’image de départ va se retrouvé collé dans
la nouvelle image au pixel de coordonnées (499-10 , 250), c'est-à-dire (489, 250).
Pour y=50 et x=200, le pixel de coordonnées (200, 50) de l’image de départ va se retrouvé collé dans
la nouvelle image au pixel de coordonnées (499 - … , … ), c'est-à-dire ( … , … ).
Pour y=125 et x=400, le pixel de coordonnées (400, 125) de l’image de départ va se retrouvé collé
dans la nouvelle image au pixel de coordonnées (499 - … , … ), c'est-à-dire ( … , … ).

Pour encore mieux visualiser ce que

fait le programme, procédez comme
ci-contre pour déplacer les pixels de
coordonnées (200, 250) et (400, 125)
de l’image de gauche, sur l’image de
droite.
(10, 250) (489, 250)

Image de départ Image symétrique

Compléter la ligne de code suivante pour qu’elle permette d’obtenir

une symétrie d’axe horizontale :
new_img.putpixel(( … , … ),( r, v, b))

Compléter la ligne de code suivante pour qu’elle permette d’obtenir

une symétrie centrale :
new_img.putpixel(( … , … ),( r, v, b))

7
 Activité 8 : Image en Noir et Blanc

Dans cette activité, vous allez utiliser un programme qui permet de transformer une image couleur
en une image en noir et blanc.
Pour cela, pour chaque pixel de l’image de départ :
1- on calcule la quantité de couleur dans le pixel
2- si cette quantité dépasse un certain seuil, alors on ajoute un pixel blanc dans l’image d’arrivée
sinon on ajoute un pixel noir dans l’image d’arrivée.

Ce programme va donc vous amener à utiliser la structure conditionnelle : Si … Alors… Sinon …

Pour tester si la quantité de couleur dans le pixel dépasse un certain seuil, on va procéder de la
manière suivante :
On calcule la moyenne des quantités de rouge, vert et bleu présentes dans le pixel considéré (comme
dans l’activité 6 pour calculer un niveau de gris) puis on compare cette moyenne à nombre par
exemple 127 (nombre situé à la moitié entre 0 et 255).

Reprenez l’activité 6 : quelle ligne de code permet de calculer la moyenne des R, V et B ?

A vous de recopier et compléter le code en remplaçant les xxx et yyy.

Programme 8 Commentaires
from PIL import Image
img = Image.open("pomme.jpg")
largeur_image =500 On crée 2 variables contenant la largeur et la
hauteur_image=500 hauteur de l'image.
new_img=Image.new('RGB', On crée une nouvelle image, de la même
(largeur_image,hauteur_image)) dimension que celle de départ.

Pour chaque valeur entière de y de 0 à 499 :

for y in range(hauteur_image):
Pour chaque valeur entière de x de 0 à 499 :
for x in range(largeur_image):
On récupère les quantités de R, V et B du
r,v,b=img.getpixel((x,y))
pixel (x,y)
g=int(0.21*r+0.7*v+0.09*b) Si la moyenne des couleurs est supérieure à
if g>127: 127, on ajoute un pixel blanc.
r=xxx
v=xxx
b=xxx Sinon on ajoute un pixel noir.
else :
r=yyy
v=yyy
b=yyy
new_img.putpixel((x,y),( r, v, b))
On sauvegarde la nouvelle image dans un fichier.
new_img.save("pommenb.bmp")

Vous pouvez ensuite améliorer votre programme en modifiant le calcul du seuil.

8
9
Projet Final :

A vous de concevoir un programme transformant une(des) image(s) que vous aurez choisie(s). Cette
transformation doit être quelque chose de nouveau, quelque chose qui ne se fait pas déjà en
quelques clics dans un logiciel de retouche d’image.

Il vous restera ensuite à vous préparer pour présenter votre travail à la classe (ce que vous avez fait,
les difficultés rencontrées, ce que vous avez appris/compris, ce qu’il resterait à faire…).

Voici quelques pistes de projet, que vous pouvez choisir de suivre, ou pas :

- Découper une image en morceaux et pour chaque morceau appliquer une(des)

transformations, sur la couleur, une symétrie, etc…

- Combiner deux images (ou plus). Par exemple on pourrait prendre un pixel dans chaque
image, situé au même endroit, en faire la somme, ou une soustraction, ou choisir le max/min
des deux et insérer le pixel, résultat de cette opération, dans une nouvelle image.

- Utiliser l’aléatoire pour que l’ordinateur génère une nouvelle image à chaque fois.
Par exemple : l’ordinateur choisie aléatoirement de modifier une quantité de rouge, vert ou
bleu, ou de procéder ou pas à une transformation (niveau de gris, noir et blanc, symétrie…)

- Détecter les contours dans une image (Pour ce projet, demander le document associé) puis
en faire quelque chose.

Aléatoire :

Pour obtenir un nombre aléatoirement dans un programme, il faut :

1. Importer le module random au début du programme. from random import*

2. Utiliser la fonction randint(a,b) pour générer un nombre aléatoire compris entre a et b
puis enregistrer ce résultat dans une variable. Exemple : alea=randint(5,15)

Remarque : Aléatoire/Pseudo-aléatoire

L’ordinateur utilise des fonctions mathématiques pour générer des nombres aléatoires. Plus
exactement, on parle de nombres pseudo-aléatoires. En effet, Un générateur de nombres pseudo-
aléatoires est un algorithme, donc une suite finie et non ambiguë d’opérations ; à partir d'un nombre
de départ donné, il générera toujours la même suite de nombres. Utiliser des algorithmes pour créer
des nombres aléatoires peut donc paraître paradoxal.

10
http://www.tangentex.com/TraitementImages.htm

11
Début de solution de l'activité 2 : les xxx sont à compléter.

from PIL import Image

mon_image = Image.open("pomme.jpg")

for i in range (0,500):

mon_image.putpixel((i,10),(133,168,3))
mon_image.putpixel((xxx, xxx),(133,168,3))
mon_image.putpixel((xxx,i),(133,168,3))
mon_image.putpixel((xxx,i),(133,168,3))

mon_image.save("pommepixelr.bmp")

Et si vraiment vous n'y arrivez pas, la solution est page suivante.

12
solution de l'activité 2

from PIL import Image

mon_image = Image.open("pomme.jpg")

for i in range (0,500):

mon_image.putpixel((i,10),(133,168,3))
mon_image.putpixel((i,489),(133,168,3))
mon_image.putpixel((10,i),(133,168,3))
mon_image.putpixel((489,i),(133,168,3))

mon_image.save("pommepixelr.bmp")

solution de l'activité 6

from PIL import Image

img = Image.open("pomme.jpg")
largeur_image=500
hauteur_image=500
for y in range(hauteur_image):
for x in range(largeur_image):
r,v,b=img.getpixel((x,y))
g=(r+v+b)//3
img.putpixel((x,y),(g, g, g))
img.save("pommedaltonien.bmp")

13