geo-activity-playground 0.38.2__py3-none-any.whl → 0.39.0__py3-none-any.whl

geo_activity_playground/webui/blueprints/entry_views.py

@@ -0,0 +1,68 @@
+import collections
+import datetime
+
+import altair as alt
+import flask
+import pandas as pd
+from flask import render_template
+from flask import Response
+
+from ...core.activities import ActivityRepository
+from ...core.activities import make_geojson_from_time_series
+from ...core.config import Config
+from ..plot_util import make_kind_scale
+
+
+def register_entry_views(
+    app: flask.Flask, repository: ActivityRepository, config: Config
+) -> None:
+    @app.route("/")
+    def index() -> Response:
+        context = {"latest_activities": []}
+
+        if len(repository):
+            kind_scale = make_kind_scale(repository.meta, config)
+            context["distance_last_30_days_plot"] = _distance_last_30_days_meta_plot(
+                repository.meta, kind_scale
+            )
+
+        meta = repository.meta.copy()
+        meta["date"] = meta["start"].dt.date
+
+        context["latest_activities"] = collections.defaultdict(list)
+        for date, activity_meta in list(meta.groupby("date"))[:-30:-1]:
+            for index, activity in activity_meta.iterrows():
+                time_series = repository.get_time_series(activity["id"])
+                context["latest_activities"][date].append(
+                    {
+                        "activity": activity,
+                        "line_geojson": make_geojson_from_time_series(time_series),
+                    }
+                )
+        return render_template("home.html.j2", **context)
+
+
+def _distance_last_30_days_meta_plot(meta: pd.DataFrame, kind_scale: alt.Scale) -> str:
+    before_30_days = pd.to_datetime(
+        datetime.datetime.now() - datetime.timedelta(days=31)
+    )
+    return (
+        alt.Chart(
+            meta.loc[meta["start"] > before_30_days],
+            width=700,
+            height=200,
+            title="Distance per day",
+        )
+        .mark_bar()
+        .encode(
+            alt.X("yearmonthdate(start)", title="Date"),
+            alt.Y("sum(distance_km)", title="Distance / km"),
+            alt.Color("kind", scale=kind_scale, title="Kind"),
+            [
+                alt.Tooltip("yearmonthdate(start)", title="Date"),
+                alt.Tooltip("kind", title="Kind"),
+                alt.Tooltip("sum(distance_km)", format=".1f", title="Distance / km"),
+            ],
+        )
+        .to_json(format="vega")
+    )

geo_activity_playground/webui/{equipment_blueprint.py → blueprints/equipment_blueprint.py}

@@ -3,10 +3,10 @@ import pandas as pd
 from flask import Blueprint
 from flask import render_template
 
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.summary_stats import get_equipment_use_table
-from geo_activity_playground.webui.plot_util import make_kind_scale
+from ...core.activities import ActivityRepository
+from ...core.config import Config
+from ...core.summary_stats import get_equipment_use_table
+from ..plot_util import make_kind_scale
 
 
 def make_equipment_blueprint(
@@ -20,6 +20,38 @@ def make_equipment_blueprint(
             repository.meta, config.equipment_offsets
         )
 
+        # Prepare data for the stacked area chart
+        activities = repository.meta
+        activities["month"] = (
+            activities["start"].dt.to_period("M").apply(lambda r: r.start_time)
+        )
+        monthly_data = (
+            activities.groupby(["month", "equipment"])
+            .agg(total_distance=("distance_km", "sum"))
+            .reset_index()
+        )
+
+        stacked_area_chart = (
+            alt.Chart(
+                monthly_data, height=300, width=1200, title="Monthly Equipment Usage"
+            )
+            .mark_area()
+            .encode(
+                x=alt.X("month:T", title="Month"),
+                y=alt.Y("total_distance:Q", title="Total Kilometers per Month"),
+                color=alt.Color("equipment:N", title="Equipment"),
+                tooltip=[
+                    alt.Tooltip("month:T", title="Date"),  # Add the date to the tooltip
+                    alt.Tooltip("equipment:N", title="Equipment"),
+                    alt.Tooltip(
+                        "total_distance:Q", format=".0f", title="Total Distance"
+                    ),
+                ],
+            )
+            .interactive()
+            .to_json(format="vega")  # Specify format="vega"
+        )
+
         equipment_variables = {}
         for equipment in equipment_summary["equipment"]:
             selection = repository.meta.loc[repository.meta["equipment"] == equipment]
@@ -115,6 +147,7 @@ def make_equipment_blueprint(
         variables = {
             "equipment_variables": equipment_variables,
             "equipment_summary": equipment_summary.to_dict(orient="records"),
+            "stacked_area_chart": stacked_area_chart,
         }
 
         return render_template("equipment/index.html.j2", **variables)

geo_activity_playground/webui/{explorer/controller.py → blueprints/explorer_blueprint.py}

@@ -1,62 +1,57 @@
 import datetime
 import itertools
-import pickle
+import logging
 
 import altair as alt
 import geojson
 import matplotlib
 import numpy as np
 import pandas as pd
+from flask import Blueprint
 from flask import flash
-
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.config import ConfigAccessor
-from geo_activity_playground.core.coordinates import Bounds
-from geo_activity_playground.core.tiles import compute_tile
-from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
-from geo_activity_playground.explorer.grid_file import get_border_tiles
-from geo_activity_playground.explorer.grid_file import logger
-from geo_activity_playground.explorer.grid_file import make_explorer_rectangle
-from geo_activity_playground.explorer.grid_file import make_explorer_tile
-from geo_activity_playground.explorer.grid_file import make_grid_file_geojson
-from geo_activity_playground.explorer.grid_file import make_grid_file_gpx
-from geo_activity_playground.explorer.grid_file import make_grid_points
-from geo_activity_playground.explorer.tile_visits import compute_tile_evolution
-from geo_activity_playground.explorer.tile_visits import TileEvolutionState
-from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
-
+from flask import redirect
+from flask import render_template
+from flask import Response
+from flask import url_for
+
+from ...core.activities import ActivityRepository
+from ...core.config import ConfigAccessor
+from ...core.coordinates import Bounds
+from ...core.tiles import compute_tile
+from ...core.tiles import get_tile_upper_left_lat_lon
+from ...explorer.grid_file import get_border_tiles
+from ...explorer.grid_file import make_explorer_rectangle
+from ...explorer.grid_file import make_explorer_tile
+from ...explorer.grid_file import make_grid_file_geojson
+from ...explorer.grid_file import make_grid_file_gpx
+from ...explorer.grid_file import make_grid_points
+from ...explorer.tile_visits import compute_tile_evolution
+from ...explorer.tile_visits import TileEvolutionState
+from ...explorer.tile_visits import TileVisitAccessor
+from ..authenticator import Authenticator
+from ..authenticator import needs_authentication
 
 alt.data_transformers.enable("vegafusion")
 
+logger = logging.getLogger(__name__)
 
-class ExplorerController:
-    def __init__(
-        self,
-        repository: ActivityRepository,
-        tile_visit_accessor: TileVisitAccessor,
-        config_accessor: ConfigAccessor,
-    ) -> None:
-        self._repository = repository
-        self._tile_visit_accessor = tile_visit_accessor
-        self._config_accessor = config_accessor
 
-    def enable_zoom_level(self, zoom: int) -> None:
-        if 0 <= zoom <= 19:
-            self._config_accessor().explorer_zoom_levels.append(zoom)
-            self._config_accessor().explorer_zoom_levels.sort()
-            self._config_accessor.save()
-            compute_tile_evolution(self._tile_visit_accessor, self._config_accessor())
-            flash(f"Enabled {zoom=} for explorer tiles.", category="success")
-        else:
-            flash(f"{zoom=} is not valid, must be between 0 and 19.", category="danger")
-
-    def render(self, zoom: int) -> dict:
-        if zoom not in self._config_accessor().explorer_zoom_levels:
+def make_explorer_blueprint(
+    authenticator: Authenticator,
+    repository: ActivityRepository,
+    tile_visit_accessor: TileVisitAccessor,
+    config_accessor: ConfigAccessor,
+) -> Blueprint:
+    blueprint = Blueprint("explorer", __name__, template_folder="templates")
+
+    @blueprint.route("/<int:zoom>")
+    def map(zoom: int):
+        if zoom not in config_accessor().explorer_zoom_levels:
             return {"zoom_level_not_generated": zoom}
 
-        tile_evolution_states = self._tile_visit_accessor.tile_state["evolution_state"]
-        tile_visits = self._tile_visit_accessor.tile_state["tile_visits"]
-        tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
+        tile_evolution_states = tile_visit_accessor.tile_state["evolution_state"]
+        tile_visits = tile_visit_accessor.tile_state["tile_visits"]
+        tile_histories = tile_visit_accessor.tile_state["tile_history"]
 
         medians = tile_histories[zoom].median()
         median_lat, median_lon = get_tile_upper_left_lat_lon(
@@ -64,10 +59,10 @@ class ExplorerController:
         )
 
         explored = get_three_color_tiles(
-            tile_visits[zoom], self._repository, tile_evolution_states[zoom], zoom
+            tile_visits[zoom], repository, tile_evolution_states[zoom], zoom
         )
 
-        return {
+        context = {
             "center": {
                 "latitude": median_lat,
                 "longitude": median_lon,
@@ -89,35 +84,74 @@ class ExplorerController:
             ),
             "zoom": zoom,
         }
+        return render_template("explorer/index.html.j2", **context)
+
+    @blueprint.route("/enable-zoom-level/<int:zoom>")
+    @needs_authentication(authenticator)
+    def enable_zoom_level(zoom: int):
+        if 0 <= zoom <= 19:
+            config_accessor().explorer_zoom_levels.append(zoom)
+            config_accessor().explorer_zoom_levels.sort()
+            config_accessor.save()
+            compute_tile_evolution(tile_visit_accessor, config_accessor())
+            flash(f"Enabled {zoom=} for explorer tiles.", category="success")
+        else:
+            flash(f"{zoom=} is not valid, must be between 0 and 19.", category="danger")
+        return redirect(url_for(".map", zoom=zoom))
 
-    def export_missing_tiles(self, zoom, north, east, south, west, suffix: str) -> str:
+    @blueprint.route(
+        "/<int:zoom>/<float:north>/<float:east>/<float:south>/<float:west>/explored.<suffix>"
+    )
+    def download(
+        zoom: int, north: float, east: float, south: float, west: float, suffix: str
+    ):
         x1, y1 = compute_tile(north, west, zoom)
         x2, y2 = compute_tile(south, east, zoom)
         tile_bounds = Bounds(x1, y1, x2 + 2, y2 + 2)
 
-        tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
+        tile_histories = tile_visit_accessor.tile_state["tile_history"]
         tiles = tile_histories[zoom]
         points = get_border_tiles(tiles, zoom, tile_bounds)
         if suffix == "geojson":
-            return make_grid_file_geojson(points)
+            result = make_grid_file_geojson(points)
         elif suffix == "gpx":
-            return make_grid_file_gpx(points)
+            result = make_grid_file_gpx(points)
+
+        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
+        return Response(
+            result,
+            mimetype=mimetypes[suffix],
+            headers={"Content-disposition": "attachment"},
+        )
 
-    def export_explored_tiles(self, zoom, north, east, south, west, suffix: str) -> str:
+    @blueprint.route(
+        "/<int:zoom>/<float:north>/<float:east>/<float:south>/<float:west>/missing.<suffix>"
+    )
+    def missing(
+        zoom: int, north: float, east: float, south: float, west: float, suffix: str
+    ):
         x1, y1 = compute_tile(north, west, zoom)
         x2, y2 = compute_tile(south, east, zoom)
         tile_bounds = Bounds(x1, y1, x2 + 2, y2 + 2)
 
-        tile_visits = self._tile_visit_accessor.tile_state["tile_visits"]
+        tile_visits = tile_visit_accessor.tile_state["tile_visits"]
         tiles = tile_visits[zoom]
         points = make_grid_points(
             (tile for tile in tiles.keys() if tile_bounds.contains(*tile)), zoom
         )
         if suffix == "geojson":
-            return make_grid_file_geojson(points)
+            result = make_grid_file_geojson(points)
         elif suffix == "gpx":
-            return make_grid_file_gpx(points)
-        ...
+            result = make_grid_file_gpx(points)
+
+        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
+        return Response(
+            result,
+            mimetype=mimetypes[suffix],
+            headers={"Content-disposition": "attachment"},
+        )
+
+    return blueprint
 
 
 def get_three_color_tiles(

geo_activity_playground/webui/blueprints/heatmap_blueprint.py

@@ -0,0 +1,233 @@
+import io
+import logging
+import pathlib
+
+import matplotlib.pylab as pl
+import numpy as np
+from flask import Blueprint
+from flask import render_template
+from flask import request
+from flask import Response
+from PIL import Image
+from PIL import ImageDraw
+
+from ...core.activities import ActivityRepository
+from ...core.config import Config
+from ...core.meta_search import apply_search_query
+from ...core.meta_search import SearchQuery
+from ...core.raster_map import convert_to_grayscale
+from ...core.raster_map import GeoBounds
+from ...core.raster_map import get_sensible_zoom_level
+from ...core.raster_map import get_tile
+from ...core.raster_map import OSM_TILE_SIZE
+from ...core.raster_map import PixelBounds
+from ...core.tasks import work_tracker
+from ...core.tiles import get_tile_upper_left_lat_lon
+from ...explorer.tile_visits import TileVisitAccessor
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
+from .explorer_blueprint import bounding_box_for_biggest_cluster
+
+logger = logging.getLogger(__name__)
+
+
+def make_heatmap_blueprint(
+    repository: ActivityRepository,
+    tile_visit_accessor: TileVisitAccessor,
+    config: Config,
+    search_query_history: SearchQueryHistory,
+) -> Blueprint:
+    blueprint = Blueprint("heatmap", __name__, template_folder="templates")
+
+    tile_histories = tile_visit_accessor.tile_state["tile_history"]
+    tile_evolution_states = tile_visit_accessor.tile_state["evolution_state"]
+    tile_visits = tile_visit_accessor.tile_state["tile_visits"]
+    activities_per_tile = tile_visit_accessor.tile_state["activities_per_tile"]
+
+    @blueprint.route("/")
+    def index():
+        query = search_query_from_form(request.args)
+        search_query_history.register_query(query)
+
+        zoom = 14
+        tiles = tile_histories[zoom]
+        medians = tiles.median(skipna=True)
+        median_lat, median_lon = get_tile_upper_left_lat_lon(
+            medians["tile_x"], medians["tile_y"], zoom
+        )
+        cluster_state = tile_evolution_states[zoom]
+
+        context = {
+            "center": {
+                "latitude": median_lat,
+                "longitude": median_lon,
+                "bbox": (
+                    bounding_box_for_biggest_cluster(
+                        cluster_state.clusters.values(), zoom
+                    )
+                    if len(cluster_state.memberships) > 0
+                    else {}
+                ),
+            },
+            "extra_args": query.to_url_str(),
+            "query": query.to_jinja(),
+        }
+
+        return render_template("heatmap/index.html.j2", **context)
+
+    @blueprint.route("/tile/<int:z>/<int:x>/<int:y>.png")
+    def tile(x: int, y: int, z: int):
+        query = search_query_from_form(request.args)
+        f = io.BytesIO()
+        pl.imsave(
+            f,
+            _render_tile_image(x, y, z, query, config, repository, activities_per_tile),
+            format="png",
+        )
+        return Response(
+            bytes(f.getbuffer()),
+            mimetype="image/png",
+        )
+
+    @blueprint.route(
+        "/download/<float:north>/<float:east>/<float:south>/<float:west>/heatmap.png"
+    )
+    def download(north: float, east: float, south: float, west: float):
+        query = search_query_from_form(request.args)
+        geo_bounds = GeoBounds(south, west, north, east)
+        tile_bounds = get_sensible_zoom_level(geo_bounds, (4000, 4000))
+        pixel_bounds = PixelBounds.from_tile_bounds(tile_bounds)
+
+        background = np.zeros((*pixel_bounds.shape, 3))
+        for x in range(tile_bounds.x1, tile_bounds.x2):
+            for y in range(tile_bounds.y1, tile_bounds.y2):
+                i = y - tile_bounds.y1
+                j = x - tile_bounds.x1
+
+                background[
+                    i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
+                    j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
+                    :,
+                ] = _render_tile_image(
+                    x,
+                    y,
+                    tile_bounds.zoom,
+                    query,
+                    config,
+                    repository,
+                    activities_per_tile,
+                )
+
+        f = io.BytesIO()
+        pl.imsave(f, background, format="png")
+        return Response(
+            bytes(f.getbuffer()),
+            mimetype="image/png",
+            headers={"Content-disposition": 'attachment; filename="heatmap.png"'},
+        )
+
+    return blueprint
+
+
+def _get_counts(
+    x: int,
+    y: int,
+    z: int,
+    query: SearchQuery,
+    repository: ActivityRepository,
+    activities_per_tile: dict[int, dict[tuple[int, int], set[int]]],
+) -> np.ndarray:
+    tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
+    tile_counts = np.zeros(tile_pixels, dtype=np.int32)
+    if not query.active:
+        tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{z}/{x}/{y}.npy")
+        if tile_count_cache_path.exists():
+            try:
+                tile_counts = np.load(tile_count_cache_path)
+            except ValueError:
+                logger.warning(
+                    f"Heatmap count file {tile_count_cache_path} is corrupted, deleting."
+                )
+                tile_count_cache_path.unlink()
+                tile_counts = np.zeros(tile_pixels, dtype=np.int32)
+        tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
+        activity_ids = activities_per_tile[z].get((x, y), set())
+
+        with work_tracker(
+            tile_count_cache_path.with_suffix(".json")
+        ) as parsed_activities:
+            if parsed_activities - activity_ids:
+                logger.warning(
+                    f"Resetting heatmap cache for {x=}/{y=}/{z=} because activities have been removed."
+                )
+                tile_counts = np.zeros(tile_pixels, dtype=np.int32)
+                parsed_activities.clear()
+            for activity_id in activity_ids:
+                if activity_id in parsed_activities:
+                    continue
+                parsed_activities.add(activity_id)
+                time_series = repository.get_time_series(activity_id)
+                for _, group in time_series.groupby("segment_id"):
+                    xy_pixels = (
+                        np.array([group["x"] * 2**z - x, group["y"] * 2**z - y]).T
+                        * OSM_TILE_SIZE
+                    )
+                    im = Image.new("L", tile_pixels)
+                    draw = ImageDraw.Draw(im)
+                    pixels = list(map(int, xy_pixels.flatten()))
+                    draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
+                    aim = np.array(im)
+                    tile_counts += aim
+        tmp_path = tile_count_cache_path.with_suffix(".tmp.npy")
+        np.save(tmp_path, tile_counts)
+        tile_count_cache_path.unlink(missing_ok=True)
+        tmp_path.rename(tile_count_cache_path)
+    else:
+        activities = apply_search_query(repository.meta, query)
+        activity_ids = activities_per_tile[z].get((x, y), set())
+        for activity_id in activity_ids:
+            if activity_id not in activities["id"]:
+                continue
+            time_series = repository.get_time_series(activity_id)
+            for _, group in time_series.groupby("segment_id"):
+                xy_pixels = (
+                    np.array([group["x"] * 2**z - x, group["y"] * 2**z - y]).T
+                    * OSM_TILE_SIZE
+                )
+                im = Image.new("L", tile_pixels)
+                draw = ImageDraw.Draw(im)
+                pixels = list(map(int, xy_pixels.flatten()))
+                draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
+                aim = np.array(im)
+                tile_counts += aim
+    return tile_counts
+
+
+def _render_tile_image(
+    x: int,
+    y: int,
+    z: int,
+    query: SearchQuery,
+    config: Config,
+    repository: ActivityRepository,
+    activities_per_tile: dict[int, dict[tuple[int, int], set[int]]],
+) -> np.ndarray:
+    tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
+    tile_counts = np.zeros(tile_pixels)
+    tile_counts += _get_counts(x, y, z, query, repository, activities_per_tile)
+
+    tile_counts = np.sqrt(tile_counts) / 5
+    tile_counts[tile_counts > 1.0] = 1.0
+
+    cmap = pl.get_cmap(config.color_scheme_for_heatmap)
+    data_color = cmap(tile_counts)
+    data_color[data_color == cmap(0.0)] = 0.0  # remove background color
+
+    map_tile = np.array(get_tile(z, x, y, config.map_tile_url)) / 255
+    map_tile = convert_to_grayscale(map_tile)
+    map_tile = 1.0 - map_tile  # invert colors
+    for c in range(3):
+        map_tile[:, :, c] = (1.0 - data_color[:, :, c]) * map_tile[
+            :, :, c
+        ] + data_color[:, :, c]
+    return map_tile

geo_activity_playground/webui/{search_blueprint.py → blueprints/search_blueprint.py}

@@ -1,22 +1,18 @@
 import urllib.parse
 from functools import reduce
 
-import dateutil.parser
 from flask import Blueprint
-from flask import flash
 from flask import redirect
 from flask import render_template
 from flask import request
-from flask import Response
 
-from ..core.activities import ActivityRepository
-from geo_activity_playground.core.config import ConfigAccessor
-from geo_activity_playground.core.meta_search import apply_search_query
-from geo_activity_playground.core.meta_search import SearchQuery
-from geo_activity_playground.webui.authenticator import Authenticator
-from geo_activity_playground.webui.authenticator import needs_authentication
-from geo_activity_playground.webui.search_util import search_query_from_form
-from geo_activity_playground.webui.search_util import SearchQueryHistory
+from ...core.activities import ActivityRepository
+from ...core.config import ConfigAccessor
+from ...core.meta_search import apply_search_query
+from ..authenticator import Authenticator
+from ..authenticator import needs_authentication
+from ..search_util import search_query_from_form
+from ..search_util import SearchQueryHistory
 
 
 def reduce_or(selections):