Add curve-aware speed analysis for rail paths

Closes #128

Implement curve radius analysis for rail transit paths
(tram, metro, rail, monorail, etc.) that estimates speed limits imposed
by track curvature and adjusts travel times accordingly
when geometry is precise enough.

transition-common:
- Add railCurves/ module with geometry analysis (radius estimation via
  inscribed circle method), curvature segmentation, speed profile
  generation (forward-backward pass with acceleration/deceleration),
  and segment travel time calculation
- Integrate curve-aware calculations into PathGeographyGenerator for
  manual routing mode only (engine/engineCustom use OSRM shapes)
- Add geometry resolution detection (high/low/none/almostStraight) to
  skip curve analysis when path shapes are too coarse
- Add constants, types, and shared utility modules

transition-frontend:
- Add CurveStatsPanel with interactive speed profile chart (Recharts)
  supporting time and distance X-axis modes, proportional chart width,
  and configurable tick intervals
- Add CurveStatsTable for per-segment travel time breakdown
- Add map layers for curve segments (orange) and large-angle vertices
  (orange circles) to help users identify imprecise path geometry
- Update TransitPathStatistics to show curve-aware travel times for
  rail modes, hiding curve comparison when geometry is not high-res
- Update TransitPathEdit with curve segment layer toggle and geometry
  resolution warnings guiding users to improve path precision
- Add styles for curve stats panel, table, chart, and toggle controls

Locales:
- Add English and French translations for all new curve analysis UI
  strings, warnings, and labels

Tests:
- Add PathRailCurves.test.ts for geometry, curvature analysis, speed
  profile, and segment travel time modules
- Add curve-aware branching tests to PathGeographyGenerator.test.ts
  verifying correct activation by mode, routing engine, and resolution
- Add geojsonOutputTestUtils.ts for curve analysis debugging/testing

New package:
- recharts for curve stats panel chart

Author: kaligrafy

locales/en/main.json

@@ -23,6 +23,7 @@
     "Locked": "Locked",
     "delete": "delete",
     "Delete": "Delete",
+    "Close": "Close",
     "loading": "loading",
     "Loading": "Loading",
     "Next": "Next",
@@ -307,5 +308,6 @@
         },
         "osmAttribution": "© OpenStreetMap contributors",
         "aerialAttribution": "Aerial imagery"
-    }
+    },
+    "DownloadSvg": "Download SVG"
 }

locales/en/transit.json

@@ -465,6 +465,8 @@
         "TravelTimes": "Travel times",
         "IncludingDwellTimes": "With dwell times",
         "ExcludingDwellTimes": "Without dwell times",
+        "ExcludingDwellTimesWithCurves": "Without dwell times (with curve limits)",
+        "ExcludingDwellTimesNoCurves": "Without dwell times (no curve limits)",
         "IncludingDwellTimesAndLayover": "With dwell times and layover time",
         "LayoverTime": "Layover time",
         "Speeds": "Speeds",
@@ -513,7 +515,41 @@
             "DefaultDecelerationIsInvalid": "Deceleration is invalid.",
             "DefaultDecelerationIsTooLow": "Deceleration is too low.",
             "DefaultDecelerationIsTooHigh": "Deceleration is too high (uncomfortable)."
-        }
+        },
+        "ShowCurveSegmentsLayer": "Show speed-restricted curve segments on map",
+        "ShowCurveSegmentsLayerHelp": "Highlights path sections where the curve radius limits the maximum speed (shown in orange on the map).",
+        "CurveStats": "Curve Speed Statistics",
+        "CurveStatsSummary": "Summary",
+        "TravelTimeWithoutCurves": "Travel time (no curve limits)",
+        "TravelTimeWithCurves": "Travel time (with curve limits)",
+        "CurveTimeDifference": "Time added by curves",
+        "AvgSpeed": "Avg. speed",
+        "AvgSpeedWithoutCurves": "Avg. speed (no curve limits)",
+        "AvgSpeedWithCurves": "Avg. speed (with curve limits)",
+        "RunningSpeed": "Running speed (max)",
+        "PerSegmentBreakdown": "Per-Segment Breakdown",
+        "Segment": "Segment",
+        "Distance": "Distance",
+        "TimeWithoutCurves": "Time (no curves)",
+        "TimeWithCurves": "Time (curves)",
+        "Difference": "Diff.",
+        "MinRadius": "Min. Radius",
+        "CurveSpeedLimit": "Curve Limit",
+        "SpeedProfile": "Speed Profile",
+        "SpeedVsTime": "Speed vs Time",
+        "SpeedVsDistance": "Speed vs Distance",
+        "DistanceKm": "Distance (km)",
+        "TimeMinutes": "Time (min)",
+        "SpeedKmH": "Speed (km/h)",
+        "ActualSpeed": "Actual Speed",
+        "MaxSpeedByCurve": "Maximum Speed (including curve limits)",
+        "TotalRunningTime": "Running time",
+        "TotalDwellTime": "Dwell time",
+        "TotalTripTime": "Total trip time",
+        "TravelTime": "Travel time",
+        "GeometryResolutionWarningNone": "The path shape uses only straight lines between stations. Curves are ignored in the calculation; travel times use simple kinematic calculation (acceleration/cruise/deceleration).",
+        "GeometryResolutionWarningLow": "The path shape has low resolution (abrupt direction changes detected). Curves are ignored in the calculation; travel times use simple kinematic calculation. Vertices with insufficient precision are highlighted with orange circles on the map. Add or adjust waypoints at these locations to smooth the path for curve-aware analysis.",
+        "GeometryResolutionWarningAlmostStraight": "The path geometry appears to be almost a straight line with no intermediate waypoints. Please validate that there are no angles greater than 10° between stations. If there are curves, please draw the path shape as precisely as possible."
     },
     "transitRouting": {
         "Routing": "Routing",

locales/fr/main.json

@@ -23,6 +23,7 @@
     "Locked": "Verrouillé",
     "delete": "supprimer",
     "Delete": "Supprimer",
+    "Close": "Fermer",
     "loading": "chargement",
     "Loading": "Chargement",
     "Next": "Suivant",
@@ -307,5 +308,6 @@
         },
         "osmAttribution": "© Contributeurs OpenStreetMap",
         "aerialAttribution": "Imagerie aérienne"
-    }
+    },
+    "DownloadSvg": "Télécharger SVG"
 }

locales/fr/transit.json

@@ -465,6 +465,8 @@
         "TravelTimes": "Temps de parcours",
         "IncludingDwellTimes": "Avec les temps d'arrêt",
         "ExcludingDwellTimes": "Sans les temps d'arrêt",
+        "ExcludingDwellTimesWithCurves": "Sans les temps d'arrêt (avec limites de courbes)",
+        "ExcludingDwellTimesNoCurves": "Sans les temps d'arrêt (sans limites de courbes)",
         "IncludingDwellTimesAndLayover": "Avec les temps d'arrêt et le battement",
         "LayoverTime": "Battement",
         "Speeds": "Vitesses",
@@ -513,7 +515,41 @@
             "DefaultDecelerationIsInvalid": "La décélération est invalide.",
             "DefaultDecelerationIsTooLow": "La décélération est trop faible.",
             "DefaultDecelerationIsTooHigh": "La décélération est trop élevée (inconfortable)."
-        }
+        },
+        "ShowCurveSegmentsLayer": "Afficher les segments de courbe à vitesse limitée sur la carte",
+        "ShowCurveSegmentsLayerHelp": "Met en évidence les sections du parcours où le rayon de courbure limite la vitesse maximale (affiché en orange sur la carte).",
+        "CurveStats": "Statistiques de vitesse en courbe",
+        "CurveStatsSummary": "Résumé",
+        "TravelTimeWithoutCurves": "Temps de parcours (sans limites de courbe)",
+        "TravelTimeWithCurves": "Temps de parcours (avec limites de courbe)",
+        "CurveTimeDifference": "Temps ajouté par les courbes",
+        "AvgSpeed": "Vitesse moy.",
+        "AvgSpeedWithoutCurves": "Vitesse moy. (sans limites de courbe)",
+        "AvgSpeedWithCurves": "Vitesse moy. (avec limites de courbe)",
+        "RunningSpeed": "Vitesse de croisière (max)",
+        "PerSegmentBreakdown": "Détail par segment",
+        "Segment": "Segment",
+        "Distance": "Distance",
+        "TimeWithoutCurves": "Temps (sans courbes)",
+        "TimeWithCurves": "Temps (courbes)",
+        "Difference": "Diff.",
+        "MinRadius": "Rayon min.",
+        "CurveSpeedLimit": "Limite courbe",
+        "SpeedProfile": "Profil de vitesse",
+        "SpeedVsTime": "Vitesse vs Temps",
+        "SpeedVsDistance": "Vitesse vs Distance",
+        "DistanceKm": "Distance (km)",
+        "TimeMinutes": "Temps (min)",
+        "SpeedKmH": "Vitesse (km/h)",
+        "ActualSpeed": "Vitesse réelle",
+        "MaxSpeedByCurve": "Vitesse maximale (incluant les limites en courbe)",
+        "TotalRunningTime": "Temps de parcours",
+        "TotalDwellTime": "Temps d'arrêt",
+        "TotalTripTime": "Temps total du trajet",
+        "TravelTime": "Temps de parcours",
+        "GeometryResolutionWarningNone": "La forme du parcours utilise seulement des lignes droites entre les stations. Les courbes sont ignorées dans le calcul; les temps de parcours utilisent un calcul cinématique simple (accélération/vitesse de croisière/décélération).",
+        "GeometryResolutionWarningLow": "La forme du parcours a une résolution faible (changements de direction abrupts détectés). Les courbes sont ignorées dans le calcul; les temps de parcours utilisent un calcul cinématique simple. Les sommets avec une précision insuffisante sont surlignés par des cercles orange sur la carte. Ajoutez ou ajustez les points de passage à ces endroits pour lisser le parcours et activer l'analyse des courbes.",
+        "GeometryResolutionWarningAlmostStraight": "La géométrie du parcours semble être presque une ligne droite sans points intermédiaires. Veuillez valider qu'il n'y a pas d'angles de plus de 10° entre les stations. S'il y a des courbes, veuillez dessiner la forme du parcours aussi précisément que possible."
     },
     "transitRouting": {
         "Routing": "Calcul de chemin",

packages/transition-common/src/services/line/types.ts

@@ -4,6 +4,9 @@
  * This file is licensed under the MIT License.
  * License text available at https://opensource.org/licenses/MIT
  */
+
+import lineModes from '../../config/lineModes';
+
 /**
  * Right-of-way categories:
  * ROW A: Fully controlled separated track/lanes used exclusively by transit vehicles, priority at all time
@@ -50,7 +53,7 @@ export type TransitMode = (typeof transitModes)[number];
  * Curves max speed: https://www.youtube.com/watch?v=veGEOSEDSlE
  * Curves geometry: https://www.thepwayengineer.com/blog/categories/track-geometry
  * Track geometry: https://en.wikipedia.org/wiki/Track_geometry
- * Gardient/Slope: https://en.wikipedia.org/wiki/Grade_(slope)#Railways
+ * Gradient/Slope: https://en.wikipedia.org/wiki/Grade_(slope)#Railways
  *
  * @param {TransitMode | undefined | null} mode The transit mode to check
  * @returns true if the mode is a rail-based mode
@@ -60,6 +63,50 @@ export function isRailMode(mode: TransitMode | undefined | null): mode is RailMo
     return (railModes as readonly string[]).includes(mode);
 }
 
+/**
+ * Return the default running speed (km/h) for a given transit mode,
+ * looked up from the lineModes configuration (`config/lineModes.ts`).
+ *
+ * Used as a fallback when the path does not have an explicit
+ * `defaultRunningSpeedKmH` value. This single lookup keeps the map
+ * curve-segment visualisation, the speed-profile chart and the
+ * statistics panel consistent.
+ *
+ * @param mode The transit mode to look up.
+ * @param fallback Value returned when the mode is unknown or null (default 80).
+ */
+export function getDefaultRunningSpeedKmH(mode: TransitMode | undefined | null, fallback = 80): number {
+    if (!mode) return fallback;
+    const entry = lineModes.find((m) => m.value === mode);
+    return entry?.defaultValues?.data?.defaultRunningSpeedKmH ?? fallback;
+}
+
+/**
+ * Return the default acceleration (m/s²) for a given transit mode,
+ * looked up from the lineModes configuration (`config/lineModes.ts`).
+ *
+ * @param mode The transit mode to look up.
+ * @param fallback Value returned when the mode is unknown or null (default 0.8).
+ */
+export function getDefaultAcceleration(mode: TransitMode | undefined | null, fallback = 0.8): number {
+    if (!mode) return fallback;
+    const entry = lineModes.find((m) => m.value === mode);
+    return entry?.defaultValues?.data?.defaultAcceleration ?? fallback;
+}
+
+/**
+ * Return the default deceleration (m/s²) for a given transit mode,
+ * looked up from the lineModes configuration (`config/lineModes.ts`).
+ *
+ * @param mode The transit mode to look up.
+ * @param fallback Value returned when the mode is unknown or null (default 0.8).
+ */
+export function getDefaultDeceleration(mode: TransitMode | undefined | null, fallback = 0.8): number {
+    if (!mode) return fallback;
+    const entry = lineModes.find((m) => m.value === mode);
+    return entry?.defaultValues?.data?.defaultDeceleration ?? fallback;
+}
+
 /** Vertical alignments:
  * underground: below grade (subway, tunnel, etc.) (level -1)
  * surface: at-grade (level 0) (solid, not water)

packages/transition-common/src/services/path/PathGeographyGenerator.ts

@@ -15,6 +15,13 @@ import {
     durationFromAccelerationDecelerationDistanceAndRunningSpeed,
     kphToMps
 } from 'chaire-lib-common/lib/utils/PhysicsUtils';
+import {
+    calculateSegmentTimeWithCurves,
+    calculateNoDwellTimeWithCurves,
+    detectGeometryResolution,
+    shouldUseCurveAnalysis
+} from './railCurves/segmentTravelTime';
+import { isRailMode, type RailMode } from '../line/types';
 
 /**
  * Get the coordinates from a geometry
@@ -77,7 +84,7 @@ const handleLegs = (path: any, points: Geojson.Feature<Geojson.Point>[], legs: (
         segmentDuration += Math.ceil(leg.duration);
         segmentDistance += Math.ceil(leg.distance);
 
-        // Path cannot finish at a waypoint, so this last segment si not part of the total calculations.
+        // Path cannot finish at a waypoint, so this last segment is not part of the total calculations.
         if (i === legs.length - 1 && !nodeIds[nextNodeIndex]) {
             // last leg is to a waypoint (missing node at the end)
             segments.push(segmentCoordinatesStartIndex);
@@ -111,14 +118,58 @@ const handleLegs = (path: any, points: Geojson.Feature<Geojson.Point>[], legs: (
                     ? segmentDuration
                     : segmentDistance / runningSpeed; // no acceleration/deceleration
 
-            const calculatedSegmentDuration = Math.ceil(
-                durationFromAccelerationDecelerationDistanceAndRunningSpeed(
-                    acceleration,
-                    deceleration,
-                    segmentDistance,
-                    runningSpeed
-                )
-            );
+            // For rail modes with 'manual' (click on map) routing, use curve-aware
+            // travel time calculation. When routingEngine is 'engine' or 'engineCustom',
+            // OSRM already provides realistic travel times that account for the
+            // road/rail network, so curve analysis is not needed.
+            // For now, cant (the lateral slope between the two tracks)
+            // and other speed limits are not supported.
+            const pathMode = path.getMode();
+            let calculatedSegmentDuration: number | null;
+
+            // For rail modes with non-engine routing, check if geometry
+            // resolution is high enough to use curve-aware calculations.
+            const segmentCoords = globalCoordinates.slice(segmentCoordinatesStartIndex, globalCoordinates.length);
+            const segGeometryResolution = detectGeometryResolution(segmentCoords, 1);
+            const useSegCurves = shouldUseCurveAnalysis(segGeometryResolution);
+
+            if (routingEngine === 'manual' && isRailMode(pathMode) && useSegCurves && segmentCoords.length >= 3) {
+                const maxSpeedKmH = runningSpeed * 3.6; // Convert from m/s to km/h
+                const curveOptions = {
+                    mode: pathMode as RailMode,
+                    runningSpeedKmH: maxSpeedKmH,
+                    accelerationMps2: acceleration,
+                    decelerationMps2: deceleration,
+                    maxSpeedKmH
+                };
+
+                // Use curve-aware calculation WITH accel/decel for station stops
+                const curveResult = calculateSegmentTimeWithCurves(
+                    globalCoordinates,
+                    segmentCoordinatesStartIndex,
+                    globalCoordinates.length - 1,
+                    curveOptions
+                );
+                calculatedSegmentDuration = Math.ceil(curveResult.timeSeconds);
+
+                // "No dwell" time: curve-aware but WITHOUT accel/decel for station stops
+                noDwellTimeDuration = calculateNoDwellTimeWithCurves(
+                    globalCoordinates,
+                    segmentCoordinatesStartIndex,
+                    globalCoordinates.length - 1,
+                    curveOptions
+                );
+            } else {
+                // Standard calculation for non-rail modes
+                calculatedSegmentDuration = Math.ceil(
+                    durationFromAccelerationDecelerationDistanceAndRunningSpeed(
+                        acceleration,
+                        deceleration,
+                        segmentDistance,
+                        runningSpeed
+                    )
+                );
+            }
             segmentDuration = calculatedSegmentDuration !== null ? calculatedSegmentDuration : -1;
 
             if (segmentDuration <= 0) {