{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![En tête](img/En_tete_general.png)\n",
    "\n",
    "\n",
    "*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*\n",
    "\n",
    "<span style=\"color: #9317B4\"> Pour exécuter une saisie Python, sélectionner la cellule et valider avec </span><span style=\"color: #B317B4\"><strong>SHIFT+Entrée</strong></span>.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Applications de filtres sur une image\n",
    "\n",
    "### Activité sur le traitement d'images n°1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le but de cette activité est de programmer et d'appliquer des <strong>filtres</strong> sur des images :<br>\n",
    "L'application d'un filtre consiste à transformer une image en modifiant les composantes R,G,B de chacun de ses pixels.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<strong>1. Exécuter la cellule ci-dessous, qui permet :\n",
    "- d'ouvrir un fichier et de stocker l'image dans un objet Python de type Image;\n",
    "- d'afficher le format, le type de codage et la dimension de l'image;\n",
    "- d'afficher l'image.</strong>\n",
    "\n",
    "NB: Vous pouvez réexécuter la cellule pour obtenir une autre image (choix aléatoire dans une bibliothèque d'images de la ville de Strasbourg)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# import du module permettant la gestion des images\n",
    "from PIL import Image\n",
    "\n",
    "#ouverture de l'image\n",
    "from random import randint\n",
    "Strasbourg = Image.open('img/Strasbourg/Strasbourg'+str(randint(1,10))+'.jpg')\n",
    "\n",
    "#affichage du format, du type et de la dimension de l'image\n",
    "print(\"Format:\",Strasbourg.format,\"\\nMode:\",Strasbourg.mode,\"\\nDimensions:\",Strasbourg.size) ; \n",
    "\n",
    "#affichage de l'image\n",
    "Strasbourg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__2. Pour éclaircir une image, on peut augmenter de 50% les composantes couleurs de chaque pixel.__<br><br>\n",
    "$\\;\\;\\;$__a. Suivre la vidéo suivante, qui détaille la fonction Python <mark>eclaircissement</mark> donnée ci-dessous.__<br><br>\n",
    "\n",
    "\n",
    "<video controls src=\"video/Traitement_image_filtre.mp4\" width=\"960\" height=\"540\" />\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\;\\;\\;$__b. Exécuter les deux cellules ci-dessous, pour appliquer la fonction <mark>eclaircissement</mark> à l'image <mark>Strasbourg</mark>.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def eclaircissement(im_originale):\n",
    "    \"\"\"\n",
    "    fonction qui renvoie l'image im_originale éclaircie\n",
    "    \"\"\"\n",
    "        \n",
    "    # récupération des dimensions de l'image originale\n",
    "    L,H = im_originale.size\n",
    "    \n",
    "    # création d'une image vierge, de même format et même dimension que l'image initiale\n",
    "    im_modifiee = Image.new( mode=im_originale.mode , size=(L,H) )\n",
    "    \n",
    "    # ouverture de l'accès aux pixels des deux images \n",
    "    pix_origine = im_originale.load()\n",
    "    pix_modifie = im_modifiee.load()\n",
    "    \n",
    "    # on parcourt tous les pixels des images\n",
    "    for x in range(L):\n",
    "        for y in range(H):\n",
    "            R,G,B = pix_origine[x,y] #récupération des composantes R,G,B du pixel original\n",
    "            \n",
    "            R = int(R*1.5)\n",
    "            G = int(G*1.5)\n",
    "            B = int(B*1.5)\n",
    "            \n",
    "            pix_modifie[x,y] = R,G,B #écriture des composantes R,G,B du pixel modifié\n",
    "    \n",
    "    # on renvoie l'image modifiée\n",
    "    return im_modifiee\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eclaircissement(Strasbourg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__3. Pour assombrir une image, on peut diminuer de 50% les composantes couleurs de l'image d'origine.__<br>\n",
    "$\\;\\;\\;$__Écrire une fonction Python <mark>assombrissement</mark> qui permet d'assombrir une image, puis tester cette fonction.__<br>\n",
    "$\\;\\;\\;$Aide : On pourra commencer par effectuer un copier/coller de la fonction <mark>eclaircissement</mark> puis l'adapter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ecrire ici la fonction assombrissement\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction assombrissement\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__4. Le principe du filtre rouge consiste à conserver les composantes rouges des pixels de l'image et à remplacer les autres par $0$.__<br><br>\n",
    "$\\;\\;\\;$__a. Écrire une fonction Python <mark>filtre_R</mark> qui applique le filtre rouge à une image, puis tester cette fonction.__<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction filtre_R\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction filtre_R\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\;\\;\\;$__b. Écrire sur le même principe des fonctions Python <mark>filtre_G</mark> et <mark>filtre_B</mark> pour les filtres vert et bleu.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction filtre_G\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction filtre_G\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction filtre_B\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction filtre_B\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__5. Dans cette question, on souhaite convertir une image couleur en image en niveau de gris.__<br>\n",
    "$\\;\\;\\;$__En RGB, on obtient un pixel en niveau de gris lorsque ses 3 composantes couleur sont égales.__<br><br>\n",
    "$\\;\\;\\;$__a. Une première méthode consiste à remplacer chacune des composantes couleur d'un pixel par la moyenne des trois composantes initiales.__<br>\n",
    "$\\;\\;\\;\\;\\;\\;$__Écrire une fonction Python <mark>gris_rapide</mark> qui effectue cette conversion.__<br>\n",
    "$\\;\\;\\;\\;\\;\\;$__Tester cette fonction.__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction gris_rapide\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction gris_rapide\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$\\;\\;\\;$__b. La perception des composantes couleur par l'oeil humain diffère selon ces couleurs.__<br>\n",
    "$\\;\\;\\;\\;\\;\\;$__Ainsi, l'organisme CIE (Commission Internationale de l'Éclairage) préconise la méthode suivante pour convertir une image en niveau de gris :__<br>\n",
    "\n",
    "<p style='background-color:#E0EDF0;'>\n",
    "<strong style='color:#84B8C5;'>Conversion en niveau de gris :</strong><br>\n",
    "On attribue à chaque composante couleur la valeur obtenue en additionnant :<br>\n",
    "21,25% de la valeur de la composante rouge initiale;<br>\n",
    "71,54% de la valeur de la composante verte;<br>\n",
    "7,21% de la valeur de la composante bleue.\n",
    "</p>\n",
    "<br>\n",
    "\n",
    "$\\;\\;\\;\\;\\;\\;$__Écrire une fonction Python <mark>gris_precis</mark> qui réalise cette conversion.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction gris_precis\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction gris_precis\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__6. Pour obtenir le négatif d'une image, on remplace chaque composante de chaque pixel par la différence entre 255 et cette composante initiale.__<br>\n",
    "$\\;\\;\\;$__Écrire une fonction Python <mark>negatif</mark> qui renvoie le négatif d'une image.__<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction negatif\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction negatif\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__7. Dans cette question, on souhaite convertir l'image en noir et blanc (sans niveaux de gris).__<br><br>\n",
    "$\\;\\;\\;$__a. Rappeler les codes R,G,B correspondant respectivement au noir et au blanc.__<br>\n",
    "$\\;\\;\\;$__b. On décide qu'un pixel sera blanc si et seulement si la moyenne de ses composantes initiales est supérieure ou égale à 128.__<br>\n",
    "$\\;\\;\\;\\;\\;\\;$__Ecrire une fonction Python <mark>NB</mark> qui réalise cette transformation.__<br>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Écrire ici la fonction NB\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tester ici un appel à la fonction NB\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='background-color:#DDDDDD;'>\n",
    "Pour démarrer l'activité sur le traitement d'images n°2 (Composition d'images) : <a href=\"https://mybinder.org/v2/gh/PythonLycee/PyLyc/master?filepath=Traitement_images_2.ipynb\"> Cliquer ici </a>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*(C) Copyright Franck CHEVRIER 2019-2020 http://www.python-lycee.com/*\n"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}