v0.1.0 first online test

CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog],
+and this project adheres to [Semantic Versioning].
+
+## [Unreleased]
+
+- /
+
+
+## [0.1.0] - 2025-02-27
+
+### Added
+
+- First online demo
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+
+
+### Security
+
+
+
+<!-- Links -->
+[keep a changelog]: https://keepachangelog.com/en/1.0.0/
+[semantic versioning]: https://semver.org/spec/v2.0.0.html
+
+<!-- Versions -->
+[unreleased]: https://huggingface.co/spaces/Lbasara/Autoroute/compare/v0.0.2...HEAD
+[0.0.2]: https://huggingface.co/spaces/Lbasara/Autoroute/v0.0.1...v0.0.2
+[0.0.1]: https://huggingface.co/spaces/Lbasara/Autoroute/tag/v0.0.1

app.py

@@ -1,147 +1,53 @@
-import io
-import random
-from typing import List, Tuple
-
-import aiohttp
+import osmnx as ox
 import panel as pn
-from PIL import Image
-from transformers import CLIPModel, CLIPProcessor
-
-pn.extension(design="bootstrap", sizing_mode="stretch_width")
-
-ICON_URLS = {
-    "brand-github": "https://github.com/holoviz/panel",
-    "brand-twitter": "https://twitter.com/Panel_Org",
-    "brand-linkedin": "https://www.linkedin.com/company/panel-org",
-    "message-circle": "https://discourse.holoviz.org/",
-    "brand-discord": "https://discord.gg/AXRHnJU6sP",
-}
-
-
-async def random_url(_):
-    pet = random.choice(["cat", "dog"])
-    api_url = f"https://api.the{pet}api.com/v1/images/search"
-    async with aiohttp.ClientSession() as session:
-        async with session.get(api_url) as resp:
-            return (await resp.json())[0]["url"]
-
-
-@pn.cache
-def load_processor_model(
-    processor_name: str, model_name: str
-) -> Tuple[CLIPProcessor, CLIPModel]:
-    processor = CLIPProcessor.from_pretrained(processor_name)
-    model = CLIPModel.from_pretrained(model_name)
-    return processor, model
-
-
-async def open_image_url(image_url: str) -> Image:
-    async with aiohttp.ClientSession() as session:
-        async with session.get(image_url) as resp:
-            return Image.open(io.BytesIO(await resp.read()))
-
-
-def get_similarity_scores(class_items: List[str], image: Image) -> List[float]:
-    processor, model = load_processor_model(
-        "openai/clip-vit-base-patch32", "openai/clip-vit-base-patch32"
-    )
-    inputs = processor(
-        text=class_items,
-        images=[image],
-        return_tensors="pt",  # pytorch tensors
-    )
-    outputs = model(**inputs)
-    logits_per_image = outputs.logits_per_image
-    class_likelihoods = logits_per_image.softmax(dim=1).detach().numpy()
-    return class_likelihoods[0]
-
-
-async def process_inputs(class_names: List[str], image_url: str):
-    """
-    High level function that takes in the user inputs and returns the
-    classification results as panel objects.
-    """
-    try:
-        main.disabled = True
-        if not image_url:
-            yield "##### ⚠️ Provide an image URL"
-            return
-    
-        yield "##### ⚙ Fetching image and running model..."
-        try:
-            pil_img = await open_image_url(image_url)
-            img = pn.pane.Image(pil_img, height=400, align="center")
-        except Exception as e:
-            yield f"##### 😔 Something went wrong, please try a different URL!"
-            return
-    
-        class_items = class_names.split(",")
-        class_likelihoods = get_similarity_scores(class_items, pil_img)
+import param
+import colorcet as cc
+import autoroute
+
+map_kwds={"font_size": 15}
+transformer = autoroute.to_Lambert93()
+
+pn.extension()
+
+class Pars(param.Parameterized):
+    orig_adr= param.String(label="Origine")
+    dest_adr= param.String(label="Destination")
+    precision = param.Integer(label="Granularité routes", bounds=(2, 6), default=4)
+par=Pars()
+
+calcul=pn.widgets.Button(button_type= "primary", name="Calculer parcours")
+carte=pn.pane.plot.Folium(min_height=1000, sizing_mode='stretch_both')
+
+def calculs(dummy):
+    orig_coo=ox.geocoder.geocode(par.orig_adr)
+    dest_coo=ox.geocoder.geocode(par.dest_adr)
+    calcul.name="Téléchargement carte"
+    G=autoroute.download_graph(orig_coo, dest_coo, par.precision)
+    calcul.name="Calcul itinéraires"
+    Gc=autoroute.add_tarifs(G)
+    orig_lamb=transformer.transform(*orig_coo)
+    dest_lamb=transformer.transform(*dest_coo)
+    orig_id=ox.nearest_nodes(Gc, *orig_lamb)
+    dest_id=ox.nearest_nodes(Gc, *dest_lamb)    
+    df=autoroute.tariftimedf(Gc, orig_id, dest_id)
+    calcul.name="Affichage résultats"
     
-        # build the results column
-        results = pn.Column("##### 🎉 Here are the results!", img)
-    
-        for class_item, class_likelihood in zip(class_items, class_likelihoods):
-            row_label = pn.widgets.StaticText(
-                name=class_item.strip(), value=f"{class_likelihood:.2%}", align="center"
-            )
-            row_bar = pn.indicators.Progress(
-                value=int(class_likelihood * 100),
-                sizing_mode="stretch_width",
-                bar_color="secondary",
-                margin=(0, 10),
-                design=pn.theme.Material,
-            )
-            results.append(pn.Column(row_label, row_bar))
-        yield results
-    finally:
-        main.disabled = False
-
+    m=None
+    for irow, row in df.iterrows():
+        gfast=ox.routing.route_to_gdf(Gc, row["path"], weight= "travel_time")
+        m=gfast.explore(m=m, map_kwds=map_kwds, color=cc.b_glasbey_category10[irow],
+                  tooltip= set(gfast.columns) & {"travel_time", "tarif", "length"},
+                  highlight_kwds={"color": "green", "weight": 3} )
 
-# create widgets
-randomize_url = pn.widgets.Button(name="Randomize URL", align="end")
+    carte.object=m  
 
-image_url = pn.widgets.TextInput(
-    name="Image URL to classify",
-    value=pn.bind(random_url, randomize_url),
-)
-class_names = pn.widgets.TextInput(
-    name="Comma separated class names",
-    placeholder="Enter possible class names, e.g. cat, dog",
-    value="cat, dog, parrot",
-)
-
-input_widgets = pn.Column(
-    "##### 😊 Click randomize or paste a URL to start classifying!",
-    pn.Row(image_url, randomize_url),
-    class_names,
-)
-
-# add interactivity
-interactive_result = pn.panel(
-    pn.bind(process_inputs, image_url=image_url, class_names=class_names),
-    height=600,
-)
+calcul.on_click(calculs)
 
-# add footer
-footer_row = pn.Row(pn.Spacer(), align="center")
-for icon, url in ICON_URLS.items():
-    href_button = pn.widgets.Button(icon=icon, width=35, height=35)
-    href_button.js_on_click(code=f"window.open('{url}')")
-    footer_row.append(href_button)
-footer_row.append(pn.Spacer())
 
-# create dashboard
-main = pn.WidgetBox(
-    input_widgets,
-    interactive_result,
-    footer_row,
+app=pn.template.MaterialTemplate(
+    title="Autoroute v0.1.0",
+    sidebar=[pn.Param(par, name="Paramètres"), calcul],
+    main=carte,
 )
 
-title = "Panel Demo - Image Classification"
-pn.template.BootstrapTemplate(
-    title=title,
-    main=main,
-    main_max_width="min(50%, 698px)",
-    header_background="#F08080",
-).servable(title=title)
+app.servable()

autoroute.py

@@ -0,0 +1,174 @@
+import geopandas as gpd
+import pandas as pd
+import networkx as nx
+import osmnx as ox
+import numpy as np
+import shapely
+from pyproj import Transformer
+from functools import partial
+
+ox.settings.useful_tags_node=["highway", "ref", "barrier", "highway:ref", "name"]
+ox.settings.useful_tags_way=["highway", "maxspeed", "name", "ref", "oneway", "toll", "barrier"]
+
+def custom_filter_order(order, start=0):
+    highway_order=["motorway", "trunk", "primary", "secondary", "tertiary",
+                   "unclassified", "residential", "service", "pedestrian"]
+    return '["highway"~"'+'|'.join(highway_order[start:order])+'"]'
+
+def osm_stations(dissolve=True):
+    osm_stations=gpd.read_file("export.geojson")
+    clean_col=osm_stations.columns[osm_stations.isna().mean()<0.9]
+    osm_clean=osm_stations[clean_col].drop(["barrier", "@id"], axis=1).dropna(subset="name")
+    osm_clean["autoroute"]=osm_clean["highway:ref"].str.replace(" ", "")
+    osm_clean["nref"]=osm_clean["operator:ref"]
+    badguys="Péage des |Péage de |Péage d'|Péage-de-|Péage du |Péage-du-|Péage "
+    osm_clean["name"]=osm_clean["name"].str.replace(badguys, "", regex=True)
+    osm_clean["osmid"]=osm_clean["id"].str.split("/").str[1].astype(int)
+    if dissolve:
+        osm_clean=osm_clean.dissolve(by='name', aggfunc='first')
+    osm_clean['geometry'] = osm_clean.geometry.to_crs("2154").centroid
+    osm_clean['latlon'] = osm_clean.geometry.to_crs("WGS84")
+    osm_clean=osm_clean.drop(columns=["id", "highway:ref", "operator:ref"])
+    return osm_clean
+
+
+def rebuild_highway(Gsub, inter, weight="travel_time"):
+    """
+        On s'inspire de osmnx.simplification::simplify_graph (l. 275)
+        On prend un graph correspondant à un composant connecté.
+        On calcule les distances minimales deux à deux, on ajoute les tarifs.
+        Pour chaque paire :
+            - on récupère le chemin.
+            - on fusionne les géométries des edges, on ajoute le temps, le tarif, début et fin
+            - on met les edges dans un set
+            - on met les noeuds non-toll_booth dans un set
+        On supprime edges et nodes.
+        On ajoute les edges recalculés.
+    """
+
+    dftarifs=pd.read_csv("tarifs2025.csv")
+    dosm=osm_stations(dissolve=False).set_index("osmid").name.to_dict()
+    
+    nodes_to_remove = set()
+    len_path = dict(nx.all_pairs_dijkstra(Gsub, weight=weight))
+    ltup=[]
+    
+    for k, v in len_path.items():
+        if k not in inter:
+            continue
+        for k1, v1 in v[0].items():
+            if k1 not in inter:
+                continue
+            ent, sor = dosm[k], dosm[k1]
+            if ent == sor:
+                continue
+            tarif = dftarifs.query(f'E=="{ent}" and S=="{sor}"').Tarif.to_list()
+            if len(tarif)!=1:
+                continue
+            route=v[1][k1]
+            edges=list(Gsub.edges[edge] for edge in nx.utils.pairwise(route))
+            nodes_to_remove.update(route)
+            #weight_sum=np.sum([edge[weight] for edge in edges])
+            length_sum=np.sum([edge["length"] for edge in edges])
+            time_sum=np.sum([edge["travel_time"] for edge in edges])
+            geometry_sum=shapely.ops.linemerge([edge["geometry"] for edge in edges])
+            
+            #dic={"E": k, "S": k1, weight: v1, "route": route, "tarif": tarif[0], "geometry": geometry_sum}
+            dic={"key": 0, "length" : length_sum, "travel_time": time_sum, "route": route, 
+                 "tarif": tarif[0], "geometry": geometry_sum}
+            ltup.append((k, k1, 0, dic))
+
+    return  ltup, nodes_to_remove.difference(inter)
+
+
+def rebuild_highways(Ga, toll_nodes):
+    ltup=[]
+    nodes_to_remove=set()
+    for wcc in nx.weakly_connected_components(Ga):
+        inter=wcc.intersection(toll_nodes)
+        if len(inter) > 1 :
+            Gsub=Ga.subgraph(wcc).copy()
+            lt, to_remove=rebuild_highway(Gsub, inter)
+            ltup.extend(lt)
+            nodes_to_remove.update(to_remove)
+    return ltup, nodes_to_remove
+
+def lamb93():
+    return "EPSG:2154"
+
+def to_Lambert93():
+    transformer = Transformer.from_crs("WGS84", lamb93()) 
+    return transformer
+
+def from_Lambert93():
+    transformer = Transformer.from_crs(lamb93(), "WGS84") 
+    return transformer
+
+def get_gdf_ellipse(orig_coo, dest_coo):
+    orig_lamb=np.array(to_Lambert93().transform(*orig_coo))
+    dest_lamb=np.array(to_Lambert93().transform(*dest_coo))
+    C=(orig_lamb+dest_lamb)/2
+    D=orig_lamb-dest_lamb
+    a=1.15 * np.linalg.norm(D) /2
+    c = 0.4 * np.linalg.norm(D) /2
+    theta=np.arctan2(D[1], D[0]) # coo sont lat, lon donc y, x
+    circ = shapely.geometry.Point(C).buffer(1)
+    ell  = shapely.affinity.scale(circ, a, c)
+    ellr = shapely.affinity.rotate(ell, theta, use_radians=True)
+
+    return gpd.GeoSeries(ellr, crs= lamb93())
+
+def get_shapely_ellipse(orig_coo, dest_coo):
+    return get_gdf_ellipse(orig_coo, dest_coo).to_crs("WGS84").geometry[0]
+
+
+def tariftime(u, v, d, l):
+    d=d[0]
+    return d["travel_time"] if "tarif" not in d else d["travel_time"] + l*d["tarif"]
+
+
+def tariftimedf(Gc, orig_id, dest_id, weight="travel_time"):
+    ltup=[]
+
+    for l in np.arange(0, 250, 5):
+        tarif= partial(tariftime, l=l)
+        fastest=nx.shortest_path(Gc, orig_id, dest_id, weight=tarif)
+        gfast=ox.routing.route_to_gdf(Gc, fastest, weight= weight)
+        prix=float(gfast["tarif"].sum()) if "tarif" in gfast else 0
+        ltup.append((prix, float(gfast["travel_time"].sum()),  fastest ))
+        if prix==0: break
+
+    df=pd.DataFrame(ltup, columns=["tarif", "time", "path"]).drop_duplicates(subset=["tarif", "time"]).reset_index()
+    df["time (mn)"]=df["time"]/60
+    return df
+
+
+def download_graph(orig_coo, dest_coo, precision):
+    buf=get_shapely_ellipse(orig_coo , dest_coo)
+    cf=custom_filter_order(precision)
+    G=ox.graph.graph_from_polygon(buf, network_type='drive', custom_filter=cf, simplify=False)
+    G=ox.simplify_graph(G, node_attrs_include=["barrier"])
+    G = ox.add_edge_speeds(G)
+    G = ox.add_edge_travel_times(G)
+    G = ox.project_graph(G, to_crs=lamb93()) 
+    return G
+    
+def add_tarifs(G):
+    gdfn, gdfe=ox.graph_to_gdfs(G)
+    if "toll" not in gdfe.columns or "barrier" not in gdfn.columns:
+        return G
+    gae=gdfe[((gdfe.highway=="motorway") & (gdfe.toll == "yes")) | (gdfe.highway=="motorway_link") ]
+    gbn=gdfn.query("barrier=='toll_booth'")
+    u, v, k = zip(*gae.index)
+    uv = set(u).union(v)
+    gan=gdfn[gdfn.index.isin(uv)]
+    Ga=ox.convert.to_digraph(ox.convert.graph_from_gdfs(gan, gae))
+    toll_nodes=gbn.index.to_list()
+    ltup, nodes_to_remove = rebuild_highways(Ga, toll_nodes)
+    Gc=G.copy()
+    Gc.remove_nodes_from(nodes_to_remove)
+    Gc.add_edges_from(ltup)
+    return Gc
+    
+
+

requirements.txt

@@ -1,6 +1,10 @@
-panel
-jupyter
-transformers
-numpy
-torch
-aiohttp
+osmnx>=2.0.0
+colorcet>=3.1.0
+geopandas>=1.0.0
+panel>=1.5.4
+param>=2.1.1
+networkx>=3.4.2
+pandas>=2.2.3
+numpy>=2.2.2
+shapely>=2.0.7
+pyproj>=3.7.0