SNT_8c_Photo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"width:100%;border-collapse:separate;border:solid 2px;border-radius:14px;\">\n",
    "    <div style=\"display:flex;\">\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "        <div style=\"display:inline;width:15%;\">SNT</div>\n",
    "        <div style=\"display:inline;width:15%;\">e8c</div>\n",
    "        <div style=\"display:inline;width:70%;text-align:right;\"><b>Photographie numérique</b></div>\n",
    "        <div style=\"display:inline;width:5%;\"></div>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;background-color:#EEE\">\n",
    "        <p style=\"width:100%;text-align:center;\">L'image numérique</p>\n",
    "    </div>\n",
    "    <div  style=\"display: flex;\">\n",
    "        <p style=\"width:100%;text-align:center;\">Création de filtres sur les images</p>\n",
    "    </div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-success\">\n",
    "    \n",
    "**Objectifs de la séquence:** \n",
    "- Comment agir sur la forme et les couleurs d'une image ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = \"alert alert-info\">\n",
    "    \n",
    "**Sommaire :**\n",
    "\n",
    "- <a href=#biblios>Bibliothèques utilisées</a>  \n",
    "- <a href=#un_point>Lire et modifier le code couleur d'un point</a>  \n",
    "- <a href=#dimensions>Dimensions d'une image: Lire une ligne </a>  \n",
    "- <a href=#niveaux_gris>Premiers filtres: Image en niveaux de gris et détection de seuil</a>  \n",
    "- <a href=#filtres_chromatiques>Filtres chromatiques: Modifer les couleurs</a>  \n",
    "- <a href=#filtres_geometriques>Filtres géométriques: Modifier la forme</a>\n",
    "</div>\n",
    "\n",
    "**Remaque:** Lorque vous rencontrez trois petits points ... C'est qu'il faut les supprimer pour mettre à cet endroit le code attendu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"biblios\"></div>\n",
    "\n",
    "## Bibliothèques utilisées\n",
    "\n",
    "Nous allons utiliser deux bibliothèques:\n",
    "- <a href=\"https://he-arc.github.io/livre-python/pillow/index.html\" >PIL</a>: Dont nous allons principalement nous servir pour ouvrir les fichiers images, en récupérer les données et les modifier\n",
    "- <a href=\"https://courspython.com/introduction-courbes.html\">matplotlib.pyplot</a>: Dont nous allons nous servir pour afficher les images modifées.  \n",
    "La bibliothèque **PIL** permet de le faire aussi, mais ici, je souhaite les afficher dans le notebook avec les axes.\n",
    "\n",
    "<span style=\"color:red\">Il est très important d'exécuter les lignes suivantes pour importer ces bibliothèques, sinon les programmes de cette page ne pourront pas être interprétés!</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from urllib.request import urlopen  # Pour ouvrir des images sur Internet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ouvrir et afficher une image  \n",
    "Pour ouvrir un fichier image nommé `mon_image.png`, il suffit de faire `img = Image.open(\"mon_image.png\")` par exemple.  \n",
    "Mais nous souhaitons ici charger une image stockée sur le web, il y a donc une petite étape supplémentaire avec `urlopen()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On récupère d'abord l'adresse d'une image sur Internet\n",
    "lien_url = \"https://github.com/ebuonocore/SNT_8_Photographie/blob/master/images/smiley_20_20_RVB.png?raw=true\"\n",
    "# Ouverture de l'image \"smiley_20_20_RVB.png\" pointées par le l'adresse URL\n",
    "img = Image.open(urlopen(lien_url))\n",
    "# Le fichier image est alors 'mémorisé' dans la variable 'img'\n",
    "plt.imshow(img) # Afficher l'image qui correspond à la variable'img'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notez que l'origine, de coordonnées (0,0), se situe dans le coin supérieur gauche."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"un_point\"></div>\n",
    "\n",
    "## Lire et modifier le code couleur d'un point\n",
    "Soit un fichier image nommé `img`, la méthode `img.getpixel((col,lig))` permet de récupérer le code couleur du pixel situé à la ligne `lig` et à la colonne `col`.  \n",
    "<u>Par exemple</u>: \n",
    "- Point A: Colonne  = 0 ; Ligne = 0 ; \n",
    "- Point B: Colonne  = 4 ; Ligne = 8 ;  \n",
    "Les lignes suivantes permettent de récupérer les codes couleurs des points A et B."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code couleur du point A\n",
    "img.getpixel((0,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code couleur du point B\n",
    "img.getpixel((4,8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Coordonnées et code couleur d'un pixel](https://github.com/ebuonocore/SNT_8_Photographie/blob/master/images/smiley_20_20_RVB_coordos&code.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chaque pixel est composé des trois couleurs fondamentales: <span style=\"color:red;font-weight:bold\">Rouge</span>, <span style=\"color:green;font-weight:bold\">Vert</span> et <span style=\"color:blue;font-weight:bold\">Bleu</span> (Voir cours 8a).  \n",
    "`getpixel()` renvoie les informations relatives à ces 3 couleurs, dont la valeur est comprise entre **0** et **255**.  \n",
    "\n",
    "On peut aussi procéder de la façon suivante pour récupérer les valeurs de chaque couleur dans des variables distinctes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r,v,b = img.getpixel((4,8))\n",
    "print(\"Canal Rouge:\", r, \"Canal Vert:\", v, \"Canal Bleu:\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La composante bleue de ce pixel est donc très faible alors que les composantes rouge et verte sont très marquées.  \n",
    "Ce pixel apparait donc Jaune (Rouge + Vert = Jaune)\n",
    "\n",
    "Vous pouvez utiliser ce <a href=\"http://www.proftnj.com/RGB3.htm\">site</a> pour composer vos couleurs. \n",
    "\n",
    "**A vous de jouer:**  \n",
    "**Q1 :** D'ailleurs, donnez les codes des couleurs suivantes :  (Remplacez les ... par le code attendu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Vert = ( ... , ... , ... )\n",
    "Noir = ( ... , ... , ... )\n",
    "Blanc = ( ... , ... , ... )\n",
    "Violet = ( ... , ... , ... ) # Donnez une combinaison possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q2 :** Récupérez le code couleur du point C : Colonne  = 6 ; Ligne = 7 ; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Code couleur du point C\n",
    "img.getpixel((...,...))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode `putpixel()` permet de forcer le code couleur d'un point de l'image.  \n",
    "<u>Par exemle:</u> `putpixel((10,8),(0,0,255))` force la couleur bleue au point de coordonnées (10,8).  \n",
    "\n",
    "Dans le code suivant, nous allons manuellement modifer la couleur de l'oeil à gauche."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = Image.open(urlopen(lien_url)) # Je recharge le fichier image dans 'img'\n",
    "img.putpixel((6,7),(180,230,200)) # Je modifie le point de coordonnées (6,7)\n",
    "img.putpixel((7,7),(80,180,140))\n",
    "img.putpixel((8,7),(180,230,200))\n",
    "img.putpixel((6,8),(80,180,140))\n",
    "img.putpixel((8,8),(80,180,140))\n",
    "img.putpixel((6,9),(180,230,200))\n",
    "img.putpixel((7,9),(80,180,140))\n",
    "img.putpixel((8,9),(180,230,200))\n",
    "plt.imshow(img) # J'affiche l'image qui correspond à la variable 'img'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**A vous de jouer:**  \n",
    "**Q3 :** Placez un point rouge au centre de l'oeil à droite.  \n",
    "Ou mieux, dessinez un oeil vert au milieu du front en copiant le code précédent et en décalant toutes les coordonnées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img = Image.open(urlopen(lien_url)) # Je recharge le fichier image dans 'img'\n",
    "img.putpixel((...,...),(...,...,...)) # Force un point rouge au milieu de l'oeil\n",
    "# Si vous êtes forme, ajoutez un oeil vert au milieu du front\n",
    "plt.imshow(img) # J'affiche l'image qui correspond à la variable 'img'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"dimensions\"></div>\n",
    "\n",
    "## Dimensions d'une image: Lire une ligne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`img.size` permet de récupérer les dimensions de l'image. (nombre de colonnes, nombre de lignes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, l'image `img` fait 20 pixels sur 20 pixels.  \n",
    "Il est alors possible de récupérer ses informatiosn dans des variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "largeur, hauteur = img.size\n",
    "print(\"L'image totalise\", largeur*hauteur, \"pixels\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Récupération de l'adresse URL d'une nouvelle image\n",
    "lien_url2 = \"https://github.com/ebuonocore/SNT_8_Photographie/blob/master/images/chaton01.jpg?raw=true\"\n",
    "img2 = Image.open(urlopen(lien_url2)) # Ouverture de cette image et enregistrement dans 'img2'\n",
    "plt.imshow(img2) # Affichage de l'image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q4 :** Calculez la taille pixels de cette image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "largeur, hauteur = img2.size\n",
    "print(\"L'image totalise\", ... , \"pixels\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le code ci-dessous permet de parcourir tous les points de l'image de la ligne 100, de la colonne 136 à 144.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range (136,145): # x prend toutes les valeurs  de 136 inclu à 145 exclu\n",
    "    code_couleur = img2.getpixel((x,100)) # On mémorie le code couleur du point (x,100)\n",
    "    print(code_couleur, end=\"\") # On affiche les codes couleurs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Parcourir_une_ligne](https://github.com/ebuonocore/SNT_8_Photographie/blob/master/images/ligne_oeil_chat.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"niveaux_gris\"></div>\n",
    "\n",
    "## Premiers filtres: Image en niveaux de gris et détection de seuil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On passe aux choses sérieuses!  \n",
    "<div class = \"alert alert-success\">\n",
    "Nous savons :\n",
    "    \n",
    "- parcourir une ligne d'une image  \n",
    "- récupérer le code couleur de chaque point  \n",
    "- le modifier  \n",
    "    \n",
    "Nous allons pouvoir faire des modifications sur l'image.  </div>\n",
    "\n",
    "<u>Premier objectif:</u> Transformer une image en niveaux de gris.  \n",
    "On commence par charger une nouvelle image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lien_url3 = \"https://github.com/ebuonocore/SNT_8_Photographie/blob/master/images/chateau01.jpg?raw=true\"\n",
    "img3 = Image.open(urlopen(lien_url3))\n",
    "plt.imshow(img3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "largeur, hauteur = img3.size # Récupération des dimensions de l'image\n",
    "for y in range (hauteur): # On parcourt toute les lignes de l'image\n",
    "    for x in range(largeur): # Pour chaque ligne, on parcourt chaque colonne\n",
    "        r,v,b = img3.getpixel((x,y)) # r, v et b récupèrent les valeurs des 3 canaux (rouge, vert et bleu)\n",
    "        g = (r+v+b)//3 # On calcul la moyenne des 3 canaux (arrondi à l'inférieur)\n",
    "        img3.putpixel((x,y),(g,g,g)) # On impose ce même niveau aux 3 canaux\n",
    "        \n",
    "plt.imshow(img3) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Deuxième objectif:</u> Créer une détection de seuil.  \n",
    "Si le niveau de gris est inférieur à 50, on force un noir profond (0,0,0), sinon, le pixel sera blanc (255,255,255)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img3 = Image.open(urlopen(lien_url3)) # On recharge l'image d'origine\n",
    "largeur, hauteur = img3.size # Récupération des dimensions de l'image\n",
    "for y in range (hauteur): # On parcourt toute les lignes de l'image\n",
    "    for x in range(largeur): # Pour chaque ligne, on parcourt chaque colonne\n",
    "        r,v,b = img3.getpixel((x,y)) # r, v et b récupèrent les valeurs des 3 canaux (rouge, vert et bleu)\n",
    "        g = (r+v+b)//3 # On calcul la moyenne des 3 canaux (arrondi à l'inférieur)\n",
    "        if g < 100:\n",
    "            img3.putpixel((x,y),(0,0,0)) # On impose un pixel noir\n",
    "        else:\n",
    "            img3.putpixel((x,y),(255,255,255)) # On impose le blanc\n",
    "        \n",
    "plt.imshow(img3) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q5 :** Modifiez la détection de seuil pour imposer du bleu si le seuil est inférieur à 80, sinon du rouge."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img3 = Image.open(urlopen(lien_url3)) # On recharge l'image d'origine\n",
    "largeur, hauteur = img3.size # Récupération des dimensions de l'image\n",
    "for y in range (hauteur): # On parcourt toute les lignes de l'image\n",
    "    for x in range(largeur): # Pour chaque ligne, on parcourt chaque colonne\n",
    "        r,v,b = img3.getpixel((x,y)) # r, v et b récupèrent les valeurs des 3 canaux (rouge, vert et bleu)\n",
    "        g = (r+v+b)//3 # On calcul la moyenne des 3 canaux (arrondi à l'inférieur)\n",
    "        if g < ...:\n",
    "            img3.putpixel((x,y),(...,...,...)) # On impose un pixel bleu\n",
    "        else:\n",
    "            img3.putpixel((x,y),(...,...,...)) # On impose le rouge\n",
    "        \n",
    "plt.imshow(img3) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"filtres_chromatiques\"></div>\n",
    "\n",
    "## Filtres chromatiques: Modifer les couleurs</a>  \n",
    "\n",
    "La structure sera la même sur les prochains programmes:\n",
    "- Je charge l'image\n",
    "- Je récupère les dimensions\n",
    "- Je parcours chaque pixel\n",
    "- Sur chaque pixel je lis le code couleur de ce point\n",
    "- J'opère une transformation sur les valeurs des canaux\n",
    "- Je force la nouvelle couleur du pixel\n",
    "\n",
    "**Q6 :** Pour faire un filtre négatif, il faut calculer le complément à 255 pour chaque canal:  \n",
    "`r = 255 - r` (pour le rouge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img3 = Image.open(urlopen(lien_url3)) # On recharge l'image d'origine\n",
    "largeur, hauteur = img3.size # Récupération des dimensions de l'image\n",
    "for y in range (hauteur): # On parcourt toute les lignes de l'image\n",
    "    for x in range(largeur): # Pour chaque ligne, on parcourt chaque colonne\n",
    "        r,v,b = img3.getpixel((x,y)) # r, v et b récupèrent les valeurs des 3 canaux (rouge, vert et bleu)\n",
    "        r = 255 - r\n",
    "        v = ...\n",
    "        b = ...\n",
    "        img3.putpixel((x,y),(r,v,b)) # On impose un pixel bleu\n",
    "        \n",
    "plt.imshow(img3) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q7 :** On peut s'amuser à simuler la vision d'une personne atteinte de daltonisme (ou dyschromatopsie):  \n",
    "Le rouge et le vert sont confondus. On va calculer la valeur moyenne entre ces 2 couleurs.  \n",
    "`d = (r + v)//2`  \n",
    "Et on impose cette  valeur aux canaux rouge et vert.  Le bleu est inchangé."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img3 = Image.open(urlopen(lien_url3)) # On recharge l'image d'origine\n",
    "largeur, hauteur = img3.size # Récupération des dimensions de l'image\n",
    "for y in range (hauteur): # On parcourt toute les lignes de l'image\n",
    "    for x in range(largeur): # Pour chaque ligne, on parcourt chaque colonne\n",
    "        r,v,b = img3.getpixel((x,y)) # r, v et b récupèrent les valeurs des 3 canaux (rouge, vert et bleu)\n",
    "        d = (r+v)//2 # On calcul la moyenne des 3 canaux (arrondi à l'inférieur)\n",
    "        img3.putpixel((x,y),(...,...,...)) # On impose un pixel bleu\n",
    "        \n",
    "plt.imshow(img3) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q8 :** Permuttez les couleurs.  \n",
    "Il faut utiliser une variable intermédiaire pour réaliser la permutation des canaux.  \n",
    "`tempo ← r`  \n",
    "`r ← v`  \n",
    "`v ← b`  \n",
    "`b ← tempo` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "img3 = Image.open(urlopen(lien_url3)) # On recharge l'image d'origine\n",
    "largeur, hauteur = img3.size # Récupération des dimensions de l'image\n",
    "for y in range (hauteur): # On parcourt toute les lignes de l'image\n",
    "    for x in range(largeur): # Pour chaque ligne, on parcourt chaque colonne\n",
    "        r,v,b = img3.getpixel((x,y)) # r, v et b récupèrent les valeurs des 3 canaux (rouge, vert et bleu)\n",
    "        tempo  = r\n",
    "        r = ...\n",
    "        v = ...\n",
    "        b = ...\n",
    "        img3.putpixel((x,y),(r,v,b)) # On impose un pixel bleu\n",
    "        \n",
    "imgplot =plt.imshow(img3) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"filtres_geometriques\"></div>\n",
    "\n",
    "## Filtres géométriques: Modifier la forme\n",
    "\n",
    "Pour finir, il est possible de faire des transformations de forme: Rotation, symétries, zoom, déformation....  \n",
    "Certaines de ces transformations sont déjà disponibles dans la <a href=\"https://pillow.readthedocs.io/en/stable/reference/Image.html\">bibliothèque **PIL**</a>.  \n",
    "On charge une nouvelle image ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lien_url4 = \"https://github.com/ebuonocore/SNT_8_Photographie/blob/master/images/montagne.jpg?raw=true\"\n",
    "img4 = Image.open(urlopen(lien_url4))\n",
    "plt.imshow(img4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "imgr = img4.rotate(90) # Méthode permettant une rotation. Vous pouvez changer l'angle pour voir.\n",
    "plt.imshow(imgr) # On affiche le résultat de la rotation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import ImageFilter # Importation de la bibliothèque\n",
    "img4 = Image.open(urlopen(lien_url4)) # On recharge l'image originale\n",
    "imgb = img4.filter(filter=ImageFilter.BLUR) # imgr récupère le résultat du filtre de floutage\n",
    "plt.imshow(imgb) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q9 Défi ultime:**  \n",
    "En partant des programmes précédents, construisez un filtre qui fasse: un grossissement par 2 de l'image, une symétire verticale ou une autre transformation de votre choix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Je vous laisse ici la structure du programme, mais en fonction du filtre, elle devra être modifiée.\n",
    "img4 = Image.open(urlopen(lien_url4)) # On recharge l'image originale\n",
    "largeur, hauteur = img4.size # Récupération des dimensions de l'image\n",
    "for y in range (hauteur): # On parcourt toute les lignes de l'image\n",
    "    for x in range(largeur): # Pour chaque ligne, on parcourt chaque colonne\n",
    "        # Transformation à programmer\n",
    "        \n",
    "        img4.putpixel((x,y),(r,v,b)) # On impose un pixel bleu\n",
    "        \n",
    "imgplot =plt.imshow(img4) # On affiche le résultat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "<p style=\"font-family:Comic Sans MS; text-align: center; color:gray; font-size: x-small; \">- Eric Buonocore. Juin 2020 -</p>\n",
    "\n",
    "![Licence CC BY NC SA](https://licensebuttons.net/l/by-nc-sa/3.0/88x31.png)\n",
    "\n",
    "<p style=\"font-family:Comic Sans MS; text-align: center; color:gray; font-size: x-small; \">Source des images: <a href=\"https://pixabay.com/\">pixabay.com/</a></p>"
   ]
  }
 ],
 "metadata": {
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}