geo-activity-playground 0.31.0__py3-none-any.whl → 0.34.1__py3-none-any.whl

geo_activity_playground/__main__.py

@@ -13,7 +13,7 @@ from geo_activity_playground.core.config import import_old_strava_config
 from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
 from geo_activity_playground.explorer.video import explorer_video_main
 from geo_activity_playground.webui.app import web_ui_main
-from geo_activity_playground.webui.upload.controller import scan_for_activities
+from geo_activity_playground.webui.upload_blueprint import scan_for_activities
 
 logger = logging.getLogger(__name__)
 

geo_activity_playground/core/activities.py

@@ -165,7 +165,7 @@ class ActivityRepository:
         return df
 
     def save(self) -> None:
-        self._meta.to_parquet(activities_file())
+        self.meta.to_parquet(activities_file())
 
 
 def make_geojson_from_time_series(time_series: pd.DataFrame) -> str:

geo_activity_playground/core/config.py

@@ -21,14 +21,16 @@ logger = logging.getLogger(__name__)
 @dataclasses.dataclass
 class Config:
     birth_year: Optional[int] = None
-    color_scheme_for_counts: str = "viridis"
+    color_scheme_for_counts: str = "teals"
     color_scheme_for_kind: str = "category10"
+    color_scheme_for_heatmap: str = "hot"
     equipment_offsets: dict[str, float] = dataclasses.field(default_factory=dict)
     explorer_zoom_levels: list[int] = dataclasses.field(
         default_factory=lambda: [14, 17]
     )
     heart_rate_resting: int = 0
     heart_rate_maximum: Optional[int] = None
+    ignore_suffixes: list[str] = dataclasses.field(default_factory=list)
     kind_renames: dict[str, str] = dataclasses.field(default_factory=dict)
     kinds_without_achievements: list[str] = dataclasses.field(default_factory=list)
     metadata_extraction_regexes: list[str] = dataclasses.field(default_factory=list)
@@ -42,6 +44,8 @@ class Config:
     strava_client_code: Optional[str] = None
     time_diff_threshold_seconds: Optional[int] = 30
     upload_password: Optional[str] = None
+    map_tile_url: str = "https://tile.openstreetmap.org/{zoom}/{x}/{y}.png"
+    map_tile_attribution: str = '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> | <a href="https://www.openstreetmap.org/fixthemap">Correct Map</a>'
 
 
 class ConfigAccessor:

geo_activity_playground/core/heatmap.py

@@ -6,6 +6,7 @@ import logging
 
 import numpy as np
 
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.tiles import compute_tile_float
 from geo_activity_playground.core.tiles import get_tile
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
@@ -123,21 +124,66 @@ def get_sensible_zoom_level(
     )
 
 
-def build_map_from_tiles(tile_bounds: TileBounds) -> np.ndarray:
-    background = np.zeros((*PixelBounds.from_tile_bounds(tile_bounds).shape, 3))
-
-    for x in range(tile_bounds.x_tile_min, tile_bounds.x_tile_max):
-        for y in range(tile_bounds.y_tile_min, tile_bounds.y_tile_max):
-            tile = np.array(get_tile(tile_bounds.zoom, x, y)) / 255
-
-            i = y - tile_bounds.y_tile_min
-            j = x - tile_bounds.x_tile_min
-
-            background[
-                i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
-                j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
-                :,
-            ] = tile[:, :, :3]
+def build_map_from_tiles_around_center(
+    center: tuple[float, float],
+    zoom: int,
+    target: tuple[int, int],
+    inner_target: tuple[int, int],
+    config: Config,
+) -> np.ndarray:
+    background = np.zeros((target[1], target[0], 3))
+
+    # We will work with the center point and have it in terms of tiles `t` and also in terms of pixels `p`. At the start we know that the tile center must be in the middle of the image.
+    t = np.array(center)
+    p = np.array([inner_target[0] / 2, inner_target[1] / 2])
+
+    # Shift both such that they are in the top-left corner of an even tile.
+    t_offset = np.array([center[0] % 1, center[1] % 1])
+    t -= t_offset
+    p -= t_offset * OSM_TILE_SIZE
+
+    # Shift until we have left the image.
+    shift = np.ceil(p / OSM_TILE_SIZE)
+    p -= shift * OSM_TILE_SIZE
+    t -= shift
+
+    num_tiles = np.ceil(np.array(target) / OSM_TILE_SIZE) + 1
+
+    for x in range(int(t[0]), int(t[0] + num_tiles[0])):
+        for y in range(int(t[1]), int(t[1]) + int(num_tiles[1])):
+            source_x_min = 0
+            source_y_min = 0
+            source_x_max = source_x_min + OSM_TILE_SIZE
+            source_y_max = source_y_min + OSM_TILE_SIZE
+
+            target_x_min = (x - int(t[0])) * OSM_TILE_SIZE + int(p[0])
+            target_y_min = (y - int(t[1])) * OSM_TILE_SIZE + int(p[1])
+            target_x_max = target_x_min + OSM_TILE_SIZE
+            target_y_max = target_y_min + OSM_TILE_SIZE
+
+            if target_x_min < 0:
+                source_x_min -= target_x_min
+                target_x_min = 0
+            if target_y_min < 0:
+                source_y_min -= target_y_min
+                target_y_min = 0
+            if target_x_max > target[0]:
+                a = target_x_max - target[0]
+                target_x_max -= a
+                source_x_max -= a
+            if target_y_max > target[1]:
+                a = target_y_max - target[1]
+                target_y_max -= a
+                source_y_max -= a
+
+            if source_x_max < 0 or source_y_max < 0:
+                continue
+
+            tile = np.array(get_tile(zoom, x, y, config.map_tile_url)) / 255
+
+            background[target_y_min:target_y_max, target_x_min:target_x_max] = tile[
+                source_y_min:source_y_max, source_x_min:source_x_max, :3
+            ]
 
     return background
 

geo_activity_playground/core/tiles.py

@@ -3,6 +3,7 @@ import logging
 import math
 import pathlib
 import time
+import urllib.parse
 from typing import Iterator
 from typing import Optional
 
@@ -13,8 +14,10 @@ from PIL import Image
 logger = logging.getLogger(__name__)
 
 
-def osm_tile_path(x: int, y: int, zoom: int) -> pathlib.Path:
-    path = pathlib.Path("Open Street Map Tiles") / f"{zoom}/{x}/{y}.png"
+def osm_tile_path(x: int, y: int, zoom: int, url_template: str) -> pathlib.Path:
+    base_dir = pathlib.Path("Open Street Map Tiles")
+    dir_for_source = base_dir / urllib.parse.quote_plus(url_template)
+    path = dir_for_source / f"{zoom}/{x}/{y}.png"
     path.parent.mkdir(parents=True, exist_ok=True)
     return path
 
@@ -62,11 +65,11 @@ def download_file(url: str, destination: pathlib.Path):
 
 
 @functools.lru_cache()
-def get_tile(zoom: int, x: int, y: int) -> Image.Image:
-    destination = osm_tile_path(x, y, zoom)
+def get_tile(zoom: int, x: int, y: int, url_template: str) -> Image.Image:
+    destination = osm_tile_path(x, y, zoom, url_template)
     if not destination.exists():
         logger.info(f"Downloading OSM tile {x=}, {y=}, {zoom=} …")
-        url = f"https://tile.openstreetmap.org/{zoom}/{x}/{y}.png"
+        url = url_template.format(x=x, y=y, zoom=zoom)
         download_file(url, destination)
     with Image.open(destination) as image:
         image.load()

geo_activity_playground/explorer/video.py

@@ -9,13 +9,14 @@ from typing import Tuple
 
 import numpy as np
 import pandas as pd
-import scipy.interpolate
 from PIL import Image
 from PIL import ImageEnhance
 from tqdm import tqdm
 
 from ..core.tiles import get_tile
 
+# import scipy.interpolate
+
 
 def build_image(
     center_x: float,

geo_activity_playground/importers/directory.py

@@ -10,6 +10,7 @@ from typing import Optional
 from tqdm import tqdm
 
 from geo_activity_playground.core.activities import ActivityMeta
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.paths import activity_extracted_dir
 from geo_activity_playground.core.paths import activity_extracted_meta_dir
 from geo_activity_playground.core.paths import activity_extracted_time_series_dir
@@ -24,13 +25,16 @@ ACTIVITY_DIR = pathlib.Path("Activities")
 
 
 def import_from_directory(
-    metadata_extraction_regexes: list[str], num_processes: Optional[int]
+    metadata_extraction_regexes: list[str], num_processes: Optional[int], config: Config
 ) -> None:
 
     activity_paths = [
         path
         for path in ACTIVITY_DIR.rglob("*.*")
-        if path.is_file() and path.suffixes and not path.stem.startswith(".")
+        if path.is_file()
+        and path.suffixes
+        and not path.stem.startswith(".")
+        and not path.suffix in config.ignore_suffixes
     ]
     work_tracker = WorkTracker(activity_extracted_dir() / "work-tracker-extract.pickle")
     new_activity_paths = work_tracker.filter(activity_paths)

geo_activity_playground/importers/strava_checkout.py

@@ -146,7 +146,7 @@ def float_with_comma_or_period(x: str) -> Optional[float]:
 
 def import_from_strava_checkout() -> None:
     checkout_path = pathlib.Path("Strava Export")
-    with open(checkout_path / "activities.csv") as f:
+    with open(checkout_path / "activities.csv", encoding="utf-8") as f:
         rows = parse_csv(f.read())
     header = rows[0]
 
@@ -159,9 +159,15 @@ def import_from_strava_checkout() -> None:
 
     if header[0] == EXPECTED_COLUMNS[0]:
         dayfirst = False
-    if header[0] == "Aktivitäts-ID":
+    elif header[0] == "Aktivitäts-ID":
         header = EXPECTED_COLUMNS
         dayfirst = True
+    else:
+        logger.error(
+            f"You are trying to import a Strava checkout where the `activities.csv` contains an unexpected header format. In order to import this, we need to map these to the English ones. Unfortunately Strava often changes the number of columns. This means that the program needs to be updated to match the new Strava export format. Please go to https://github.com/martin-ueding/geo-activity-playground/issues and open a new issue and share the following output in the ticket:"
+        )
+        print(header)
+        sys.exit(1)
 
     table = {
         header[i]: [rows[r][i] for r in range(1, len(rows))] for i in range(len(header))

geo_activity_playground/webui/activity/blueprint.py

@@ -55,6 +55,13 @@ def make_activity_blueprint(
             **activity_controller.render_day(int(year), int(month), int(day)),
         )
 
+    @blueprint.route("/day-sharepic/<year>/<month>/<day>/sharepic.png")
+    def day_sharepic(year: str, month: str, day: str):
+        return Response(
+            activity_controller.render_day_sharepic(int(year), int(month), int(day)),
+            mimetype="image/png",
+        )
+
     @blueprint.route("/name/<name>")
     def name(name: str):
         return render_template(

geo_activity_playground/webui/activity/controller.py

@@ -21,11 +21,9 @@ from geo_activity_playground.core.activities import make_geojson_from_time_serie
 from geo_activity_playground.core.activities import make_speed_color_bar
 from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.heart_rate import HeartRateZoneComputer
-from geo_activity_playground.core.heatmap import add_margin_to_geo_bounds
-from geo_activity_playground.core.heatmap import build_map_from_tiles
+from geo_activity_playground.core.heatmap import build_map_from_tiles_around_center
 from geo_activity_playground.core.heatmap import GeoBounds
-from geo_activity_playground.core.heatmap import get_bounds
-from geo_activity_playground.core.heatmap import get_sensible_zoom_level
+from geo_activity_playground.core.heatmap import OSM_MAX_ZOOM
 from geo_activity_playground.core.heatmap import OSM_TILE_SIZE
 from geo_activity_playground.core.heatmap import PixelBounds
 from geo_activity_playground.core.heatmap import TileBounds
@@ -128,7 +126,7 @@ class ActivityController:
         if len(time_series) == 0:
             time_series = self._repository.get_time_series(id)
         return make_sharepic(
-            activity, time_series, self._config.sharepic_suppressed_fields
+            activity, time_series, self._config.sharepic_suppressed_fields, self._config
         )
 
     def render_day(self, year: int, month: int, day: int) -> dict:
@@ -172,8 +170,24 @@ class ActivityController:
             "date": datetime.date(year, month, day).isoformat(),
             "total_distance": activities_that_day["distance_km"].sum(),
             "total_elapsed_time": activities_that_day["elapsed_time"].sum(),
+            "day": day,
+            "month": month,
+            "year": year,
         }
 
+    def render_day_sharepic(self, year: int, month: int, day: int) -> bytes:
+        meta = self._repository.meta
+        selection = meta["start"].dt.date == datetime.date(year, month, day)
+        activities_that_day = meta.loc[selection]
+
+        time_series = [
+            self._repository.get_time_series(activity_id)
+            for activity_id in activities_that_day["id"]
+        ]
+        assert len(activities_that_day) > 0
+        assert len(time_series) > 0
+        return (make_day_sharepic(activities_that_day, time_series, self._config),)
+
     def render_all(self) -> dict:
         cmap = matplotlib.colormaps["Dark2"]
         fc = geojson.FeatureCollection(
@@ -454,47 +468,74 @@ def pixels_in_bounds(bounds: PixelBounds) -> int:
     return (bounds.x_max - bounds.x_min) * (bounds.y_max - bounds.y_min)
 
 
-def make_sharepic(
-    activity: ActivityMeta,
-    time_series: pd.DataFrame,
-    sharepic_suppressed_fields: list[str],
-) -> bytes:
-    lat_lon_data = np.array([time_series["latitude"], time_series["longitude"]]).T
+def make_sharepic_base(time_series_list: list[pd.DataFrame], config: Config):
+    all_time_series = pd.concat(time_series_list)
+    tile_x = all_time_series["x"]
+    tile_y = all_time_series["y"]
+    tile_width = tile_x.max() - tile_x.min()
+    tile_height = tile_y.max() - tile_y.min()
 
-    geo_bounds = get_bounds(lat_lon_data)
-    geo_bounds = add_margin_to_geo_bounds(geo_bounds)
-    tile_bounds = get_sensible_zoom_level(geo_bounds, (1500, 1500))
-    tile_bounds = make_tile_bounds_square(tile_bounds)
-    background = build_map_from_tiles(tile_bounds)
-    # background = convert_to_grayscale(background)
+    target_width = 600
+    target_height = 600
+    footer_height = 100
+    target_map_height = target_height - footer_height
 
-    crop_mask = get_crop_mask(geo_bounds, tile_bounds)
-    assert pixels_in_bounds(crop_mask) <= 10_000_000, crop_mask
+    zoom = int(
+        min(
+            np.log2(target_width / tile_width / OSM_TILE_SIZE),
+            np.log2(target_map_height / tile_height / OSM_TILE_SIZE),
+            OSM_MAX_ZOOM,
+        )
+    )
 
-    background = background[
-        crop_mask.y_min : crop_mask.y_max,
-        crop_mask.x_min : crop_mask.x_max,
-        :,
-    ]
+    tile_xz = tile_x * 2**zoom
+    tile_yz = tile_y * 2**zoom
+
+    tile_xz_center = (
+        (tile_xz.max() + tile_xz.min()) / 2,
+        (tile_yz.max() + tile_yz.min()) / 2,
+    )
+
+    background = build_map_from_tiles_around_center(
+        tile_xz_center,
+        zoom,
+        (target_width, target_height),
+        (target_width, target_map_height),
+        config,
+    )
 
     img = Image.fromarray((background * 255).astype("uint8"), "RGB")
     draw = ImageDraw.Draw(img, mode="RGBA")
 
-    for _, group in time_series.groupby("segment_id"):
-        xs, ys = compute_tile_float(
-            group["latitude"], group["longitude"], tile_bounds.zoom
-        )
-        yx = list(
-            (
-                int((x - tile_bounds.x_tile_min) * OSM_TILE_SIZE - crop_mask.x_min),
-                int((y - tile_bounds.y_tile_min) * OSM_TILE_SIZE - crop_mask.y_min),
+    for time_series in time_series_list:
+        for _, group in time_series.groupby("segment_id"):
+            yx = list(
+                zip(
+                    (tile_xz - tile_xz_center[0]) * OSM_TILE_SIZE + target_width / 2,
+                    (tile_yz - tile_xz_center[1]) * OSM_TILE_SIZE
+                    + target_map_height / 2,
+                )
             )
-            for x, y in zip(xs, ys)
-        )
 
-        draw.line(yx, fill="red", width=4)
+            draw.line(yx, fill="red", width=4)
+
+    return img
 
-    draw.rectangle([0, img.height - 70, img.width, img.height], fill=(0, 0, 0, 128))
+
+def make_sharepic(
+    activity: ActivityMeta,
+    time_series: pd.DataFrame,
+    sharepic_suppressed_fields: list[str],
+    config: Config,
+) -> bytes:
+    footer_height = 100
+
+    img = make_sharepic_base([time_series], config)
+
+    draw = ImageDraw.Draw(img, mode="RGBA")
+    draw.rectangle(
+        [0, img.height - footer_height, img.width, img.height], fill=(0, 0, 0, 180)
+    )
 
     facts = {
         "kind": f"{activity['kind']}",
@@ -515,19 +556,62 @@ def make_sharepic(
         if not key in sharepic_suppressed_fields
     }
 
-    draw.text((35, img.height - 70 + 10), "      ".join(facts.values()), font_size=20)
+    draw.text(
+        (35, img.height - footer_height + 10),
+        "      ".join(facts.values()),
+        font_size=20,
+    )
+
+    draw.text(
+        (img.width - 250, img.height - 20),
+        "Map: © Open Street Map Contributors",
+        font_size=14,
+    )
+
+    f = io.BytesIO()
+    img.save(f, format="png")
+    return bytes(f.getbuffer())
+
+
+def make_day_sharepic(
+    activities: pd.DataFrame,
+    time_series_list: list[pd.DataFrame],
+    config: Config,
+) -> bytes:
+    footer_height = 100
 
-    # img_array = np.array(img) / 255
+    img = make_sharepic_base(time_series_list, config)
+
+    draw = ImageDraw.Draw(img, mode="RGBA")
+    draw.rectangle(
+        [0, img.height - footer_height, img.width, img.height], fill=(0, 0, 0, 180)
+    )
 
-    # weight = np.dstack([img_array[:, :, 0]] * 3)
+    date = activities.iloc[0]["start"].date()
+    distance_km = activities["distance_km"].sum()
+    elapsed_time: pd.Timedelta = activities["elapsed_time"].sum()
+    elapsed_time = elapsed_time.round("s")
 
-    # background = (1 - weight) * background + img_array
-    # background[background > 1.0] = 1.0
-    # background[background < 0.0] = 0.0
+    facts = {
+        "date": f"{date}",
+        "distance_km": f"{distance_km:.1f} km",
+        "elapsed_time": re.sub(r"^0 days ", "", f"{elapsed_time}"),
+    }
+
+    draw.text(
+        (35, img.height - footer_height + 10),
+        "      ".join(facts.values()),
+        font_size=20,
+    )
+
+    draw.text(
+        (img.width - 250, img.height - 20),
+        "Map: © Open Street Map Contributors",
+        font_size=14,
+    )
 
     f = io.BytesIO()
     img.save(f, format="png")
-    # pl.imsave(f, background, format="png")
     return bytes(f.getbuffer())
 
 

geo_activity_playground/webui/activity/templates/activity/day.html.j2

@@ -17,7 +17,7 @@
             });
             L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
                 maxZoom: 19,
-                attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+                attribution: '{{ map_tile_attribution|safe }}'
             }).addTo(map);
 
             let geojson = L.geoJSON({{ geojson| safe }}, {
@@ -30,7 +30,7 @@
         <ol>
             {% for activity in activities %}
             <li><span style="color: {{ activity['color'] }};">█</span> <a
-                    href="{{ url_for('activity.show', id=activity.id) }}">{{
+                    href="{{ url_for('.show', id=activity.id) }}">{{
                     activity.name }}</a></li>
             {% endfor %}
         </ol>
@@ -80,4 +80,8 @@
     </div>
 </div>
 
+<h2>Share picture</h2>
+
+<p><img src="{{ url_for('.day_sharepic', year=year, month=month, day=day) }}" /></p>
+
 {% endblock %}

geo_activity_playground/webui/activity/templates/activity/lines.html.j2

@@ -21,7 +21,7 @@
             });
             L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
                 maxZoom: 19,
-                attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+                attribution: '{{ map_tile_attribution|safe }}'
             }).addTo(map);
 
             let geojson = L.geoJSON({{ geojson| safe }}, {

geo_activity_playground/webui/activity/templates/activity/name.html.j2

@@ -17,7 +17,7 @@
             });
             L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
                 maxZoom: 19,
-                attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+                attribution: '{{ map_tile_attribution|safe }}'
             }).addTo(map);
 
             let geojson = L.geoJSON({{ geojson| safe }}, {
@@ -64,7 +64,8 @@
             <tbody>
                 {% for activity in activities %}
                 <tr>
-                    <td><span style="color: {{ activity['color'] }};">█</span> <a href="{{ url_for('activity.show', id=activity.id) }}">{{
+                    <td><span style="color: {{ activity['color'] }};">█</span> <a
+                            href="{{ url_for('activity.show', id=activity.id) }}">{{
                             activity.name }}</a></td>
                     <td>{{ activity.start|dt }}</td>
                     <td>{{ activity.distance_km | round(1) }}</td>

geo_activity_playground/webui/activity/templates/activity/show.html.j2

@@ -52,7 +52,7 @@
             });
             L.tileLayer('/tile/pastel/{z}/{x}/{y}.png', {
                 maxZoom: 19,
-                attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+                attribution: '{{ map_tile_attribution|safe }}'
             }).addTo(map);
 
             let geojson = L.geoJSON({{ color_line_geojson| safe }}, {
@@ -160,7 +160,7 @@
         })
         L.tileLayer('/tile/color/{z}/{x}/{y}.png', {
             maxZoom: 19,
-            attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+            attribution: '{{ map_tile_attribution|safe }}'
         }).addTo(map)
 
         let geojson_layer = L.geoJSON(geojson).addTo(map)

geo_activity_playground/webui/app.py

@@ -3,6 +3,8 @@ import importlib
 import json
 import pathlib
 import secrets
+import shutil
+import urllib.parse
 
 from flask import Flask
 from flask import render_template
@@ -20,7 +22,7 @@ from .search.blueprint import make_search_blueprint
 from .square_planner.blueprint import make_square_planner_blueprint
 from .summary.blueprint import make_summary_blueprint
 from .tile.blueprint import make_tile_blueprint
-from .upload.blueprint import make_upload_blueprint
+from .upload_blueprint import make_upload_blueprint
 from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.config import ConfigAccessor
 from geo_activity_playground.webui.auth.blueprint import make_auth_blueprint
@@ -97,7 +99,8 @@ def web_ui_main(
         url_prefix="/explorer",
     )
     app.register_blueprint(
-        make_heatmap_blueprint(repository, tile_visit_accessor), url_prefix="/heatmap"
+        make_heatmap_blueprint(repository, tile_visit_accessor, config_accessor()),
+        url_prefix="/heatmap",
     )
     app.register_blueprint(
         make_settings_blueprint(config_accessor, authenticator),
@@ -115,7 +118,7 @@ def web_ui_main(
         make_summary_blueprint(repository, config_accessor()),
         url_prefix="/summary",
     )
-    app.register_blueprint(make_tile_blueprint(), url_prefix="/tile")
+    app.register_blueprint(make_tile_blueprint(config_accessor()), url_prefix="/tile")
     app.register_blueprint(
         make_upload_blueprint(
             repository, tile_visit_accessor, config_accessor(), authenticator
@@ -123,11 +126,20 @@ def web_ui_main(
         url_prefix="/upload",
     )
 
+    base_dir = pathlib.Path("Open Street Map Tiles")
+    dir_for_source = base_dir / urllib.parse.quote_plus(config_accessor().map_tile_url)
+    if base_dir.exists() and not dir_for_source.exists():
+        subdirs = base_dir.glob("*")
+        dir_for_source.mkdir()
+        for subdir in subdirs:
+            shutil.move(subdir, dir_for_source)
+
     @app.context_processor
     def inject_global_variables() -> dict:
         return {
             "version": _try_get_version(),
             "num_activities": len(repository),
+            "map_tile_attribution": config_accessor().map_tile_attribution,
         }
 
     app.run(host=host, port=port)

geo_activity_playground/webui/entry_controller.py

@@ -16,10 +16,10 @@ class EntryController:
         self._config = config
 
     def render(self) -> dict:
-        kind_scale = make_kind_scale(self._repository.meta, self._config)
         result = {"latest_activities": []}
 
         if len(self._repository):
+            kind_scale = make_kind_scale(self._repository.meta, self._config)
             result["distance_last_30_days_plot"] = distance_last_30_days_meta_plot(
                 self._repository.meta, kind_scale
             )

geo_activity_playground/webui/equipment/controller.py

@@ -87,7 +87,7 @@ class EquipmentController:
                 )
                 .mark_bar()
                 .encode(
-                    alt.X("kind", title="Year"),
+                    alt.X("kind", title="Kind"),
                     alt.Y("sum(distance_km)", title="Distance / km"),
                 )
                 .to_json(format="vega")