Images.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Traitement et création d'images\n",
    "\n",
    "## Exemple\n",
    "\n",
    "`import` permet d'importer de nouvelles possibilités (types, classes, fonctions, données, ...). On étend ainsi les capacités de Python.\n",
    "\n",
    "`as` permet de donner un nom raccourci pour taper plus vite.\n",
    "\n",
    "Pour utiliser un objet dans le module, il suffit alors de donner le nom raccourci suivi d'un point et du nom de l'objet souhaité dans le module.\n",
    "\n",
    "Exécuter le code Python suivant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant Python connait l'objet pyplot du module matplotlib. Nous l'avons renommé `mpl` pour y accéder plus vite.\n",
    "\n",
    "Nous pouvons donc l'utiliser."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "image = mpl.imread(\"damier.jpeg\")  # la variable image contient une image lue\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Soyons curieux. Que contient la variable image ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np     # np va nous permettre de manipuler des tableaux\n",
    "print(np.array(image)) # affiche l'image sous la forme d'un tableau (array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En observant le contenu de la variable image, nous nous apercevons qu'il s'agit d'une liste de listes de nombres ou, grâce au module numpy, d'un tableau (array) de nombres.\n",
    "\n",
    "En Python, une liste est un ensemble ordonné d'objets séparés par des virgules et délimité par des crochets.\n",
    "\n",
    "Par exemple : `[ objet1 , objet2 , objet3 ]`.\n",
    "\n",
    "Que se passerait-il si nous créions notre variable image, non pas à partir d'une vraie image mais à partir d'une liste de listes rangées en tableau (array)..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np     # np va nous permettre de manipuler des tableaux\n",
    "\n",
    "image = [ [0,0,0,1,1,1,1,0,0,0],\n",
    "          [0,0,0,1,0,0,1,0,0,0],\n",
    "          [0,0,0,1,0,0,1,0,0,0],\n",
    "          [1,1,1,1,1,1,1,1,1,1],\n",
    "          [1,1,1,1,1,1,1,1,1,1],\n",
    "          [0,1,0,0,0,0,0,0,1,0],\n",
    "          [1,1,1,0,0,0,0,1,1,1],\n",
    "          [1,0,1,0,0,0,0,1,0,1],\n",
    "          [1,0,1,0,0,0,0,1,0,1],\n",
    "          [1,0,1,0,0,0,0,1,0,1]\n",
    "        ]\n",
    "\n",
    "print(np.array(image))\n",
    "\n",
    "mpl.imshow(image,cmap='gray')\n",
    "mpl.show()             "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'après ce que nous venons d'observer, une image est un ensemble de tous petits carrés alignés régulièrement. Chaque élément de l'image, appelé pixel (contraction de picture element), est codé par un nombre qui détermine sa couleur.\n",
    "\n",
    "Une image est une liste de lignes et une ligne est une liste de pixel.\n",
    "\n",
    "<IMG SRC=\"Images0.png\">\n",
    "\n",
    "<IMG SRC=\"Images1.png\">\n",
    "\n",
    "La figure est fausse, c'est le contraire en informatique, 0 % est noir et 1 = 100 % est blanc. Mais vous avez compris le principe.\n",
    "\n",
    "## Illustrations et mise en place des instructions nécessaires au codage\n",
    "\n",
    "### Un peu de nuances\n",
    "\n",
    "Prenons une image d'une ligne de 10 points. Choisissons les 10 premiers nombres entiers comme \"couleurs\".\n",
    "\n",
    "Notre image est donc une liste d'une ligne donc une liste d'une liste de pixels.\n",
    "\n",
    "C'est pourquoi nous allons entourer notre liste de nombres par des crochets doubles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl\n",
    "import numpy as np\n",
    "image = [[0,1,2,3,4,5,6,7,8,9]]\n",
    "print(np.array(image))\n",
    "mpl.imshow(image,cmap='gray')  # on force l'image en niveaux de gris\n",
    "mpl.show()\n",
    "mpl.imshow(image)              # on laisse le module matplotlib choisir les couleurs\n",
    "mpl.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Liste de nombres entiers\n",
    "\n",
    "Comment aller plus vite pour obtenir une rangée de nombres entiers ?\n",
    "\n",
    "On utilise l'instruction `range(n)` qui simule une rangée de $n$ nombres en partant de 0 (donc jusqu'à $n-1$). En Python, on appelle cela un itérateur.\n",
    "\n",
    "Nous allons créer une liste contenant une rangée de 20 nombres (de 0 à 19) avec l'instruction `list(range(20))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl \n",
    "image = [list(range(19))]\n",
    "print(image)\n",
    "mpl.imshow(image,cmap='gray')\n",
    "mpl.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice\n",
    "\n",
    "Changer le code ci-dessus pour obtenir 50 nuances de gris.\n",
    "\n",
    "### Répétition de liste\n",
    "\n",
    "On remarque que plus la ligne est longue et plus le module matplotlib la représente fine. C'est parce que les pixels sont carrés.\n",
    "\n",
    "Nous allons donc demander à Python de répéter plusieurs fois la même ligne pour augmenter l'épaisseur.\n",
    "\n",
    "Pour cela, il suffit de multiplier une liste par un nombre $n$ pour avoir son contenu répété $n$ fois.\n",
    "\n",
    "### Exemples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "[1]*5 # le nombre 1 mis dans une liste où il est répété 5 fois"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "[ [1,2,3] ]*5 # la liste [1,2,3] est mise dans une liste où elle est répétée 5 fois"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "image = [list(range(20))]*5 # une image de 5 lignes identiques\n",
    "print(np.array(image))\n",
    "plt.imshow(image,cmap='gray')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice\n",
    "\n",
    "1. Créer dans le cadre de code ci-dessous, une liste de 20 zéros.\n",
    "2. Créer une liste de 8 listes de 10 zéros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# cadre de code pour l'exercice\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Piège en Python avec les copies de listes\n",
    "\n",
    "Malheureusement, nous ne pourrons pas procéder ainsi pour créer une image noire (0 = noir).\n",
    "\n",
    "En effet, Python est fainéant et lorsqu'on lui a demandé de recopier plusieurs fois la même liste, il a effectivement utilisé la même liste.\n",
    "\n",
    "Nous le verrons un peu plus tard. Pour l'instant cherchons à :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accéder à une ligne ou à un pixel donné\n",
    "\n",
    "<IMG SRC=\"Images2.png\">\n",
    "\n",
    "Remarquez comment sont tracés les axes. L'axe des ordonnées est repéré du haut vers le bas. et l'axe des abscisses de la gauche vers la droite.\n",
    "\n",
    "La raison est technique et historique. Dans les anciens écrans à tube cathodique, un flux d'électrons était projeté sur l'écran pour tracer les pixels. Le rayon commençait son écriture en haut à gauche de l'écran, il écrivait une ligne, puis passait à la ligne suivante.\n",
    "\n",
    "Maintenant, les images sont décrites de la même manière. D'abord la ligne en partant du haut, puis la colonne en partant de la droite.\n",
    "\n",
    "Pour accéder à la liste complète de la ligne $n$ de l'image, on écrit `image[n]`.\n",
    "\n",
    "Pour accéder au pixel $p$ de la ligne $n$ de l'image, on écrit `image[n][p]`.\n",
    "\n",
    "### exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "image = [ [0,0,0,1,1,1,1,0,0,0],\n",
    "          [0,0,0,1,0,0,1,0,0,0],\n",
    "          [0,0,0,1,0,0,1,0,0,0],\n",
    "          [1,1,1,1,1,1,1,1,1,1],\n",
    "          [1,1,1,1,1,1,1,1,1,1],\n",
    "          [0,1,0,0,0,0,0,0,1,0],\n",
    "          [1,1,1,0,0,0,0,1,1,1],\n",
    "          [1,0,1,0,0,0,0,1,0,1],\n",
    "          [1,0,1,0,0,0,0,1,0,1],\n",
    "          [1,0,1,0,0,0,0,1,0,1]\n",
    "        ]\n",
    "\n",
    "print(image[5]) # affiche la ligne 6 ;-)\n",
    "print(image[0][3]) # affiche le 4e pixel de la ligne 1 ;-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice\n",
    "\n",
    "Dans le code ci-dessous, afficher la couleur du 424e pixel de la 500e ligne de l'image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl\n",
    "image = mpl.imread(\"damier.jpeg\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La bonne réponse est 61."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Retour sur le piège en Python avec les copies de listes\n",
    "\n",
    "Python est fainéant et lorsqu'on demande de recopier plusieurs fois la même liste, il utilise effectivement la même liste.\n",
    "\n",
    "Exécuter le code suivant qui illustre la situation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "image = [list(range(9))]*5\n",
    "print(np.array(image))\n",
    "\n",
    "print(\"on change seulement la troisième valeur de la troisième ligne\")\n",
    "image[2][2] = 9\n",
    "\n",
    "print(np.array(image))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Toutes les listes ont leur troisième valeur modifiée.\n",
    "\n",
    "C'est parce que les listes sont des objets mutables (hors programme pour les élèves mais piège pour les profs qui veulent utiliser les listes).\n",
    "\n",
    "En clair, cela signifie que lorsqu'on croit recopier une liste, on ne fait que mettre une deuxième étiquette sur la même liste. Si on modifie la liste, les différentes étiquettes montrent l'objet modifié.\n",
    "\n",
    "### Exercice\n",
    "\n",
    "Dans le cadre de code ci-dessous,\n",
    "\n",
    "1. Créer une liste contenant les nombres entiers de 0 à 15.\n",
    "   et mettre l'étiquette a sur cette liste. <br> *Attention, on ne veut pas une liste contenant une liste de nombres entiers.*\n",
    "2. Mettre l'étiquette b sur a. (copier a dans b)\n",
    "3. Dans a, changer la première valeur de a en 16.\n",
    "4. Afficher a et b.\n",
    "5. Créer une nouvelle liste d'entiers de 0 à 15 et mettre l'étiquette a dessus.\n",
    "6. Afficher a et b."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# cadre de code à compléter\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici ce que Python a fait : (en Python, on parle de shallow copy)\n",
    "\n",
    "<IMG SRC=\"Images3.png\">\n",
    "\n",
    "Et ce que l'on voudrait qu'il fasse : (en Python, on parle de deep copy)\n",
    "\n",
    "<IMG SRC=\"Images4.png\">\n",
    "\n",
    "À la fin du code précédent, on a détaché l'étiquette a de la liste précédemment créée pour la mettre sur une nouvelle. Mais l'étiquette b est toujours sur l'ancienne liste.\n",
    "\n",
    "Si on veut créer une vraie copie, il faut utiliser la fonction copy du module copy.\n",
    "\n",
    "### Exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import copy\n",
    "a = list(range(15))\n",
    "b = copy.copy(a)\n",
    "a[0] = 16\n",
    "print(\"a=\",a,\"\\n\",\"b=\",b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solution pour créer un tableau (liste de listes) remplies de 0\n",
    "\n",
    "Nous allons utiliser les fonctions du module numpy permettant de manipuler des tableaux.\n",
    "\n",
    "Nous alloons utiliser deux fonctions.\n",
    "\n",
    "La fonction `zeros([nblignes,nbcolonnes])` permet de créer un tableau de `nblignes` et `nbcolonnes` rempli de 0.\n",
    "\n",
    "La fonction `tolist()` qui transforme un tableau en liste de listes.\n",
    "\n",
    "Nous allons l'utiliser ainsi :\n",
    "\n",
    "### Exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "image = np.zeros([3,4]).tolist()\n",
    "print(image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercice\n",
    "\n",
    "Modifier le code précédent pour créer un tableau de 8 lignes de 2 colonnes.\n",
    "\n",
    "### Création d'une image pleine de bruit\n",
    "\n",
    "Dans le code Python suivant, nous créons une image carré (50x50) vide (tous les pixels à zéro) puis nous la remplissons de nombres entiers aléatoires compris entre 0 et 10 à l'aide de la fonction `randint(0, 10)` du module random."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "image = np.zeros([50,60]).tolist()\n",
    "\n",
    "for ligne in range(50):\n",
    "    for pixel in range(60):\n",
    "        image[ligne][pixel] = random.randint(0, 10)\n",
    "\n",
    "mpl.imshow(image,cmap='gray')\n",
    "mpl.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercices\n",
    "\n",
    "Vous voilà maintenant prêts pour faire les exercices suivants.\n",
    "\n",
    "Dans chaque exercice, il s'agit de compléter le code pour obtenir l'image demandée. Les premières lignes et les dernières lignes sont données pour gagner un peu de temps et se concentrer sur l'algorithme demandé et son implémentation en Python.\n",
    "\n",
    "la variable hauteur contient le nombre de ligne de l'image et la variable largeur contient le nombre de pixels sur une ligne."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice (négatif d'une image)\n",
    "\n",
    "Compléter le code Python suivant pour fabriquer le négatif de l'image.\n",
    "\n",
    "Dans un négatif, les blancs deviennent noirs et les noirs deviennent blancs\n",
    "\n",
    "Pour cela, la valeur de chaque pixel est \"inversée\".\n",
    "\n",
    "Mais comme les écrans ne connaissent que 255 niveaux de gris, on remplace la $valeur$ de chaque pixel par $255 - valeur$ du pixel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère\n",
    "import numpy as np                 # np va nous permettre de manipuler des tableaux\n",
    "import copy\n",
    "\n",
    "originale = mpl.imread(\"damier.jpeg\") # la variable image contient une image lue\n",
    "image = copy.copy(originale).tolist() # image est une copie modifiable\n",
    "hauteur = len(image)               # la variable hauteur contient le nombre de ligne de l'image\n",
    "largeur = len(image[0])            # la variable largeur contient le nombre de pixels sur une ligne\n",
    "\n",
    "\n",
    "# compléter ici\n",
    "\n",
    "\n",
    "print(\"L'originale\")\n",
    "mpl.imshow(originale,cmap='gray')  # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran  \n",
    "print(\"et son négatif\")\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice (assombrir une image)\n",
    "\n",
    "Compléter le code Python suivant pour assombrir l'image.\n",
    "\n",
    "Pour cela, la valeur de chaque pixel doit être diminuée de 30 %."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère\n",
    "import numpy as np                 # np va nous permettre de manipuler des tableaux\n",
    "import copy\n",
    "\n",
    "originale = mpl.imread(\"damier.jpeg\") # la variable image contient une image lue\n",
    "image = copy.copy(originale).tolist() # image est une copie modifiable\n",
    "hauteur = len(image)               # la variable hauteur contient le nombre de ligne de l'image\n",
    "largeur = len(image[0])            # la variable largeur contient le nombre de pixels sur une ligne\n",
    "\n",
    "\n",
    "# compléter ici\n",
    "\n",
    "\n",
    "print(\"L'originale\")\n",
    "mpl.imshow(originale,cmap='gray')  # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran  \n",
    "print(\"et sa copie plus sombre\")\n",
    "image[0][0] = 255                  # un pixel bien blanc pour mieux voir les sombres\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice (éclaircir une image)\n",
    "\n",
    "Compléter le code Python suivant pour éclaircir l'image.\n",
    "\n",
    "Pour cela, la valeur de chaque pixel doit être augmentée de 20 %.\n",
    "\n",
    "Mais comme les écrans ne connaissent que 255 niveaux de gris, si la valeur obtenue est supérieure à 255 alors cette valeur doit être remplacée par 255."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère\n",
    "import numpy as np                 # np va nous permettre de manipuler des tableaux\n",
    "import copy\n",
    "\n",
    "originale = mpl.imread(\"damier.jpeg\") # la variable image contient une image lue\n",
    "image = copy.copy(originale).tolist() # image est une copie modifiable\n",
    "hauteur = len(image)               # la variable hauteur contient le nombre de ligne de l'image\n",
    "largeur = len(image[0])            # la variable largeur contient le nombre de pixels sur une ligne\n",
    "\n",
    "\n",
    "# compléter ici\n",
    "\n",
    "\n",
    "print(\"L'originale\")\n",
    "mpl.imshow(originale,cmap='gray')  # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran  \n",
    "print(\"et sa copie plus claire\")\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show() \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Exercice (quadriller une image)\n",
    "\n",
    "Compléter le code Python suivant pour quadriller l'image.\n",
    "\n",
    "Faire un quadrillage en dessinant une ligne noire horizontale toutes les 100 lignes et en dessinant une ligne noire verticale tous les 100 pixels.\n",
    "\n",
    "Une fois ceci fait, vous ne verrez pas tous les traits car ils sont trop minces et pas affichés. Faire grossir les lignes (4 pixels de large pour toutes les voir)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère\n",
    "import numpy as np                 # np va nous permettre de manipuler des tableaux\n",
    "import copy\n",
    "\n",
    "originale = mpl.imread(\"damier.jpeg\") # la variable image contient une image lue\n",
    "image = copy.copy(originale).tolist() # image est une copie modifiable\n",
    "hauteur = len(image)               # la variable hauteur contient le nombre de ligne de l'image\n",
    "largeur = len(image[0])            # la variable largeur contient le nombre de pixels sur une ligne\n",
    "\n",
    "\n",
    "# compléter ici\n",
    "\n",
    "\n",
    "print(\"L'originale\")\n",
    "mpl.imshow(originale,cmap='gray')  # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran  \n",
    "print(\"et sa copie quadrillée\")\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice (image reflet)\n",
    "\n",
    "Compléter le code Python suivant pour faire le reflet de l'image dans une flaque d'eau.\n",
    "\n",
    "Pour cela, il faut inverser l'ordre des lignes. Le haut devient le bas et le bas devient le haut.\n",
    "\n",
    "Attention, il y a un piège pour échanger deux valeurs..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère\n",
    "import numpy as np                 # np va nous permettre de manipuler des tableaux\n",
    "import copy\n",
    "\n",
    "originale = mpl.imread(\"damier.jpeg\") # la variable image contient une image lue\n",
    "image = copy.copy(originale).tolist() # image est une copie modifiable\n",
    "hauteur = len(image)               # la variable hauteur contient le nombre de ligne de l'image\n",
    "largeur = len(image[0])            # la variable largeur contient le nombre de pixels sur une ligne\n",
    "\n",
    "\n",
    "# compléter ici\n",
    "\n",
    "\n",
    "print(\"L'originale\")\n",
    "mpl.imshow(originale,cmap='gray')  # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran  \n",
    "print(\"et son reflet dans l'eau\")\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice (image miroir)\n",
    "\n",
    "Compléter le code Python suivant pour faire le reflet de l'image dans un miroir.\n",
    "\n",
    "Pour cela, il faut inverser l'ordre des pixels dans la ligne. La droite devient la gauche et la gauche devient la droite."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère\n",
    "import numpy as np                 # np va nous permettre de manipuler des tableaux\n",
    "import copy\n",
    "\n",
    "originale = mpl.imread(\"damier.jpeg\") # la variable image contient une image lue\n",
    "image = copy.copy(originale).tolist() # image est une copie modifiable\n",
    "hauteur = len(image)               # la variable hauteur contient le nombre de ligne de l'image\n",
    "largeur = len(image[0])            # la variable largeur contient le nombre de pixels sur une ligne\n",
    "\n",
    "\n",
    "# compléter ici\n",
    "\n",
    "\n",
    "print(\"L'originale\")\n",
    "mpl.imshow(originale,cmap='gray')  # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran  \n",
    "print(\"et son reflet dans un miroir\")\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercice (contours)\n",
    "\n",
    "La reconnaissance de formes dans une image est une composante importante de l'analyse d'images. Elle se décompose en plusieurs étapes qui consistent à extraire les contours des objets dans l'image afin de les reconnaitre ou d'en détecter le mouvement. La première de ces étapes est la mise en évidence des contours des objets dans l'image. C'est cette étape que nous allons aborder très succintement.\n",
    "\n",
    "Un contour définit la limite d'un objet dans une image. Cette limite est caractérisée par un changement dans l'image : un changement de couleur ou de contraste. Ce changement se traduit dans la valeur des pixels qui sont localisés de part et d'autre de la limite. Nous sommes donc à la recherche d'un moyen de détecter et de localiser un changement. \n",
    "\n",
    "Considérons un pixel p(i,j) dans une image couleur. Ce pixel est-il semblable, de même couleur, que ses voisins ? Si non, quelle est la différence de couleur entre lui et ses voisins ? Est-elle grande, ce qui signifierait qu'il est situé à la limite d'un objet ? Que signifie une \"grande\" ou une \"petite\" différence ? Comment la mesurer pratiquement ? C'est ce que nous allons essayer de traduire en algorithme.\n",
    "\n",
    "Ce problème a fait l'objet de très nombreuses recherches. Il existe des algorithmes très efficaces et compliqués pour résoudre ce problème, surtout s'agissant d'images en couleurs. Mais il existe aussi des moyens simples, pas très performants mais utiles pour comprendre. Voyons une solution rudimentaire et ses résultats.\n",
    "\n",
    "Le principe est de récupérer la valeur de chaque pixel avoisinant pour chaque pixel de l'image, ce que nous ferons dans une boucle.\n",
    "\n",
    "<IMG SRC=\"pixels.png\">\n",
    "\n",
    "Puis de mesurer la différence, la \"distance\", entre notre pixel de référence et ses voisins en utilisant une fonction de norme standard, que vous reconnaissez sûrement ! Il existe bien d'autres normes, mais allons au plus simple :\n",
    "\n",
    "  $norme = \\sqrt{(p1-p3)^2+(p2-p4)^2}$\n",
    "\n",
    "Après avoir calculé la distance entre les pixels voisins, nous décidons si ce pixel est sur un contour ou pas à l'aide d'un seuillage. S'il est inférieur au seuil, par exemple 250, c'est à dire pas très \"distant\" de ses voisins, nous décidons qu'il n'est pas élément d'un contour et nous le traçons en blanc, sinon, nous le traçons en noir, comme un contour.\n",
    "\n",
    "Compléter le code Python suivant pour détecter les contours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as mpl    # mpl sera notre repère\n",
    "import numpy as np                 # np va nous permettre de manipuler des tableaux\n",
    "import copy\n",
    "from math import sqrt\n",
    "\n",
    "originale = mpl.imread(\"damier.jpeg\") # la variable image contient une image lue\n",
    "image = copy.copy(originale).tolist() # image est une copie modifiable\n",
    "hauteur = len(image)               # la variable hauteur contient le nombre de ligne de l'image\n",
    "largeur = len(image[0])            # la variable largeur contient le nombre de pixels sur une ligne\n",
    "\n",
    "\n",
    "# compléter ici\n",
    "\n",
    "\n",
    "print(\"L'originale\")\n",
    "mpl.imshow(originale,cmap='gray')  # On affiche l'image dans le repère\n",
    "mpl.show()                         # On affiche le repère à l'écran  \n",
    "print(\"et ses contours\")\n",
    "mpl.imshow(image,cmap='gray')      # On affiche l'image dans le repère\n",
    "mpl.show() "
   ]
  }
 ],
 "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}