Upload 4 files

pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "autoroute"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "matplotlib>=3.9.2",
+    "networkx>=3.4.2",
+    "osmnx>=2",
+    "pdfplumber>=0.11.4",
+    "plotly>=5.24.1",
+    "pymupdf>=1.24.13",
+    "pymupdf4llm>=0.0.17",
+    "pypdf2<3.0",
+    "pyvis>=0.3.2",
+    "scipy>=1.14.1",
+    "tabula-py>=2.10.0",
+    "tabula>=1.0.5",
+    "scikit-learn>=1.5.2",
+    "jupyterlab>=4.3.1",
+    "folium>=0.18.0",
+    "panel>=1.5.4",
+    "param>=2.1.1",
+    "mapclassify>=2.8.1",
+    "colorcet>=3.1.0",
+]

tournenrond.py

@@ -0,0 +1,214 @@
+import numpy as np
+import osmnx as ox
+import networkx as nx
+import folium
+from networkx.classes.function import path_weight
+from osmnx.geocoder import geocode
+import panel as pn
+import param
+import colorcet as cc
+from plotly import graph_objects as go
+from shapely.ops import linemerge
+from pyproj import Transformer
+import pandas as pd
+import geopandas as gpd
+from io import BytesIO
+from time import sleep
+
+ox.settings.elevation_url_template="https://api.opentopodata.org/v1/aster30m?locations={locations}"
+pn.extension('plotly')
+
+class Pars(param.Parameterized):
+    adresse= param.String(label="Adresse", default="Rue du Stade Saint-Ouen-de-Mimbré")
+    bornes = param.Range(label="Distance (km)", bounds=(1, 43), default=(5, 7), step=1)
+    pente=param.Number(label="Pente segment max (%)", bounds=(0, 15), default=10)
+    nresults=param.Integer(label="Number of results", bounds=(1, 20), default=5)
+    precision= param.Number(label="Précision (%)", softbounds=(0, 10), default=1,
+                            doc="Plus faible : plus précis, plus élevé : calcul plus rapide\n5 est un bon compromis")
+    
+par=Pars()
+
+
+def is_feasible(points, p, min_dist):
+    selected_points = [points[0]]
+    last_position = points[0]
+    
+    for i in range(1, len(points)):
+        if points[i] - last_position >= min_dist:
+            selected_points.append(points[i])
+            last_position = points[i]
+            if len(selected_points) == p:
+                return True, selected_points
+    return False, []
+
+def sorted_maxmin_dispersion(points, p):
+    left = 0
+    right = points[-1] - points[0]
+    best_dist = 0
+    best_points = []
+    
+    while left <= right:
+        mid = (left + right) // 2
+        feasible, selected_points = is_feasible(points, p, mid)
+        if feasible:
+            best_dist = mid
+            best_points = selected_points
+            left = mid + 1
+        else:
+            right = mid - 1
+    return best_points, best_dist
+
+def maxmin_dispersion(points, p) :
+    if p>=len(points):
+        return points, 0
+    points.sort()
+    best_points, best_dist=sorted_maxmin_dispersion(points, p)
+    best_points[-1]=points[-1]
+    return best_points, best_dist
+
+
+def cycle_maxmin_dispersion(points, p, longueur):
+    if p>=len(points):
+        return points, 0
+    points.sort()
+    best_points, best_dist=sorted_maxmin_dispersion( points + [points[0] + longueur], p+1)
+    return best_points[:-1], best_dist
+
+
+
+
+
+def create_trace(choixtrace):
+    df= dic_dfg[ int(choixtrace)-1 ]
+    dfg = gpd.GeoDataFrame(index=[0], crs='epsg:4326', geometry=[linemerge(df.geometry.to_list())])
+    sio = BytesIO()
+    dfg.to_file(sio, 'GPX')
+    sio.seek(0)
+    return sio
+
+
+fig = go.Figure()
+dic_dfg={}
+calcul=pn.widgets.Button(button_type= "primary", name="Calculer parcours")
+carte=pn.pane.plot.Folium(min_height=1000, sizing_mode='stretch_both')
+choixtrace=pn.widgets.Select(name="Sélection trace", visible=False)
+filedownload = pn.widgets.FileDownload(name="Télécharger GPX", button_type="primary",
+    callback=pn.bind(create_trace, choixtrace), filename='RunLoop.gpx', visible=False
+)
+
+elev=pn.pane.Plotly(fig, sizing_mode='stretch_width', visible=False)
+
+tuiles= pn.widgets.RadioBoxGroup(name='Style carte',
+                                 options={'Style classique' : 'OpenStreetMap', 'Style clair': 'Cartodb Positron'}, inline=True)
+
+
+def download_graph(coo):
+    G = ox.graph_from_point(coo, dist=par.bornes[1]*1000/2, dist_type="network", network_type='walk')
+    return G
+    
+def consolidate_intersections(G):
+    Gp= ox.projection.project_graph(G)
+    tolerance=sum(par.bornes)/2 * par.precision *10 # bornes en km, precision en %
+    Gc=ox.simplification.consolidate_intersections(Gp, tolerance=tolerance)
+    return Gc
+
+
+def filter_elevations(Gc):
+    Gc=ox.projection.project_graph(Gc, to_latlong=True)
+    Ge=ox.elevation.add_edge_grades(ox.elevation.add_node_elevations_google(Gc, batch_size=100, pause=0.5))
+    Gf=Ge.copy()
+    for s, t, d in Ge.edges(data=True):
+        if d['grade_abs']>par.pente/100:
+            Gf.remove_edge(s, t)
+    return Gf
+
+def get_paths(Gf, lon, lat):
+    source, target, _=ox.distance.nearest_edges(Gf, lon, lat)
+    mindist, maxdist=1000*par.bornes[0], 1000*par.bornes[1]
+    Gfu=ox.convert.to_digraph(Gf).to_undirected()
+    short_paths=nx.shortest_simple_paths(Gfu, source=source, target=target, weight="length")
+    dist=0
+    chemins=[]
+    i=0
+    
+    while dist<maxdist:
+        i+=1
+        path=next(short_paths)+[source]
+        dist=path_weight(Gfu, path, weight="length")
+        if dist>mindist:
+            chemins.append((dist, path))
+            
+    return chemins    
+
+
+def get_elevation(dfg, Gc):
+    df=pd.DataFrame(linemerge(dfg.geometry.to_list()).coords, columns=["x", "y"])
+    df[["ym", "xm"]]=linemerge(dfg.to_crs(Gc.graph["crs"]).geometry.to_list()).coords
+    df["segdists"]=np.hypot(*(df[["xm", "ym"]].diff().fillna(0).T.values))
+    df["segcumsum"]=np.cumsum(df["segdists"])
+
+    pts, optdist = maxmin_dispersion(df.segcumsum.to_list(), 100)
+    
+    df2=df[df['segcumsum'].isin(pts)].copy()
+    Gchemin=nx.MultiDiGraph()
+    Gchemin.add_nodes_from( list(zip (df2.index, df2[["x", "y"]].to_dict('records'))) )
+    Gchemin=ox.elevation.add_node_elevations_google(Gchemin)
+    sleep(0.5)
+    idx, prop= zip(*Gchemin.nodes(data=True))
+    df2["elevation"]=pd.DataFrame(prop, index=idx)["elevation"]
+    return df2
+
+def calculs(dummy):
+
+    coo=geocode(par.adresse)
+    lat, lon = coo
+
+    G=download_graph(coo)
+    Gll=consolidate_intersections(G)
+    Gf=filter_elevations(Gll)
+    chemins=get_paths(Gf, lon, lat)
+    
+    distances=[chemin[0] for chemin in chemins]
+    selected_points, distance = maxmin_dispersion(distances, p=par.nresults)
+    good_chemins=[chemin for chemin in chemins if chemin[0] in selected_points]
+    elevations={}
+
+    m=None
+    
+    for ic, (distance, chemin)  in enumerate(good_chemins):
+        dfg=ox.routing.route_to_gdf(Gf, chemin).to_crs("latlon")
+        dic_dfg[ic]=dfg
+        m=dfg.explore(m=m, color=cc.b_glasbey_category10[ic], line_width=2, tiles="Cartodb Positron")
+        elevations[ic]=get_elevation(dfg, Gll)
+        
+    
+    folium.Marker( location=[lat, lon],  tooltip=par.adresse,
+                  icon=folium.Icon(prefix="fa", icon="fa-person-running")).add_to(m)
+
+    carte.object=m    
+    labels=[]
+
+    fig.data=[]
+    
+    for idx, df in elevations.items():
+        label=str(idx+1)
+        labels.append(label)
+        fig.add_trace(go.Scatter(x=df.segcumsum, y=df.elevation, name=label,
+                      mode='lines', line_color=cc.b_glasbey_category10[idx], line_shape='spline'))
+    
+    fig.update_layout(xaxis_title="Distance", yaxis_title="Élévation", margin=dict(l=20, r=20, t=20, b=20),)
+
+    choixtrace.options=labels
+    carte.visible=True    
+    filedownload.visible=True
+    elev.visible=True
+    choixtrace.visible=True
+
+
+calcul.on_click(calculs)
+
+
+app=pn.Column(pn.Row(pn.Column( pn.Param(par, width=300, name="Paramètres"), tuiles, calcul, choixtrace, filedownload),
+                   elev),
+            carte)
+app.servable()