{"cells":[{"metadata":{},"cell_type":"markdown","source":"![En tête general](https://raw.githubusercontent.com/PythonLycee/PyLyc/master/img/En_tete_general.png)\n\n\n<i>© Copyright Franck CHEVRIER 2019-2021 https://www.python-lycee.com.</i><br>\n<i>Les activités partagées sur <a href=\"https://capytale2.ac-paris.fr/web/accueil\"><strong>Capytale</strong></a> sont sous licence <a href=\"https://creativecommons.org/licenses/by-sa/3.0/fr/\">Creative Commons</a>.</i>\n\n<span style=\"color: #9317B4\"> Pour exécuter une saisie Python, sélectionner la cellule et valider avec </span><span style=\"color: #B317B4\"><strong>SHIFT+Entrée</strong></span>.\n"},{"metadata":{},"cell_type":"markdown","source":"# Applications de filtres sur une image <span style=\"color: red\"> (corrigé)</span> \n\n### Activité sur le traitement d'images n°1"},{"metadata":{},"cell_type":"markdown","source":"Le but de cette activité est de programmer et d'appliquer des <strong>filtres</strong> sur des images :<br>\nL'application d'un filtre consiste à transformer une image en modifiant les composantes R,G,B de chacun de ses pixels.\n"},{"metadata":{},"cell_type":"markdown","source":"<strong>1. Exécuter la cellule ci-dessous, qui permet :\n- d'ouvrir un fichier et de stocker l'image dans un objet Python de type Image;\n- d'afficher le format, le type de codage et la dimension de l'image;\n- d'afficher l'image.</strong>\n\nNB: Vous pouvez réexécuter la cellule pour obtenir une autre image (choix aléatoire dans une bibliothèque d'images de la ville de Strasbourg)."},{"metadata":{"scrolled":false,"trusted":true},"cell_type":"code","source":"# import du module permettant la gestion des images\nfrom PIL import Image\nimport requests\nfrom io import BytesIO\n\n#ouverture de l'image\nfrom random import randint\nStrasbourg = Image.open(BytesIO(requests.get('https://raw.githubusercontent.com/PythonLycee/PyLyc/master/img/Strasbourg/Strasbourg'+str(randint(1,10))+'.jpg').content))\n\n#affichage du format, du type et de la dimension de l'image\nprint(\"Format:\",Strasbourg.format,\"\\nMode:\",Strasbourg.mode,\"\\nDimensions:\",Strasbourg.size) ; \n\n#affichage de l'image\nStrasbourg","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"__2. Pour éclaircir une image, on peut augmenter de 50% les composantes couleurs de chaque pixel.__<br><br>\n$\\;\\;\\;$__a. Suivre la vidéo suivante, qui détaille la fonction Python <mark>eclaircissement</mark> donnée ci-dessous.__<br><br>\n\n\n<video controls src=\"https://raw.githubusercontent.com/PythonLycee/PyLyc/master/video/Traitement_image_filtre.mp4\" width=\"960\" height=\"540\" />\n\n\n"},{"metadata":{},"cell_type":"markdown","source":"$\\;\\;\\;$__b. Exécuter les deux cellules ci-dessous, pour appliquer la fonction <mark>eclaircissement</mark> à l'image <mark>Strasbourg</mark>.__"},{"metadata":{"trusted":true},"cell_type":"code","source":"def eclaircissement(im_originale):\n    \"\"\"\n    fonction qui renvoie l'image im_originale éclaircie\n    \"\"\"\n        \n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            R = int(R*1.5)\n            G = int(G*1.5)\n            B = int(B*1.5)\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee\n    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"eclaircissement(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"__3. Pour assombrir une image, on peut diminuer de 50% les composantes couleurs de l'image d'origine.__<br>\n$\\;\\;\\;$__Écrire une fonction Python <mark>assombrissement</mark> qui permet d'assombrir une image, puis tester cette fonction.__<br>\n$\\;\\;\\;$Aide : On pourra commencer par effectuer un copier/coller de la fonction <mark>eclaircissement</mark> puis l'adapter."},{"metadata":{"trusted":true},"cell_type":"code","source":"# Ecrire ici la fonction assombrissement\n\ndef assombrissement(im_originale):\n    \"\"\"\n    fonction qui renvoie l'image im_originale assombrie\n    \"\"\"    \n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            R = int(R*0.5)\n            G = int(G*0.5)\n            B = int(B*0.5)\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction assombrissement\n\nassombrissement(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"__4. Le principe du filtre rouge consiste à conserver les composantes rouges des pixels de l'image et à remplacer les autres par $0$.__<br><br>\n$\\;\\;\\;$__a. Écrire une fonction Python <mark>filtre_R</mark> qui applique le filtre rouge à une image, puis tester cette fonction.__<br>\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Écrire ici la fonction filtre_R\n\ndef filtre_R(im_originale):\n    \"\"\"\n    fonction qui renvoie l'image im_originale filtrée en rouge\n    \"\"\"    \n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            # pas de modification de R\n            G = 0\n            B = 0\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"scrolled":false,"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction filtre_R\nfiltre_R(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"$\\;\\;\\;$__b. Écrire sur le même principe des fonctions Python <mark>filtre_G</mark> et <mark>filtre_B</mark> pour les filtres vert et bleu.__"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Écrire ici la fonction filtre_G\n\ndef filtre_G(im_originale):\n    \"\"\"\n    fonction qui renvoie l'image im_originale filtrée en vert\n    \"\"\"        \n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            R = 0\n            # pas de modification de G\n            B = 0\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction filtre_G\nfiltre_G(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Écrire ici la fonction filtre_B\n\ndef filtre_B(im_originale):\n    \"\"\"\n    fonction qui renvoie l'image im_originale filtrée en bleu\n    \"\"\"        \n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            R = 0\n            G = 0\n            # pas de modification de B\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction filtre_B\nfiltre_B(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"__5. Dans cette question, on souhaite convertir une image couleur en image en niveau de gris.__<br>\n$\\;\\;\\;$__En RGB, on obtient un pixel en niveau de gris lorsque ses 3 composantes couleur sont égales.__<br><br>\n$\\;\\;\\;$__a. Une première méthode consiste à remplacer chacune des composantes couleur d'un pixel par la moyenne des trois composantes initiales.__<br>\n$\\;\\;\\;\\;\\;\\;$__Écrire une fonction Python <mark>gris_rapide</mark> qui effectue cette conversion.__<br>\n$\\;\\;\\;\\;\\;\\;$__Tester cette fonction.__\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Écrire ici la fonction gris_rapide\n\ndef gris_rapide(im_originale):\n    \"\"\"\n    fonction qui renvoie l'image im_originale en niveau de gris\n    par la méthode de la moyenne\n    \"\"\"        \n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            moyenne = int((R+G+B)/3) # ou (R+G+B)//3 (calcul de la moyenne des trois composantes)\n            R = moyenne\n            G = moyenne\n            B = moyenne\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction gris_rapide\ngris_rapide(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"$\\;\\;\\;$__b. La perception des composantes couleur par l'oeil humain diffère selon ces couleurs.__<br>\n$\\;\\;\\;\\;\\;\\;$__Ainsi, l'organisme CIE (Commission Internationale de l'Éclairage) préconise la méthode suivante pour convertir une image en niveau de gris :__<br>\n\n<p style='background-color:#E0EDF0;'>\n<strong style='color:#84B8C5;'>Conversion en niveau de gris :</strong><br>\nOn attribue à chaque composante couleur la valeur obtenue en additionnant :<br>\n21,25% de la valeur de la composante rouge initiale;<br>\n71,54% de la valeur de la composante verte;<br>\n7,21% de la valeur de la composante bleue.\n</p>\n<br>\n\n$\\;\\;\\;\\;\\;\\;$__Écrire une fonction Python <mark>gris_precis</mark> qui réalise cette conversion.__"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Écrire ici la fonction gris_precis\n\ndef gris_precis(im_originale):\n    \"\"\"\n    fonction qui renvoie l'image im_originale en niveau de gris\n    avec la convention CIE\n    \"\"\"\n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            nouv = int(0.2125*R+0.7154*G+0.0721*B) # calcul avec la convention de la CIE\n            R = nouv\n            G = nouv\n            B = nouv\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction gris_precis\ngris_precis(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"__6. Pour obtenir le négatif d'une image, on remplace chaque composante de chaque pixel par la différence entre 255 et cette composante initiale.__<br>\n$\\;\\;\\;$__Écrire une fonction Python <mark>negatif</mark> qui renvoie le négatif d'une image.__<br>\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Écrire ici la fonction negatif\n\ndef negatif(im_originale):\n    \"\"\"\n    fonction qui renvoie le négatif de l'image im_originale   \n    \"\"\"\n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            R = 255-R\n            G = 255-G\n            B = 255-B\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction negatif\nnegatif(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"__7. Dans cette question, on souhaite convertir l'image en noir et blanc (sans niveaux de gris).__<br><br>\n$\\;\\;\\;$__a. Rappeler les codes R,G,B correspondant respectivement au noir et au blanc.__<br>\n$\\;\\;\\;$__b. On décide qu'un pixel sera blanc si et seulement si la moyenne de ses composantes initiales est supérieure ou égale à 128.__<br>\n$\\;\\;\\;\\;\\;\\;$__Ecrire une fonction Python <mark>NB</mark> qui réalise cette transformation.__<br>\n"},{"metadata":{"trusted":true},"cell_type":"code","source":"# Écrire ici la fonction NB\n\ndef NB(im_originale):\n    \"\"\"\n    fonction qui renvoie le négatif de l'image im_originale   \n    \"\"\"\n    # récupération des dimensions de l'image originale\n    L,H = im_originale.size\n    \n    # création d'une image vierge, de même format et même dimension que l'image initiale\n    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n    \n    # ouverture de l'accès aux pixels des deux images \n    pix_origine = im_originale.load()\n    pix_modifie = im_modifiee.load()\n    \n    # on parcourt tous les pixels des images\n    for x in range(L):\n        for y in range(H):\n            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n            \n            if (R+G+B)/3>=128:\n                R,G,B = (255,255,255)\n            else:\n                R,G,B = (0,0,0)\n            \n            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n    \n    # on renvoie l'image modifiée\n    return im_modifiee","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Tester ici un appel à la fonction NB\nNB(Strasbourg)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"<i>© Copyright Franck CHEVRIER 2019-2021 https://www.python-lycee.com.</i><br>\n<i>Les activités partagées sur <a href=\"https://capytale2.ac-paris.fr/web/accueil\"><strong>Capytale</strong></a> sont sous licence <a href=\"https://creativecommons.org/licenses/by-sa/3.0/fr/\">Creative Commons</a>.</i>"}],"metadata":{"celltoolbar":"Raw Cell Format","kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.10"}},"nbformat":4,"nbformat_minor":2}