{
 "cells": [
  {
   "attachments": {
    "Entete.png": {
     "image/png": "[encoded data, 26904 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Entete.png](attachment:Entete.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center> <font color=\"#595959\" size=\"28\"><b>CODAGE DES IMAGES NUMERIQUES</b></font></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>"
   ]
  },
  {
   "attachments": {
    "prog.PNG": {
     "image/png": "[encoded data, 42552 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![prog.PNG](attachment:prog.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>"
   ]
  },
  {
   "attachments": {
    "APN.jpg": {
     "image/jpeg": "[encoded data, 22468 characters]"
    },
    "mavica.jpg": {
     "image/jpeg": "[encoded data, 22428 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">En **1969**, invention du capteur CCD (Charge Couple Device) par deux ingénieurs des Laboratoires BELL, **George Elwood Smith** et **William Boyle**, ce qui leur vaudra de se partager le **prix Nobel de physique en 2009**.\n",
    ">\n",
    ">En **1975** un ingénieur de Kodak, **Steven Sasson**, met au point le premier appareil photo électronique, un prototype de **3,6 kg** qui capture des images de **100×100 points en N&B**. L’enregistrement d’une photo sur une bande magnétique en cassette prend **23 s**.\n",
    ">\n",
    ">![APN.jpg](attachment:APN.jpg)\n",
    ">\n",
    ">En août **1981**, Sony présente le **MAVICA** (Magnetic Video Camera), qui stocke 50 images couleur de **490 × 570 points** au format NTSC, lisible sur un téléviseur.\n",
    ">\n",
    ">![mavica.jpg](attachment:mavica.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ## 1 – IMAGES NUMERIQUES"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une image numérique est formée d'un **tableau de points** ou **pixels**. Plus la densité des points est élevée, plus le nombre d'informations est grand et plus la résolution de l'image est élevée. La place occupée en mémoire et la durée de traitement en seront d'autant plus grandes. Les images vues sur un écran de télévision ou une photographie sont des images matricielles. On obtient également des images matricielles à l'aide d'un appareil photo numérique, d'une caméra vidéo numérique ou d'un scanner.\n",
    "\n",
    "L’image est divisée en (**m colonnes x n lignes**) cellules appelées **pixel** (**Picture Elément**).\n",
    "\n",
    "Chaque pixel est lui-même composé de trois composantes : **Rouge**, **Verte** et **Bleue**. Pour comprendre comment représenter les images en couleurs, il faut d’abord s’intéresser à la manière dont notre œil perçoit les couleurs. Notre œil contient des cellules, les cônes, qui sont sensibles à la couleur, c’est-à-dire à la longueur d’onde, de la lumière qu’ils reçoivent. Ces cônes sont de trois sortes, dont le maximum de sensibilité est respectivement dans le rouge (560 nm), le vert (530 nm) et le bleu (424 nm)."
   ]
  },
  {
   "attachments": {
    "image.PNG": {
     "image/png": "[encoded data, 122616 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.PNG](attachment:image.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 – CODAGE DES COULEURS"
   ]
  },
  {
   "attachments": {
    "rgb.PNG": {
     "image/png": "[encoded data, 19060 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il existe plusieurs **modes de codage des couleurs** d’une image numérique, le plus utilisé pour le maniement des images est l'espace colorimétrique **RGB** (**Red Green Blue**) ou **RVB** (**Rouge Vert Bleu**) par synthèse additive. Une image RGB est composée de la **somme des trois rayonnements lumineux** Rouge, Vert, Bleu dont les faisceaux sont superposés. A **l'intensité maximale** ils produisent une **lumière blanche**. \n",
    "\n",
    "![rgb.PNG](attachment:rgb.PNG)\n",
    "\n",
    "Dans une image au format RGB chaque pixel est composé d’un triplet de nombres entiers R, G, et B où :\n",
    "- l’entier R compris entre 0 et 255 représente le niveau de rouge ;\n",
    "- l’entier G compris entre 0 et 255 représente le niveau de vert (green en anglais) ;\n",
    "- l’entier B compris entre 0 et 255 représente le niveau de bleu."
   ]
  },
  {
   "attachments": {
    "couleursRGB.PNG": {
     "image/png": "[encoded data, 72472 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une couleur RGB peut donc être représenter par le **triplet (R, G, B)** ou bien dans certains cas par un **code hexadécimal : #RRVVBB** dans lequel chaque couleur est représentée par deux caractères hexadécimaux :\n",
    "\n",
    "![couleursRGB.PNG](attachment:couleursRGB.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chacune de ces composantes R, G et B est **codée sur un octet**. Il faut donc **3 octets pour coder un pixel**. On parle aussi de **système couleur 24 bits**.\n",
    "\n",
    "Une image numérique RVB est représentée par **3 tableaux à 2 dimensions** dont la taille dépend du nombre de pixels contenus dans l’image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercice 1 :**<br>\n",
    ">\n",
    ">Soit une image de 800 x 600 codée en mode RGB.\n",
    ">\n",
    ">**1. Donner** le nombre maximum de couleurs possibles pour un pixel.<br>\n",
    ">**2. Déterminer** le nombre de pixels composant cette image.<br>\n",
    ">**3. Calculer** le poids mémoire de cette image en Ko."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Réponses :**<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercice 2 :**<br>\n",
    ">\n",
    ">**1. Prendre** une image avec votre téléphone portable.<br>\n",
    ">**2. Donner** le format (extension), le nombre de pixels et le poids mémoire de cette image.<br>\n",
    ">**3. Calculer** son poids théorique et comparez au poids réel.<br>\n",
    ">**4. En déduire** le taux de compression.<br>\n",
    ">**5. Réaliser** plusieurs clichés (image contrastée, surface uniforme) et comparez les poids obtenus.<br>\n",
    ">**6. Chercher** sur le web et **compléter** les caractéristiques des formats **GIF**, **PNG**, **JPEG** et **BPM**.<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Réponses :**<br>\n",
    ">\n",
    ">1.\n",
    ">\n",
    ">2.\n",
    ">\n",
    ">3.\n",
    ">\n",
    ">4.\n",
    ">\n",
    ">5.\n",
    ">\n",
    ">6.\n",
    ">- **GIF**<br>\n",
    ">  **Nombre de couleurs** :<br>\n",
    ">\n",
    ">  **Description** :\n",
    "> <br>\n",
    ">- **PNG**<br>\n",
    ">  **Nombre de couleurs** :<br>\n",
    ">\n",
    ">  **Description** :\n",
    "> <br>\n",
    ">- **JPG**<br>\n",
    ">  **Nombre de couleurs** :<br>\n",
    ">\n",
    ">  **Description** :\n",
    "> <br>\n",
    ">- **BMP**<br>\n",
    ">  **Nombre de couleurs** :<br>\n",
    "> \n",
    ">  **Description** :"
   ]
  },
  {
   "attachments": {
    "modes-3.PNG": {
     "image/png": "[encoded data, 35256 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Afin d’illustrer ce codage RGB des couleurs, vous allez construire une image dont vous pourrez faire varier à souhait la couleur. Pour cela vous allez utiliser le **module PIL** (**librairie Pillow**) qui est une bibliothèque python permettant la **manipulation des images**.\n",
    "\n",
    "La fonction `Image.new(mode, (colonne, ligne))` permet de créer un image en choisissant le **mode de codage des couleurs** et les dimensions de l’image. Parmi les différents modes on trouve :\n",
    "![modes-3.PNG](attachment:modes-3.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le module PIL (librairie Pillow) est une bibliothèque python permettant la **manipulation des images**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercice 3 :**<br>\n",
    ">\n",
    ">**1. Vérifier** que le module PIL est fonctionnel en éxécutant la ligne suivante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import PIL"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**2. Editer** le code ci-dessous puis **tester** le."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "def nouvelle_image():\n",
    "    colonne, ligne = 250, 150\n",
    "    image = Image.new('RGB', (colonne, ligne))      # Création d'une image RGB\n",
    "    for x in range(colonne):\n",
    "        for y in range (ligne):\n",
    "            image.putpixel((x, y), (120, 200, 90))  # Couleur pixel en (x, y)\n",
    "    image.show()                        # Affichage de l'image\n",
    "    image.save('photo1.jpeg', 'jpeg') \n",
    "nouvelle_image()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**4. Donner** le nombre de pixels qui constituent cette image.<br>\n",
    ">**5. Donner** les valeurs des composantes R, G et B. **Justifier** la couleur de l’image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Réponses :**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**6. Modifier** le programme suivant afin d'obtenir une image en dégradée de rouge. **Tester** le."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#solution dégradé de rouge sur colonne\n",
    "from PIL import Image\n",
    "\n",
    "def nouvelle_image():\n",
    "    colonne, ligne = 250, 150\n",
    "    R = ............                                         # Composante rouge initialisée à 0\n",
    "    image = Image.new('RGB', (colonne, ligne))\n",
    "    for x in range(colonne):\n",
    "        R =  ............                                    # On incrémente R de 1\n",
    "        for y in range(ligne):\n",
    "            image.putpixel((x, y), (......  , ...... , ......))\n",
    "    image.show()\n",
    "    image.save('photo2.jpeg', 'jpeg') \n",
    "nouvelle_image()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 - IMAGES NUMERIQUES EN NOIR ET BLANC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans une image numérique en **noir et blanc** ou **monochrome**, chaque pixel ne possède que **deux couleur**s : noir et blanc. Chaque pixel est alors **codé sur 1 bit**.\n",
    "\n",
    "Pour obtenir une image en noir et blanc à partir d’une image RGB, il faut effectuer un **seuillage**. Pour ce faire, nous choisissons un seuil (par exemple **`127`**).\n",
    "- Si une des trois composantes dépasse la valeur du seuil, le pixel prendra la couleur blanche. Si un pixel possède par exemple le triplet **`(202, 186, 210)`**, il faut le remplacer par **`1`**.\n",
    "- Sinon le pixel prendra la couleur noire. Si un pixel possède par exemple le triplet **`(123, 74, 210)`**, il faut le remplacer par **`0`**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode `img.getpixel((x, y))` permet de récupérer le triplet (R, G, B) du pixel `(x, y)`. La méthode `img.putpixel((x, y), couleur)` permet de modifier la couleur du pixel `(x, y)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercice 4 :**<br>\n",
    ">\n",
    "> **Compléter** et **éditer** le script ci-dessous qui permet de modifier l'image `pont.jpg` (ce fichier a été attaché au Notebook) en une image en Noir et Blanc. **Tester** le."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "img_RGB = Image.open('pont.jpg')\n",
    "col, lig = img_RGB.size                         # dimensions de l’image RGB \n",
    "img_NB = Image.new(......, (col, lig))        # création d'une image NB\n",
    "for x in range(col):\n",
    "    for y in range (lig):\n",
    "        R, G, B = img_RGB.getpixel((x, y))      # On récupère le triplet (R, G, B)\n",
    "        if ............................................. :\n",
    "            img_NB.putpixel((x, y), ......)       # On place le pixel en blanc\n",
    "        else: \n",
    "            img_NB.putpixel((x, y),......)       # On place le pixel en noir\n",
    "img.save('photoNB.jpeg', 'jpeg') \n",
    "img_NB.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 - IMAGES NUMERIQUES EN NIVEAUX DE GRIS"
   ]
  },
  {
   "attachments": {
    "niveauxG.PNG": {
     "image/png": "[encoded data, 15408 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce type d’images la couleur est **codée sur un octet** (**256 valeurs**) :\n",
    "\n",
    "![niveauxG.PNG](attachment:niveauxG.PNG)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour passer d’une image couleur RGB à une image en niveau de gris, on utilise la formule : **Gris = 0,299 × R + 0,587 × G + 0,114 × B** \n",
    "\n",
    "Une image numérique en niveau de gris est représentée par 1 tableau à 2 dimensions dont la taille dépend du nombre de pixels contenus dans l’image avec la valeur de la couleur **Gris** étant un nombre entier compris entre **0 et 255**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercice 5 :**<br>\n",
    ">\n",
    "> **Compléter** et **éditer** le script ci-dessous qui permet de modifier l'image `pont.jpg` en une image en niveau de gris. **Tester** le."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "img_RGB = Image.open('pont.jpg')\n",
    "col, lig = img_RGB.size                     # dimensions de l’image RGB \n",
    "img_gris = Image.new(......, (col, lig))  # création d'une image niveaux gris\n",
    "for x in range(col):\n",
    "    for y in range (lig):\n",
    "        R, G, B = img_RGB.getpixel((x, y)) \t# On récupère le triplet (R, G, B)\n",
    "        gris = ................................................ # calcul niveau de gris\n",
    "        img_gris.putpixel((x, y), ......)        # On mofidie la couleur du pixel\n",
    "img.save('photoGris.jpeg', 'jpeg') \n",
    "img_gris.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7 - EFFET MIROIR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercice 6 :**<br>\n",
    ">\n",
    "> **1. Exécuter** le programme ci-dessous. **Indiquer** quelle modification a été apportée à l’image."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "img = Image.open('pont.jpg')\n",
    "col, lig = img.size\n",
    "img_mod = Image.new('RGB', (col, lig)) \t      # Création image RGB\n",
    "\n",
    "for x in range (lig):                         # On va parcourir toutes les lignes\n",
    "    for y in range(col):                      # Pour chaque ligne, on va parcourir toutes les colonnes\n",
    "        pixel = img.getpixel((y, x))          # On récupère le triplet (R, G, B) \n",
    "        img_mod.putpixel((col - 1 - y, lig - 1 - x), pixel)\n",
    "img.save('photoRotation.jpeg', 'jpeg') \n",
    "img_mod.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Réponse :**<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **2. Compléter** le programme ci-dessous permettant d'effectuer un effet miroir."
   ]
  },
  {
   "attachments": {
    "pontMiroir.jpg": {
     "image/jpeg": "[encoded data, 30820 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![pontMiroir.jpg](attachment:pontMiroir.jpg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "\n",
    "img = Image.open('pont.jpg')\n",
    "col, lig = img.size\n",
    "img_mod = Image.new('RGB', (col, lig))            #création image RGB\n",
    "\n",
    "for x in range (lig):                          # On va parcourir toutes les lignes\n",
    "    for y in range(col):                       # Pour chaque ligne, on va parcourir toutes les colonnes\n",
    "        pixel = img.getpixel((y, x))           # On récupère le triplet (R, G, B) \n",
    "        ..........................................................  # On modifie le pixel\n",
    "img.save('photoMiroir.jpeg', 'jpeg') \n",
    "img_mod.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8 - METADONNEES EXIF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un fichier \"image\" issu d'un appareil photo numérique contient plus qu'une simple image. On trouve en effet des informations sur l'image elle-même (définition, résolution...) mais aussi des informations sur la prise de vue (date et heure, lieu...). Cette spécification des fichiers \"image\" d'un appareil photo numérique s'appelle **EXIF (EXchangeable Image file Format)**. Ces données contenues dans un fichier \"image\" d'un appareil photo s'appellent des **métadonnées**.\n",
    "\n",
    "La plupart des logiciels de retouche photo permettent de lire ces métadonnées. Nous n'allons pas utiliser ce type de logiciel, nous allons plutôt écrire un petit programme Python (plus précisément, nous utiliserons la bibliothèque Python \"PIL\")."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Exercice 7 :**<br>\n",
    ">\n",
    "> **1. Exécuter** le programme ci-dessous :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import PIL.Image\n",
    "img = PIL.Image.open('lieumystere.jpg')\n",
    "exif_data = img._getexif()\n",
    "exif_data"
   ]
  },
  {
   "attachments": {
    "Exif-3.png": {
     "image/png": "[encoded data, 32672 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comme vous pouvez le constater, nous avons un système clé:valeur (à chaque clé correspond une valeur). Les clés sont \"codées\" par des nombres, pour comprendre la signification de ces nombres, consultez le site http://www.exiv2.org/tags.html.\n",
    "![Exif-3.png](attachment:Exif-3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **2.**\tEn vous aidant du site web cité ci-dessus, **donner** les informations suivantes pour l'image `lieumystere.jpg` :\n",
    "> - la largeur de l'image en pixel\n",
    "> - la hauteur de l'image en pixel\n",
    "> - le fabricant du matériel\n",
    "> - la date et l'heure de la prise de vue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Réponses :**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>"
   ]
  },
  {
   "attachments": {
    "exif_GPS-2.PNG": {
     "image/png": "[encoded data, 35544 characters]"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**La clé \"34853\"** n'est pas tout le temps présente puisqu'il s'agit des coordonnées (latitude, longitude) de la prise de vue, il faut donc que l'appareil photo intègre un GPS (ce qui est le cas des smartphones).\n",
    "![exif_GPS-2.PNG](attachment:exif_GPS-2.PNG)\n",
    "\n",
    "**Les lignes 1, 2, 3 et 4 vont particulièrement nous intéresser :**\n",
    "\n",
    "- Ligne 1 : Précise que nous sommes dans l'hémisphère Nord\n",
    "- Ligne 2 : Nous avons la latitude (45.0, 33.0, 18.330688) exprimée ici en latitude en degrés, minute, seconde\n",
    "- Ligne 3 : Précise que nous sommes à l'ouest (W) du méridien de Greenwich\n",
    "- Ligne 4 : Nous avons la longitude (0.0, 57.0, 23.080258) exprimée ici en degrés, minute, seconde\n",
    "\n",
    "Pour convertir des \"degrés, minute, seconde\" aussi noté DMS en \"degrés décimaux\" (DD) qui est l'unité qui est utilisée en \"cartographie\", il faut appliquer la formule suivante :"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "DD = degres+(minute/60)+(seconde/3600)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "> **3. Determiner** les coordonnées DD du lieu où a été prise la phto mystère."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Lattitude =\n",
    "Lattitude"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Longitude =\n",
    "Longitude"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ATTENTION : pour que la conversion soit correcte, il faut ajouter un signe moins devant la longitude au format DD si nous\n",
    "sommes situés à l'ouest du méridien de Greenwich. De même la lattitude est négative dans l'hémisphère sud.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **4. Tester** les lignes de code suivantes qui permettent d'afficher les coordonnées GPS du lycée Gustave Eiffel sur une carte. La carte est enregistrée dans le fichier `maCarte.html`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Exemple\n",
    "import folium\n",
    "#Affiche une carte \n",
    "maps = folium.Map(location=[44.82910801, -0.56478487], zoom_start = 17)\n",
    "#Affiche un marqueur\n",
    "folium.Marker([44.82910801, -0.56478487]).add_to(maps)\n",
    "\n",
    "maps.save('maCarte.html') #permet de générer la page HTML\n",
    "maps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**5. Compléter** le programme ci-dessous afin d'afficher sur une carte l'emplacement du lieu où a été prise la photo mystère."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import folium\n",
    "#Affiche une carte \n",
    "maps = folium.Map(location = [..........................., ...........................], zoom_start = 17)     \n",
    "#Affiche un marqueur\n",
    "folium.Marker([..........................., ...........................]).add_to(maps)\n",
    "\n",
    "#permet de générer la page HTML\n",
    "maps.save('CartePhotoMystere.html')\n",
    "maps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**6. Indiquer** où se trouve le lieu de la photo mystère."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Réponse :**"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
