[US] Ajouter une interface Dash Minimale - Formulaire et affichage dynamique des données

front/app/components/features/map/__init__.py

@@ -0,0 +1,4 @@
+# Réexporte Map depuis la nouvelle implémentation.
+from .map_component import Map
+
+__all__ = ["Map"]

front/app/components/features/map/color_scale.py

@@ -0,0 +1,40 @@
+from dataclasses import dataclass
+import numpy as np
+import pandas as pd
+
+@dataclass(frozen=True)
+class ColorScale:
+    vmin: float
+    vmax: float
+
+    def _rng(self) -> float:
+        r = self.vmax - self.vmin
+        return r if r > 1e-9 else 1.0
+
+    def legend(self, v) -> str:
+        if pd.isna(v):
+            return "Donnée non disponible"
+        rng = self._rng()
+        t1 = self.vmin + rng / 3.0
+        t2 = self.vmin + 2 * rng / 3.0
+        v = float(v)
+        if v <= t1:
+            return "Accès rapide"
+        if v <= t2:
+            return "Accès moyen"
+        return "Accès lent"
+
+    def rgba(self, v) -> list[int]:
+        if pd.isna(v):
+            return [200, 200, 200, 140]
+        z = (float(v) - self.vmin) / self._rng()
+        z = max(0.0, min(1.0, z))
+        r = int(255 * z)
+        g = int(64 + 128 * (1 - z))
+        b = int(255 * (1 - z))
+        return [r, g, b, 180]
+
+def fit_color_scale(series: pd.Series) -> ColorScale:
+    s = pd.to_numeric(series, errors="coerce").replace([np.inf, -np.inf], np.nan).dropna()
+    vmin, vmax = (float(s.min()), float(s.max())) if not s.empty else (0.0, 1.0)
+    return ColorScale(vmin=vmin, vmax=vmax)

front/app/components/features/map/components.py

@@ -0,0 +1,73 @@
+import dash_deck
+from dash import html
+import dash_mantine_components as dmc
+
+from .config import HEADER_OFFSET_PX, SIDEBAR_WIDTH
+from app.components.features.study_area_summary import StudyAreaSummary
+from app.components.features.scenario_controls import ScenarioControlsPanel
+
+from .tooltip import default_tooltip
+
+def DeckMap(id_prefix: str, deck_json: str) -> dash_deck.DeckGL:
+    return dash_deck.DeckGL(
+        id=f"{id_prefix}-deck-map",
+        data=deck_json,
+        tooltip=default_tooltip(),
+        mapboxKey="",
+        style={
+            "position": "absolute",
+            "inset": 0,
+            "height": "100vh",
+            "width": "100%",
+        },
+    )
+
+def SummaryPanelWrapper(zones_gdf, id_prefix: str):
+    return html.Div(
+        id=f"{id_prefix}-summary-wrapper",
+        children=StudyAreaSummary(zones_gdf, visible=True, id_prefix=id_prefix),
+    )
+
+def ControlsSidebarWrapper(id_prefix: str):
+     return html.Div(
+        dmc.Paper(
+            children=[
+                dmc.Stack(
+                    [
+                        ScenarioControlsPanel(
+                            id_prefix=id_prefix,
+                            min_radius=15,
+                            max_radius=50,
+                            step=1,
+                            default=40,
+                            default_insee="31555",
+                        )
+                    ],
+                    gap="md",
+                )
+            ],
+            withBorder=True,
+            shadow="md",
+            radius="md",
+            p="md",
+            style={
+                "width": "100%",
+                "height": "100%",
+                "overflowY": "auto",
+                "overflowX": "hidden",
+                "background": "#ffffffee",
+                "boxSizing": "border-box",
+            },
+        ),
+        id=f"{id_prefix}-controls-sidebar",
+        style={
+            "position": "absolute",
+            "top": f"{HEADER_OFFSET_PX}px",
+            "left": "0px",
+            "bottom": "0px",
+            "width": f"{SIDEBAR_WIDTH}px",
+            "zIndex": 1200,
+            "pointerEvents": "auto",
+            "overflow": "hidden",
+        },
+    )

front/app/components/features/map/config.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+# ---------- CONSTANTES ----------
+CARTO_POSITRON_GL = "https://basemaps.cartocdn.com/gl/positron-gl-style/style.json"
+FALLBACK_CENTER = (1.4442, 43.6045)  # Toulouse
+
+HEADER_OFFSET_PX = 80
+SIDEBAR_WIDTH = 340
+
+# ---------- OPTIONS ----------
+@dataclass(frozen=True)
+class DeckOptions:
+    zoom: float = 10
+    pitch: float = 35
+    bearing: float = -15
+    map_style: str = CARTO_POSITRON_GL

front/app/components/features/map/deck_factory.py

@@ -0,0 +1,46 @@
+import pydeck as pdk
+import pandas as pd
+import geopandas as gpd
+
+from .config import FALLBACK_CENTER, DeckOptions
+from .geo_utils import safe_center
+from .color_scale import fit_color_scale
+from .layers import build_zones_layer, build_flows_layer
+
+def make_layers(zones_gdf: gpd.GeoDataFrame, flows_df: pd.DataFrame, zones_lookup: gpd.GeoDataFrame):
+    scale = fit_color_scale(zones_gdf.get("average_travel_time", pd.Series(dtype="float64")))
+    layers = []
+    zl = build_zones_layer(zones_gdf, scale)
+    if zl is not None:
+        layers.append(zl)
+    fl = build_flows_layer(flows_df, zones_lookup)
+    if fl is not None:
+        layers.append(fl)
+    return layers
+
+def make_deck(scn: dict, opts: DeckOptions) -> pdk.Deck:
+    zones_gdf: gpd.GeoDataFrame = scn["zones_gdf"].copy()
+    flows_df: pd.DataFrame = scn["flows_df"].copy()
+    zones_lookup: gpd.GeoDataFrame = scn["zones_lookup"].copy()
+
+    layers = make_layers(zones_gdf, flows_df, zones_lookup)
+    lon, lat = safe_center(zones_gdf) or FALLBACK_CENTER
+
+    view_state = pdk.ViewState(
+        longitude=lon,
+        latitude=lat,
+        zoom=opts.zoom,
+        pitch=opts.pitch,
+        bearing=opts.bearing,
+    )
+
+    return pdk.Deck(
+        layers=layers,
+        initial_view_state=view_state,
+        map_provider="carto",
+        map_style=opts.map_style,
+        views=[pdk.View(type="MapView", controller=True)],
+    )
+
+def make_deck_json(scn: dict, opts: DeckOptions) -> str:
+    return make_deck(scn, opts).to_json()

front/app/components/features/map/geo_utils.py

@@ -0,0 +1,62 @@
+import logging
+from typing import Optional, Tuple
+
+import geopandas as gpd
+import numpy as np
+import pandas as pd
+from shapely.geometry import Polygon, MultiPolygon
+
+logger = logging.getLogger(__name__)
+
+def ensure_wgs84(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """Assure EPSG:4326 pour la sortie."""
+    g = gdf.copy()
+    if g.crs is None:
+        g = g.set_crs(4326, allow_override=True)
+    elif getattr(g.crs, "to_epsg", lambda: None)() != 4326:
+        g = g.to_crs(4326)
+    return g
+
+def centroids_lonlat(gdf: gpd.GeoDataFrame) -> gpd.GeoDataFrame:
+    """Ajoute colonnes lon/lat calculées en mètres (EPSG:3857) puis reprojetées en 4326."""
+    g = gdf.copy()
+    if g.crs is None:
+        g = g.set_crs(4326, allow_override=True)
+    g_m = g.to_crs(3857)
+    pts_m = g_m.geometry.centroid
+    pts_ll = gpd.GeoSeries(pts_m, crs=g_m.crs).to_crs(4326)
+    g["lon"] = pts_ll.x.astype("float64")
+    g["lat"] = pts_ll.y.astype("float64")
+    return g
+
+def safe_center(gdf: gpd.GeoDataFrame) -> Optional[Tuple[float, float]]:
+    """Calcule un centroïde global robuste en WGS84, sinon None."""
+    try:
+        zvalid = gdf[gdf.geometry.notnull() & gdf.geometry.is_valid]
+        if zvalid.empty:
+            return None
+        centroid = ensure_wgs84(zvalid).geometry.unary_union.centroid
+        return float(centroid.x), float(centroid.y)
+    except Exception as e:
+        logger.warning("safe_center failed: %s", e)
+        return None
+
+def fmt_num(v, nd=1):
+    try:
+        return f"{round(float(v), nd):.{nd}f}"
+    except Exception:
+        return "N/A"
+
+def fmt_pct(v, nd=1):
+    try:
+        return f"{round(float(v) * 100.0, nd):.{nd}f} %"
+    except Exception:
+        return "N/A"
+
+def as_polygon_rings(geom):
+    """Retourne les anneaux extérieurs d’un Polygon/MultiPolygon sous forme de liste de coordonnées."""
+    if isinstance(geom, Polygon):
+        return [list(geom.exterior.coords)]
+    if isinstance(geom, MultiPolygon):
+        return [list(p.exterior.coords) for p in geom.geoms]
+    return []

front/app/components/features/map/layers.py

@@ -0,0 +1,94 @@
+from typing import List, Dict
+import pandas as pd
+import numpy as np
+import pydeck as pdk
+import geopandas as gpd
+
+from .geo_utils import ensure_wgs84, as_polygon_rings, fmt_num, fmt_pct, centroids_lonlat
+from .color_scale import ColorScale
+
+def _polygons_records(zones_gdf: gpd.GeoDataFrame, scale: ColorScale) -> List[Dict]:
+    g = ensure_wgs84(zones_gdf)
+    out = []
+    for _, row in g.iterrows():
+        rings = as_polygon_rings(row.geometry)
+        if not rings:
+            continue
+
+        zone_id = row.get("transport_zone_id", "Zone inconnue")
+        insee = row.get("local_admin_unit_id", "N/A")
+        avg_tt = pd.to_numeric(row.get("average_travel_time", np.nan), errors="coerce")
+        total_dist_km = pd.to_numeric(row.get("total_dist_km", np.nan), errors="coerce")
+        total_time_min = pd.to_numeric(row.get("total_time_min", np.nan), errors="coerce")
+        share_car = pd.to_numeric(row.get("share_car", np.nan), errors="coerce")
+        share_bicycle = pd.to_numeric(row.get("share_bicycle", np.nan), errors="coerce")
+        share_walk = pd.to_numeric(row.get("share_walk", np.nan), errors="coerce")
+
+        for ring in rings:
+            out.append({
+                "geometry": [[float(x), float(y)] for x, y in ring],
+                "fill_rgba": scale.rgba(avg_tt),
+                "Unité INSEE": str(insee),
+                "Identifiant de zone": str(zone_id),
+                "Temps moyen de trajet (minutes)": fmt_num(avg_tt, 1),
+                "Niveau d’accessibilité": scale.legend(avg_tt),
+                "Distance totale parcourue (km/jour)": fmt_num(total_dist_km, 1),
+                "Temps total de déplacement (min/jour)": fmt_num(total_time_min, 1),
+                "Part des trajets en voiture (%)": fmt_pct(share_car, 1),
+                "Part des trajets à vélo (%)": fmt_pct(share_bicycle, 1),
+                "Part des trajets à pied (%)": fmt_pct(share_walk, 1),
+            })
+    return out
+
+def build_zones_layer(zones_gdf: gpd.GeoDataFrame, scale: ColorScale) -> pdk.Layer | None:
+    polys = _polygons_records(zones_gdf, scale)
+    if not polys:
+        return None
+    return pdk.Layer(
+        "PolygonLayer",
+        data=polys,
+        get_polygon="geometry",
+        get_fill_color="fill_rgba",
+        pickable=True,
+        filled=True,
+        stroked=True,
+        get_line_color=[0, 0, 0, 80],
+        lineWidthMinPixels=1.5,
+        elevation_scale=0,
+        opacity=0.4,
+        auto_highlight=True,
+    )
+
+def build_flows_layer(flows_df: pd.DataFrame, zones_lookup: gpd.GeoDataFrame) -> pdk.Layer | None:
+    if flows_df is None or flows_df.empty:
+        return None
+
+    lookup_ll = centroids_lonlat(zones_lookup)
+    f = flows_df.copy()
+    f["flow_volume"] = pd.to_numeric(f["flow_volume"], errors="coerce").fillna(0.0)
+    f = f[f["flow_volume"] > 0]
+
+    f = f.merge(
+        lookup_ll[["transport_zone_id", "lon", "lat"]],
+        left_on="from", right_on="transport_zone_id", how="left"
+    ).rename(columns={"lon": "lon_from", "lat": "lat_from"}).drop(columns=["transport_zone_id"])
+    f = f.merge(
+        lookup_ll[["transport_zone_id", "lon", "lat"]],
+        left_on="to", right_on="transport_zone_id", how="left"
+    ).rename(columns={"lon": "lon_to", "lat": "lat_to"}).drop(columns=["transport_zone_id"])
+    f = f.dropna(subset=["lon_from", "lat_from", "lon_to", "lat_to"])
+    if f.empty:
+        return None
+
+    f["flow_width"] = (1.0 + np.log1p(f["flow_volume"])).astype("float64").clip(0.5, 6.0)
+
+    return pdk.Layer(
+        "ArcLayer",
+        data=f,
+        get_source_position=["lon_from", "lat_from"],
+        get_target_position=["lon_to", "lat_to"],
+        get_source_color=[255, 140, 0, 180],
+        get_target_color=[0, 128, 255, 180],
+        get_width="flow_width",
+        pickable=True,
+    )