ISN-Python3-Image.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 3 : Le BN pour le traitement des images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- http://www.mathly.fr/tp1_img.php\n",
    "- https://cache.media.eduscol.education.fr/file/maths_std2a/31/6/LyceeGT_Ressource_STD2A_7-nuances_de_gris-maths_198316.pdf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Préparation\n",
    "Il existe de nombreuses bibliothèques Python permettant la manipulation d’images.  \n",
    "\n",
    "Nous allons dans un premier temps explorer ici la solution **`pillow`** qui est la version Python3 du très célèbre module **`PIL`** (Python Image Library).\n",
    "\n",
    "Pour pouvoir utiliser les fonctionnalités d'une bibliothèque, il faut au préalable l'importer dans le notebook jupyter actif, par exemple, tester la commande :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import PIL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "S’il ne se passe rien c’est bon signe, c’est que votre environnement Python connaît cette bibliothèque.  \n",
    "Dans le cas contraire vous obtenez un message d’erreur, il faut alors installer la bibliothèque manquante à partir d'un terminal de commande..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Précaution\n",
    "Avant de (mal) traiter une image, il est bon de s'assurer d'être autorisé à le faire.\n",
    "\n",
    "Ainsi, l'image utilisée dans ce Bloc-Note résulte d'une recherche sur le métamoteur [CC search](https://search.creativecommons.org/). \n",
    "<img src=\"https://ericecmorlaix.github.io/img/mesange.jpg\" alt=\"mesange image\" title=\"Une jeune mésange bleu\" width=\"50%\">\n",
    "\n",
    "Elle est sous licence *CC0 Creative Commons (Free for commercial use, No attribution required)* et est disponible au téléchargement sur la page : https://pixabay.com/en/bird-tit-blue-tit-young-2396015/\n",
    "\n",
    "Dans le répertoire de ce bloc-note, télécharger le fichier image ci-dessus en ligne de commande, dans une cellule comme ci-dessous ou depuis un terminal... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "'wget' n'est pas reconnu en tant que commande interne\n",
      "ou externe, un programme ex‚cutable ou un fichier de commandes.\n"
     ]
    }
   ],
   "source": [
    "! wget https://ericecmorlaix.github.io/img/mesange.jpg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Premiers pas avec `pillow` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "img = Image.open(\"mesange.jpg\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'objet retourné, img peut être interrogé afin d'obtenir les informations de taille, format, et mode :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print(img.size, img.format, img.mode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut connaître la valeur d'un pixel (0,0) (ici le coin supérieur gauche) ainsi :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img.getpixel((0,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Ce résultat est de type `tuple`, un \"n-uplet\", c'est à dire une collection ordonnée et non modifiable (contrairement à une liste) d'éléments. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "type(img.getpixel((0,0)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut donc ne récupérer qu'une seule composante de couleur, comme par exemple ici le vert :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img.getpixel((0,0))[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un pixel de l'image (RGB) peut être modifié en donnant ses coordonnées et ses nouvelles composantes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img.putpixel((0,0),(255,0,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On vérifie alors la modification :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img.getpixel((0,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aussi, pour agir sur une zone plus importante de notre image nous pouvons avantageusement utiliser des boucles imbriquées tel que par exemple :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range (120,270) :\n",
    "    for j in range (100,200):\n",
    "        img.putpixel((i,j),(255,255,255))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Le résultat de la modification peut alors être visualisée très simplement avec **`jupyter notebook`** :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La modification peut aussi, mais uniquement avec jupyter sur une machine locale, être visualisée dans l'application d'affichage d'image par défaut avec la fonction `show()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis on peut sauvegarder l'image résultante :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img.save(\"imgV0.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un nouveau fichier image a été créé à la racine du répertoire contenant ce bloc note.  Attention : si un fichier du même nom existait déjà, il sera tout simplement écrasé et remplacé par le nouveau."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Visualiser un fichier image\n",
    "L'environnement de jupyter offre alors de très nombreuses solutions pour voir les modifications que nous avons apportées à notre image ainsi enregistrée :\n",
    "* Pour la visualiser dans le navigateur, il suffit de double cliquer sur le fichier créé dans le répertoire de ce notebook via le dashboard. L'image s'affiche alors dans un nouvel onglet du navigateur.\n",
    "![image fichier image modifiée](https://ericecmorlaix.github.io/img/fichierImageModif.png \"Fichier de l'image sauvegardée\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pour l'insérer dans notre Bloc Note, on peut utiliser le Mardown ou encore l'HTML"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "![image traitée](imgV0.png \"Image après traitement\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "<img src=\"imgV0.png\" alt=\"image traitée\" title=\"Image après traitement\" width=\"65%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* on peut aussi faire appel au `display` de `Ipython`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from IPython.display import Image\n",
    "Image(\"imgV0.png\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* On peut même faire appel à `matplotlib` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(img)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plus avant avec `Pillow`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Créer une image à partir de rien\n",
    "La commande suivante crée une image de taille 400×300, contenant 3 plans de couleurs, et initialement entièrement grise :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "monImage=Image.new(\"RGB\",(400,300),\"grey\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "monImage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Les principaux modes sont :   \n",
    "<table><tr><th>Mode</th><th>Bands</th><th>Description</th></tr>\n",
    "<tr><td>\"1\" </td><td> 1 </td><td> Blanc et noire (monochrome), un bit par pixel.</td></tr>\n",
    "<tr><td> \"L\" </td><td> 1 </td><td> Échelle de gris, un octet de 8 bits par pixel.</td></tr>\n",
    "<tr><td>\"RGB\" </td><td> 3 </td><td> rouge-vert-bleu, trois octets par pixel.</td></tr>\n",
    "<tr><td> \"RGBA\" </td><td> 4 </td><td> couleur avec une bande de transparence, de quatre octets par pixel, avec le canal alpha  variant de 0 (transparent)  à 255 (opaque).</td></tr>\n",
    "<tr><td> \"CMYK\" </td><td> 4 </td><td> Cyan-magenta-jaune-noir, couleur de quatre octets par pixel.</td></tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonctions de dessin avancées\n",
    "Il est possible de dessiner sur une image. Pour cela, on commence par obtenir une instance de ImageDraw:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from PIL import ImageDraw\n",
    "imgd = ImageDraw.Draw(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puis on dessine sur ce nouvel objet :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "imgd.line([(250,200),(300,250)], (0,255,255), width=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regarder aussi la documentation sur internet <a href=\"http://effbot.org/imagingbook/imagedraw.htm\">http://effbot.org/imagingbook/imagedraw.htm</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-Projet :\n",
    "\n",
    "### Augmenter l'image :\n",
    "> * Ajouter un cadre autour du rectangle blanc avec un texte dedans...\n",
    "\n",
    "### Appliquer un traitement :\n",
    "> * Afficher l'image en noir et blanc, avec un filtre bleu, vert, rouge, cépia, avec du flou, ...\n",
    "\n",
    "### Transparence :\n",
    "> Voici une image crée avec processing et python.\n",
    "\n",
    "> <center><img width=300px src=\"https://ericecmorlaix.github.io/img/ghost.png\"></center>\n",
    "\n",
    "> * Transformer les pixels de cette image pour rendre le fond transparent puis isoler chaque fantôme dans une image indépendante.\n",
    "\n",
    "> Aide : Pour ajouter un canal alpha avec la valeur 0 (transparent) à tous les pixels: ``img.putalpha(0)``\n",
    "\n",
    "### Calcul du diamètre d'un disque\n",
    "> Voici l'image du drapeau du Bangladesh. \n",
    "<center><img  width=300px src=\"https://ericecmorlaix.github.io/img/Bangladesh.png\"></center>\n",
    "> * Estimer le diamètre (en pixel) du disque rouge de l'image.\n",
    "> * Déterminer le centre du cercle\n",
    "\n",
    "### QR Code :\n",
    "> * Initier un générateur de QR Code après avoir regardé la vidéo de Micode : https://youtu.be/N2Wz1T4drsg  \n",
    "> Voir aussi les sites :\n",
    "    * http://www-igm.univ-mlv.fr/~dr/XPOSE2011/QRCode/index.html\n",
    "    * http://blog.qartis.com/decoding-small-qr-codes-by-hand/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Besoin d'aide :\n",
    "\n",
    "Le module phare de traitement de l'image en Python, PIL (Python Image Library) n'a pas tout de suite été porté en Python 3. Comme c'est souvent le cas dans le monde du libre, un fork pour Python 3 est apparu : Pillow. Pillow et PIL s'utilisent donc pratiquement de la même façon.\n",
    "\n",
    "La documentation complète de Pillow est accessible ici : https://pillow.readthedocs.io\n",
    "\n",
    "D'autres informations peuvent être trouvées dans la documentation de PIL : http://effbot.org/imagingbook/\n",
    "\n",
    "et sur ce site : http://jlbicquelet.free.fr/scripts/python/pil/pil.php#manipulation2\n",
    "\n",
    "L'autocomplétion présente toutes les méthodes de l'objet instancié en appuyant sur la touche **`Tab`** après le point : "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "img."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut également appeler la documentation pour obtenir la liste des fonctions disponibles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "help(img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ressources :\n",
    "\n",
    "* https://deptinfo-ensip.univ-poitiers.fr/ENS/doku/doku.php/stu:python_gui:tuto_images\n",
    "* http://fsincere.free.fr/isn/python/cours_python_ch10.php\n",
    "* http://dept-info.labri.fr/~namyst/ens/lycee/TD1.html\n",
    "* http://dept-info.labri.fr/~namyst/ens/lycee/TD2.html\n",
    "* https://github.com/topics/pillow?after=Y3Vyc29yOjMw&o=desc&s=updated&utf8=%E2%9C%93"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Retour sur `matplotlib` et `numpy`\n",
    "\n",
    "C'est bien connu, une image est composée de pixels. Ces pixels peuvent être décrits par un tableau homogène de nombres.  \n",
    "Or la façon la plus efficace de manipuler des tableaux de nombres en Python est d'utiliser la bibliothèque Numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    }
   ],
   "source": [
    "%pylab inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pixels = plt.imread(\"mesange.jpg\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pixels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "pixels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.imshow(pixels)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "N'importe quelle couleur peut être produite en superposant des sources de lumières rouge, verte et bleue dans des proportions adéquates. La couleur d'un pixel peut donc être représentée par trois nombres compris entre 0 et 255 donnant respectivement les quantités de chacune des couleurs primaires rouge, verte et bleue. C'est le principe du codage RGB.\n",
    "\n",
    "Une image couleur est donc décrite par un tableau à trois dimensions : (hauteur, largeur, 3). On peut se représenter ce tableau comme la superposition de trois tableaux 2D.\n",
    "\n",
    "* pixels[i, j, 0] est l'intensité de rouge du pixel de coordonnées (i, j)\n",
    "* pixels[i, j, 1] est l'intensité de vert du pixel de coordonnées (i, j)\n",
    "* pixels[i, j, 2] est l'intensité de bleu du pixel de coordonnées (i, j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le slicing\n",
    "Les cases du tableau peuvent être accédées individuellement ou par tranche (slice en anglais) :\n",
    "\n",
    "| Syntaxe     |      Signification      |\n",
    "|:----------|:-------------|\n",
    "| `pixels[i, j, c]` |  Pixel de coordonnées `(i, j)` pour la composante de couleur `c` |\n",
    "| `pixels[i:r, j:s, c]` |    Sous-tableau 3D formé des lignes de `i` à `r-1` et des colonnes de `j` à `s-1` pour la composante de couleur `c`  |\n",
    "| `pixels[:i, j:, c]` | Sous-tableau 3D formé des lignes strictement inférieures à `i` et des colonnes supérieures ou égales à `j` pour la composante de couleur `c`|\n",
    "| `pixels[:, j, c]` |  Colonne `j` (tableau 2D) |\n",
    "\n",
    "> Créer des filtres en utilisant le slicing :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour sauvegarder un fichier de l'image après traitement :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "plt.imsave(\"monImageModifiee.png\", pixelsModifies)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Autres bibliothèques pour le traitement des images :\n",
    "\n",
    "### `imageio`\n",
    "* https://pypi.python.org/pypi/imageio\n",
    "* http://imageio.readthedocs.io/en/latest/examples.html\n",
    "\n",
    "### `PyGame`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--\n",
    "from PIL import Image\n",
    "\n",
    "def mystere(i):\n",
    "    (l, h) = i.size\n",
    "    for y in range(h):\n",
    "        for x in range(l):\n",
    "            c = Image.getpixel(i, (x, y))\n",
    "            inv = 255 - c\n",
    "            Image.putpixel(i, (x, y), inv)\n",
    "\n",
    "im=Image.open(\"img/mesange.jpg\")\n",
    "Image.show(im)\n",
    "\n",
    "mystere(im)\n",
    "Image.show(im)\n",
    "-->"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}