www.mesmaths.com

3-itinéraire routier

Florent Girod — 2023-06-20T11:39:30Z

Grâce à la fonction Router de la bibliothèque pyroutelib3, il va être possible de générer automatiquement un itinéraire entre deux points donnés.

pour commencer

Ci-dessous un code permettant de voir le fonctionnement des fonctions relatives à Router ; copiez/collez-le dans Pyzo et faites-le fonctionner :

code à copier/coller

##import des bibliothèques
 from pyroutelib3 import Router
 import folium
 
 ##choix du type de parcours et de l'icone
 router = Router("car")#on cherche à construire un parcours pour : car, cycle, foot, horse, tram, train
 icone="car"#choix de l'icone des marqueurs
 
 ##on identifie les points de départ et d'arrivée
 point_depart = (45.128046, 5.588483)
 point_arrivee = (45.0667, 5.55)
 
 depart = router.findNode(point_depart[0], point_depart[1])
 arrivee = router.findNode(point_arrivee[0], point_arrivee[1])
 status, route = router.doRoute(depart, arrivee)
 if status == 'success':
 routeLatLons = list(map(router.nodeLatLon, route))
 #routeLatLons est un tuple qui stocke les latitudes et les longitudes
 #routeLatLons[0] est la liste des latitudes
 #routeLatLons[1] est la liste des longitudes
 
 ##initialisation de la carte et choix de l'échelle
 c= folium.Map(location=[(point_depart[0]+point_arrivee[0])/2, (point_depart[1]+point_arrivee[1])/2], zoom_start=13)#carte centrée sur le milieu du segment [depart ; arrivee]
 #on marque le départ
 folium.Marker(routeLatLons[0], popup="Départ", icon=folium.Icon(icon=icone, prefix="fa", color="green")).add_to(c)
 #on marque l'arrivée
 folium.Marker(routeLatLons[-1], popup="Arrivée après "+str(distance)+ " km", icon=folium.Icon(icon=icone, prefix="fa", color="red")).add_to(c)
 
 ##on trace la route
 folium.PolyLine(routeLatLons, color="red", weight=2.5, opacity=1).add_to(c)#on trace la route en une couleur voulue
 
 ##carte sauvegardée
 c.save('maRoute.html')

A faire : choisissez un autre lieu de départ et un autre lieu d'arrivée ; modifier le type de mode de circulation et observez.

distance

Il faut tout d'abord bien noter que dans ce programme, routeLatLons est une liste qui stocke les coordonnées de nombreux points qui composent le parcours.

Dans cette bibliothèque, une fonction permet de calculer directement la distance entre deux points dont on connaît les coordonnées (latitude, longitude).

Sa syntaxe est : distance( coord(point) , coord(point suivant) ).

A faire : créer une liste d[] qui contiendra la distance entre deux points successifs du parcours, et une liste d_cum[] qui contiendra la distance cumulée entre le point de départ et un point du parcours.

Aide : la fonction sum(d) retourne la somme des valeurs contenues dans la liste d.

réponse

##calcul des distances cumulées
 L=len(routeLatLons)#taille de la liste = nombre de points
 d=[]#initialisation de la distance : liste vide
 d_cum=[]#initialisation de la distance cumulée: liste vide
 for i in range(1, L):
 d.append(router.distance(routeLatLons[i-1],routeLatLons[i]))#liste des distances entre deux points
 d_cum.append(sum(d))#liste des distances cumulées
 distance=round(d_cum[-1], 2)#écriture arrondie à deux chiffres après la virgule

marquage de l'itinéraire

On peut à présent marquer des points sur l'itinéraire donnant par exemple le cumul de la distance au fur et à mesure.

On rappelle :

pour marquer un point : folium.Circle((latitude, longitude), radius=2) place un cercle de rayon 2 (un point) au lieu dont les coordonnées (latitude, longitude) sont précisées.
d_cum=[i] donne la valeur de la distance cumulée entre le point de départ et i^ème point du parcours.
pour indiquer du texte relatif à un point, on ajouter comme paramètre popup=" texte " dans la fonction folium.Circle précédente.

réponse

##on marque certains points
 pas=10
 for i in range(1, L, pas):#on positionne des marqueurs tous les ...pas... points
 folium.Circle(routeLatLons[i], radius=2, popup="point n°"+str(i)+" : "+str(round(d_cum[i],2))+" km").add_to(c)

résultat attendu

2-parcours

Florent Girod — 2023-06-20T11:39:23Z

Nous allons ajouter progressivement sur une carte un parcours avec divers éléments.

trace GPS

Les compteurs de vélo (type Garmin) ou montres de ce type enregistrent les coordonnées GPS.

Voici deux fichiers .gpx prêts à l'emploi, déjà convertis correctement avec une extension .csv :


parcours1


parcours2

Vous pouvez travailler à partir de vos propres données ; ci-dessous une aide pour le faire :

aide pour utiliser ses propres données

Une fois le compteur (ou la montre) connecté à l'ordinateur, on télécharge le fichier retraçant un parcours ; sur un compteur Garmin, le fichier est en .fit

On doit le convertir en .gpx

Ce site https://www.gpsies.com/convert.do?language=fr&client=summit le fait ; après s'être inscrit, on peut simplement faire la conversion en déposant le fichier .fit ; un fichier .gpx est rendu ; on l'enregistre ensuite avec l'extension .csv.

Petite manipulation à faire : il faut supprimer toutes les espaces (qui sont comptabilisées en python et qui poseront problème).

Pour cela, faire Ctrl H, puis taper une espace dans la partie 'rechercher', rien dans la partie 'remplacer' et demander à remplacer partout.

Une vidéo pour illustrer.

import

On va importer dans un programme Python un fichier .csv contenant de nombreuses informations, notamment les coordonnées GPS (latitude, longitude) de nombreux points, leur altitude et l'heure à laquelle on se trouvait à cet endroit.

En voici le code commenté :

##importation des bibliothèques
 import os
 import folium
 
 ##fonction permettant de stocker les données qui nous concernent dans des listes
 def lire_fich(file):
 f = open(file, mode = "r")#ouverture du fichier en mode lecture ("r" pour read)
 lc, la, lt = [], [], [] #initalisation des listes lc (liste coordonnées) / la (liste altitudes) / lt (liste temps)
 for ligne in f:
 if ligne[:5] == " l = ligne.split('"')#on trie les données séparées par " par .split('"')
 lc.append( (float(l[1]), float(l[3])) )#on ne conserve que les valeurs voulues
 elif ligne[:3] == " l = ligne.split("ele")#on trie les données séparées par ele par .split('ele')
 la.append( float(l[1][1:-2]) )#on ne conserve que les valeurs voulues
 elif ligne[:3] == " l = ligne.split(":")#on trie les données séparées par : par .split(':')
 lt.append( int(l[0][-2:]+l[1]+l[2][:2]) )#on ne conserve que les valeurs voulues
 f.close()#on ferme le fichier
 return lc, la, lt #on retourne trois listes ; la première est une "liste de listes" car chaque valeur est un couple de coordonées.
 
 ##programme principal
 data=lire_fich("tour3.csv")#on décode le fichier gps -> data est un tuple (~une liste) dont le premier terme est le couple de coordonnées, le second l'altitude et le troisième donne le temps
 c= folium.Map(location=[data[0][0][0], data[0][0][1]],zoom_start=12)#intialisation de la carte aux premières coordonnées gps, avec un zoom de 12
 L=len(data[0])#nombre de points dans le fichier
 
 #des marqueurs pour le départ et l'arrivée (on y indiquera l'altitude)
 folium.Marker(data[0][0], popup="DEPART altitude : "+str(data[1][0]), icon=folium.Icon(icon="bicycle", prefix="fa", color="green")).add_to(c)
 folium.Marker(data[0][L-1], popup="ARRIVEE altitude : "+str(data[1][0]), icon=folium.Icon(icon="bicycle", prefix="fa", color="red")).add_to(c)
 
 
 folium.PolyLine(data[0], color="red", weight=2.5, opacity=1).add_to(c)#on trace la route en une couleur voulue
 
 c.save('monParcours3.html')#sauvegarde du fichier en extension .html

A faire : modifier quelques paramètres dans ce code (la couleur du parcours, la manière d'indiquer le départ et l'arrivée) et visualiser les effets en rafraîchissant la page (par F5).

profil

On peut à présent exploiter les données stockées dans data et chercher à produire un profil du parcours.

En effet, data[1] est une liste qui contient toutes les altitudes.

On pourra dans un premier temps représenter ces altitudes en supposant que la distance parcourue entre deux marqueurs est la même.

On obtient une courbe du type :

réponse

###profil du parcours
 import matplotlib.pyplot as plt
 abscisse=[]
 for i in range(L):
 abscisse.append(i)
 plt.plot(abscisse, data[1])
 plt.show()

kilométrage

On peut chercher à donner un cumulé du kilométrage qui serait indiqué par exemple sur chaque 'popup'

On utilise pour cela la fonction suivante (pas évidente du tout !!)

code de la fonction distance

###distance entre deux points
 import math#pour utiliser la fonction racine carrée (sqrt)
 
 def distance(origin, destination):#fonction donnant la distance entre deux points connaissant leurs coordonnées gps ; la variable "origin" est un couple de valeurs (long, lat) de même que la variable "destination"
 lat1, lon1 = origin
 lat2, lon2 = destination
 radius = 6371 # km
 
 dlat = math.radians(lat2-lat1)
 dlon = math.radians(lon2-lon1)
 a = math.sin(dlat/2) * math.sin(dlat/2) + math.cos(math.radians(lat1)) \
 * math.cos(math.radians(lat2)) * math.sin(dlon/2) * math.sin(dlon/2)
 c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
 d = radius * c
 
 return d#distance donnée en km

Ainsi, distance( data[0][0] , data[0][1]) donne la distance (en km) entre les deux premiers points relevés par le GPS.

A faire : stocker dans une liste d_entre les distances entres deux points GPS, puis dans une liste d_cum la distance parcourue depuis le départ.

réponse

##distance et distance cumulée
 d_entre=[]
 d=0
 d_cum=[]
 
 for i in range(L-1):
 d_entre.append(distance(data[0][i] , data[0][i+1]))
 d=d+distance(data[0][i] , data[0][i+1])
 d_cum.append(d)

des points sur le parcours

On peut également positionner des points le long du parcours qui indiqueront par exemple l'altitude du lieu.

Les points étant trop nombreux, on ne les placera pas tous.

Voici le code :

pas=100
 for i in range(0, L, pas):#on positionne des marqueurs tous les ...pas... points
 folium.Circle([data[0][i][0], data[0][i][1]], radius=2, popup="point n°"+str(i)+" : "+str(data[1][i])+" d'altitude").add_to(c)

A faire : modifier l'indication donnée par chaque point afin qu'elle renseigne sur (au choix) : la distance partielle parcourue, le dénivelé cumulé.

remarques

On peut à présent tracer le 'vrai profil' du parcours, en construisant les points d'abscisse 'distance parcourue' et d'ordonnée 'altitude'

réponse

##vrai profil
 import matplotlib.pyplot as plt
 d_cum.insert(0, 0)#on ajoute à la liste d_cum 0 en première position
 plt.plot(d_cum, data[1])#pour rappel, data[1] est une liste contenant les altitudes des points
 plt.show()

Détermination du dénivelé cumulé (positif et négatif)

réponse

##dénivelé cumulé
 cum_pos=0
 cum_neg=0
 
 for i in range(L-1):
 delta=data[1][i+1]-data[1][i]
 if delta>0:
 cum_pos+=delta
 else:
 cum_neg-=delta

1-une carte

Florent Girod — 2023-06-20T11:39:16Z

On va montrer comment créer pas à pas une carte à laquelle on va ajouter des informations grâce à un programme python

pour commencer

Faire fonctionner le code suivant :

import folium
 c= folium.Map(location=[45.188529, 5.724524],zoom_start=10)
 c.save('maCarte.html')

question 1 : Que s'est-il passé ?

réponse

Une page web s'ouvre, centrée sur Grenoble, à l'échelle du département.

remarque : on peut par la suite zoomer à l'aide de la molette de la souris ou d'une icône -/+ en haut à gauche de la carte.

question 2 : Modifier la valeur zoom_start=10 ; quel est l'effet obtenu ? (pour visualiser, il suffit de rafraîchir la page web en faisant F5 par exemple)

réponse

L'échelle est modifiée :

zoom_start=5 donne la carte de l'Europe !
zoom_start=20 donne une échelle permettant de voir le quartier autour duquel on est centré au départ.

question 3 : En recherchant les coordonnées (latitude, longitude) du Mont-Blanc, faites un travail similaire pour obtenir une page ouvrant sur une carte centrée sur le Mont-Blanc, avec un zoom régler sur 10.

Nommer la page "montblanc.html".

réponse

import folium
 c= folium.Map(location=[45.832622, 6.865175],zoom_start=10)
 c.save('montblanc.html')

marqueurs

On peut avoir envie d'ajouter des marqueurs ; compiler ce code :

import folium
 c= folium.Map(location=[45.188529, 5.724524],zoom_start=20)
 folium.Marker([45.188529, 5.724524], popup="place Victor Hugo").add_to(c)
 c.save('maCarte.html')

question 4 : Que se passe-t-il ?

réponse

Un marqueur pointe exactement la place Victor Hugo et lorsque la souris arrive sur ce marqueur, le message 'place Victor Hugo' apparaît.

On peut changer le type de marqueur ainsi que sa couleur en ajoutant des paramètres comme dans cet exemple :

folium.Marker([45.188529, 5.724524],popup="place de Verdun",folium.Icon(icon='ambulance', prefix="fa", color='red')).add_to(c)

question 5 : Faites différents essais en modifiant le symbole et sa couleur.

les couleurs possibles

'red', 'blue', 'green', 'purple', 'orange', 'darkred', 'lightred', 'beige', 'darkblue', 'darkgreen', 'cadetblue', 'darkpurple', 'white', 'pink', 'lightblue', 'lightgreen', 'gray', 'black', 'lightgray'

des icones

'home', 'glass', 'flag', 'star', 'bookmark', 'info-sign', 'cloud', 'ambulance'

liste

S'il on veut pointer plusieurs lieux avec des marqueurs différents, on peut recopier plusieurs fois le code précédent en indiquant les paramètres voulus (longitude, latitude, type d'icône, couleur de l'icône) mais ce sera très long et répétitif.

On présente ici une méthode utilisant une liste :

une liste pour les latitudes
une liste pour les longitudes
une liste pour les types d'icône
une liste pour la couleur

par exemple, si on veut saisir 4 points, on aura des listes du type :

lat=[45.1167, 45.0667 , 45.1333, 45.1833]
 long=[5.5833, 5.55, 5.5333, 5.6167]
 nom_lieu=['Lans en Vercors', 'Villard de Lans', 'Méaudre', 'Engins']
 col=['green', 'blue' ,'red', 'gray']

question 6 : choisir 4 lieux autour de Grenoble (si vous le souhaitez, les coordonnées données précédemment) sur lesquels on placera une icône en forme de bicyclette avec 4 couleurs différentes par la méthode de parcours d'une liste.

objectif

réponse

import folium
 
 lat=[45.1167, 45.0667 , 45.1333, 45.1833]
 long=[5.5833, 5.55, 5.5333, 5.6167]
 nom_lieu=['Lans en Vercors', 'Villard de Lans', 'Méaudre', 'Engins']
 col=['green', 'blue' ,'red', 'gray']
 c= folium.Map(location=[45.166672, 5.71667],zoom_start=11)
 for i in range(4):
 folium.Marker([lat[i], long[i]],popup=nom_lieu[i],icon=folium.Icon(icon="bicycle", prefix="fa", color=col[i])).add_to(c)
 c.save('maCarte.html')

import

On peut faire beaucoup mieux que précédemment ! Imaginez que vous ayez envie de saisir des dizaines de points ... il sera bien plus pratique de les saisir dans un fichier annexe et de l'importer ; voici un modèle reprenant un cas similaire au précédent.

document en .csv

Enregistrez ce qui suit dans un éditeur de texte (Notepaad++ ou bloc note) et enregistrez-le dans le même dossier que votre programme en cours.

Bien penser à indiquer l'extension .csv

Lieu,Latitude,Longitude,Icon,Color

Lans-en-Vercors,45.1167,5.5833,bicycle,green

VillarddeLans,45.0667,5.55,bicycle,blue

Méaudre,45.1333,5.5333,bicycle,red

Engins,45.1833,5.6167,bicycle,gray

On peut ensuite, grâce à une fonction de la bibliothèque pandas importer ces données ; par exemple data.iloc[i,0] importe la i^ème ligne de la 1^ère colonne (indexée à 0).

Ce qui est importé est considéré comme une chaîne de caractères (ce qui convient ici pour la première colonne qui correspond aux lieux)

Pour la seconde colonne qui donne la latitude, il faudra forcer l'import à retourner un nombre 'flottant' par float(data.iloc[i,1])

question 7 : adapter le code précédent avec les informations précédents pour utiliser le fichier .cvs et l'importer.

réponse

import folium
 import pandas#pour traiter les données
 data=pandas.read_csv('import.csv',sep=',')#import des données
 c= folium.Map(location=[45.166672, 5.71667],zoom_start=11)
 
 for i in range(data.shape[0]):#nombre de lignes
 nom_lieu=data.iloc[i,0]
 lat=float(data.iloc[i,1])
 long=float(data.iloc[i,2])
 icone=data.iloc[i,3]
 col=data.iloc[i,4]
 folium.Marker([lat, long], popup=nom_lieu, icon=folium.Icon(icon=icone, prefix="fa", color=col)).add_to(c)
 c.save('maCarte.html')

projet

Des idées :

* proposer un parcours thématique à Grenoble ou dans votre lieu de vie avec des indications.

* faites une cartographie de vos amis et/ou famille en incluant un code couleur et des indications.

séquence

Florent Girod — 2023-06-20T11:39:05Z

séance n°1

En classe, classe entière

activité 1 :

matériel nécessaire : n>3 mètres (si possible mètres ruban) et une figurine

des élèves modélisent des satellites ; on positionne la figurine quelques part et on veut savoir combien de satellites sont nécessaires pour déterminer l'unique point où se situe la figurine.

conclusion : avec trois satellites, on peut déterminer exactement la position d'u point, connaissant la distance avec chacun de ces satellites.

question : pourquoi est-il nécessaire d'avoir 4 satellites pour positionner un point ?

activité 2 : Trame NMEA à programmer sur calculatrice / Python (voir fiche TI)

séance n°2

En demi groupes, en salle informatique

A partir d'une trame NMEA, positionner le point repéré sur une carte : utilisation de la bibliothèque folium et autres activités (marqueurs etc.)

séance n°3

En classe, classe entière

Exposé ?

calculs d'itinéraires en classe à partir d'une carte routière : recherche du chemin le plus court (le plus rapide)

matériel : carte photocopiée en couleur (20 exemplaires ?) plastifiée

présentation de l'algorithme de Djistra par vidéo : ici par exemple questions : en classe ? à la maison ? préparer un petit questionnaire à compléter pendant la vidéo

séance n°4

En demi groupes, en salle informatique

un rapide passage sur le site Géoportail pour voir le principe d'une SIG avec différentes couches à voir sur la carte

poursuite du travail sur les programmes Python (folium)

site personnel complété avec ce qui a été fait sur la séquence