3_1_pillow_sol.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import division, print_function\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "plt.rcParams['image.interpolation'] = 'none'\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Image Library (Pillow)\n",
    "La Python Image Library(*PIL*) est une bibliothèque de traitement des images utilisée pour appliquer des opérations simples sur les images. Néanmoins comme *PIL* n'est plus maintenue depuis 2009, un fork dénommé *PILLOW* a pris la place de la librairie originelle. \n",
    "\n",
    "Dans cette section, nous allons donc présenter les différentes possibilitées offertes par *PILLOW*.\n",
    "Cette section est librement adaptée des tutoriels proposés par :\n",
    "- http://pillow.readthedocs.io/en/3.2.x/handbook/tutorial.html\n",
    "\n",
    "Cette section ne propose qu'une simple présentation des possibilités offertes par *PILLOW* et n'est bien évidemment pas exhaustive. Par conséquent, nous vous renvoyons vers la documentation de *PILLOW* pour plus d'informations sur l'utilisation et les possibilités qu'offre la librairie :\n",
    "- https://pypi.python.org/pypi/Pillow/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Opérations simple\n",
    "\n",
    "Tout les codes de PILLOW sont contenus dans le module `PIL`. \n",
    "\n",
    "Commençons par inclure les fonctions liées au traitement des images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'ouverture d'une image se fait par la commande :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Image.open('exo_img/pillow/input/iguanes.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'image est définie par un type propre à **PILLOW**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Image.open('exo_img/pillow/input/iguanes.png')\n",
    "print(type(im))\n",
    "print(im.format, im.size, im.mode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour accéder à l'image il est donc nécessaire d'utiliser les getter/setter spécifique de *PILLOW*.\n",
    "\n",
    "Il est possible d'accéder à la valeur d'un pixel par la fonction `getpixel`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Sous forme de tuple\n",
    "rgb = im.getpixel((3,10))\n",
    "\n",
    "print('La couleur du pixel (3, 10) est : %s' %(rgb, ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# En séparant les cannaux\n",
    "r, g, b = im.getpixel((3,10))\n",
    "\n",
    "print('Le niveau de rouge du pixel (3, 10) vaut : %d' %r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour définir la valeur d'un pixel, il est nécessaire d'utiliser la fonction `putpixel`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('Valeur du pixel avant utilisation du setter : %s' %(im.getpixel((3,10)), ))\n",
    "\n",
    "im.putpixel((3, 10), (30, 200, 100))\n",
    "\n",
    "print('Valeur du pixel après utilisation du setter : %s' %(im.getpixel((3,10)), ))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCICE : \n",
    "Remplissez la fonction `draw_X` de sorte à ce qu'elle dessine une croix blanche de 100px de large sur l'image. \n",
    "Le point `pos` correspond au coin supérieur gauche de la croix :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def draw_X(im, pos):\n",
    "    \"\"\"Draw an X of size 100px.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    im : pillow image\n",
    "    \n",
    "    pos : tuple,\n",
    "        Position of the superior left corner.\n",
    "        \n",
    "    Return\n",
    "    ------\n",
    "    im_out : pillow image\n",
    "        Copy of `im` with a white cross ap the position `pos`\n",
    "    \"\"\"\n",
    "    length, width = im.size\n",
    "    im = im.copy()\n",
    "    \n",
    "    # Prmemière branche\n",
    "    for x, y in zip(range(pos[0], pos[0] + 101), \n",
    "                    range(pos[1], pos[1] + 101)):\n",
    "        if x >= length or x < 0 or y < 0 or y >= width:\n",
    "            continue\n",
    "        im.putpixel((x, y), (255, 255, 255))\n",
    "        \n",
    "    # Deuxième branche\n",
    "    for x, y in zip(range(pos[0] + 100, pos[0] -1 , -1), \n",
    "                    range(pos[1], pos[1] + 101)):\n",
    "        if x >= length or y >= width:\n",
    "            continue\n",
    "        im.putpixel((x, y), (255, 255, 255))        \n",
    "    \n",
    "    return im"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "draw_X(im, (370, 130))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `save` permet de sauver l'image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "draw_X(im, (370, 130)).save('exo_img/pillow/input/iguanes_with_cross.jpg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Transformations\n",
    "En plus des opérations basiques de lecture/écriture/accés, *PILLOW* offre la possibilité d'effectuer un certain nombre de traitements simples. \n",
    "\n",
    "Commençons par appliquer quelques transformations affines.\n",
    "Il est possible de définir des vignettes d'une image avec la fonction `thumbnail`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im = Image.open('exo_img/pillow/input/iguanes.png')\n",
    "im.thumbnail((250, 250))\n",
    "im"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si néanmoins, on souhaite redimensionner l'image sans vouloir conserver les proportions de l'images, il vaut mieux utiliser la fonction `resize`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.resize((300, 150))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `crop` permet de recadrer l'image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "im.crop?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# X0_pos, Y0_pos, X1_pos, Y1_pos\n",
    "im.crop((10, 10, 110, 110))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`transpose` permet d'appliquer certaine transformations basique:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.transpose(Image.FLIP_LEFT_RIGHT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.transpose(Image.FLIP_TOP_BOTTOM)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.transpose(Image.ROTATE_90)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.transpose(Image.ROTATE_180)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.transpose(Image.ROTATE_270)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour appliquer une rotation avec plus de précision, il suffit d'utiliser la fonction `rotate`. Attention l'angle passée en paramètre est dans le sens anti-horaire :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.rotate(45)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction `convert` permet de convertir le format de l'image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "im.convert?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#im.convert(\"CMYK\")\n",
    "im.convert(\"L\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Filtrage\n",
    "**Pillow** offre également des fonctions de retouche et de filtrage. Ces dernières sont contenues dans le module `Pil.ImageFilter`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from PIL import ImageFilter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Certains de ces filtres sont prédéfinis:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im = Image.open('exo_img/pillow/input/iguanes.png')\n",
    "im.thumbnail((500, 500))\n",
    "im.filter(ImageFilter.BLUR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.filter(ImageFilter.FIND_EDGES)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.filter(ImageFilter.EDGE_ENHANCE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'autres sont paramétrables :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ImageFilter.GaussianBlur?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.filter(ImageFilter.GaussianBlur(radius=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ImageFilter.MedianFilter?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.filter(ImageFilter.MedianFilter(size=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCICE\n",
    "Le module `ImageFilter` offre la fonction `Kernel` qui permet de définir le filtre linéaire à appliquer sur l'image. \n",
    "\n",
    "A partir de la fonction ImageFilter.Kernel créér un détecteur de contour horizontaux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ImageFilter.Kernel?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "width, length = 3,3\n",
    "kernel = -1., -1., -1., 0., 0., 0., 1., 1., 1.\n",
    "im.filter(ImageFilter.Kernel(size=(width, length), kernel=kernel))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "width, length = 3,3\n",
    "kernel = -1., -1., -1., 0., 0., 0., 1., 1., 1.\n",
    "im.filter(ImageFilter.Kernel(size=(width, length), kernel=kernel, scale=1.))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "width, length = 3,3\n",
    "kernel = -1., -1., -1., 0., 0., 0., 1., 1., 1.\n",
    "im.filter(ImageFilter.Kernel(size=(width, length), kernel=kernel, scale=6., offset=128))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4 Retouche des images\n",
    "Le module `PIL.ImageEnhance` propose un certain nombre de fonctions de retouche des image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from PIL import ImageEnhance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En voici par exemples quelques-uns :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "color_enhancer = ImageEnhance.Color(im)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(color_enhancer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "color_enhancer.enhance?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "color_enhancer.enhance(1.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "contrast_enhancer = ImageEnhance.Contrast(im)\n",
    "contrast_enhancer.enhance?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ImageEnhance.Contrast(im).enhance(1.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "brightness_enhancer = ImageEnhance.Brightness\n",
    "brightness_enhancer?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "ImageEnhance.Brightness(im).enhance(1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour définir un traitement plus spécifique il est possible d'utiliser la fonction `point`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "im.point(lambda i: i * 1.2 + 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 EXERCICE : Script d'automatisation\n",
    "Nous vous proposons de définir un script d'automatisation du traitement des images.\n",
    "\n",
    "Commençons par définir le traitement à appliquer à chacune des images :\n",
    "- Créer une vignette de l'image d'origine pour qu'elle soit d'une taille max de 500x500\n",
    "- le niveau de vert des pixels dont la valeur rouge est < 100 est multiplié par un facteur 0.7\n",
    "\n",
    "Pour ce faire, il faudra définir un masque de l'image en utilisant la fonction `point`.\n",
    "Vous aurez également besoin des fonctions `split`, `paste` et `merge`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def apply_treatment(im):\n",
    "    im.thumbnail((500, 500))\n",
    "    source = im.split()\n",
    "    R, G, B = 0, 1, 2\n",
    "\n",
    "    # select regions where red is less than 100\n",
    "    mask = source[R].point(lambda i: i < 100 and 255)\n",
    "\n",
    "    # process the green band\n",
    "    out = source[G].point(lambda i: i * 0.7)\n",
    "\n",
    "    # paste the processed band back, but only where red was < 100\n",
    "    source[G].paste(out, None, mask)\n",
    "\n",
    "    # build a new multiband image\n",
    "    return Image.merge(im.mode, source)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous vous proposons de vérifier le traitement sur une seule image pour le moment:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "apply_treatment(im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Bonus**: Les modules `glob` et `os` fournissent tout ce qu'il faut pour créer de nouveaux répertoires et extraire le nom d'un fichier. À partir de ces modules, appliquer le traitement `apply_treatment` à l'ensemble de photos contenues dans le répertoire `exo_img/pillow/input` et sauver chaque nouvelle image dans le répertoire `exo_img/pillow/thumbnails`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import glob\n",
    "import os\n",
    "from PIL import Image\n",
    "\n",
    "# Creation du repertoire s'il n'existe pas encore\n",
    "if not os.path.exists('exo_img/pillow/thumbnails'):\n",
    "    os.makedirs('exo_img/pillow/thumbnails')\n",
    "    \n",
    "# Liste toute les images dans le repertoire\n",
    "for filename in glob.glob(\"exo_img/pillow/input/*\"):\n",
    "    # Lecture de l'image\n",
    "    print(\"Reading input image: %s\" % filename)\n",
    "    im_orig = Image.open(filename)\n",
    "    \n",
    "    # Modification de l'image d'origine\n",
    "    im = apply_treatment(im_orig)\n",
    "    \n",
    "    # Extraction\n",
    "    basename = os.path.basename(filename)\n",
    "    filename = os.path.splitext(basename)[0]\n",
    "    thumb_filename = \"exo_img/pillow/thumbnails/%s.png\" % filename\n",
    "    \n",
    "    # Enregistrement de l'image avec le même nom au format png \n",
    "    print(\"Save modified image: %s\" % thumb_filename)\n",
    "    im.save(thumb_filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Pour plus d'informations sur *PILLOW*, nous vous renvoyons vers la documentation officielle :\n",
    "http://pillow.readthedocs.io/en/3.2.x/handbook/tutorial.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}