geo-activity-playground 0.31.0__tar.gz → 0.33.0__tar.gz

{geo_activity_playground-0.31.0 → geo_activity_playground-0.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.31.0
+Version: 0.33.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding

{geo_activity_playground-0.31.0 → geo_activity_playground-0.33.0}/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-0.31.0 → geo_activity_playground-0.33.0}/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-0.31.0 → geo_activity_playground-0.33.0}/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-0.31.0 → geo_activity_playground-0.33.0}/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-0.31.0 → geo_activity_playground-0.33.0}/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:
@@ -458,43 +456,58 @@ def make_sharepic(
     activity: ActivityMeta,
     time_series: pd.DataFrame,
     sharepic_suppressed_fields: list[str],
+    config: Config,
 ) -> bytes:
-    lat_lon_data = np.array([time_series["latitude"], time_series["longitude"]]).T
+    tile_x = time_series["x"]
+    tile_y = time_series["y"]
+    tile_width = tile_x.max() - tile_x.min()
+    tile_height = tile_y.max() - tile_y.min()
+
+    target_width = 600
+    target_height = 600
+    footer_height = 100
+    target_map_height = target_height - footer_height
+
+    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,
+        )
+    )
 
-    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)
+    tile_xz = tile_x * 2**zoom
+    tile_yz = tile_y * 2**zoom
 
-    crop_mask = get_crop_mask(geo_bounds, tile_bounds)
-    assert pixels_in_bounds(crop_mask) <= 10_000_000, crop_mask
+    tile_xz_center = (
+        (tile_xz.max() + tile_xz.min()) / 2,
+        (tile_yz.max() + tile_yz.min()) / 2,
+    )
 
-    background = background[
-        crop_mask.y_min : crop_mask.y_max,
-        crop_mask.x_min : crop_mask.x_max,
-        :,
-    ]
+    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),
+            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.rectangle([0, img.height - 70, img.width, img.height], fill=(0, 0, 0, 128))
+    draw.rectangle(
+        [0, img.height - footer_height, img.width, img.height], fill=(0, 0, 0, 180)
+    )
 
     facts = {
         "kind": f"{activity['kind']}",
@@ -515,19 +528,20 @@ def make_sharepic(
         if not key in sharepic_suppressed_fields
     }
 
-    draw.text((35, img.height - 70 + 10), "      ".join(facts.values()), font_size=20)
-
-    # img_array = np.array(img) / 255
-
-    # weight = np.dstack([img_array[:, :, 0]] * 3)
+    draw.text(
+        (35, img.height - footer_height + 10),
+        "      ".join(facts.values()),
+        font_size=20,
+    )
 
-    # background = (1 - weight) * background + img_array
-    # background[background > 1.0] = 1.0
-    # background[background < 0.0] = 0.0
+    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-0.31.0 → geo_activity_playground-0.33.0}/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 }}, {

{geo_activity_playground-0.31.0 → geo_activity_playground-0.33.0}/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-0.31.0 → geo_activity_playground-0.33.0}/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-0.31.0 → geo_activity_playground-0.33.0}/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-0.31.0 → geo_activity_playground-0.33.0}/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
@@ -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-0.31.0 → geo_activity_playground-0.33.0}/geo_activity_playground/webui/explorer/templates/explorer/index.html.j2

@@ -73,7 +73,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 explorer_layer_cluster_color = L.geoJSON(explorer_geojson, {
                 style: function (feature) {
@@ -87,58 +87,34 @@
             let explorer_layer_first_age_color = L.geoJSON(explorer_geojson, {
                 style: function (feature) {
                     return {
-                        color: "#440154", fillColor: feature.properties.first_age_color,
-                        weight: 0.5
+                        color: " #440154", fillColor: feature.properties.first_age_color, weight: 0.5
                     }
                 },
                 onEachFeature: onEachFeature
-            })
-            let explorer_layer_last_age_color = L.geoJSON(explorer_geojson, {
-                style: function (feature) {
-                    return {
-                        color: "#440154", fillColor: feature.properties.last_age_color, weight:
-                            0.5
-                    }
-                },
-                onEachFeature: onEachFeature
-            })
-
-            let bbox = {{ center.bbox| safe }}
-            if (bbox) {
-                map.fitBounds(L.geoJSON(bbox).getBounds())
-            }
-
-            let explorer_square_layer = L.geoJSON(square_geojson,
-                {
-                    style: function (feature) {
+            }) let explorer_layer_last_age_color = L.geoJSON(explorer_geojson, {
+                style:
+                    function (feature) {
                         return {
-                            color: "blue", fill: false, weight: 2
+                            color: "#440154", fillColor: feature.properties.last_age_color, weight:
+                                0.5
                         }
-                    }
-                }
-            ).addTo(map)
-
-            active_layer = explorer_layer_cluster_color
-
-            function changeColor(method) {
+                    }, onEachFeature: onEachFeature
+            }) let bbox = {{ center.bbox| safe }} if (bbox) {
+                map.fitBounds(L.geoJSON(bbox).getBounds())
+            } let explorer_square_layer = L.geoJSON(square_geojson, {
+                style: function (feature) { return { color: "blue", fill: false, weight: 2 } }
+            }).addTo(map)
+            active_layer = explorer_layer_cluster_color function changeColor(method) {
                 map.removeLayer(active_layer)
-                if (method == "cluster") {
-                    active_layer = explorer_layer_cluster_color
-                } else if (method == "first") {
+                if (method == "cluster") { active_layer = explorer_layer_cluster_color } else if (method == "first") {
                     active_layer = explorer_layer_first_age_color
                 } else if (method == "last") {
                     active_layer = explorer_layer_last_age_color
-                }
-                map.addLayer(active_layer)
-            }
-
-            function downloadAs(suffix) {
-                bounds = map.getBounds()
-                zoom = "{{ zoom }}"
-                window.location.href =
-                    `/explorer/${zoom}/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}/${suffix}`
-            }
-        </script>
+                } map.addLayer(active_layer)
+            } function downloadAs(suffix) {
+                bounds = map.getBounds() zoom = "{{ zoom }}"
+                window.location.href = `/explorer/${zoom}/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}/${suffix}`
+            } </script>
     </div>
 </div>
 

{geo_activity_playground-0.31.0 → geo_activity_playground-0.33.0}/geo_activity_playground/webui/heatmap/blueprint.py

@@ -6,12 +6,15 @@ from flask import Response
 from ...core.activities import ActivityRepository
 from ...explorer.tile_visits import TileVisitAccessor
 from .heatmap_controller import HeatmapController
+from geo_activity_playground.core.config import Config
 
 
 def make_heatmap_blueprint(
-    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+    repository: ActivityRepository,
+    tile_visit_accessor: TileVisitAccessor,
+    config: Config,
 ) -> Blueprint:
-    heatmap_controller = HeatmapController(repository, tile_visit_accessor)
+    heatmap_controller = HeatmapController(repository, tile_visit_accessor, config)
     blueprint = Blueprint("heatmap", __name__, template_folder="templates")
 
     @blueprint.route("/")

{geo_activity_playground-0.31.0 → geo_activity_playground-0.33.0}/geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -8,6 +8,7 @@ from PIL import Image
 from PIL import ImageDraw
 
 from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.heatmap import convert_to_grayscale
 from geo_activity_playground.core.heatmap import GeoBounds
 from geo_activity_playground.core.heatmap import get_sensible_zoom_level
@@ -29,10 +30,14 @@ OSM_TILE_SIZE = 256  # OSM tile size in pixel
 
 class HeatmapController:
     def __init__(
-        self, repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+        self,
+        repository: ActivityRepository,
+        tile_visit_accessor: TileVisitAccessor,
+        config: Config,
     ) -> None:
         self._repository = repository
         self._tile_visit_accessor = tile_visit_accessor
+        self._config = config
 
         self.tile_histories = self._tile_visit_accessor.tile_state["tile_history"]
         self.tile_evolution_states = self._tile_visit_accessor.tile_state[
@@ -140,11 +145,11 @@ class HeatmapController:
         tile_counts = np.sqrt(tile_counts) / 5
         tile_counts[tile_counts > 1.0] = 1.0
 
-        cmap = pl.get_cmap("hot")
+        cmap = pl.get_cmap(self._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)) / 255
+        map_tile = np.array(get_tile(z, x, y, self._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):
@@ -168,7 +173,12 @@ class HeatmapController:
         background = np.zeros((*pixel_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
+                tile = (
+                    np.array(
+                        get_tile(tile_bounds.zoom, x, y, self._config.map_tile_url)
+                    )
+                    / 255
+                )
 
                 i = y - tile_bounds.y_tile_min
                 j = x - tile_bounds.x_tile_min

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

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