added climb profiles

app.py

@@ -119,6 +119,9 @@ def grade_to_color(grade):
 
 
 def find_climbs(df: pd.DataFrame) -> pd.DataFrame:
+    """Detect all valleys and peaks. Filter out climbs and
+    add meta data (lenght, meters climbed, average grade, climb_score, ...)
+    """
     peaks, _ = find_peaks(df["smoothed_elevation"])
     df_peaks = df.iloc[peaks, :].assign(base=0).assign(kind="peak")
     valleys, _ = find_peaks(df["smoothed_elevation"].max() - df["smoothed_elevation"])
@@ -184,7 +187,14 @@ def generate_height_profile_json(df: pd.DataFrame) -> str:
 
     elevation = (
         alt.Chart(
-            df[["distance_from_start", "smoothed_elevation", "smoothed_grade_color"]]
+            df[
+                [
+                    "distance_from_start",
+                    "smoothed_elevation",
+                    "smoothed_grade_color",
+                    "grade",
+                ]
+            ]
         )
         .mark_bar()
         .encode(
@@ -204,6 +214,16 @@ def generate_height_profile_json(df: pd.DataFrame) -> str:
                 title=None,
             ),
             color=alt.Color("smoothed_grade_color").scale(None),
+            tooltip=[
+                alt.Tooltip(
+                    "distance_from_start:Q", title="Distance (km)", format=".2f"
+                ),
+                alt.Tooltip("smoothed_elevation:Q", title="Elevation (m)", format="d"),
+                alt.Tooltip("grade_percent:Q", title="Grade (%)", format=".0%"),
+            ],
+        )
+        .transform_calculate(
+            grade_percent="datum.grade/100",
         )
     )
     max_elevation = df["elev"].max().round(-1)
@@ -272,7 +292,17 @@ def generate_height_profile_json(df: pd.DataFrame) -> str:
         df_peaks_filtered.reset_index(drop=True)
         .assign(number=lambda df_: df_.index + 1)
         .assign(circle_pos=lambda df_: df_["max_elevation"] + 20)[
-            ["distance_from_start", "max_elevation", "circle_pos", "number"]
+            [
+                "distance_from_start",
+                "max_elevation",
+                "circle_pos",
+                "number",
+                "length",
+                "total_ascent",
+                "grade",
+                "climb_score",
+                "prev_distance_from_start",
+            ]
         ]
     )
     # annotation = (
@@ -294,6 +324,19 @@ def generate_height_profile_json(df: pd.DataFrame) -> str:
             ),
             y="max_elevation",
             text="number",
+            tooltip=[
+                alt.Tooltip(
+                    "prev_distance_from_start:Q", title="Starts at (km)", format=".2f"
+                ),
+                alt.Tooltip("total_ascent:Q", title="Total ascent (m)", format="d"),
+                alt.Tooltip("length:Q", title="Length (km)", format=".2f"),
+                alt.Tooltip("grade_percent:Q", title="Average Grade", format=".0%"),
+                alt.Tooltip("climb_score:Q", title="Climb score", format="d"),
+            ],
+        )
+        .transform_calculate(
+            grade_percent="datum.grade/(100*1000)",
+            # total_ascent_int="Math.round(datum.total_ascent)",
         )
     )
     chart = (
@@ -306,15 +349,47 @@ def generate_height_profile_json(df: pd.DataFrame) -> str:
     return chart, df_peaks_filtered
 
 
+def generate_climb_profile(df_hill: pd.DataFrame, title: str):
+    climb_profile = (
+        alt.Chart(
+            df_hill,
+            title=alt.Title(
+                title,
+                anchor="start",
+            ),
+        )
+        .mark_area()
+        .encode(
+            x=alt.X("distance_from_start")
+            .axis(grid=False, tickCount=10, labelExpr="datum.label + ' m'", title=None)
+            .scale(domain=(0, df_hill["distance_from_start"].max())),
+            y=alt.Y("elev").axis(
+                domain=False,
+                ticks=False,
+                tickCount=5,
+                labelExpr="datum.label + ' m'",
+                title=None,
+            ),
+            color=alt.Color("color_grade").scale(None),
+            tooltip=[
+                alt.Tooltip("distance_from_start:Q", title="Distance (m)", format="d"),
+                alt.Tooltip("elev:Q", title="Elevation (m)", format="d"),
+                alt.Tooltip("grade_percent:Q", title="Grade (%)", format=".0%"),
+            ],
+        )
+        .transform_calculate(
+            grade_percent="datum.grade/100",
+        )
+    )
+    return climb_profile
+
+
 gpx_file = st.file_uploader("Upload gpx file", type=["gpx"])
 
 if gpx_file is not None:
     ave_lat, ave_lon, lon_list, lat_list, h_list = get_gpx(gpx_file)
     df = pd.DataFrame({"lon": lon_list, "lat": lat_list, "elev": h_list})
-    route_map = folium.Map(
-        location=[ave_lat, ave_lon],
-        zoom_start=12,
-    )
+    route_map = folium.Map(location=[ave_lat, ave_lon], zoom_start=12, height=400)
     folium.PolyLine(
         list(zip(lat_list, lon_list)), color="red", weight=2.5, opacity=1
     ).add_to(route_map)
@@ -338,15 +413,62 @@ if gpx_file is not None:
             if row["length"] >= 1
             else f"{row['length']*1000:.0f} m"
         )
-        popup_text = f"""Lenght: {length}<br>
-                Avg. grade: {row['grade']/1000:.1f}%"""
+        popup_text = f"""Climb {index+1}<br>
+                Lenght: {length}<br>
+                Avg. grade: {row['grade']/1000:.1f}%<br>
+                Total ascend: {int(row['total_ascent'])}m
+        """
         popup = folium.Popup(popup_text, min_width=100, max_width=200)
         folium.Marker(
             [row["lat"], row["lon"]],
-            popup=popup,
+            # popup=popup,
             icon=icon_div,
         ).add_to(route_map)
-        route_map.add_child(folium.CircleMarker([row["lat"], row["lon"]], radius=15))
+
+        df_hill = (
+            df[
+                df["distance_from_start"].between(
+                    row["prev_distance_from_start"],
+                    row["distance_from_start"],
+                )
+            ]
+            .assign(
+                distance_from_start=lambda df_: (
+                    df_["distance_from_start"] - row["prev_distance_from_start"]
+                )
+                * 1_000
+            )
+            .assign(color_grade=lambda df_: df_["grade"].map(grade_to_color))
+        )
+        # df_hill_resample = df_hill.groupby((df_hill["distance_from_start"]*1000).round(-2)).agg({"elev":"mean", "grade":"mean"}).reset_index()
+        # df_hill_resample["color_grade"] = df_resampled["grade"].map(grade_to_color)
+        title = f"Climb {index+1}: {row['length']:.2f}km {(row['grade']/100_000):.2%} {int(row['total_ascent']):d}hm"
+        climb_profile = generate_climb_profile(df_hill, title)
+        climb_profile_json = json.loads(climb_profile.to_json())
+
+        vega = folium.features.VegaLite(
+            climb_profile_json,
+            width=200,
+            height=200,
+        )
+        circle = folium.CircleMarker(
+            radius=15,
+            location=[row["lat"], row["lon"]],
+            # tooltip = label,
+            color="crimson",
+            fill=True,
+        )
+        # popup = folium.Popup()
+        # vega.add_to(popup)
+        popup.add_to(circle)
+        circle.add_to(route_map)
+        # circle_marker = folium.CircleMarker(
+        #     [row["lat"], row["lon"]],
+        #     radius=15,
+        #     popup=folium.Popup(max_width=400).add_child(
+        #         folium.VegaLite(climb_profile_json, width=400, height=400)
+        #     ),
+        # )
 
     st.table(
         df_peaks[
@@ -354,6 +476,28 @@ if gpx_file is not None:
         ].reset_index(drop=True)
     )
 
-    st_data = st_folium(route_map, height=450, width=850)
+    st_data = st_folium(route_map, height=600, width=850)
 
     st.altair_chart(chart, use_container_width=True)
+
+    for index, row in df_peaks.reset_index(drop=True).iterrows():
+        df_hill = (
+            df[
+                df["distance_from_start"].between(
+                    row["prev_distance_from_start"],
+                    row["distance_from_start"],
+                )
+            ]
+            .assign(
+                distance_from_start=lambda df_: (
+                    df_["distance_from_start"] - row["prev_distance_from_start"]
+                )
+                * 1_000
+            )
+            .assign(color_grade=lambda df_: df_["grade"].map(grade_to_color))
+        )
+        # df_hill_resample = df_hill.groupby((df_hill["distance_from_start"]*1000).round(-2)).agg({"elev":"mean", "grade":"mean"}).reset_index()
+        # df_hill_resample["color_grade"] = df_resampled["grade"].map(grade_to_color)
+        title = f"Climb {index+1}: {row['length']:.2f}km {(row['grade']/100_000):.2%} {int(row['total_ascent']):d}hm"
+        climb_profile = generate_climb_profile(df_hill, title)
+        st.altair_chart(climb_profile, use_container_width=True)