geo-activity-playground 0.22.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

geo_activity_playground/webui/{equipment_controller.py → equipment/controller.py}

@@ -1,8 +1,8 @@
 import altair as alt
 import pandas as pd
 
-from ..core.config import get_config
 from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.config import get_config
 
 
 class EquipmentController:
@@ -18,7 +18,8 @@ class EquipmentController:
                         "time": group["start"],
                         "total_distance_km": group["distance_km"].cumsum(),
                     }
-                )
+                ),
+                include_groups=False,
             )
             .reset_index()
         )
@@ -52,7 +53,8 @@ class EquipmentController:
                         "last_use": group["start"].iloc[-1],
                     },
                     index=[0],
-                )
+                ),
+                include_groups=False,
             )
             .reset_index()
             .sort_values("last_use", ascending=False)

geo_activity_playground/webui/explorer/blueprint.py

@@ -0,0 +1,54 @@
+from flask import Blueprint
+from flask import render_template
+from flask import Response
+
+from ...core.activities import ActivityRepository
+from ...explorer.tile_visits import TileVisitAccessor
+from .controller import ExplorerController
+
+
+def make_explorer_blueprint(
+    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> Blueprint:
+    explorer_controller = ExplorerController(repository, tile_visit_accessor)
+    blueprint = Blueprint("explorer", __name__, template_folder="templates")
+
+    @blueprint.route("/<zoom>")
+    def map(zoom: str):
+        return render_template(
+            "explorer/index.html.j2", **explorer_controller.render(int(zoom))
+        )
+
+    @blueprint.route("/<zoom>/<north>/<east>/<south>/<west>/explored.<suffix>")
+    def download(zoom: str, north: str, east: str, south: str, west: str, suffix: str):
+        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
+        return Response(
+            explorer_controller.export_explored_tiles(
+                int(zoom),
+                float(north),
+                float(east),
+                float(south),
+                float(west),
+                suffix,
+            ),
+            mimetype=mimetypes[suffix],
+            headers={"Content-disposition": "attachment"},
+        )
+
+    @blueprint.route("/<zoom>/<north>/<east>/<south>/<west>/missing.<suffix>")
+    def missing(zoom: str, north: str, east: str, south: str, west: str, suffix: str):
+        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
+        return Response(
+            explorer_controller.export_missing_tiles(
+                int(zoom),
+                float(north),
+                float(east),
+                float(south),
+                float(west),
+                suffix,
+            ),
+            mimetype=mimetypes[suffix],
+            headers={"Content-disposition": "attachment"},
+        )
+
+    return blueprint

geo_activity_playground/webui/{explorer_controller.py → explorer/controller.py}

@@ -112,8 +112,12 @@ def get_three_color_tiles(
     cmap_last = matplotlib.colormaps["plasma"]
     tile_dict = {}
     for tile, tile_data in tile_visits.items():
-        first_age_days = (today - tile_data["first_time"].date()).days
-        last_age_days = (today - tile_data["last_time"].date()).days
+        if not pd.isna(tile_data["first_time"]):
+            first_age_days = (today - tile_data["first_time"].date()).days
+            last_age_days = (today - tile_data["last_time"].date()).days
+        else:
+            first_age_days = 10000
+            last_age_days = 10000
         tile_dict[tile] = {
             "first_activity_id": str(tile_data["first_id"]),
             "first_activity_name": repository.get_activity_by_id(tile_data["first_id"])[

geo_activity_playground/webui/{templates/explorer.html.j2 → explorer/templates/explorer/index.html.j2}

@@ -10,8 +10,8 @@
             explored.square_size }}².
         </p>
         <p>Open the <a
-                href="/square-planner/{{ zoom }}/{{ explored.square_x }}/{{ explored.square_y }}/{{ explored.square_size }}">Square
-                Planner</a> to plan the next extention.</p>
+                href="{{ url_for('square_planner.index', zoom=zoom, x=explored.square_x, y=explored.square_y, size=explored.square_size) }}">Square
+                Planner</a> to plan the next extension.</p>
     </div>
 </div>
 

geo_activity_playground/webui/heatmap/blueprint.py

@@ -0,0 +1,41 @@
+from flask import Blueprint
+from flask import render_template
+from flask import request
+from flask import Response
+
+from ...core.activities import ActivityRepository
+from ...explorer.tile_visits import TileVisitAccessor
+from .heatmap_controller import HeatmapController
+
+
+def make_heatmap_blueprint(
+    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> Blueprint:
+    heatmap_controller = HeatmapController(repository, tile_visit_accessor)
+    blueprint = Blueprint("heatmap", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def index():
+        return render_template(
+            "heatmap/index.html.j2",
+            **heatmap_controller.render(request.args.getlist("kind"))
+        )
+
+    @blueprint.route("/tile/<z>/<x>/<y>/<kinds>.png")
+    def tile(x: str, y: str, z: str, kinds: str):
+        return Response(
+            heatmap_controller.render_tile(int(x), int(y), int(z), kinds.split(";")),
+            mimetype="image/png",
+        )
+
+    @blueprint.route("/download/<north>/<east>/<south>/<west>/<kinds>")
+    def download(north: str, east: str, south: str, west: str, kinds: str):
+        return Response(
+            heatmap_controller.download_heatmap(
+                float(north), float(east), float(south), float(west), kinds.split(";")
+            ),
+            mimetype="image/png",
+            headers={"Content-disposition": 'attachment; filename="heatmap.png"'},
+        )
+
+    return blueprint

geo_activity_playground/webui/{heatmap_controller.py → heatmap/heatmap_controller.py}

@@ -1,11 +1,9 @@
 import io
 import logging
 import pathlib
-import pickle
 
 import matplotlib.pylab as pl
 import numpy as np
-import pandas as pd
 from PIL import Image
 from PIL import ImageDraw
 
@@ -17,7 +15,7 @@ from geo_activity_playground.core.tasks import work_tracker
 from geo_activity_playground.core.tiles import get_tile
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
 from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
-from geo_activity_playground.webui.explorer_controller import (
+from geo_activity_playground.webui.explorer.controller import (
     bounding_box_for_biggest_cluster,
 )
 
@@ -38,15 +36,22 @@ class HeatmapController:
         self.tile_histories = self._tile_visit_accessor.histories
         self.tile_evolution_states = self._tile_visit_accessor.states
         self.tile_visits = self._tile_visit_accessor.visits
+        self.activities_per_tile = self._tile_visit_accessor.activities_per_tile
 
-    def render(self) -> dict:
+    def render(self, kinds: list[str] = []) -> dict:
         zoom = 14
         tiles = self.tile_histories[zoom]
-        medians = tiles.median()
+        medians = tiles.median(skipna=True)
         median_lat, median_lon = get_tile_upper_left_lat_lon(
             medians["tile_x"], medians["tile_y"], zoom
         )
         cluster_state = self.tile_evolution_states[zoom]
+
+        available_kinds = sorted(self._repository.meta["kind"].unique())
+
+        if not kinds:
+            kinds = available_kinds
+
         return {
             "center": {
                 "latitude": median_lat,
@@ -58,18 +63,21 @@ class HeatmapController:
                     if len(cluster_state.memberships) > 0
                     else {}
                 ),
-            }
+            },
+            "kinds": kinds,
+            "available_kinds": available_kinds,
+            "kinds_str": ";".join(kinds),
         }
 
-    def _render_tile_image(self, x: int, y: int, z: int) -> np.ndarray:
+    def _get_counts(self, x: int, y: int, z: int, kind: str) -> np.ndarray:
         tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
-        tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{z}/{x}/{y}.npy")
+        tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{kind}/{z}/{x}/{y}.npy")
         if tile_count_cache_path.exists():
             tile_counts = np.load(tile_count_cache_path)
         else:
             tile_counts = np.zeros(tile_pixels, dtype=np.int32)
         tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
-        activity_ids = self.tile_visits[z].get((x, y), {}).get("activity_ids", set())
+        activity_ids = self.activities_per_tile[z].get((x, y), set())
         if activity_ids:
             with work_tracker(
                 tile_count_cache_path.with_suffix(".json")
@@ -78,6 +86,9 @@ class HeatmapController:
                     if activity_id in parsed_activities:
                         continue
                     parsed_activities.add(activity_id)
+                    activity = self._repository.get_activity_by_id(activity_id)
+                    if activity["kind"] != kind:
+                        continue
                     time_series = self._repository.get_time_series(activity_id)
                     for _, group in time_series.groupby("segment_id"):
                         xy_pixels = (
@@ -93,6 +104,16 @@ class HeatmapController:
                         aim = np.array(im)
                         tile_counts += aim
             np.save(tile_count_cache_path, tile_counts)
+        return tile_counts
+
+    def _render_tile_image(
+        self, x: int, y: int, z: int, kinds: list[str]
+    ) -> np.ndarray:
+        tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
+        tile_counts = np.zeros(tile_pixels)
+        for kind in kinds:
+            tile_counts += self._get_counts(x, y, z, kind)
+
         tile_counts = np.sqrt(tile_counts) / 5
         tile_counts[tile_counts > 1.0] = 1.0
 
@@ -109,12 +130,14 @@ class HeatmapController:
             ] + data_color[:, :, c]
         return map_tile
 
-    def render_tile(self, x: int, y: int, z: int) -> bytes:
+    def render_tile(self, x: int, y: int, z: int, kinds: list[str]) -> bytes:
         f = io.BytesIO()
-        pl.imsave(f, self._render_tile_image(x, y, z), format="png")
+        pl.imsave(f, self._render_tile_image(x, y, z, kinds), format="png")
         return bytes(f.getbuffer())
 
-    def download_heatmap(self, north, east, south, west) -> bytes:
+    def download_heatmap(
+        self, north: float, east: float, south: float, west: float, kinds: list[str]
+    ) -> bytes:
         geo_bounds = GeoBounds(south, west, north, east)
         tile_bounds = get_sensible_zoom_level(geo_bounds, (4000, 4000))
 
@@ -130,7 +153,7 @@ class HeatmapController:
                     i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
                     j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
                     :,
-                ] = self._render_tile_image(x, y, tile_bounds.zoom)
+                ] = self._render_tile_image(x, y, tile_bounds.zoom, kinds)
 
         f = io.BytesIO()
         pl.imsave(f, background, format="png")

geo_activity_playground/webui/{templates/heatmap.html.j2 → heatmap/templates/heatmap/index.html.j2}

@@ -7,6 +7,21 @@
     </div>
 </div>
 
+<div class="row mb-3">
+    <div class="col">
+        <form action="" method="GET">
+            {% for kind in available_kinds %}
+            <div class="form-check form-check-inline form-switch">
+                <input class="form-check-input" type="checkbox" role="switch" id="{{ kind }}" name="kind"
+                    value="{{ kind }}" {{ 'checked' if kind in kinds else '' }} />
+                <label class="form-check-label" for="{{ kind }}">{{ kind }}</label>
+            </div>
+            {% endfor %}
+            <button type="submit" class="btn btn-primary">Show selected kinds</button>
+        </form>
+    </div>
+</div>
+
 <div class="row mb-3">
     <div class="col">
         <div id="heatmap" style="height: 800px;"></div>
@@ -18,7 +33,7 @@
                 center: [{{ center.latitude }}, {{ center.longitude }}],
             zoom: 12
             });
-            L.tileLayer('/heatmap/tile/{z}/{x}/{y}.png', {
+            L.tileLayer('/heatmap/tile/{z}/{x}/{y}/{{ kinds_str }}.png', {
                 maxZoom: 19,
                 attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
             }).addTo(map)
@@ -32,7 +47,7 @@
             function downloadAs() {
                 bounds = map.getBounds()
                 window.location.href =
-                    `/heatmap/download/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}`
+                    `/heatmap/download/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}/{{ kinds_str }}`
             }
         </script>
     </div>

geo_activity_playground/webui/search_controller.py

@@ -14,14 +14,6 @@ class SearchController:
         activities = []
         for _, row in self._repository.meta.iterrows():
             if name in row["name"]:
-                activities.append(
-                    {
-                        "name": row["name"],
-                        "start": row["start"].isoformat(),
-                        "kind": row["kind"],
-                        "distance_km": row["distance_km"],
-                        "elapsed_time": row["elapsed_time"],
-                    }
-                )
+                activities.append(row)
 
         return {"activities": activities}

geo_activity_playground/webui/square_planner/blueprint.py

@@ -0,0 +1,38 @@
+from flask import Blueprint
+from flask import render_template
+from flask import Response
+
+from ...core.activities import ActivityRepository
+from ...explorer.tile_visits import TileVisitAccessor
+from .controller import SquarePlannerController
+
+
+def make_square_planner_blueprint(
+    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> Blueprint:
+    blueprint = Blueprint("square_planner", __name__, template_folder="templates")
+    controller = SquarePlannerController(repository, tile_visit_accessor)
+
+    @blueprint.route("/<zoom>/<x>/<y>/<size>")
+    def index(zoom, x, y, size):
+        return render_template(
+            "square_planner/index.html.j2",
+            **controller.action_planner(int(zoom), int(x), int(y), int(size))
+        )
+
+    @blueprint.route("/<zoom>/<x>/<y>/<size>/missing.<suffix>")
+    def square_planner_missing(zoom, x, y, size, suffix: str):
+        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
+        return Response(
+            controller.export_missing_tiles(
+                int(zoom),
+                int(x),
+                int(y),
+                int(size),
+                suffix,
+            ),
+            mimetype=mimetypes[suffix],
+            headers={"Content-disposition": "attachment"},
+        )
+
+    return blueprint

geo_activity_playground/webui/summary/blueprint.py

@@ -0,0 +1,16 @@
+from flask import Blueprint
+from flask import render_template
+
+from ...core.activities import ActivityRepository
+from .controller import SummaryController
+
+
+def make_summary_blueprint(repository: ActivityRepository) -> Blueprint:
+    summary_controller = SummaryController(repository)
+    blueprint = Blueprint("summary", __name__, template_folder="templates")
+
+    @blueprint.route("/")
+    def index():
+        return render_template("summary/index.html.j2", **summary_controller.render())
+
+    return blueprint

geo_activity_playground/webui/summary/controller.py

@@ -0,0 +1,268 @@
+import collections
+import datetime
+import functools
+from typing import Optional
+
+import altair as alt
+import pandas as pd
+
+from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.activities import make_geojson_from_time_series
+
+
+class SummaryController:
+    def __init__(self, repository: ActivityRepository) -> None:
+        self._repository = repository
+
+    @functools.cache
+    def render(self) -> dict:
+        df = embellished_activities(self._repository.meta)
+        df = df.loc[df["consider_for_achievements"]]
+
+        year_kind_total = (
+            df[["year", "kind", "distance_km", "hours"]]
+            .groupby(["year", "kind"])
+            .sum()
+            .reset_index()
+        )
+
+        return {
+            "plot_distance_heatmap": plot_distance_heatmap(df),
+            "plot_monthly_distance": plot_monthly_distance(df),
+            "plot_yearly_distance": plot_yearly_distance(year_kind_total),
+            "plot_year_cumulative": plot_year_cumulative(df),
+            "tabulate_year_kind_mean": tabulate_year_kind_mean(df)
+            .reset_index()
+            .to_dict(orient="split"),
+            "plot_weekly_distance": plot_weekly_distance(df),
+            "nominations": [
+                (
+                    self._repository.get_activity_by_id(activity_id),
+                    reasons,
+                    make_geojson_from_time_series(
+                        self._repository.get_time_series(activity_id)
+                    ),
+                )
+                for activity_id, reasons in nominate_activities(
+                    self._repository.meta
+                ).items()
+            ],
+        }
+
+
+def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:
+    nominations: dict[int, list[str]] = collections.defaultdict(list)
+
+    subset = meta.loc[meta["consider_for_achievements"]]
+
+    i = subset["distance_km"].idxmax()
+    nominations[i].append(f"Greatest distance: {meta.loc[i].distance_km:.1f} km")
+
+    i = subset["elapsed_time"].idxmax()
+    nominations[i].append(f"Longest elapsed time: {meta.loc[i].elapsed_time}")
+
+    i = subset["calories"].idxmax()
+    nominations[i].append(f"Most calories burnt: {meta.loc[i].calories:.0f} kcal")
+
+    i = subset["steps"].idxmax()
+    nominations[i].append(f"Most steps: {meta.loc[i].steps:.0f}")
+
+    for kind, group in meta.groupby("kind"):
+        for key, text in [
+            (
+                "distance_km",
+                lambda row: f"Greatest distance for {row.kind}: {row.distance_km:.1f} km",
+            ),
+            (
+                "elapsed_time",
+                lambda row: f"Longest elapsed time for {row.kind}: {row.elapsed_time}",
+            ),
+            (
+                "calories",
+                lambda row: f"Most calories burnt for {row.kind}: {row.calories:.0f} kcal",
+            ),
+            ("steps", lambda row: f"Most steps for {row.kind}: {row.steps:.0f}"),
+        ]:
+            series = group[key]
+            i = series.idxmax()
+            if not pd.isna(i):
+                nominations[i].append(text(meta.loc[i]))
+
+    return nominations
+
+
+def embellished_activities(meta: pd.DataFrame) -> pd.DataFrame:
+    df = meta.copy()
+    df["year"] = [start.year for start in df["start"]]
+    df["month"] = [start.month for start in df["start"]]
+    df["day"] = [start.day for start in df["start"]]
+    df["week"] = [start.isocalendar().week for start in df["start"]]
+    df["hours"] = [
+        elapsed_time.total_seconds() / 3600 for elapsed_time in df["elapsed_time"]
+    ]
+    del df["elapsed_time"]
+    return df
+
+
+def plot_distance_heatmap(meta: pd.DataFrame) -> str:
+    return (
+        alt.Chart(
+            meta.loc[
+                (
+                    meta["start"]
+                    >= pd.to_datetime(
+                        datetime.datetime.now() - datetime.timedelta(days=2 * 365)
+                    )
+                )
+            ],
+            title="Daily Distance Heatmap",
+        )
+        .mark_rect()
+        .encode(
+            alt.X("date(start):O", title="Day of month"),
+            alt.Y(
+                "yearmonth(start):O",
+                scale=alt.Scale(reverse=True),
+                title="Year and month",
+            ),
+            alt.Color("sum(distance_km)", scale=alt.Scale(scheme="viridis")),
+            [
+                alt.Tooltip("yearmonthdate(start)", title="Date"),
+                alt.Tooltip(
+                    "sum(distance_km)", format=".1f", title="Total distance / km"
+                ),
+                alt.Tooltip("count(distance_km)", title="Number of activities"),
+            ],
+        )
+        .to_json(format="vega")
+    )
+
+
+def plot_monthly_distance(meta: pd.DataFrame) -> str:
+    return (
+        alt.Chart(
+            meta.loc[
+                (
+                    meta["start"]
+                    >= pd.to_datetime(
+                        datetime.datetime.now() - datetime.timedelta(days=2 * 365)
+                    )
+                )
+            ],
+            title="Monthly Distance",
+        )
+        .mark_bar()
+        .encode(
+            alt.X("month(start)", title="Month"),
+            alt.Y("sum(distance_km)", title="Distance / km"),
+            alt.Color("kind", scale=alt.Scale(scheme="category10"), title="Kind"),
+            alt.Column("year(start):O", title="Year"),
+        )
+        .resolve_axis(x="independent")
+        .to_json(format="vega")
+    )
+
+
+def plot_yearly_distance(year_kind_total: pd.DataFrame) -> str:
+    return (
+        alt.Chart(year_kind_total, title="Total Distance per Year")
+        .mark_bar()
+        .encode(
+            alt.X("year:O", title="Year"),
+            alt.Y("distance_km", title="Distance / km"),
+            alt.Color("kind", title="Kind"),
+            [
+                alt.Tooltip("year:O", title="Year"),
+                alt.Tooltip("kind", title="Kind"),
+                alt.Tooltip("distance_km", title="Distance / km"),
+            ],
+        )
+        .to_json(format="vega")
+    )
+
+
+def plot_year_cumulative(df: pd.DataFrame) -> str:
+    year_cumulative = (
+        df[["year", "week", "distance_km"]]
+        .groupby("year")
+        .apply(
+            lambda group: pd.DataFrame(
+                {"week": group["week"], "distance_km": group["distance_km"].cumsum()}
+            ),
+            include_groups=False,
+        )
+        .reset_index()
+    )
+
+    return (
+        alt.Chart(year_cumulative, width=500, title="Cumultative Distance per Year")
+        .mark_line()
+        .encode(
+            alt.X("week", title="Week"),
+            alt.Y("distance_km", title="Distance / km"),
+            alt.Color("year:N", title="Year"),
+            [
+                alt.Tooltip("week", title="Week"),
+                alt.Tooltip("year:N", title="Year"),
+                alt.Tooltip("distance_km", title="Distance / km"),
+            ],
+        )
+        .interactive()
+        .to_json(format="vega")
+    )
+
+
+def tabulate_year_kind_mean(df: pd.DataFrame) -> pd.DataFrame:
+    year_kind_mean = (
+        df[["year", "kind", "distance_km", "hours"]]
+        .groupby(["year", "kind"])
+        .mean()
+        .reset_index()
+    )
+
+    year_kind_mean_distance = year_kind_mean.pivot(
+        index="year", columns="kind", values="distance_km"
+    )
+
+    return year_kind_mean_distance
+
+
+def plot_weekly_distance(df: pd.DataFrame) -> str:
+    week_kind_total_distance = (
+        df[["year", "week", "kind", "distance_km"]]
+        .groupby(["year", "week", "kind"])
+        .sum()
+        .reset_index()
+    )
+    week_kind_total_distance["year_week"] = [
+        f"{year}-{week:02d}"
+        for year, week in zip(
+            week_kind_total_distance["year"], week_kind_total_distance["week"]
+        )
+    ]
+
+    last_year = week_kind_total_distance["year"].iloc[-1]
+    last_week = week_kind_total_distance["week"].iloc[-1]
+
+    return (
+        alt.Chart(
+            week_kind_total_distance.loc[
+                (week_kind_total_distance["year"] == last_year)
+                | (week_kind_total_distance["year"] == last_year - 1)
+                & (week_kind_total_distance["week"] >= last_week)
+            ],
+            title="Weekly Distance",
+        )
+        .mark_bar()
+        .encode(
+            alt.X("year_week", title="Year and Week"),
+            alt.Y("distance_km", title="Distance / km"),
+            alt.Color("kind", title="Kind"),
+            [
+                alt.Tooltip("year_week", title="Year and Week"),
+                alt.Tooltip("kind", title="Kind"),
+                alt.Tooltip("distance_km", title="Distance / km"),
+            ],
+        )
+        .to_json(format="vega")
+    )