Sortie_Volcan_V1.ipynb

{
 "cells": [
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Membre 1 :\n",
    "Membre 2 :\n",
    "Membre 3 :\n",
    "Membre 4 :\n",
    "\n",
    "Date :\n",
    "\n",
    "Classe :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">\n",
    "  <b>\n",
    "    <font size =\"+3\">\n",
    "     <u>SORTIE AU PITON DE LA FOURNAISE</u>\n",
    "    </font>\n",
    "  </b>\n",
    "</h1>\n",
    "<br/>\n",
    "<br/>\n",
    "<p align = \"justify\">\n",
    "    <i>Ce travail sur le Piton de la Fournaise sera l'occasion de faire de la géologie avec une approche de terrain, de \n",
    "       connaitre les grandes périodes de l'édification de la région du Volcan mais aussi de remobiliser les connaissances \n",
    "       acquises en SNT l'année dernière.\n",
    "    </i>\n",
    "    <br/>\n",
    "    <br/>\n",
    "    <b>Exécuter</b> le code Python de la cellule ci-dessous (\"ctrl+entrer\" au clavier en étant dans la cellule ou cliquer \n",
    "       sur \"Run\" dans la barre d'icônes).\n",
    "    <br/>\n",
    "   <i> NB: les élèments situés après \"#\" sont des annotations et ne sont pas pris en ligne de compte par le programme.</i>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Audio, Image, YouTubeVideo #cette ligne de code importe les librairie Python en lien avec \n",
    "                                                       #le traitement des fichiers vidéo, audio ou encore des vidéos \n",
    "                                                       #YouTube.\n",
    "import pandas  #importe la librairie qui va traiter les bases de données sous forme de frame"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 align=\"center\">\n",
    "  <b>\n",
    "    <font size =\"+2\">\n",
    "     <u>RAPPEL</u>\n",
    "    </font>\n",
    "  </b>\n",
    "</h2>\n",
    "<br/>\n",
    "<br/>\n",
    "<p>\n",
    "    <b>Exécuter</b> les codes Python des 2 cellules suivantes afin de visionner les vidéos Youtube et remobiliser certaines        notions vues ans les niveaux précedents (à réaliser avant la sortie).\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id = 'FpA0cgSucx4'                          #cette ligne indique le numéro de la vidéo (observable à la fin de l'URL).\n",
    "YouTubeVideo(id=id, width=640, height=480)  #ici,on définit la taille de la fenêtre d'affichage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "id = '8PMYjn838FA'\n",
    "YouTubeVideo(id=id, width=854, height=480)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3 align=\"center\">\n",
    "  <b>\n",
    "    <font size =\"+2\">\n",
    "     <u>INTRODUCTION</u>\n",
    "    </font>\n",
    "  </b>\n",
    "</h3>\n",
    "<p align=\"justify\">\n",
    "    La Réunion est un volcan bouclier dont base à 4000 m de profondeur (voir figure 1 et 2). Ses dimensions sont de 100 km de long sur 75 km de      \n",
    "    large.\n",
    "</p>\n",
    "<br/>\n",
    "<div align = \"center\">\n",
    "<figure>\n",
    "  <img src=\"https://jv0itg.am.files.1drv.com/y4mge-0Ouxbpg6RBZsh86Ctno5uAhEi2lf8bWP4v63_Cp6CmCArTew9rx8OJpC2ddHGRUwrinCUoUWAri0HZGuGPduo2W4UileeG8cLFOjqRCjCKBuwbZ6iB9YIMNbpGqdYECL3G500OE6xJDjEfdxTCYskyqE2fCzF5gGCqb55AyBtMFBwCfEg2FoeEwXXv0JUxS2F8BpqCPhGxSboelNPtg?width=348&height=339&cropmode=none\" width=\"348\" height=\"339\" />\n",
    "  <figcaption>Figure1. Carte bathymétrique générale de la Réunion (d'après JF. LENAT et Ph. LABAZUY 1990)</figcaption>\n",
    "</figure>\n",
    "</div>\n",
    "<br/>\n",
    "<div align = \"center\">\n",
    "  <figure>\n",
    "    <img src=\"https://91rqnq.am.files.1drv.com/y4mDaOhcd1MpnW24HkuP3hyg12jX2FSofeDfZxrNLrX5i-6cHduUd6EewFv431Ccvg7NtnIlqJJKxg7STfK8ermqqpm3-WOcKDzDFjNGBelE3aj53pI_a1iHlkJOgIvV1n--3GIJDlJrsVR3JmVY4HPPdVKyVyRNID99oJk7jmCF-GqDXyw2zkJSZyNvcPAQn7eJb0bCD6lpkF5FGRrqzVuyQ?width=657&height=195&cropmode=none\" width=\"657\" height=\"195\" />\n",
    "    <figcaption>Figure 2. Carte topographique NW-SE (AA') de l'île de la Réunion (d'après P. BACHELERY 1981)</figcaption>\n",
    "  </figure>\n",
    "</div>\n",
    "<br/>\n",
    "<p align=\"justify\">\n",
    "    La superficie de l’île est de 2512 km<sup>2</sup>. Elle est constituée de 2 massifs volcaniques (cf. figure 3) : \n",
    "<ul align=\"left\">\n",
    "<li>Le Piton  des Neiges (aujourd’hui endormi), à l’origine des 2/3 (en vert sur la figure 3) de l’île et dont l’altitude est de 3070 m</li>\n",
    "<li>Le Piton de la Fournaise qui a produit qui en a produit 1/3 (en marron sur la figure 3), avec une altitude de 2632 m</li>\n",
    "</ul>\n",
    "</p>\n",
    "<div align = \"center\">\n",
    "    <figure>\n",
    "      <img src=\"https://xozxpw.am.files.1drv.com/y4mJB4UiXLVpfWFOafKPS6i0W1SHSrsCOqhpP1hIxI3ykjgBV-hjprIw-QPkVr-d95jrS4p- \n",
    "       pgGGcbPLY8R3mmPR_epPUu8ak5v6BFIwu2_Cy37DqCYX4KdK0jFW-6uF9o_jgxC8uZs0Ypw_ZZt-1cdeClySn1zM6U71iskVidxZnBlvzpNZsrLTTAPUR \n",
    "       OlN0NQyi2dQKojMUamQt0gCZSc4w?width=568&height=298&cropmode=none\" width=\"568\" height=\"298\" />\n",
    "       <figcaption>Figure 3. Les édifices à l'origine de la Réunion (source : IGN-1997- modifié par le BRGM en 2005)</figcaption>\n",
    "    </figure>\n",
    "</div>\n",
    "<br/>\n",
    "<p align=\"justify\">\n",
    "    La base de l’ile est un bouclier mis en place entre -7 à -5 Ma. L’île émerge vers -3 Ma avec Piton des Neiges. Entre -1 Ma et – 450 ka, un volcan dont le centre      \n",
    "    d’émission devait se situer vers le Grand Brûlé entre en fonctionnement, le Piton des Alizés. Des traces de ce volcans sont retrouvées au large de l’Enclos. Le  \n",
    "    Piton de la Fournaise entre en action aux alentours de -450 ka. Ses productions vont recouvrir celles du Piton des Alizés. On découpe le fonctionnement de  \n",
    "    ce nouveau volcan en trois phases : la bouclier ancien, entre -450 ka à -150, la bouclier récent, entre -150 ka et -4,7 ka, puis la Fournaise actuelle. \n",
    "</P>\n",
    "<br/>\n",
    "<p align=\"justify\">\n",
    "    <b>\n",
    "       <font size =\"+1\">\n",
    "           Durant cette sortie, nous allons retracer les grands événements qui ont permis la construction de l’édifice volcanique actuellement actif, le Piton de la  \n",
    "           Fournaise. \n",
    "       </font>\n",
    "    </b>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3><u>Point de départ : le lycée Lislet Geoffroy</u></h3>\n",
    "<p><b>Objectif : localiser la position du lycée sur une carte numérique</b></p>\n",
    "\n",
    "<br/>\n",
    "<p align = \"justify\">\n",
    "    Comme l'année dernière, en SNT (Thème 5- géolocalisation), nous allons faire appel à <i>Open Street Map</i>. La cellule \n",
    "    ci-dessous va servir de rappel avec une carte de Paris qui vous est fammilière.\n",
    "    <br/>\n",
    "    <br/>\n",
    "    <b>Analyser</b> puis <b>éxécuter</b> le code Python de la cellule ci-dessous (\"ctrl+entrer\" au clavier ou cliquer sur         \"Run\" dans la barre d'icônes en étant dans la cellule).\n",
    "</p>   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import folium    # Importation de la bibliothèque folium qui contient des fonctions (méthodes) permettant d'agir \n",
    "                 # sur des cartes numériques\n",
    "\n",
    "carte_Paris = folium.Map(location=[48.85646, 2.34263], width='80%', height='80%', tiles=\"OpenStreetMap\", zoom_start=13) \n",
    "     # On créé une variable \"carte_Paris\" dans laquelle on stocke un fond de carte avec son centre correspondant \n",
    "     # aux coordonnées [Latitude, longitude]. \n",
    "     # On définit la taille du cadre et le zoom de départ.\n",
    "\n",
    "folium.Marker([48.85646, 2.34263],  # Création d'un marqueur au point de cordonnées [latitude, longitude]\n",
    "        popup=\"Centre geographique de Paris\", # Indication du contenu du marqueur - éviter les accents car non reconnus\n",
    "            icon=folium.Icon(color='blue')  # Attribution de la couleur, ici bleue\n",
    "                                       ).add_to(carte_Paris)  # Ajout du marqueur dans la variable \"carte_Paris\", \n",
    "                                                              #c'est à dire, la carte voulue\n",
    "\n",
    "carte_Paris # on affiche la carte\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align = \"justify\">\n",
    "    1. Selon le même principe, <b>créer</b>, à l'aide d'un code Python, une carte centrée sur le lycée (dont emplacement   \n",
    "    montré par un marqueur bleu) que vous stockerez dans la   \n",
    "    variable \"carte_Reunion\". Vous chercherez les coordonnées de l'établissement en utilisant le site\n",
    "    <a href=\"https://www.coordonnees-gps.fr/\">coordonnees-gps.fr</a> et/ou <a href=\"https://www.google.fr/maps/\">Google   \n",
    "    Maps</a> et garderez la même taille de carte mais prendrez une valeur de zoom \n",
    "    de départ de 15. L'importation de la librairie \"folium\" n'est plus nécessaire à ce stade.\n",
    "</p>    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align = \"justify\">\n",
    "   <b>Analyser</b> le code Python de la cellule ci-dessous qui consiste, pour l'ordinateur, à trouver le chemin le plus   \n",
    "    court grâce à l'algorithme de <a href=\"https://www.youtube.com/watch?v=MybdP4kice4\">Djisktra</a> (voir SNT-thème5-Séance3) \n",
    "    et à l'afficher. <b>Exécuter</b> les codes des cellules ci-dessous après les avoir étudiés  \n",
    "    (\"ctrl+entrer\" au clavier ou cliquer sur \"Run\" dans la barre d'icônes en étant dans la cellule).\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyroutelib3 import Router   # Importation du module Router: celui-ci correspond à une partie de la bibliothèque \n",
    "                                 # pyroutelib3 qui contient des fonctions (méthodes) permettant de calculer et tracer des itinéraires\n",
    "                                 # sur des cartes numériques\n",
    "\n",
    "# affectation des coordonnées GPS d'un lieu dans une variable\n",
    "centre_geographique_Paris = (48.85646, 2.34263)\n",
    "Point_zero = (48.8533249, 2.3488596)\n",
    "Assemblee_nationale = (48.8617608, 2.3179738)\n",
    "\n",
    "# Chargement d'une carte Open Street Map (OSM)\n",
    "carte_Paris = folium.Map(location=centre_geographique_Paris, width='80%', height='80', tiles=\"OpenStreetMap\", zoom_start=14)\n",
    "\n",
    "# Placement des marqueurs\n",
    "folium.Marker(centre_geographique_Paris, popup=\"Centre geographique de Paris\", icon=folium.Icon(color='blue')).add_to(carte_Paris) \n",
    "folium.Marker(Point_zero, popup=\"Point zero des routes de France \", icon=folium.Icon(color='red')).add_to(carte_Paris)  \n",
    "folium.Marker(Assemblee_nationale, popup=\"Assemblee nationale \", icon=folium.Icon(color='orange')).add_to(carte_Paris)       \n",
    "\n",
    "print(\"debut routage, veuillez patientez svp ...\") # Alerte permettant de vous indiquer que l'exécution du calcul \n",
    "                 # d'itinéraire a débuté (le calcul est long ...)\n",
    "\n",
    "router = Router(\"car\")  # option de routage en voiture. On aurait pu demander un itinéraire à pied.\n",
    "\n",
    "depart = router.findNode(centre_geographique_Paris[0], centre_geographique_Paris[1])   # définition du point de départ\n",
    "                     # de l'itinéraire: ici, le centre géographique de Paris, en spécifiant sa latitude et sa longitude\n",
    "\n",
    "\n",
    "arrivee = router.findNode(Assemblee_nationale[0], Assemblee_nationale[1])    # définition du point de d'arrivée\n",
    "                     # de l'itinéraire: ici, l'assemblée nationale, en spécifiant sa latitude et sa longitude\n",
    "\n",
    "\n",
    "status, route = router.doRoute(depart, arrivee)   # C'est cette instruction qui permet de calculer l'itinéraire demandé \n",
    "                                                  # en estimant des points de passage. Une partie de l'algorithme utilisé \n",
    "                                                  # ici exploite l'algorithme de Dijkstra\n",
    "        \n",
    "# Cette pseudo fonction, qu'on appelle \"méthode\", renvoie 2 variables: status et route. \n",
    "# La variable status permet de savoir si le calcul d'itinéraire a abouti ou non.\n",
    "# La variable route recueille l'ensemble des résultats issus du calcul de l'itinéraire.\n",
    "\n",
    "# Les lignes suivantes vérifient si le calcul a abouti à partir d'un test. \n",
    "\n",
    "if status == 'success':    # Si le calcul a abouti\n",
    "    print(\"route trouvée\")  # la phrase \"route trouvée\" est affichée\n",
    "    routeLatLons = list(map(router.nodeLatLon, route))   # le programme regroupe dans la même variable routeLatLons \n",
    "                                                         # les coordonnées de tous les points de passage trouvés\n",
    "else:                      # Sinon (ou autrement dit, si le calcul n'a pas abouti)\n",
    "    print(\"route pas trouvée !\")   # la phrase \"route pas trouvée\" est affichée\n",
    "    print(routeLatLons)   # Les points de passage calculés partiellement sont affichés\n",
    "    \n",
    "# La boucle for ci-dessous permet d'associer à chaque point de passage de la variable routeLatLons un marqueur rouge \n",
    "for coord in routeLatLons:\n",
    "    coord=list(coord)\n",
    "    folium.CircleMarker(coord,radius = 3,fill=True, color='red' ).add_to(carte_Paris)\n",
    "\n",
    "# Tracé d'une ligne brisée de couleur bleue entre 2 points de passage successifs\n",
    "folium.PolyLine(routeLatLons, color=\"blue\", weight=2.5, opacity=1).add_to(carte_Paris) \n",
    "\n",
    "carte_Paris"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcul_itineraire_Paris(X, Y):   #on définit une fonction qui va déterminer les itinéraires entre \n",
    "                                     #les points qui nous intéressent.\n",
    "    router = Router(\"car\")  #\"car\" = déplacement en voiture. Si on est à pied, on tape \"foot\", \"cycle\" à vélo, etc.\n",
    "    depart = router.findNode(X[0], X[1]) #coordonnées du point de départ (latitude, longitude)\n",
    "    arrivee = router.findNode(Y[0], Y[1]) #coordonnées du point d'arrivée (latitude, longitude)\n",
    "    status, route = router.doRoute(depart, arrivee)\n",
    "    if status == 'success':\n",
    "        print(\"route trouvée\")\n",
    "        routeLatLons = list(map(router.nodeLatLon, route))\n",
    "    else:\n",
    "        print(\"route pas trouvée !\")\n",
    "        print(routeLatLons)\n",
    "    for coord in routeLatLons:\n",
    "        coord=list(coord)\n",
    "        folium.CircleMarker(coord,radius = 3,fill=True, color='red' ).add_to(carte_Paris)\n",
    "    folium.PolyLine(routeLatLons, color=\"blue\", weight=2.5, opacity=1).add_to(carte_Paris) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "site_Paris =  [centre_geographique_Paris, Point_zero, Assemblee_nationale]\n",
    "\n",
    "print(\"debut routage, veuillez patientez svp ...\") \n",
    "\n",
    "i = 0 \n",
    "\n",
    "while i < len(site_Paris)-1:\n",
    "    calcul_itineraire_Paris(site_Paris[i], site_Paris[i+1])\n",
    "    i = i+1\n",
    "\n",
    "carte_Paris"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align = \"justify\">\n",
    "    On se propose de déterminer l'itinéraire à suivre pour aller de chez vous (noté :  Maison) au lycée Lislet Geoffroy \n",
    "    (noté : Lycee_Lislet_Geoffroy) à pied en centrant la carte sur le parc de la Trinité (noté : Parc_Trinite). Chaque élément \n",
    "    aura un marqueur avec sa propre couleur et aura un zoom de 14. \n",
    "</p>\n",
    "<p align = \"justify\">\n",
    "    La fonction à utiliser, qui différe de la précédente par sa localisation, vous est donnée ci-dessous.\n",
    "    <b>Exécuter</b> la.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcul_itineraire_Lycee(X, Y):\n",
    "    router = Router(\"foot\")\n",
    "    depart = router.findNode(X[0], X[1])\n",
    "    arrivee = router.findNode(Y[0], Y[1])\n",
    "    status, route = router.doRoute(depart, arrivee)\n",
    "    if status == 'success':\n",
    "        print(\"route trouvée\")\n",
    "        routeLatLons = list(map(router.nodeLatLon, route))\n",
    "    else:\n",
    "        print(\"route pas trouvée !\")\n",
    "        print(routeLatLons)\n",
    "    for coord in routeLatLons:\n",
    "        coord=list(coord)\n",
    "        folium.CircleMarker(coord,radius = 3,fill=True, color='red' ).add_to(carte_Reunion)\n",
    "    folium.PolyLine(routeLatLons, color=\"blue\", weight=2.5, opacity=1).add_to(carte_Reunion) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align = \"justify\">\n",
    "    2. <b>Compléter</b> les coordonnées manquantes dans la cellule ci-dessous.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# affectation des coordonnées GPS d'un lieu dans une variable\n",
    "Parc_Trinite =  \n",
    "Maison = \n",
    "Lycee_Lislet_Geoffroy = \n",
    "\n",
    "\n",
    "# Chargement d'une carte OSM\n",
    "carte_Reunion = folium.Map(location=Parc_Trinite, width='80%', height='80%', tiles=\"OpenStreetMap\", zoom_start=14)\n",
    "\n",
    "# Placement des marqueurs\n",
    "folium.Marker(Parc_Trinite, popup=\"Parc_Trinite\", icon=folium.Icon(color='green')).add_to(carte_Reunion)\n",
    "folium.Marker(Lycee_Lislet_Geoffroy, popup=\"Lycee_Lislet_Geoffroy\", icon=folium.Icon(color='blue')).add_to(carte_Reunion)\n",
    "folium.Marker(Maison, popup=\"Maison\", icon=folium.Icon(color='black')).add_to(carte_Reunion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align = \"justify\">\n",
    "    La fonction à utiliser, qui différe de la précédente par sa localisation, vous est donnée ci-dessous.\n",
    "    <b>Exécuter</b> la.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align = \"justify\">\n",
    "    3. <b>Compléter</b> les lignes manquantes dans la cellule ci-dessous et <b>exécuter</b> le programme.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "site_Lycee = [Maison, Lycee_Lislet_Geoffroy]\n",
    "\n",
    "print(\"debut routage, veuillez patientez svp ...\")\n",
    "\n",
    "i = 0 \n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "# Affichage de la carte\n",
    "carte_Reunion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p align = \"justify\">\n",
    "    Pour aller du lycée au premier arrêt, Le_Nez_de_Boeuf (Point de vue sur la Rivière des Rempart RF5), l'autocar va devoir \n",
    "    passer par l'Est de l'île traversant Sainte_Marie (Station Totale les Cafés RN2), Saint_André (Station Vito RN2), \n",
    "    Saint_Benoit (Station Vito RN2), La_Plaine_des_Palmistes (station Vito RN3) et La_Plaine_des_Cafres (cité du Volcan).Tous \n",
    "    les marqueurs seront en noir mis à part le Piton des Neiges qui sera en vert.\n",
    "</p>\n",
    "<p align = \"justify\">\n",
    "    4. En suivant le même principe les lignes de code Python précédentes, <b>Positionner</b> ces lieux sur une carte. Celle-ci doit montrer la Réunion (zoom = 10) et être centrée sur le Piton des Neiges.\n",
    "</p>\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# affectation des coordonnées GPS d'un lieu dans une variable\n",
    "Piton_des_neiges = \n",
    "Lycee_Lislet_Geoffroy = \n",
    "Sainte_Marie = \n",
    "Saint_Andre = \n",
    "Saint_Benoit = \n",
    "La_Plaine_des_Palmistes = \n",
    "La_Plaine_des_Cafres = \n",
    "Le_Nez_de_Boeuf = \n",
    "\n",
    "# Chargement d'une carte OSM\n",
    "carte_Reunion = \n",
    "\n",
    "# Placement des marqueurs\n",
    "\n",
    "\n",
    "\n",
    "# Affichage de la carte\n",
    "carte_Reunion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><b>Activer</b> la fonction permettant l'obtention de l'itinéraire</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calcul_itineraire_Volcan(X, Y):\n",
    "    router = Router(\"car\")\n",
    "    depart = router.findNode(X[0], X[1])\n",
    "    arrivee = router.findNode(Y[0], Y[1])\n",
    "    status, route = router.doRoute(depart, arrivee)\n",
    "    if status == 'success':\n",
    "        print(\"route trouvée\")\n",
    "        routeLatLons = list(map(router.nodeLatLon, route))\n",
    "    else:\n",
    "        print(\"route pas trouvée !\")\n",
    "        print(routeLatLons)\n",
    "    for coord in routeLatLons:\n",
    "        coord=list(coord)\n",
    "        folium.CircleMarker(coord,radius = 3,fill=True, color='red' ).add_to(carte_Reunion)\n",
    "    folium.PolyLine(routeLatLons, color=\"blue\", weight=2.5, opacity=1).add_to(carte_Reunion) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p><b>Compléter</b> et <b>Lancer</b> la boucle de détermination de l'itinéraire.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "site_Volcan = []\n",
    "\n",
    "print(\"debut routage, veuillez patientez svp ...\")\n",
    "\n",
    "\n",
    "    \n",
    "# Affichage de la carte\n",
    "carte_Reunion"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}