TP1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TP1 : quantification, histogramme et égalisation, interpolation, couleur\n",
    "\n",
    "Dans ce TP, quelques images sont fournies, mais vous êtes fortement encouragés à récupérer et expérimenter sur d'autres images récupérées sur le web.\n",
    "\n",
    "Les TP de traitement d'images sont réalisés en Python3, à l'aide de la librairie [scikit-image](http://scikit-image.org/docs/stable/). Les tableaux utilisés  (`ndarray`) par cette librairie pour manipuler les images proviennent de la librairie [numpy](https://docs.scipy.org/doc/). L'affichage des images et autres figures est réalisé grace à [matplotlib](https://matplotlib.org/contents.html). La documentation de ces trois librairies vous sera donc bien utile.\n",
    "\n",
    "Dans ce TP, les questions seront indiquées dans un bloc **question**, et les réponses seront à donner dans le bloc **réponse**  situé en dessous du bloc de question. Vos réponses sont à rédiger en [markdown](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet). Vous pourrez ainsi répondre non seulement avec du texte, mais aussi avec des tableaux et des images.\n",
    "\n",
    "Ce TP est à réaliser en deux séances d'1h30.\n",
    "\n",
    "**Remarque importante:** Les questions posées dans ce TP requièrent généralement des <u>réponses courtes mais justifées</u>. Un simple oui ou non ne nous est d'aucune utilité pour juger de votre compréhension de la question et de sa réponse...\n",
    "\n",
    "**Autre remarque:** Il y a parfois plusieurs sous-questions dans une même question. <u>Pensez a répondre à toutes les sous-questions</u>.\n",
    "\n",
    "## Manipulation d'image\n",
    "\n",
    "- Nous allons commencer par charger et afficher une image à l'aide du code ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": false,
    "tags": []
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "46497d5f771f40309983921b059a24bc"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "<matplotlib.image.AxesImage at 0x11e245048>"
     },
     "metadata": {},
     "execution_count": 3
    }
   ],
   "source": [
    "%matplotlib widget\n",
    "# la ligne précédente permet d'afficher les figures directement dans votre notebook et de pouvoir interagir avec\n",
    "\n",
    "from skimage import io # on charge le module permettant d'ouvrir des images\n",
    "import matplotlib.pyplot as plt # gestion des figures\n",
    "\n",
    "im = io.imread('talvi.jpg')\n",
    "plt.imshow(im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Les images sont manipulées sous forme de tableau à 2 (niveaux de gris) ou 3 dimensions (couleur). Le type python utilisé pour représenter ces tableaux est `ndarray` de la librairie numpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "type de données utilisé: <class 'numpy.ndarray'>\nnombre de dimensions de l'image: 3\ndimensions: (400, 300, 3)\n"
    }
   ],
   "source": [
    "print(\"type de données utilisé:\", type(im))\n",
    "print(\"nombre de dimensions de l'image:\",im.ndim)\n",
    "print(\"dimensions:\", im.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 1:** Expliquez les dimensions affichée pour l'image d'exemple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 1:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2:** Le code suivant transforme l'image d'origine en niveau de gris. Modifiez le afin d'afficher les dimensions de la nouvelle image. Cela correspond-t-il à ce que vous attendez ? Y a-t-il une différence entre les deux méthodes utilisées ? (si oui) pourquoi ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 2:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": false,
    "tags": []
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "eae0881650074ad480727c722a666169"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "0e76eb910bde4f789f167120d9426806"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "a2ad1dc1ed204a948ecb629bc08dda31"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "4.314527777777777\n"
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Text(0.5, 1.0, 'différence')"
     },
     "metadata": {},
     "execution_count": 5
    }
   ],
   "source": [
    "from skimage import color # fonctions de conversion de couleur\n",
    "\n",
    "\n",
    "# Traitement des images\n",
    "im_gris1=im.mean(2)\n",
    "im_gris2=(color.rgb2grey(im)*255).astype('uint8') #rgb2grey renvoie une image avec 0<= valeurs <=1\n",
    "diff=abs(im_gris1-im_gris2)\n",
    "\n",
    "# Affichage sous forme de différentes figures (attention les numéros de figure sont valables dans tout le notebook)\n",
    "plt.figure(2)\n",
    "plt.imshow(im_gris1, cmap=plt.cm.gray) # cmap=plt.cm.gray permet d'afficher les image en niveaux de gris avec la bonne palette\n",
    "plt.title(\"moyenne\")\n",
    "\n",
    "plt.figure(3)\n",
    "plt.imshow(im_gris2, cmap=plt.cm.gray)\n",
    "plt.title(\"rgb2grey\")\n",
    "\n",
    "plt.figure(4)\n",
    "print(diff.mean())\n",
    "plt.imshow(diff, cmap=plt.cm.gray)\n",
    "plt.title(\"différence\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantification\n",
    "\n",
    "### Comment ça marche ?\n",
    "\n",
    "Fixer par exemple la variable `Q=8` pour le taux de quantification, puis lancer le script ci-dessous. Essayer pour diverse images (talvi, dégradés, etc.) et déterminer si, à Q identique la visibilité des dégradation dépend des images ou zones d'images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "09b301d33d354299991bda2ee1f6349d"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Text(0.5, 1.0, 'requantifié Q=32')"
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "source": [
    "import numpy as np # manipulation des ndarray\n",
    "\n",
    "# Init \n",
    "Q=32\n",
    "im = io.imread('talvi.jpg')\n",
    "\n",
    "# Traitements \n",
    "im_gris=(color.rgb2grey(im)*255).astype('uint8')\n",
    "im_requantifiee = Q * np.round(im_gris/Q)\n",
    "\n",
    "# Affichage sous forme de différentes sous figures\n",
    "plt.figure()  #les numéros de figure ne sont pas obligatoires\n",
    "\n",
    "plt.subplot(121) # 121 = 1 ligne, 2 colonnes, 1ère sous figure\n",
    "plt.imshow(im_gris, cmap=plt.cm.gray)\n",
    "plt.title(\"image de départ\")\n",
    "\n",
    "plt.subplot(122) # 122 = 1 ligne, 2 colonnes, 2ème sous figure\n",
    "plt.imshow(im_requantifiee, cmap=plt.cm.gray)\n",
    "plt.title(\"requantifié Q=\" + str(Q))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 3:** Visualiser l'effet de cette opération pour Q=2, puis Q=38 et Q=71."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 3:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 4:** Montrer que cet algorithme réalise de la compression d'images avec perte."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 4:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comment mesurer la dégradation ?\n",
    "\n",
    "**Question 5:** Cette dégration visuelle (évaluation subjective de votre part) est-t-elle perceptible pour des quantifications (`Q`) faibles ?\n",
    "\n",
    "On pourrait qualifier objectivement et numériquement la dégradation par différentes mesures d'erreur (cf. code ci-dessous)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 5:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true,
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "erreur quadratique moyenne (mse): 85.842175\nrapport signal bruit (psnr): 28.793796479662667\nsimilarité structurelle (ssim): 0.8808622932284417\n"
    }
   ],
   "source": [
    "from skimage import measure # fonctions de mesure d'erreur\n",
    "\n",
    "err_quad=measure.compare_mse(im_gris, im_requantifiee)\n",
    "print(\"erreur quadratique moyenne (mse):\", err_quad)\n",
    "psnr=measure.compare_psnr(im_gris/255, im_requantifiee/255) # compare_psnr a besoin d'images avec des 0 <= valeur <=1\n",
    "print(\"rapport signal bruit (psnr):\", psnr)\n",
    "ssim=measure.compare_ssim(im_gris, im_requantifiee)\n",
    "print(\"similarité structurelle (ssim):\", ssim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 6:** Chercher la signification de chacune de ces mesures. De quelle manière doit on les interpréter ? Correspondent elle à votre évaluation subjective ? Est-ce que cette fidélité depend des images / zones d'images ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 6:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Histogramme, seuillage\n",
    "\n",
    "Le script ci-dessous calcule et affiche l'histogramme des niveaux de gris d'une image, après quantification uniforme en N boites.\n",
    "\n",
    "** Question 7:** Essayez les trois cas `N=256`, `N=50` et `N=10`. Pour plusieurs images de votre choix, faire le lien entre les régions de l'histogramme et les régions de l'image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 7:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "612b6c7d994f4d749b13a5c117a5e5f0"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "<BarContainer object of 256 artists>"
     },
     "metadata": {},
     "execution_count": 8
    }
   ],
   "source": [
    "from skimage import exposure\n",
    "\n",
    "N = 256 # Expérimenter avec d'autres valeurs\n",
    "im = io.imread('talvi.jpg') # Expérimenter avec d'autres images\n",
    "im_gris=(color.rgb2grey(im)*255).astype('uint8') # transcodage de l'image en uint8 pour avec un histogramme discret\n",
    "\n",
    "(histo, bin_centers)=exposure.histogram(im_gris,N)\n",
    "plt.figure()\n",
    "plt.bar(np.arange(N), histo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Question 8: ** Que fait le petit script ci-dessous ? Quel est le rôle de la variable `SEUIL` (testez différentes valeurs) ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 8:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "** Question 9: ** Quel est le lien ente cette opération de seuillage et l'histogramme de l'image ? A quoi ressemble l'histogramme de l'image seuillée ? (vous pouvez ajouter du code pour l'afficher)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 9:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "868c4d8f0b4740afb674eb5b981e8aa3"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "<matplotlib.image.AxesImage at 0x1201c75f8>"
     },
     "metadata": {},
     "execution_count": 9
    }
   ],
   "source": [
    "SEUIL = 75\n",
    "\n",
    "# une double boucle (lente)  pour effectuer notre traitement sur chaque pixel\n",
    "im_thresholded = np.zeros( im_gris.shape )\n",
    "largeur = im_gris.shape[1]\n",
    "hauteur = im_gris.shape[0]\n",
    "\n",
    "for y in range(0, hauteur):\n",
    "    for x in range(0, largeur):\n",
    "        if im_gris[y][x] > SEUIL:\n",
    "            im_thresholded[y][x] = 255\n",
    "        else:\n",
    "            im_thresholded[y][x] = 0\n",
    "\n",
    "# On peut aussi remplacer la double boucle précédente par ceci\n",
    "#im_thresholded = (im_gris > SEUIL)*255\n",
    "\n",
    "plt.figure()\n",
    "plt.imshow(im_thresholded, cmap=plt.cm.gray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Question 10: ** Dans une nouvelle cellule de script, adaptez le programme précédent pour réaliser un effet \"inverse vidéo\" sur l'image originale (un pixel de sortie doit être d'autant plus foncé qu'il n'était clair en entrée)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# VOTRE CODE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Restauration par transformation de l'intensité : égalisation d'histogramme\n",
    "\n",
    "L'objectif de cette opération est \"d'améliorer\" une image en transformant son contraste, c'est à dire d'exploiter \"au mieux\" la dynamique de luminance disponible.\n",
    "\n",
    "**Question 11:** Exécuter le script ci-dessous et interprétez les résultats pour l'image `essai.jpg`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 11:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "717e35d584c84bac9aa9f286f37ebde0"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Text(0.5, 1.0, 'histogramme cumulé')"
     },
     "metadata": {},
     "execution_count": 18
    }
   ],
   "source": [
    "plt.rcParams['figure.subplot.hspace'] = 0.8 # espace un peu les sous-figures verticalement\n",
    "from skimage import exposure\n",
    "nb_bins=256\n",
    "\n",
    "# Chargement de l'image\n",
    "im = io.imread('low.png') # Expérimenter avec d'autres images\n",
    "im_gris=(color.rgb2grey(im)*255.0).astype('uint8') # transcodage de l'image en uint8 pour avec un histogramme discret\n",
    "\n",
    "# Histogramme normale et cumulé de l'image de départ\n",
    "im_gris_histo, im_bins = exposure.histogram( im_gris, nb_bins )\n",
    "im_gris_cumul, im_cumul_bins = exposure.cumulative_distribution( im_gris, nb_bins )\n",
    "\n",
    "# Egalisation + histogramme\n",
    "im_eq = exposure.equalize_hist(im_gris,nb_bins)\n",
    "im_eq_histo, im_bins = exposure.histogram( im_eq, nb_bins )\n",
    "im_eq_cumul, im_cumul_bins = exposure.cumulative_distribution( im_eq, nb_bins )\n",
    "\n",
    "# Affichage\n",
    "plt.figure()\n",
    "plt.subplot(321)\n",
    "plt.imshow(im_gris, cmap=plt.cm.gray)\n",
    "plt.title(\"image de départ\")\n",
    "\n",
    "plt.subplot(322)\n",
    "plt.imshow(im_eq, cmap=plt.cm.gray)\n",
    "plt.title(\"image egalisée\")\n",
    "\n",
    "plt.subplot(323)\n",
    "plt.bar(np.arange(im_gris_histo.size), im_gris_histo)\n",
    "plt.title(\"histogramme\")\n",
    "\n",
    "plt.subplot(324)\n",
    "plt.bar(np.arange(im_eq_histo.size), im_eq_histo)\n",
    "plt.title(\"histogramme\")\n",
    "\n",
    "plt.subplot(325)\n",
    "plt.bar(np.arange(im_gris_cumul.size), im_gris_cumul )\n",
    "plt.title(\"histogramme cumulé\")\n",
    "\n",
    "plt.subplot(326)\n",
    "plt.bar(np.arange(im_eq_cumul.size), im_eq_cumul )\n",
    "plt.title(\"histogramme cumulé\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 12**: Pourquoi l'histogramme après égalisation n'est il pas tout à fait plat ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 12:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 13:** Est-il correct d'affirmer que cette transformation s'écrit sous la forme $I_{sortie}(x,y)=transformation(I_{entree}(x,y))$ ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 13:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 15:** La transformation est-elle linéaire ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 15:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 16:** S'adapte-t-elle automatiquement à l'image traitée ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 16:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 17:** Selon vous, quels sont les contenus d'images pour lesquels l'égalisation d'histogramme est très (ou très peu) efficace ? Tentez d'en trouver sur le web et de leur appliquer l'algorithme d'égalisation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 17:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Agrandissement d'image\n",
    "\n",
    "La numérisation des images procède à une discrétisation spatiale, en posant une grille discrète de pixels sur une réalité initialement continue. De nombreuses tâches ont besoin de déterminer l'intensité de l'image en des coordonnées \"non entières\". Pour estimer cette intensité, on s'appuie souvent sur une hypothèse sur la fonction \"luminance\": sa continuité, continuité de sa dérivée, etc.\n",
    "\n",
    "Le script ci-dessous agrandit une image selon deux méthodes : réplication et interpolation bilinéaire."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "text/plain": "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …",
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "49e6dd90320a4b7dac4d36bb31e43a33"
      }
     },
     "metadata": {}
    },
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": "Text(0.5, 1.0, 'Interpolation bilinéaire')"
     },
     "metadata": {},
     "execution_count": 15
    }
   ],
   "source": [
    "plt.rcParams['image.interpolation'] = 'nearest' # pour ne par faire d'interpolation lors du zoom sur les figures \n",
    "# Chargement de l'image\n",
    "im = io.imread('talvi.jpg') # Expérimenter avec d'autres images\n",
    "im_gris=color.rgb2grey(im)*255\n",
    "\n",
    "largeur = im_gris.shape[1]\n",
    "hauteur = im_gris.shape[0]\n",
    "\n",
    "# Réplication\n",
    "im_2x_replic = np.zeros( (hauteur*2,largeur*2) )\n",
    "\n",
    "for y in range(0, hauteur):\n",
    "    for x in range(0, largeur):\n",
    "        xx=2*x\n",
    "        yy=2*y\n",
    "        \n",
    "        im_2x_replic[yy][xx] = im_gris[y][x]\n",
    "        im_2x_replic[yy][xx+1] = im_gris[y][x]\n",
    "        im_2x_replic[yy+1][xx] = im_gris[y][x]\n",
    "        im_2x_replic[yy+1][xx+1] = im_gris[y][x]\n",
    "        \n",
    "# Interpolation bilinéaire\n",
    "im_2x_bilin = np.zeros( (hauteur*2,largeur*2) )\n",
    "\n",
    "for y in range(0, hauteur-1):\n",
    "    for x in range(0, largeur-1):\n",
    "        xx=2*x\n",
    "        yy=2*y\n",
    "        \n",
    "        im_2x_bilin[yy][xx] = im_gris[y][x]\n",
    "        im_2x_bilin[yy][xx+1] = 0.5*(im_gris[y][x]+im_gris[y][x+1])\n",
    "        im_2x_bilin[yy+1][xx] = 0.5*(im_gris[y][x]+im_gris[y+1][x])\n",
    "        im_2x_bilin[yy+1][xx+1] = 0.25*(im_gris[y][x]+im_gris[y][x+1]+im_gris[y+1][x]+im_gris[y+1][x+1])\n",
    "        \n",
    "# Affichage\n",
    "plt.figure()\n",
    "\n",
    "plt.subplot(121)\n",
    "plt.imshow(im_2x_replic, cmap=plt.cm.gray)\n",
    "plt.title(\"Réplication\")\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.imshow(im_2x_bilin, cmap=plt.cm.gray)\n",
    "plt.title(\"Interpolation bilinéaire\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 18**: Comparez la complexité algorithmique des deux méthodes et leur rendu visuel (zoomez sur des parties bien contrastées de l'image)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Réponse 18:** VOTRE REPONSE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 19**: Comment faire une interpolation bilinéaire pour un zoom d'un facteur plus élevé que 2 ? (proposez une modification de l'algorithm initial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# VOTRE CODE ICI"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 20**: Comment réduire par 2 les dimensions d'une image ? (proposez et mettez en oeuvre deux méthodes : l'une naive, et l'autre prenant en compte les considérations spectrales vues en traitement du signal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# VOTRE CODE ICI"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3.8.5 64-bit",
   "language": "python",
   "name": "python_defaultSpec_1599038455849"
  },
  "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-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}