a_la_facon_d_Andy_Warhol_terminale.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# À la façon d'Andy Warhol - 3\n",
    "\n",
    "L'activité suivante complète les activités de seconde et première situées dans le même dossier.\n",
    "\n",
    "Il peut être nécessaire de revoir ces activités avant d'aborder celle-ci."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On commence par importer toutes les bibliothèques nécessaires :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# installation de pillow\n",
    "import sys\n",
    "!{sys.executable} -m pip install pillow\n",
    "# puis importation du module Image\n",
    "from PIL import Image\n",
    "# utilisation de widgets pour une disposition en ligne des images\n",
    "import ipywidgets as widgets\n",
    "# utilisation de io pour conversion des images\n",
    "import io\n",
    "# utilisation de chemin normalisé vers les fichiers du système\n",
    "import os.path as path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " La classe `Image` du module `Image` contient [une méthode `split`](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.Image.split) qui renvoie un tuple d'images correspondant aux canaux la composant :\n",
    " \n",
    " - une image de type `RGB` est composée de 3 canaux (Rouge, Vert et Bleu)\n",
    " - une image de type `RGBA` est composée de 4 canaux (Rouge, Vert, Bleu et Transparence)\n",
    " - une image `L` est composée d'un seul canal (niveau de gris)\n",
    " - etc.\n",
    " \n",
    "[Voir les différents types](https://pillow.readthedocs.io/en/stable/handbook/concepts.html#concept-modes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fichier_image = path.join('images', 'boole.jpg')\n",
    "img = Image.open(fichier_image)\n",
    "\n",
    "img.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode `split`, n'exprimant qu'un seul canal, renvoie une image de type `L`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "position = (0, 0)\n",
    "\n",
    "print(f\"Le pixel haut gauche de l'image de départ contient {img.getpixel(position)}\")\n",
    "\n",
    "for i, couleur in enumerate(['rouge', 'vert', 'bleu']):\n",
    "    print(f\"Le pixel haut gauche du canal {couleur} de \\\n",
    "l'image de départ contient {img.split()[i].getpixel(position)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut alors utiliser la méthode des `widgets` vue précédemment qu'on transforme en fonctions renvoyant la boite à afficher :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def conversion_widget(image, format=\"jpeg\"):\n",
    "    \"\"\"renvoie un widget IPython/Jupyter contenant l'image à afficher\"\"\"\n",
    "    img_byte_arr = io.BytesIO()\n",
    "    image.save(img_byte_arr, format=format)\n",
    "    img_byte_arr = img_byte_arr.getvalue()\n",
    "    return widgets.Image(value=img_byte_arr)\n",
    "\n",
    "def boiteNB_images_rvb(image):\n",
    "    \"\"\"renvoie un widget HBox contenant les images NB issues des canaux de l'image\"\"\"\n",
    "    wid = []\n",
    "    for im in image.split():\n",
    "        wid.append(conversion_widget(im))\n",
    "    return widgets.HBox(wid)\n",
    "    \n",
    "display(boiteNB_images_rvb(img))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut constater que les images sont en noir et blanc (enfin plutôt en nuances de gris) et ne sont pas les mêmes puisque chacune est l'expression d'une couleur différente. Pour permettre l'identification des images par leur couleur d'origine, on peut les coloriser grâce à la fonction de classe [merge](https://pillow.readthedocs.io/en/stable/reference/Image.html#PIL.Image.merge).\n",
    "\n",
    "Pour ne pas exprimer les deux autres canaux, on crée une image vide (avec des 0) ayant la même dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def coloriser_image_L(L_image, numero_canal):\n",
    "    image_vide = Image.new(\"L\", L_image.size, \"black\")\n",
    "    canaux = [image_vide, image_vide, image_vide]\n",
    "    # on exprime le canal souhaité\n",
    "    canaux[numero_canal] = L_image\n",
    "    return Image.merge(\"RGB\", tuple(canaux))\n",
    "\n",
    "\n",
    "def boite_images_rvb(image):\n",
    "    \"\"\"renvoie un widget HBox contenant les images couleurs issues des canaux de l'image\"\"\"\n",
    "    wid = []\n",
    "    for n_canal, im in enumerate(image.split()):\n",
    "        im_colorise = coloriser_image_L(im, n_canal)\n",
    "        wid.append(conversion_widget(im_colorise))\n",
    "    return widgets.HBox(wid)\n",
    "    \n",
    "display(boite_images_rvb(img))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On constate que mettre du rouge sur l'image NB exprimant le rouge est tout à fait artificiel : on aurait bien pu la coloriser dans une autre couleur.\n",
    "\n",
    "Certains satellites produisent des images sur des bandes invisibles à l'oeil, c'est la cas des satellites européens [Pléiades](https://fr.wikipedia.org/wiki/Pl%C3%A9iades_(satellite)) qui intègre un capteur **infra-rouge** :\n",
    "\n",
    "![](infrarouge.png)\n",
    "\n",
    "Pour rendre compte *visiblement* de ce canal, les ingénieurs peuvent voir simplement une image NB ou alors ils rréorganisent les canaux des images en remplaçant le canal rouge par le canal infra-rouge : ainsi le rouge exprime l'infra-rouge.\n",
    "\n",
    "C'est le cas dans cette image :\n",
    "\n",
    "![](remplacement.png)\n",
    "\n",
    "\n",
    "[issue de ce site](https://e-cours.univ-paris1.fr/modules/uved/envcal/html/compositions-colorees/3-differentes-composition-coloree/2-1-vraie-fausse-couleur%20.html).\n",
    "\n",
    "L'infra-rouge permet notamment de détecter sur la Terre les zones humides et de différencier les natures de sols. Ce canal est aussi utilisé en astro-photographie. Les photographes amateurs de ce genre de photographie modifie leur appareil (à leurs risques et périls) pour pouvoir enregister ce canal. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On écrit alors à partir de la fonction `coloriser_image` une fonction`fusion_canaux` qui fusionne les canaux demandés :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fusion_canaux(image, liste_canaux):\n",
    "    canaux = image.split()\n",
    "    image_vide = Image.new(\"L\", image.size, \"black\")\n",
    "    canaux_voulus = [image_vide, image_vide, image_vide]\n",
    "    for canal in liste_canaux:\n",
    "        canaux_voulus[canal] = canaux[canal]\n",
    "    return Image.merge(\"RGB\", tuple(canaux_voulus))\n",
    "\n",
    "display(fusion_canaux(img, [1]))\n",
    "display(fusion_canaux(img, [0, 1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sur le modèle de la fonction `boite_image_rvb`, on définit la fonction `boite_image` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def boite_images(image, liste_canaux):\n",
    "    \"\"\"renvoie un widget HBox contenant les images couleurs issues des canaux de l'image\"\"\"\n",
    "    wid = []\n",
    "    \n",
    "    for liste in liste_canaux:\n",
    "        im = fusion_canaux(image, liste)\n",
    "        wid.append(conversion_widget(im))\n",
    "    return widgets.HBox(wid)\n",
    "\n",
    "display(boite_images(img, [[0], [1], [2]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On termine avec un affichage d'images en 3 x 3 (3 en largeur et 3 en hauteur).\n",
    "\n",
    "Sur le même pricipe vue avec le widget `HBox`, on peut empiler verticalement avec un widget `VBox`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def matrice_images(image, liste_canaux):\n",
    "    wid = []\n",
    "    \n",
    "    liste_canaux = [liste_canaux[i:i + 3] for i in range(0, len(liste_canaux), 3)]\n",
    "    for liste in liste_canaux:\n",
    "        wid.append(boite_images(image, liste))\n",
    "    return widgets.VBox(wid)\n",
    "    \n",
    "canaux_voulus = [[0], [1], [0, 1], [1], [2], [1, 2], [2], [0], [2, 0]]\n",
    "display(matrice_images(img, canaux_voulus))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.9.1+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}