♣ Exercice I1 : Téléchargez l'image suivante de l'énoncé et mettez-la dans le dossier de votre futur script Python.
Créez des scripts en utilisant Image de PIL pour :
          - afficher la taille et le format de l'image,
          - afficher la valeur du pixel de coordonnée (400,250),
          - modifier sa valeur pour qu'elle soit égale à (250,250,250) -i.e au blanc-,
          - enregistrer l'image sous le nom de simple_manipulation.png
          - afficher l'image avec Python.

Code copiable : [Afficher]

from PIL import Image
img = Image.open("sosoftware_white_new.png")

print("La taille du logo est ", img.size)
print("Son format est ",img.format)
print("La valeur du pixel de coordonnées (400,250) est ",img.getpixel((400,250)))
img.putpixel((400,250),(250,250,250))
img.save("simple_manipulation.png")
img.show()

img.close()

L1. On sait que l'on va utiliser Image de PIL, donc on l'importe.
L2. On ouvre l'image sur laquelle on va travailler à l'aide de open en créant l'instance img.

Attention !!!
Il faut mettre le chemin vers l'image, mais dans le cas où elle se situe dans le dossier de travail on peut mettre seulement son nom.

L4. On récupère la taille de l'image en se servant de la méthode size appliquée sur l'instance img, puis on affiche à l'aide de la fonction print.
L5. On fait de même avec la méthode format pour récupérer le format de l'image.
L6. On récupère la valeur RGB (red, green, blue) du pixel de coordonnées (400,250) grâce à getpixel qui prend le tuple de coordonnées en paramètre.

Information :
Le pixel en (0,0) correspond au pixel le plus en haut à gauche de l'image. La première coordonnée croît lorsqu'on se déplace vers la droite de l'image, et la seconde croît lorsqu'on se déplace vers le bas de l'image.

L7. On utilise putpixel pour modifier la valeur d'un pixel : putpixel prend en paramètre un tuple correspondant aux coordonnées du pixel, puis la valeur à mettre.
L8. L’enregistrement de l'image modifiée se fait avec la méthode save.
L9. L'affichage de l'image modifiée est faite avec la méthode show.

♣ Exercice I2 : Téléchargez l'image de l'énoncé et mettez-la dans le dossier de votre futur script Python.
Créez un script qui affiche l'image avec seulement deux couleurs : le noir et le blanc.

Code copiable : [Afficher]

from PIL import Image
img = Image.open("sosoftware_white_new.png")
size = img.size

for i in range(size[0]):
    for j in range(size[1]):
        if img.getpixel((i,j))[0] < 255 or img.getpixel((i,j))[1] < 255 or img.getpixel((i,j))[2] < 255 :
            img.putpixel((i,j),(0,0,0))

img.show()
img.close()

L1. On importe Image depuis PIL.
L2. On crée l'instance img en ouvrant l'image de l'énoncé.
L3. On récupère la taille de l'image pour parcourir tous ses pixels.

Boucle for : L5. On parcourt l'image en largeur :
                    Boucle for : L6. On parcourt l'image en hauteur :
                                        L7. Si l'une des valeurs du pixel (obtenues par la méthode getpixel) considéré n'est pas égale à 255, alors c'est qu'il ne s'agit pas d'un pixel blanc.
                                                      L8. On rend le pixel noir en lui donnant la valeur (0,0,0) à l'aide de putpixel.

L10. On affiche l'image avec show.

♣ Exercice I3 : Créez un script qui affiche l'image en nuance de gris.

Code copiable : [Afficher]

from PIL import Image
img = Image.open("sosoftware_white_new.png")
size = img.size

for i in range(size[0]):
    for j in range(size[1]):
        val = int((img.getpixel((i,j))[0] + img.getpixel((i,j))[1] + img.getpixel((i,j))[2])/3)
        img.putpixel((i,j),(val,val,val))

img.show()
img.close()

L1. On importe Image depuis PIL.
L2. On crée l'instance img en ouvrant l'image de l'énoncé.
L3. On récupère la taille de l'image pour parcourir tous Ses pixels.

Boucle for : L5. On parcourt l'image en largeur :
                    Boucle for : L6. On parcourt l'image en hauteur :
                                        L7. Donc, pour tout pixel : on récupère la moyenne des trois valeurs du pixel i,j dans la variable val,
                                        L8. puis on définit la valeur du pixel i,j comme étant (val,val,val) qui correspond à du gris.

L10. On affiche l'image avec show.

Remarque : La fonction grayscale de ImageOps le fait aussi très bien ! Le script équivalent est le suivant :
[Afficher]

from PIL import Image, ImageOps

img = Image.open("sosoftware_white_new.png")
img2 = ImageOps.grayscale(img)
img2.show()
img.close()

♣ Exercice I4 : Créez un script qui affiche une nouvelle image correspondant au symétrique de l'image.

Code copiable : [Afficher]

from PIL import Image
img = Image.open("Creuse_ane.jpg")
size = img.size

imgNew = Image.new(img.mode,size)
for i in range(size[0]):
    for j in range(size[1]):
        color = img.getpixel((i,j))
        imgNew.putpixel((size[0]-i-1,j),color)

imgNew.show()
img.close()

L1. On importe Image depuis PIL.
L2. On crée l'instance img en ouvrant l'image de l'énoncé.
L3. On récupère la taille de l'image pour parcourir tous ses pixels.

L5. On crée une nouvelle image via la fonction new qui prend en paramètres le mode et la taille de la nouvelle image.
Boucle for : L6. On parcourt l'image en largeur :
                    Boucle for : L7. On parcourt l'image en hauteur :
                                        L8. On récupère la couleur du pixel de coordonnées (i,j) dans l'image de base.
                                        L9. On donne la couleur du pixel (i,j) de l'image de base au pixel se trouvant dans l'autre moitié de l'image par symétrie (i.e la largeur - i ).
L11. On affiche la nouvelle image.

ATTENTION !!! Le pixel en (0,0) correspond au pixel le plus en haut à gauche de l'image. La première coordonnée croît lorsqu'on se déplace vers la droite de l'image, et la seconde croît lorsqu'on se déplace vers le bas de l'image.

Remarque : La fonction mirror de ImageOps renvoie la symétrie voulue. Voici le script équivalent :[Afficher]

from PIL import Image, ImageOps

img = Image.open("Creuse_ane.jpg")
img2 = ImageOps.mirror(img)
img2.show()

img.close()

♣ Exercice I5 : Créez un script qui affiche une nouvelle image correspondant à l'image quatre fois plus petite.

Code copiable : [Afficher]

from PIL import Image

import numpy as np
img = Image.open("Creuse_ane.jpg")
size = img.size

imgNew = Image.new(img.mode,(int(np.ceil(size[0]/2)),int(np.ceil(size[1]/2))))
for i in range(size[0]):
    for j in range(size[1]):
        if (i+j)%4 == 0:
            color = img.getpixel((i,j))
            imgNew.putpixel((i//2,j//2),color)

imgNew.show()
img.close()

♣ Exercice I6 : Créez un script qui affiche une nouvelle image de même taille que petit_gris.jpg et composée de 4 reproductions de cette image.

Code copiable : [Afficher]

from PIL import Image
import numpy as np
img = Image.open("petit_gris.jpg")
size = img.size

imgNew = Image.new(img.mode,(2*int(np.ceil(size[0]/2)),2*int(np.ceil(size[1]/2))))
for i in range(size[0]):
    for j in range(size[1]):
        if (i+j)%4 == 0:
            color = img.getpixel((i,j))
            imgNew.putpixel((i//2,j//2),color)
            imgNew.putpixel((i//2 + int(np.ceil(size[0]/2)),j//2),color)
            imgNew.putpixel((i//2,j//2 + int(np.ceil(size[1]/2))),color)
            imgNew.putpixel((i//2 + int(np.ceil(size[0]/2)),j//2 + int(np.ceil(size[1]/2))),color)

imgNew.show()
img.close()

L1. On importe Image depuis PIL.
L2. On importe numpy pour utiliser l'arrondi à l'entier dans la taille de la futur l'image.
L3. On crée l'instance img en ouvrant l'image de l'énoncé.
L4. On récupère la taille de l'image pour parcourir tous ses pixels.

L6. On crée une nouvelle image via la fonction new qui prend en paramètres le mode et la taille de la nouvelle image. Ici on utilise la taille de la petite image multipliée par 2 pour chaque dimension, pour éviter les problèmes d'arrondi.
Boucle for : L7. On parcourt l'image en largeur :
                    Boucle for : L8. On parcourt l'image en hauteur :
                                        L9. Pour diviser la taille de l'image par 4 sans trop la détériorer, on garde 1 pixel sur 4. Ainsi, on garde un pixel tous les 4 pixels (i.e. tous les pixels de numéros i+j multiples de 4). S'il s'agit d'un de ces pixels :
                                          L10. On récupère la couleur du pixel.
L11. Image du coin en haut à gauche : on colore le pixel dont les coordonnées sont 2 fois plus petites (sans oublier de prendre le partie entière, d'où l'opération //)
                                                      L12. Image du coin en haut à droite : on colore le pixel qui a les même coordonnées que celui d'avant mais avec un décalage d'une largeur de petite image (demi image de base).
                                                      L13. Image du coin en bas à gauche : on colore le pixel qui a les même coordonnées que celui du coin en haut à gauche mais décalé d'une hauteur de petite image (demi image de base).
                                                      L14. Image du coin en bas à gauche : on colore le pixel qui a les même coordonnées que celui du coin en haut à gauche mais avec un décalage d'une largeur de petite image et d'une hauteur de petite image (demi image de base).

L16. On affiche la nouvelle image.

♣ Exercice I7 : Téléchargez les images données dans l'énoncé et mettez-les dans le dossier de votre futur script Python. Créez un script qui affiche une nouvelle image correspondant au logo (sans le fond blanc) superposé à l'image du chat.

Code copiable : [Afficher]

from PIL import Image
img = Image.open("petit_gris.jpg")
logo = Image.open("sosoftware_white_new.png")
img_size = img.size
logo_size = logo.size

imgNew = Image.new(img.mode,img_size)

for i in range(img_size[0]):
    for j in range(img_size[1]):
        img_color = img.getpixel((i,j))
        if i < logo_size[0] and j < logo_size[1]:
            logo_color = logo.getpixel((i,j))
            if logo_color != (255,255,255):
                imgNew.putpixel((i,j),logo_color)
            else :
                imgNew.putpixel((i,j),img_color)
        else :
            imgNew.putpixel((i,j),img_color)


imgNew.show()
img.close()

L1. On importe Image depuis PIL.
L2. On crée l'instance logo en ouvrant le logo de l'énoncé.
L3. On crée l'instance img en ouvrant l'image de l'énoncé.
L4. On récupère la taille de l'image pour parcourir tous ses pixels.
L5. On récupère la taille du logo pour récupérer les couleurs de ses pixels.

L7. On crée la nouvelle image de la même taille et du même mode que l'image du chat.

Boucle for : L9 On parcourt l'image en largeur :
                    Boucle for : L10. On parcourt l'image en hauteur :
                                        L11. On récupère la couleur du pixel dans l'image du chat.
                                        L12. Si on est dans la partie de l'image où se trouvera le logo (i.e. que les coordonnées du pixel considéré sont inférieures à la taille du pixel (= coordonnée max)),
                                                            L13. On récupère la couleur du pixel du logo.
                                                            L14. S'il ne s'agit pas de couleur blanche (i.e. qu'il ne s'agit pas du fond du logo),
                                                                               L15. on colore le pixel de la nouvelle image avec la couleur du pixel du logo,
                                                            L16. Sinon on doit recopier l'image du chat,
                                                                               L17. on colore le pixel de la nouvelle image avec la couleur du pixel de l'image du chat.
L18. Si on n'est pas dans la partie de l'image où se trouvera le logo,
L19. on recopie la couleur du pixel de l'image du chat dans la nouvelle image.

L22. On affiche la nouvelle image.

♣ Exercice I8 : Créez un script qui affiche une image correspondant à cette image tournée de 30° et superposée à la même image tournée de -30°.
Code copiable :[Afficher]

from PIL import Image
img = Image.open("Cochon_d_Inde.png")
imgNew1 = img.rotate(30,expand = True)
imgNew2 = img.rotate(-30,expand = True)

size = imgNew1.size

for i in range(size[0]):
    for j in range(size[1]):
        color = imgNew1.getpixel((i,j))
        if color != (0,0,0) and imgNew2.getpixel((i,j)) == (0,0,0):
            imgNew2.putpixel((i,j),color)

imgNew2.show()
img.close()

L1. On importe Image depuis PIL.
L2. On crée l'instance img en ouvrant l'image de l'énoncé.
L3. On crée l'instance imgNew1 correspondant à la rotation de 30° de l'image img en rajoutant des bords pour garder toute l'image (paramètre expand à True).
L4. On fait de même pour imgNew2 correspondant à la rotation de -30°.

L6. On récupère la taille des images crées (sans oublier que imgNew1 et 2 sont de même taille car la rotation appliquée est de même valeur).

Boucle for : L8. On parcourt les images en largeur :
                    Boucle for : L9. On parcourt les images en hauteur :
                                        L10. On récupère la couleur du pixel (i,j) de imgNew1.
                                        L11. S'il ne s'agit pas de noir (i.e. pas (0,0,0)), alors on regarde si le pixel (i,j) de l'autre image est noir.
                                                     L12. Dans le cas où il l'est, on recopie le pixel (i,j) de imgNew1 à la même position dans l'imgNew2.

L14. On affiche imgNew2.

♣ Exercice I9 : Créez un script qui affiche l'image avec le logo redimensionnée en 600x600 et tourné de 25° dans le coin en bas à gauche de l'image de la vache (sans le fond blanc).
Code copiable : [Afficher]

from PIL import Image
logo = Image.open("sosoftware_white_new.png")
img = Image.open("vache.jpg")

logo = logo.resize((600,600)).rotate(25,expand = True)

imgW,imgH = img.size
logoW,logoH = logo.size

for i in range(imgW - logoW,imgW ):
    for j in range(imgH - logoH, imgH):
            color = logo.getpixel((i - (imgW - logoW), j - (imgH - logoH)))
            if color != (255,255,255) and color != (0,0,0):
                img.putpixel((i,j),color)

img.show()
logo.close()
img.close()

L1. On importe Image depuis PIL.
L2. On crée l'instance logo en ouvrant le logo de l'énoncé.
L3. On crée l'instance img en ouvrant l'image de l'énoncé.

L5. On redimensionne le logo à l'aide de la méthode resize, et on le tourne à l'aide de la méthode rotate. Le paramètre expand de rotate permet de garder le logo en entier en rajoutant des pixels noirs (i.e (0,0,0)).

L7. On récupère les dimensions de l'image dans les variables imgW et imgH.
L8. On récupère les dimensions du logo dans les variables logoW et logoH.

Boucle for : L10. On parcourt les pixels de l'image où se trouvera le logo, en parcourant la largeur, (cf. Aide dans la page de l'énoncé).
                    Boucle for : L11. et la hauteur où se trouvera le logo dans l'image : (cf. Aide dans la page de l'énoncé).
                                        L12. On récupère la couleur du logo sans oublier de repasser dans le référentiel du logo.
                                        L13. Si le pixel n'est ni blanc (i.e. qu'il ne s'agit pas du fond) ni noir (i.e qu'il ne s'agit pas d'un des pixels rajoutés par la méthode rotate pour compléter l'image),
                                                      L14. alors il s'agit d'un pixel du logo qui nous intéresse. On place ce pixel dans l'image.

L16. On affiche l'image.

♣ Exercice I10 : Comme vous l'avez peut-être remarqué, une image couleur est constituée de trois canaux de couleurs différentes : un rouge, un vert et un bleu.
Récupérez les trois différents canaux de l'image téléchargée, affichez les trois images correspondantes l'une à côté de l'autre et enregistrez l'image obtenue.
Code copiable : [Afficher]

from PIL import Image

img = Image.open("Ibis_rouge.jpg")
r,g,b = img.split()

result = Image.new(img.mode,(img.size[0]*3,img.size[1]))
result.paste(r,(0,0))
result.paste(g,(img.size[0],0))
result.paste(b,(2*img.size[0],0))
result.save("ibis_result.jpg")
img.close()

L1. On importe Image depuis PIL.

L3. On crée l'instance img en ouvrant l'image de l'énoncé.
L4. A l'aide de la méthode split, appliquée à l'instance img, on récupère les trois instanceS r, g et b correspondant aux 3 canaux rouge, vert et bleu de img.

L6. On crée une nouvelle image (pour l'instant vide) du même mode que l'image de départ img. On lui donne la même hauteur que l'image de départ mais 3 fois sa largeur car on va disposer trois images de même taille que l'image de départ.
L7. A l'aide de paste on place l'image r en position (0,0) dans l'image result.
L8. A l'aide de paste on place l'image g décal2E d'une largeur d'image de départ (i.e de position (une largeur, 0) dans l'image result).
L9. A l'aide de paste on place l'image b en position (deux largeurs,0) dans l'image result.
L10. On sauvegarde le résultat (cf. ci-dessous) sous le nom "ibis_result.jpg".

Remarques : On remarque que l'oiseau, majoritairement rouge, est bien plus claire dans l'image 1 correspondant au canal rouge. Il est bien plus sombre sur les deux autres canaux.
De même, l'herbe verte est plus claire dans l'image correspondant au canal vert (image 2).
On remarque que l'image n'a pas beaucoup de composantes bleues car l'image correspondant au canal bleu (image 3) est très sombre.

♣ Exercice I11 : En utilisant les modules Image et ImageFilter de PIL, créez une fonction qui floute un carré central de l'image et dont les dimensions sont 3 fois plus petites que celle de l'image. La fonction doit avoir 2 paramètres : le chemin vers l'image et l'intensité du floutage (valant 1 par défaut), et elle doit afficher l'image finale.

Code copiable : [Afficher]

from PIL import Image, ImageFilter

def BLUR_centre(path,n = 1):
    img = Image.open(path)
    H = img.size[0]
    L = img.size[1]

    pic = img.crop((H//3,L//3,2*H//3,2*L//3))
    for i in range(n):
        pic = pic.filter(ImageFilter.BLUR)

    img.paste(pic,(H//3,L//3,2*H//3,2*L//3))
    img.show()

if __name__ == '__main__':
    BLUR_centre("poule_fluffy.jpg",n = 100)

L1. On importe Image et ImageFilter depuis PIL.

L3. On définit notre fonction en la nommant BLUR_centre, et en nommant ses deux paramètres path et n (sans oublier de mettre n à 1 par défaut).
L4. On ouvre l'image de base path en créant l'instance img.
L5. et L6. On place dans H (resp. L) sa hauteur (resp. largeur).

L8. On récupère dans pic le morceau de l'image à traiter à l'aide de crop. "crop" prend en paramètres les coordonnées du point en haut à gauche et du point en bas à droite permettant de délimiter le morceau qui nous intéresse (cf. les ronds sur la photo explicatif ci-dessous).
L9. à L10. On applique le filtre BLUR (floutage) sur ce morceau d'image, autant de fois qu'il le faut (i.e. n fois).

L12. On place le morceau d'image traité où il faut dans l'image de base,
L13. puis on affiche l'image obtenue.

Voici un schéma expliquant le paramètre choisi dans crop( ) et dans paste( ) :

Voici les résultats obtenus sur la première image, pour n = 10 (2ème image) et n = 100 (3ième image) :

poule_fluffy