geo-activity-playground 0.34.2__py3-none-any.whl → 0.35.1__py3-none-any.whl

geo_activity_playground/__main__.py

@@ -12,6 +12,7 @@ from geo_activity_playground.core.config import import_old_config
 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.heatmap_video import main_heatmap_video
 from geo_activity_playground.webui.app import web_ui_main
 from geo_activity_playground.webui.upload_blueprint import scan_for_activities
 
@@ -80,6 +81,17 @@ def main() -> None:
     subparser = subparsers.add_parser("cache", help="Cache stuff")
     subparser.set_defaults(func=lambda options: main_cache(options.basedir))
 
+    subparser = subparsers.add_parser(
+        "heatmap-video", help="Create a video with the evolution of the heatmap"
+    )
+    subparser.add_argument("latitude", type=float)
+    subparser.add_argument("longitude", type=float)
+    subparser.add_argument("zoom", type=int)
+    subparser.add_argument("--decay", type=float, default=0.05)
+    subparser.add_argument("--video-width", type=int, default=1920)
+    subparser.add_argument("--video-height", type=int, default=1080)
+    subparser.set_defaults(func=main_heatmap_video)
+
     options = parser.parse_args()
     coloredlogs.install(
         fmt="%(asctime)s %(name)s %(levelname)s %(message)s",

geo_activity_playground/core/raster_map.py

@@ -0,0 +1,250 @@
+import collections
+import dataclasses
+import functools
+import logging
+import pathlib
+import time
+import urllib.parse
+
+import numpy as np
+import requests
+from PIL import Image
+
+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_upper_left_lat_lon
+
+
+logger = logging.getLogger(__name__)
+
+
+OSM_TILE_SIZE = 256  # OSM tile size in pixel
+OSM_MAX_ZOOM = 19  # OSM maximum zoom level
+MAX_TILE_COUNT = 2000  # maximum number of tiles to download
+
+## Basic data types ##
+
+
+@dataclasses.dataclass
+class GeoBounds:
+    """
+    Models an area on the globe as a rectangle of latitude and longitude.
+
+    Latitude goes from South Pole (-90°) to North Pole (+90°). Longitude goes from West (-180°) to East (+180°). Be careful when converting latitude to Y-coordinates as increasing latitude will mean decreasing Y.
+    """
+
+    lat_min: float
+    lon_min: float
+    lat_max: float
+    lon_max: float
+
+
+@dataclasses.dataclass
+class TileBounds:
+    zoom: int
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+
+    @property
+    def width(self) -> int:
+        return self.x2 - self.x1
+
+    @property
+    def height(self) -> int:
+        return self.y2 - self.y1
+
+
+@dataclasses.dataclass
+class PixelBounds:
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+
+    @classmethod
+    def from_tile_bounds(cls, tile_bounds: TileBounds) -> "PixelBounds":
+        return pixel_bounds_from_tile_bounds(tile_bounds)
+
+    @property
+    def width(self) -> int:
+        return self.x2 - self.x1
+
+    @property
+    def height(self) -> int:
+        return self.y2 - self.y1
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        return self.height, self.width
+
+
+@dataclasses.dataclass
+class RasterMapImage:
+    image: np.ndarray
+    tile_bounds: TileBounds
+    geo_bounds: GeoBounds
+    pixel_bounds: PixelBounds
+
+
+## Converter functions ##
+
+
+def tile_bounds_from_geo_bounds(geo_bounds: GeoBounds) -> TileBounds:
+    x1, y1 = compute_tile_float(geo_bounds.lat_max, geo_bounds.lon_min)
+    x2, y2 = compute_tile_float(geo_bounds.lat_min, geo_bounds.lon_min)
+    return TileBounds(x1, y1, x2, y2)
+
+
+def pixel_bounds_from_tile_bounds(tile_bounds: TileBounds) -> PixelBounds:
+    return PixelBounds(
+        int(tile_bounds.x1 * OSM_TILE_SIZE),
+        int(tile_bounds.y1 * OSM_TILE_SIZE),
+        int(tile_bounds.x2 * OSM_TILE_SIZE),
+        int(tile_bounds.y2 * OSM_TILE_SIZE),
+    )
+
+
+def get_sensible_zoom_level(
+    bounds: GeoBounds, picture_size: tuple[int, int]
+) -> TileBounds:
+    zoom = OSM_MAX_ZOOM
+
+    while True:
+        x_tile_min, y_tile_max = map(
+            int, compute_tile_float(bounds.lat_min, bounds.lon_min, zoom)
+        )
+        x_tile_max, y_tile_min = map(
+            int, compute_tile_float(bounds.lat_max, bounds.lon_max, zoom)
+        )
+
+        x_tile_max += 1
+        y_tile_max += 1
+
+        if (x_tile_max - x_tile_min) * OSM_TILE_SIZE <= picture_size[0] and (
+            y_tile_max - y_tile_min
+        ) * OSM_TILE_SIZE <= picture_size[1]:
+            break
+
+        zoom -= 1
+
+    tile_count = (x_tile_max - x_tile_min) * (y_tile_max - y_tile_min)
+
+    if tile_count > MAX_TILE_COUNT:
+        raise RuntimeError("Zoom value too high, too many tiles to download")
+
+    return TileBounds(zoom, x_tile_min, y_tile_min, x_tile_max, y_tile_max)
+
+
+@functools.lru_cache()
+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 = url_template.format(x=x, y=y, zoom=zoom)
+        download_file(url, destination)
+    with Image.open(destination) as image:
+        image.load()
+        image = image.convert("RGB")
+    return image
+
+
+def tile_bounds_around_center(
+    tile_center: tuple[float, float], pixel_size: tuple[int, int], zoom: int
+) -> TileBounds:
+    x, y = tile_center
+    width = pixel_size[0] / OSM_TILE_SIZE
+    height = pixel_size[1] / OSM_TILE_SIZE
+    return TileBounds(
+        zoom, x - width / 2, y - height / 2, x + width / 2, y + height / 2
+    )
+
+
+def _paste_array(
+    target: np.ndarray, source: np.ndarray, offset_0: int, offset_1: int
+) -> None:
+    source_min_0 = 0
+    source_min_1 = 0
+    source_max_0 = source.shape[0]
+    source_max_1 = source.shape[1]
+
+    target_min_0 = offset_0
+    target_min_1 = offset_1
+    target_max_0 = offset_0 + source.shape[0]
+    target_max_1 = offset_1 + source.shape[1]
+
+    if target_min_1 < 0:
+        source_min_1 -= target_min_1
+        target_min_1 = 0
+    if target_min_0 < 0:
+        source_min_0 -= target_min_0
+        target_min_0 = 0
+    if target_max_1 > target.shape[1]:
+        a = target_max_1 - target.shape[1]
+        target_max_1 -= a
+        source_max_1 -= a
+    if target_max_0 > target.shape[0]:
+        a = target_max_0 - target.shape[0]
+        target_max_0 -= a
+        source_max_0 -= a
+
+    if source_max_1 < 0 or source_max_0 < 0:
+        return
+
+    target[target_min_0:target_max_0, target_min_1:target_max_1] = source[
+        source_min_0:source_max_0, source_min_1:source_max_1
+    ]
+
+
+def map_image_from_tile_bounds(tile_bounds: TileBounds, config: Config) -> np.ndarray:
+    pixel_bounds = pixel_bounds_from_tile_bounds(tile_bounds)
+    background = np.zeros((pixel_bounds.height, pixel_bounds.width, 3))
+
+    north_west = np.array([tile_bounds.x1, tile_bounds.y1])
+    offset = north_west % 1
+    tile_anchor = north_west - offset
+    pixel_anchor = np.array([0, 0]) - np.array(offset * OSM_TILE_SIZE, dtype=np.int64)
+
+    num_tile_x = int(np.ceil(tile_bounds.width)) + 1
+    num_tile_y = int(np.ceil(tile_bounds.height)) + 1
+
+    for x in range(int(tile_anchor[0]), int(tile_anchor[0] + num_tile_x)):
+        for y in range(int(tile_anchor[1]), int(tile_anchor[1]) + num_tile_y):
+            tile = np.array(get_tile(tile_bounds.zoom, x, y, config.map_tile_url)) / 255
+            _paste_array(
+                background,
+                tile,
+                (y - int(tile_anchor[1])) * OSM_TILE_SIZE + int(pixel_anchor[1]),
+                (x - int(tile_anchor[0])) * OSM_TILE_SIZE + int(pixel_anchor[0]),
+            )
+
+    return background
+
+
+def convert_to_grayscale(image: np.ndarray) -> np.ndarray:
+    image = np.sum(image * [0.2126, 0.7152, 0.0722], axis=2)
+    image = np.dstack((image, image, image))
+    return image
+
+
+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
+
+
+def download_file(url: str, destination: pathlib.Path):
+    if not destination.parent.exists():
+        destination.parent.mkdir(exist_ok=True, parents=True)
+    r = requests.get(
+        url,
+        allow_redirects=True,
+        headers={"User-Agent": "Martin's Geo Activity Playground"},
+    )
+    assert r.ok
+    with open(destination, "wb") as f:
+        f.write(r.content)
+    time.sleep(0.1)

geo_activity_playground/core/tiles.py

@@ -1,34 +1,12 @@
-import functools
 import logging
 import math
-import pathlib
-import time
-import urllib.parse
 from typing import Iterator
 from typing import Optional
 
 import numpy as np
-import requests
-from PIL import Image
-
-logger = logging.getLogger(__name__)
-
-
-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
 
 
-def compute_tile(lat: float, lon: float, zoom: int) -> tuple[int, int]:
-    x = np.radians(lon)
-    y = np.arcsinh(np.tan(np.radians(lat)))
-    x = (1 + x / np.pi) / 2
-    y = (1 - y / np.pi) / 2
-    n = 2**zoom
-    return int(x * n), int(y * n)
+logger = logging.getLogger(__name__)
 
 
 def compute_tile_float(lat: float, lon: float, zoom: int) -> tuple[float, float]:
@@ -40,6 +18,11 @@ def compute_tile_float(lat: float, lon: float, zoom: int) -> tuple[float, float]
     return x * n, y * n
 
 
+def compute_tile(lat: float, lon: float, zoom: int) -> tuple[int, int]:
+    x, y = compute_tile_float(lat, lon, zoom)
+    return int(x), int(y)
+
+
 def get_tile_upper_left_lat_lon(
     tile_x: int, tile_y: int, zoom: int
 ) -> tuple[float, float]:
@@ -50,33 +33,6 @@ def get_tile_upper_left_lat_lon(
     return lat_deg, lon_deg
 
 
-def download_file(url: str, destination: pathlib.Path):
-    if not destination.parent.exists():
-        destination.parent.mkdir(exist_ok=True, parents=True)
-    r = requests.get(
-        url,
-        allow_redirects=True,
-        headers={"User-Agent": "Martin's Geo Activity Playground"},
-    )
-    assert r.ok
-    with open(destination, "wb") as f:
-        f.write(r.content)
-    time.sleep(0.1)
-
-
-@functools.lru_cache()
-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 = url_template.format(x=x, y=y, zoom=zoom)
-        download_file(url, destination)
-    with Image.open(destination) as image:
-        image.load()
-        image = image.convert("RGB")
-    return image
-
-
 def xy_to_latlon(x: float, y: float, zoom: int) -> tuple[float, float]:
     """
     Returns (lat, lon) in degree from OSM coordinates (x,y) rom https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames

geo_activity_playground/explorer/video.py

@@ -13,7 +13,7 @@ from PIL import Image
 from PIL import ImageEnhance
 from tqdm import tqdm
 
-from ..core.tiles import get_tile
+from ..core.raster_map import get_tile
 
 # import scipy.interpolate
 

geo_activity_playground/heatmap_video.py

@@ -0,0 +1,93 @@
+import collections
+import os
+import pathlib
+
+import matplotlib.pyplot as pl
+import numpy as np
+import pandas as pd
+from PIL import Image
+from PIL import ImageDraw
+from tqdm import tqdm
+
+from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.core.raster_map import convert_to_grayscale
+from geo_activity_playground.core.raster_map import map_image_from_tile_bounds
+from geo_activity_playground.core.raster_map import OSM_TILE_SIZE
+from geo_activity_playground.core.raster_map import tile_bounds_around_center
+from geo_activity_playground.core.tiles import compute_tile_float
+
+
+def main_heatmap_video(options) -> None:
+    zoom: int = options.zoom
+    print(options)
+    video_size = options.video_width, options.video_height
+    os.chdir(options.basedir)
+
+    repository = ActivityRepository()
+    repository.reload()
+    assert len(repository) > 0
+    config_accessor = ConfigAccessor()
+
+    center_xy = compute_tile_float(options.latitude, options.longitude, zoom)
+
+    tile_bounds = tile_bounds_around_center(center_xy, video_size, zoom)
+    background = map_image_from_tile_bounds(tile_bounds, config_accessor())
+
+    background = convert_to_grayscale(background)
+    background = 1.0 - background  # invert colors
+
+    activities_per_day = collections.defaultdict(set)
+    for activity in tqdm(
+        repository.iter_activities(), desc="Gather activities per day"
+    ):
+        activities_per_day[activity["start"].date()].add(activity["id"])
+
+    running_counts = np.zeros(background.shape[:2], np.float64)
+
+    output_dir = pathlib.Path("Heatmap Video")
+    output_dir.mkdir(exist_ok=True)
+
+    first_day = min(activities_per_day)
+    last_day = max(activities_per_day)
+    days = pd.date_range(first_day, last_day)
+    for current_day in tqdm(days, desc="Generate video frames"):
+        for activity_id in activities_per_day[current_day.date()]:
+            im = Image.new("L", video_size)
+            draw = ImageDraw.Draw(im)
+
+            time_series = repository.get_time_series(activity_id)
+            for _, group in time_series.groupby("segment_id"):
+                tile_xz = group["x"] * 2**zoom
+                tile_yz = group["y"] * 2**zoom
+
+                xy_pixels = list(
+                    zip(
+                        (tile_xz - center_xy[0]) * OSM_TILE_SIZE
+                        + options.video_width / 2,
+                        (tile_yz - center_xy[1]) * OSM_TILE_SIZE
+                        + options.video_height / 2,
+                    )
+                )
+                pixels = [int(value) for t in xy_pixels for value in t]
+                draw.line(pixels, fill=1, width=max(3, 6 * (zoom - 17)))
+                aim = np.array(im)
+                running_counts += aim
+
+        tile_counts = np.sqrt(running_counts) / 5
+        tile_counts[tile_counts > 1.0] = 1.0
+
+        cmap = pl.get_cmap(config_accessor().color_scheme_for_heatmap)
+        data_color = cmap(tile_counts)
+        data_color[data_color == cmap(0.0)] = 0.0  # remove background color
+
+        rendered = np.zeros_like(background)
+        for c in range(3):
+            rendered[:, :, c] = (1.0 - data_color[:, :, c]) * background[
+                :, :, c
+            ] + data_color[:, :, c]
+
+        img = Image.fromarray((rendered * 255).astype("uint8"), "RGB")
+        img.save(output_dir / f"{current_day.date()}.png", format="png")
+
+        running_counts *= 1 - options.decay

geo_activity_playground/importers/activity_parsers.py

@@ -24,7 +24,7 @@ class ActivityParseError(BaseException):
 
 
 def read_activity(path: pathlib.Path) -> tuple[ActivityMeta, pd.DataFrame]:
-    suffixes = path.suffixes
+    suffixes = [s.lower() for s in path.suffixes]
     metadata = ActivityMeta()
 
     if suffixes[-1] == ".gz":

geo_activity_playground/webui/activity/blueprint.py

@@ -1,6 +1,5 @@
 import json
 import urllib.parse
-from collections.abc import Collection
 
 from flask import Blueprint
 from flask import redirect
@@ -9,26 +8,20 @@ from flask import request
 from flask import Response
 from flask import url_for
 
-from ...core.activities import ActivityRepository
-from ...explorer.tile_visits import TileVisitAccessor
-from .controller import ActivityController
-from geo_activity_playground.core.config import Config
+from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.paths import activity_meta_override_dir
-from geo_activity_playground.core.privacy_zones import PrivacyZone
+from geo_activity_playground.webui.activity.controller import ActivityController
 from geo_activity_playground.webui.authenticator import Authenticator
 from geo_activity_playground.webui.authenticator import needs_authentication
 
 
 def make_activity_blueprint(
+    activity_controller: ActivityController,
     repository: ActivityRepository,
-    tile_visit_accessor: TileVisitAccessor,
-    config: Config,
     authenticator: Authenticator,
 ) -> Blueprint:
     blueprint = Blueprint("activity", __name__, template_folder="templates")
 
-    activity_controller = ActivityController(repository, tile_visit_accessor, config)
-
     @blueprint.route("/all")
     def all():
         return render_template(

geo_activity_playground/webui/activity/controller.py

@@ -12,8 +12,6 @@ import pandas as pd
 from PIL import Image
 from PIL import ImageDraw
 
-from ...explorer.grid_file import make_grid_file_geojson
-from ...explorer.grid_file import make_grid_points
 from geo_activity_playground.core.activities import ActivityMeta
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.activities import make_geojson_color_line
@@ -21,14 +19,13 @@ 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 build_map_from_tiles_around_center
-from geo_activity_playground.core.heatmap import GeoBounds
-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
 from geo_activity_playground.core.privacy_zones import PrivacyZone
-from geo_activity_playground.core.tiles import compute_tile_float
+from geo_activity_playground.core.raster_map import map_image_from_tile_bounds
+from geo_activity_playground.core.raster_map import OSM_MAX_ZOOM
+from geo_activity_playground.core.raster_map import OSM_TILE_SIZE
+from geo_activity_playground.core.raster_map import tile_bounds_around_center
+from geo_activity_playground.explorer.grid_file import make_grid_file_geojson
+from geo_activity_playground.explorer.grid_file import make_grid_points
 from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
 
 logger = logging.getLogger(__name__)
@@ -412,62 +409,6 @@ def name_minutes_plot(meta: pd.DataFrame) -> str:
     )
 
 
-def make_pixel_bounds_square(bounds: PixelBounds) -> PixelBounds:
-    x_radius = (bounds.x_max - bounds.x_min) // 2
-    y_radius = (bounds.y_max - bounds.y_min) // 2
-    x_center = (bounds.x_max + bounds.x_min) // 2
-    y_center = (bounds.y_max + bounds.y_min) // 2
-
-    radius = max(x_radius, y_radius)
-
-    return PixelBounds(
-        x_min=x_center - radius,
-        y_min=y_center - radius,
-        x_max=x_center + radius,
-        y_max=y_center + radius,
-    )
-
-
-def make_tile_bounds_square(bounds: TileBounds) -> TileBounds:
-    x_radius = (bounds.x_tile_max - bounds.x_tile_min) / 2
-    y_radius = (bounds.y_tile_max - bounds.y_tile_min) / 2
-    x_center = (bounds.x_tile_max + bounds.x_tile_min) / 2
-    y_center = (bounds.y_tile_max + bounds.y_tile_min) / 2
-
-    radius = max(x_radius, y_radius)
-
-    return TileBounds(
-        zoom=bounds.zoom,
-        x_tile_min=int(x_center - radius),
-        y_tile_min=int(y_center - radius),
-        x_tile_max=int(np.ceil(x_center + radius)),
-        y_tile_max=int(np.ceil(y_center + radius)),
-    )
-
-
-def get_crop_mask(geo_bounds: GeoBounds, tile_bounds: TileBounds) -> PixelBounds:
-    min_x, min_y = compute_tile_float(
-        geo_bounds.lat_max, geo_bounds.lon_min, tile_bounds.zoom
-    )
-    max_x, max_y = compute_tile_float(
-        geo_bounds.lat_min, geo_bounds.lon_max, tile_bounds.zoom
-    )
-
-    crop_mask = PixelBounds(
-        int((min_x - tile_bounds.x_tile_min) * OSM_TILE_SIZE),
-        int((max_x - tile_bounds.x_tile_min) * OSM_TILE_SIZE),
-        int((min_y - tile_bounds.y_tile_min) * OSM_TILE_SIZE),
-        int((max_y - tile_bounds.y_tile_min) * OSM_TILE_SIZE),
-    )
-    crop_mask = make_pixel_bounds_square(crop_mask)
-
-    return crop_mask
-
-
-def pixels_in_bounds(bounds: PixelBounds) -> int:
-    return (bounds.x_max - bounds.x_min) * (bounds.y_max - bounds.y_min)
-
-
 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"]
@@ -496,13 +437,11 @@ def make_sharepic_base(time_series_list: list[pd.DataFrame], config: Config):
         (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,
+    tile_bounds = tile_bounds_around_center(
+        tile_xz_center, (target_width, target_height - footer_height), zoom
     )
+    tile_bounds.y2 += footer_height / OSM_TILE_SIZE
+    background = map_image_from_tile_bounds(tile_bounds, config)
 
     img = Image.fromarray((background * 255).astype("uint8"), "RGB")
     draw = ImageDraw.Draw(img, mode="RGBA")

geo_activity_playground/webui/app.py

@@ -9,25 +9,34 @@ import urllib.parse
 from flask import Flask
 from flask import render_template
 
-from ..core.activities import ActivityRepository
-from ..explorer.tile_visits import TileVisitAccessor
-from .activity.blueprint import make_activity_blueprint
-from .calendar.blueprint import make_calendar_blueprint
-from .eddington.blueprint import make_eddington_blueprint
-from .entry_controller import EntryController
-from .equipment.blueprint import make_equipment_blueprint
-from .explorer.blueprint import make_explorer_blueprint
-from .heatmap.blueprint import make_heatmap_blueprint
-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 geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.config import Config
 from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
+from geo_activity_playground.webui.activity.blueprint import make_activity_blueprint
+from geo_activity_playground.webui.activity.controller import ActivityController
 from geo_activity_playground.webui.auth.blueprint import make_auth_blueprint
 from geo_activity_playground.webui.authenticator import Authenticator
+from geo_activity_playground.webui.calendar.blueprint import make_calendar_blueprint
+from geo_activity_playground.webui.calendar.controller import CalendarController
+from geo_activity_playground.webui.eddington.blueprint import make_eddington_blueprint
+from geo_activity_playground.webui.eddington.controller import EddingtonController
+from geo_activity_playground.webui.entry_controller import EntryController
+from geo_activity_playground.webui.equipment.blueprint import make_equipment_blueprint
+from geo_activity_playground.webui.equipment.controller import EquipmentController
+from geo_activity_playground.webui.explorer.blueprint import make_explorer_blueprint
+from geo_activity_playground.webui.explorer.controller import ExplorerController
+from geo_activity_playground.webui.heatmap.blueprint import make_heatmap_blueprint
+from geo_activity_playground.webui.search.blueprint import make_search_blueprint
 from geo_activity_playground.webui.settings.blueprint import make_settings_blueprint
+from geo_activity_playground.webui.square_planner.blueprint import (
+    make_square_planner_blueprint,
+)
+from geo_activity_playground.webui.summary.blueprint import make_summary_blueprint
+from geo_activity_playground.webui.summary.controller import SummaryController
+from geo_activity_playground.webui.tile.blueprint import make_tile_blueprint
+from geo_activity_playground.webui.tile.controller import TileController
+from geo_activity_playground.webui.upload_blueprint import make_upload_blueprint
 
 
 def route_start(app: Flask, repository: ActivityRepository, config: Config) -> None:
@@ -77,26 +86,35 @@ def web_ui_main(
 
     authenticator = Authenticator(config_accessor())
 
+    config = config_accessor()
+    summary_controller = SummaryController(repository, config)
+    tile_controller = TileController(config)
+    activity_controller = ActivityController(repository, tile_visit_accessor, config)
+    calendar_controller = CalendarController(repository)
+    equipment_controller = EquipmentController(repository, config)
+    eddington_controller = EddingtonController(repository)
+    explorer_controller = ExplorerController(
+        repository, tile_visit_accessor, config_accessor
+    )
+
     route_start(app, repository, config_accessor())
 
     app.register_blueprint(make_auth_blueprint(authenticator), url_prefix="/auth")
-
     app.register_blueprint(
-        make_activity_blueprint(
-            repository, tile_visit_accessor, config_accessor(), authenticator
-        ),
+        make_activity_blueprint(activity_controller, repository, authenticator),
         url_prefix="/activity",
     )
-    app.register_blueprint(make_calendar_blueprint(repository), url_prefix="/calendar")
     app.register_blueprint(
-        make_eddington_blueprint(repository), url_prefix="/eddington"
+        make_calendar_blueprint(calendar_controller), url_prefix="/calendar"
+    )
+    app.register_blueprint(
+        make_eddington_blueprint(eddington_controller), url_prefix="/eddington"
     )
     app.register_blueprint(
-        make_equipment_blueprint(repository, config_accessor()), url_prefix="/equipment"
+        make_equipment_blueprint(equipment_controller), url_prefix="/equipment"
     )
     app.register_blueprint(
-        make_explorer_blueprint(repository, tile_visit_accessor, config_accessor),
-        url_prefix="/explorer",
+        make_explorer_blueprint(explorer_controller), url_prefix="/explorer"
     )
     app.register_blueprint(
         make_heatmap_blueprint(repository, tile_visit_accessor, config_accessor()),
@@ -115,10 +133,10 @@ def web_ui_main(
         url_prefix="/search",
     )
     app.register_blueprint(
-        make_summary_blueprint(repository, config_accessor()),
-        url_prefix="/summary",
+        make_summary_blueprint(summary_controller), url_prefix="/summary"
     )
-    app.register_blueprint(make_tile_blueprint(config_accessor()), url_prefix="/tile")
+
+    app.register_blueprint(make_tile_blueprint(tile_controller), url_prefix="/tile")
     app.register_blueprint(
         make_upload_blueprint(
             repository, tile_visit_accessor, config_accessor(), authenticator

geo_activity_playground/webui/calendar/blueprint.py

@@ -1,15 +1,12 @@
 from flask import Blueprint
 from flask import render_template
 
-from ...core.activities import ActivityRepository
-from .controller import CalendarController
+from geo_activity_playground.webui.calendar.controller import CalendarController
 
 
-def make_calendar_blueprint(repository: ActivityRepository) -> Blueprint:
+def make_calendar_blueprint(calendar_controller: CalendarController) -> Blueprint:
     blueprint = Blueprint("calendar", __name__, template_folder="templates")
 
-    calendar_controller = CalendarController(repository)
-
     @blueprint.route("/")
     def index():
         return render_template(

geo_activity_playground/webui/eddington/blueprint.py

@@ -1,15 +1,12 @@
 from flask import Blueprint
 from flask import render_template
 
-from ...core.activities import ActivityRepository
 from .controller import EddingtonController
 
 
-def make_eddington_blueprint(repository: ActivityRepository) -> Blueprint:
+def make_eddington_blueprint(eddington_controller: EddingtonController) -> Blueprint:
     blueprint = Blueprint("eddington", __name__, template_folder="templates")
 
-    eddington_controller = EddingtonController(repository)
-
     @blueprint.route("/")
     def index():
         return render_template(

geo_activity_playground/webui/equipment/blueprint.py

@@ -1,18 +1,12 @@
 from flask import Blueprint
 from flask import render_template
 
-from ...core.activities import ActivityRepository
-from .controller import EquipmentController
-from geo_activity_playground.core.config import Config
+from geo_activity_playground.webui.equipment.controller import EquipmentController
 
 
-def make_equipment_blueprint(
-    repository: ActivityRepository, config: Config
-) -> Blueprint:
+def make_equipment_blueprint(equipment_controller: EquipmentController) -> Blueprint:
     blueprint = Blueprint("equipment", __name__, template_folder="templates")
 
-    equipment_controller = EquipmentController(repository, config)
-
     @blueprint.route("/")
     def index():
         return render_template(

geo_activity_playground/webui/explorer/blueprint.py

@@ -4,20 +4,12 @@ from flask import render_template
 from flask import Response
 from flask import url_for
 
-from ...core.activities import ActivityRepository
-from ...explorer.tile_visits import TileVisitAccessor
-from .controller import ExplorerController
-from geo_activity_playground.core.config import ConfigAccessor
+from geo_activity_playground.webui.explorer.controller import ExplorerController
 
 
 def make_explorer_blueprint(
-    repository: ActivityRepository,
-    tile_visit_accessor: TileVisitAccessor,
-    config_accessor: ConfigAccessor,
+    explorer_controller: ExplorerController,
 ) -> Blueprint:
-    explorer_controller = ExplorerController(
-        repository, tile_visit_accessor, config_accessor
-    )
     blueprint = Blueprint("explorer", __name__, template_folder="templates")
 
     @blueprint.route("/<zoom>")

geo_activity_playground/webui/explorer/templates/explorer/index.html.j2

@@ -34,16 +34,15 @@
 <div class="row mb-3">
     <div class="col">
         <div class="btn-group mb-3" role="group">
-            <button type="button" class="btn btn-secondary" onclick="changeColor('cluster')">Cluster</button>
-            <button type="button" class="btn btn-secondary" onclick="changeColor('first')">First Visit</button>
-            <button type="button" class="btn btn-secondary" onclick="changeColor('last')">Last Visit</button>
+            <button type="button" class="btn btn-primary" onclick="changeColor('cluster')">Cluster</button>
+            <button type="button" class="btn btn-primary" onclick="changeColor('first')">First Visit</button>
+            <button type="button" class="btn btn-primary" onclick="changeColor('last')">Last Visit</button>
         </div>
         <div id="explorer-map" class="mb-1" style="height: 800px;"></div>
         <p>Download tiles in visible area: <a href="#" onclick="downloadAs('explored.geojson')">Explored as GeoJSON</a>,
             <a href="#" onclick="downloadAs('explored.gpx')"">Explored as GPX</a>, <a href=" #"
                 onclick="downloadAs('missing.geojson')">Missing as GeoJSON</a> or <a href="#"
                 onclick="downloadAs('missing.gpx')"">Missing as GPX</a>.</p>
-
         <script>
             function onEachFeature(feature, layer) {
                 if (feature.properties && feature.properties.first_visit) {
@@ -71,10 +70,11 @@
                 center: [{{ center.latitude }}, {{ center.longitude }}],
             zoom: 10
             })
-            L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
+            let tile_layer = L.tileLayer('/tile/grayscale/{z}/{x}/{y}.png', {
                 maxZoom: 19,
                 attribution: '{{ map_tile_attribution|safe }}'
-            }).addTo(map)
+            });
+            tile_layer.addTo(map)
             let explorer_layer_cluster_color = L.geoJSON(explorer_geojson, {
                 style: function (feature) {
                     return {
@@ -115,6 +115,8 @@
                 bounds = map.getBounds(); zoom = "{{ zoom }}"
                 window.location.href = `/explorer/${zoom}/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}/${suffix}`
             } </script>
+                <p></p><button type="button" class="btn btn-secondary btn-sm"
+                    onclick="map.removeLayer(tile_layer)">Remove map background</button>
     </div>
 </div>
 

geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -9,12 +9,12 @@ 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
-from geo_activity_playground.core.heatmap import PixelBounds
+from geo_activity_playground.core.raster_map import convert_to_grayscale
+from geo_activity_playground.core.raster_map import GeoBounds
+from geo_activity_playground.core.raster_map import get_sensible_zoom_level
+from geo_activity_playground.core.raster_map import get_tile
+from geo_activity_playground.core.raster_map import PixelBounds
 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 (
@@ -117,9 +117,7 @@ class HeatmapController:
                     time_series = self._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
+                            np.array([group["x"] * 2**z - x, group["y"] * 2**z - y]).T
                             * OSM_TILE_SIZE
                         )
                         im = Image.new("L", tile_pixels)
@@ -171,8 +169,8 @@ class HeatmapController:
         pixel_bounds = PixelBounds.from_tile_bounds(tile_bounds)
 
         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):
+        for x in range(tile_bounds.x1, tile_bounds.x2):
+            for y in range(tile_bounds.y1, tile_bounds.y2):
                 tile = (
                     np.array(
                         get_tile(tile_bounds.zoom, x, y, self._config.map_tile_url)
@@ -180,8 +178,8 @@ class HeatmapController:
                     / 255
                 )
 
-                i = y - tile_bounds.y_tile_min
-                j = x - tile_bounds.x_tile_min
+                i = y - tile_bounds.y1
+                j = x - tile_bounds.x1
 
                 background[
                     i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,

geo_activity_playground/webui/summary/blueprint.py

@@ -1,13 +1,10 @@
 from flask import Blueprint
 from flask import render_template
 
-from ...core.activities import ActivityRepository
 from .controller import SummaryController
-from geo_activity_playground.core.config import Config
 
 
-def make_summary_blueprint(repository: ActivityRepository, config: Config) -> Blueprint:
-    summary_controller = SummaryController(repository, config)
+def make_summary_blueprint(summary_controller: SummaryController) -> Blueprint:
     blueprint = Blueprint("summary", __name__, template_folder="templates")
 
     @blueprint.route("/")

geo_activity_playground/webui/summary/controller.py

@@ -1,7 +1,6 @@
 import collections
 import datetime
 import functools
-from typing import Optional
 
 import altair as alt
 import pandas as pd

geo_activity_playground/webui/tile/blueprint.py

@@ -2,14 +2,11 @@ from flask import Blueprint
 from flask import Response
 
 from .controller import TileController
-from geo_activity_playground.core.config import Config
 
 
-def make_tile_blueprint(config: Config) -> Blueprint:
+def make_tile_blueprint(tile_controller: TileController) -> Blueprint:
     blueprint = Blueprint("tiles", __name__, template_folder="templates")
 
-    tile_controller = TileController(config)
-
     @blueprint.route("/color/<z>/<x>/<y>.png")
     def tile_color(x: str, y: str, z: str):
         return Response(

geo_activity_playground/webui/tile/controller.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as pl
 import numpy as np
 
 from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.tiles import get_tile
+from geo_activity_playground.core.raster_map import get_tile
 
 
 class TileController:

{geo_activity_playground-0.34.2.dist-info → geo_activity_playground-0.35.1.dist-info}/METADATA

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

{geo_activity_playground-0.34.2.dist-info → geo_activity_playground-0.35.1.dist-info}/RECORD

@@ -1,26 +1,27 @@
 geo_activity_playground/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/__main__.py,sha256=qbKjs7IsJwF2gB3b0lh7tGt6uraPqq5w-xGBIxrgoHI,3988
+geo_activity_playground/__main__.py,sha256=vFKB0Jjk8ImDHqok6Fddb5CRWHEnxyn5r4Zs0A1EsCQ,4585
 geo_activity_playground/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geo_activity_playground/core/activities.py,sha256=MiQev1L7NnSVnxgbArlT-FpWTESTwnKh7pyT1tcEHqU,6926
 geo_activity_playground/core/config.py,sha256=uqiwk7CgcuGx8JemHSsRKjRwyNT1YTb7V0gX0OJhfaI,5109
 geo_activity_playground/core/coordinates.py,sha256=tDfr9mlXhK6E_MMIJ0vYWVCoH0Lq8uyuaqUgaa8i0jg,966
 geo_activity_playground/core/enrichment.py,sha256=fUmk6avy_rqePlHmJQFTQhAxjgIRaxxmq18N2OSXBBg,7771
 geo_activity_playground/core/heart_rate.py,sha256=IwMt58TpjOYqpAxtsj07zP2ttpN_J3GZeiv-qGhYyJc,1598
-geo_activity_playground/core/heatmap.py,sha256=iTxefUTjTToPrKpVbauJHXkqxpNppXOEK6vvKuNkHkk,5906
 geo_activity_playground/core/paths.py,sha256=RBeUi38riP_msTGPy1TsPRNiblzE-lFivaJSLULE8b0,2503
 geo_activity_playground/core/privacy_zones.py,sha256=4TumHsVUN1uW6RG3ArqTXDykPVipF98DCxVBe7YNdO8,512
+geo_activity_playground/core/raster_map.py,sha256=yoq5s883BEA2v5C6EYVynkOwynJMka9d2rmoa-W1uIE,7178
 geo_activity_playground/core/similarity.py,sha256=Jo8jRViuORCxdIGvyaflgsQhwu9S_jn10a450FRL18A,3159
 geo_activity_playground/core/tasks.py,sha256=aMDBWJqp6ek2ao6G6Xa8GOSZbcQqXoWL74SGRowRPIk,2942
 geo_activity_playground/core/test_tiles.py,sha256=zce1FxNfsSpOQt66jMehdQRVoNdl-oiFydx6iVBHZXM,764
 geo_activity_playground/core/test_time_conversion.py,sha256=Sh6nZA3uCTOdZTZa3yOijtR0m74QtZu2mcWXsDNnyQI,984
-geo_activity_playground/core/tiles.py,sha256=qUe4h3rzHJb8xThAgUKSLElt8S6zID_OuaWXDkWLwAU,3539
+geo_activity_playground/core/tiles.py,sha256=lV6X1Uc9XQecu2LALIvxpnMcLsVtWx7JczJ5a_S1eZE,2139
 geo_activity_playground/core/time_conversion.py,sha256=x5mXG6Y4GtdX7CBmwucGNSWBp9JQJDbZ7u0JkdUY1Vs,379
 geo_activity_playground/explorer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geo_activity_playground/explorer/grid_file.py,sha256=k6j6KBEk2a2BY-onE8SV5TJsERGGyOrlY4as__meWpA,3304
 geo_activity_playground/explorer/tile_visits.py,sha256=CSHAjgzKWe1iB-zvaqgsR5Z_lFycpWqUfxnPCAWvYaU,14173
-geo_activity_playground/explorer/video.py,sha256=35-mMEvD8phnc2xbWdwCHhl_uMIUogHrnFwrTfk2Yj8,4392
+geo_activity_playground/explorer/video.py,sha256=7j6Qv3HG6On7Tn7xh7Olwrx_fbQnfzS7CeRg3TEApHg,4397
+geo_activity_playground/heatmap_video.py,sha256=Oc3EAAsW27zhG28Rmy3i2GoN1rjm1UFgb53eSHr9GP8,3503
 geo_activity_playground/importers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/importers/activity_parsers.py,sha256=XNQs0ziqAcVqIoiLAX5Ndmhb6v__29XdjUPvNvc7oBI,11082
+geo_activity_playground/importers/activity_parsers.py,sha256=5MvtjmXruPAoUO1KlDycoj677NeETgODiyxsFjXNppg,11103
 geo_activity_playground/importers/csv_parser.py,sha256=O1pP5GLhWhnWcy2Lsrr9g17Zspuibpt-GtZ3ZS5eZF4,2143
 geo_activity_playground/importers/directory.py,sha256=CA-vFOMm8G4MSM_Q09OwQKduCApL2PWaxLTVxgw_xpw,5908
 geo_activity_playground/importers/strava_api.py,sha256=cJCZsLemhOlxTtZh0z_npidgae9SD5HyEUry2uvem_A,7775
@@ -30,38 +31,38 @@ geo_activity_playground/importers/test_directory.py,sha256=ljXokx7q0OgtHvEdHftcQ
 geo_activity_playground/importers/test_strava_api.py,sha256=4vX7wDr1a9aRh8myxNrIq6RwDBbP8ZeoXXPc10CAbW4,431
 geo_activity_playground/webui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geo_activity_playground/webui/activity/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/webui/activity/blueprint.py,sha256=2Fa_6a86Aa3Yr3hQdkRylQqqVusyyVzPd1x3il5ZXNk,4176
-geo_activity_playground/webui/activity/controller.py,sha256=0HXQZAD9Muf62jV-GqQKJPq5qNgdbV-KEcPmHX_8iGo,21429
+geo_activity_playground/webui/activity/blueprint.py,sha256=J2f6zzBtwkrem51WDakLXKahVcOxMT2JKbbFgu0VFws,3914
+geo_activity_playground/webui/activity/controller.py,sha256=Gps0qGa3vd3xvBW4EIpwoQxYbkYItFfzlz0tzaj8HCA,19508
 geo_activity_playground/webui/activity/templates/activity/day.html.j2,sha256=wkYmcnIsMlvE9wgKemYCNU6jwsk5IJvg8pcBA2OMh00,2795
 geo_activity_playground/webui/activity/templates/activity/edit.html.j2,sha256=ckcTTxcQOhmvvAGNTEOtWCUG4LhvO4HfQImlIa5qKs8,1530
 geo_activity_playground/webui/activity/templates/activity/lines.html.j2,sha256=_ZDg1ruW-9UMJfOudy1-uY_-IcSSaagq7tPCih5Bb8g,1079
 geo_activity_playground/webui/activity/templates/activity/name.html.j2,sha256=tKviMqMouHEGv3xBQVIsJgwj_hjwAsmGVefM3UMqlYg,2437
 geo_activity_playground/webui/activity/templates/activity/show.html.j2,sha256=bEx37UGSTeeJl7gN4fjyOpINFQwZ5Zm-HOKpLqcJGfs,6905
-geo_activity_playground/webui/app.py,sha256=KghChBgJvRZ9Cx7Z5wmqx6X0Q6GH-2hi97eaKEE_Zvc,5118
+geo_activity_playground/webui/app.py,sha256=MXjd5iOYY7q_wGYgMKOj0T2z7cJ9KxpevVGHD5V95ws,6521
 geo_activity_playground/webui/auth/blueprint.py,sha256=Lx-ZvMnfHLC1CMre1xPQI3k_pCtQoZvgRhtmafULzoE,812
 geo_activity_playground/webui/auth/templates/auth/index.html.j2,sha256=ILQ5HvTEYc3OrtOAIFt1VrqWorVD70V9DC342znmP70,579
 geo_activity_playground/webui/authenticator.py,sha256=k278OEVuOfAmTGT4F2X4pqSTwwkK_FA87EIhAeysEqc,1416
 geo_activity_playground/webui/calendar/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/webui/calendar/blueprint.py,sha256=rlnhgU2DWAcdLMRq7m77NzrM_aDyp4s3kuuQHuzjHhg,782
+geo_activity_playground/webui/calendar/blueprint.py,sha256=Kjyx9lkJoM5tL8vNba0Y7HhJuFRVId4F-ONZsXpKyyg,721
 geo_activity_playground/webui/calendar/controller.py,sha256=QpSAkR2s1sbLSu6P_fNNTccgGglOzEH2PIv1XwKxeVY,2778
 geo_activity_playground/webui/calendar/templates/calendar/index.html.j2,sha256=xoR6R4cUgTQNRHQv3m3f4Bc-yCjJEsJj5d4_CWlJsRo,1427
 geo_activity_playground/webui/calendar/templates/calendar/month.html.j2,sha256=sRIiNo_Rp9CHary6e-lnpKJKOuAonoDEBvKMxzbTLQE,1802
 geo_activity_playground/webui/eddington/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/webui/eddington/blueprint.py,sha256=evIvueLfDWVTxJ9pRguqmZ9-Pybd2WmBRst_-7vX2QA,551
+geo_activity_playground/webui/eddington/blueprint.py,sha256=2VUiH0HXqp4hK86PmcyOtZ2WTlunJqmsArOYRpVLaAc,452
 geo_activity_playground/webui/eddington/controller.py,sha256=ly7JSkSS79kO4CL_xugB62uRuuWKVqOjbN-pheelv94,2910
 geo_activity_playground/webui/eddington/templates/eddington/index.html.j2,sha256=XHKeUymQMS5x00PLOVlg-nSRCz_jHB2pvD8QunULWJ4,1839
 geo_activity_playground/webui/entry_controller.py,sha256=McxbyouKWHJ3a2R9agPazZoG7VHiFO1RvnkBr08dMH8,2168
 geo_activity_playground/webui/equipment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/webui/equipment/blueprint.py,sha256=_NIhRJuJNbXpEd_nEPo01AqnUqPgo1vawFn7E3yoeng,636
+geo_activity_playground/webui/equipment/blueprint.py,sha256=kJhCSdakke_UhT2RIP-fMoAMaC1oFttRoCPeiAIaB6g,491
 geo_activity_playground/webui/equipment/controller.py,sha256=lMivui3EBUnkYZf9Lgv1kHZ0c7IxRAza-ox8YOz3ONY,4079
 geo_activity_playground/webui/equipment/templates/equipment/index.html.j2,sha256=fvRaDbCuiSZ8AzJTpu1dk8FTAGZ2yfsLhprtVYHFZWo,1802
 geo_activity_playground/webui/explorer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/webui/explorer/blueprint.py,sha256=EKnBs8llqT6Wy1uac18dF2epp3TebF9p3iGlSbj6Vl0,2337
+geo_activity_playground/webui/explorer/blueprint.py,sha256=iLmdayavR7B1_l67VvkMGsaYeABSXEe9IwTydK_-Owg,2027
 geo_activity_playground/webui/explorer/controller.py,sha256=pIzWh0TpLJgKQZlS325-QT7nA1q9ms7fRqQIp24PNfo,11705
-geo_activity_playground/webui/explorer/templates/explorer/index.html.j2,sha256=aGos75uUyjevDWKSyQwVyvuGHIY6qoGASMbgU6k71YU,6707
+geo_activity_playground/webui/explorer/templates/explorer/index.html.j2,sha256=3t9ikAF6oMvEaVlS3Kb1tj9ngomIQlatzqPnqVsEDKA,6908
 geo_activity_playground/webui/heatmap/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 geo_activity_playground/webui/heatmap/blueprint.py,sha256=ZEImDIwT3uiDIKapqCU49llvyqG79n7ZEu1GHgoLZqo,1558
-geo_activity_playground/webui/heatmap/heatmap_controller.py,sha256=Qw9MGW3TFWlG2JkA_r9RHgYq4hvPiJaZeAg5D9lIFC0,7821
+geo_activity_playground/webui/heatmap/heatmap_controller.py,sha256=sUTfM-wwQXe4B4tyuQka9s9bfXLVyexaF0yyM8_q2xk,7728
 geo_activity_playground/webui/heatmap/templates/heatmap/index.html.j2,sha256=BMjqbZ-btSFawuNDxgZxOkF5JvhD_p9DOBJ-4-1IKnU,1833
 geo_activity_playground/webui/plot_util.py,sha256=pTTQoqOCkLVjkgOit7mbry28kMruZIL8amZozSzEpxQ,283
 geo_activity_playground/webui/search/blueprint.py,sha256=7TDsiqEowMyHNlFImk-hCGso69KOieG4rfJnLRHpRz8,3300
@@ -114,19 +115,19 @@ geo_activity_playground/webui/static/vega@5,sha256=5DLHUaY2P0ph2mKSDMfX69E88J2Cl
 geo_activity_playground/webui/static/web-app-manifest-192x192.png,sha256=eEImN6iWfSv-EnSNPL5WbX84PKakse_8VZMBPWWye3o,13582
 geo_activity_playground/webui/static/web-app-manifest-512x512.png,sha256=vU9oQ4HnQerFDZVzcAT9twj4_Doc6_9v9wVvoRI-f_E,48318
 geo_activity_playground/webui/summary/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/webui/summary/blueprint.py,sha256=tfA2aPF19yKwkQOb5lPQBySoQYYhTn49Iuh0SYvsGP8,593
-geo_activity_playground/webui/summary/controller.py,sha256=FyPdC98maX0P5sJ4j5Z7-ZSiirLh_jmu_PszKXqTV8A,9425
+geo_activity_playground/webui/summary/blueprint.py,sha256=7Yc8aQ9zTy8Rd0-yI_jV3cvQi5cwSe_Wn5O1JSvHq0s,416
+geo_activity_playground/webui/summary/controller.py,sha256=CJZKGaVXJenuoIbypzbH_MwMKBICGr_F4Adu9LMWtPU,9397
 geo_activity_playground/webui/summary/templates/summary/index.html.j2,sha256=ctOx3Qjx6nRDpUtFf1DlJhK_gtU77Vwx_S6euLz9-W4,5183
 geo_activity_playground/webui/templates/home.html.j2,sha256=IdCqI_LLcYrpUjjCO-tbXR4s05XYrPOateiJ4idF3bo,2202
 geo_activity_playground/webui/templates/page.html.j2,sha256=Mt1M0hw1V7sPnQmo6kRO_e49B4to30eDkAf-J35xXas,10624
 geo_activity_playground/webui/templates/upload/index.html.j2,sha256=I1Ix8tDS3YBdi-HdaNfjkzYXVVCjfUTe5PFTnap1ydc,775
 geo_activity_playground/webui/templates/upload/reload.html.j2,sha256=YZWX5eDeNyqKJdQAywDBcU8DZBm22rRBbZqFjrFrCvQ,556
 geo_activity_playground/webui/tile/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geo_activity_playground/webui/tile/blueprint.py,sha256=q0sw_F8L367Df01yjZijikEIglFBgg9lN61sbTAEOKQ,1018
-geo_activity_playground/webui/tile/controller.py,sha256=XjUTbyAMeQET1D3mFtT8r5-xMcMOaELPZWtQ1Xp7Cuw,1428
+geo_activity_playground/webui/tile/blueprint.py,sha256=WTkqeOhagnDCquyBtOsZQLzI41arIEdGBe46jnMEkNg,934
+geo_activity_playground/webui/tile/controller.py,sha256=UY_dVQrjSYCXTkVjgQwQumltPPIUOQfdnN8nJv1m54I,1433
 geo_activity_playground/webui/upload_blueprint.py,sha256=topLI9ytDUFkqCc9AlOqDkjhABUwnPJ1tX_7XrBPbxc,4412
-geo_activity_playground-0.34.2.dist-info/LICENSE,sha256=4RpAwKO8bPkfXH2lnpeUW0eLkNWglyG4lbrLDU_MOwY,1070
-geo_activity_playground-0.34.2.dist-info/METADATA,sha256=zJSlC24LGmWQ63Ozp6X6ZGqgFbTzr5M7qBVerF_JwHc,1573
-geo_activity_playground-0.34.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-geo_activity_playground-0.34.2.dist-info/entry_points.txt,sha256=pbNlLI6IIZIp7nPYCfAtiSiz2oxJSCl7DODD6SPkLKk,81
-geo_activity_playground-0.34.2.dist-info/RECORD,,
+geo_activity_playground-0.35.1.dist-info/LICENSE,sha256=4RpAwKO8bPkfXH2lnpeUW0eLkNWglyG4lbrLDU_MOwY,1070
+geo_activity_playground-0.35.1.dist-info/METADATA,sha256=tXXmYUBsCfdgXnO_D5nXqvc8xIv237xH0Upkgdw6r_A,1573
+geo_activity_playground-0.35.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+geo_activity_playground-0.35.1.dist-info/entry_points.txt,sha256=pbNlLI6IIZIp7nPYCfAtiSiz2oxJSCl7DODD6SPkLKk,81
+geo_activity_playground-0.35.1.dist-info/RECORD,,

geo_activity_playground/core/heatmap.py

@@ -1,194 +0,0 @@
-"""
-This code is based on https://github.com/remisalmon/Strava-local-heatmap.
-"""
-import dataclasses
-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
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclasses.dataclass
-class GeoBounds:
-    lat_min: float
-    lon_min: float
-    lat_max: float
-    lon_max: float
-
-
-def get_bounds(lat_lon_data: np.ndarray) -> GeoBounds:
-    return GeoBounds(*np.min(lat_lon_data, axis=0), *np.max(lat_lon_data, axis=0))
-
-
-def add_margin(lower: float, upper: float) -> tuple[float, float]:
-    spread = upper - lower
-    margin = spread / 20
-    return max(0.0, lower - margin), upper + margin
-
-
-def add_margin_to_geo_bounds(bounds: GeoBounds) -> GeoBounds:
-    lat_min, lat_max = add_margin(bounds.lat_min, bounds.lat_max)
-    lon_min, lon_max = add_margin(bounds.lon_min, bounds.lon_max)
-    return GeoBounds(lat_min, lon_min, lat_max, lon_max)
-
-
-OSM_TILE_SIZE = 256  # OSM tile size in pixel
-OSM_MAX_ZOOM = 19  # OSM maximum zoom level
-MAX_TILE_COUNT = 2000  # maximum number of tiles to download
-
-
-@dataclasses.dataclass
-class TileBounds:
-    zoom: int
-    x_tile_min: int
-    x_tile_max: int
-    y_tile_min: int
-    y_tile_max: int
-
-
-@dataclasses.dataclass
-class PixelBounds:
-    x_min: int
-    x_max: int
-    y_min: int
-    y_max: int
-
-    @classmethod
-    def from_tile_bounds(cls, tile_bounds: TileBounds) -> "PixelBounds":
-        return cls(
-            int(tile_bounds.x_tile_min) * OSM_TILE_SIZE,
-            int(tile_bounds.x_tile_max) * OSM_TILE_SIZE,
-            int(tile_bounds.y_tile_min) * OSM_TILE_SIZE,
-            int(tile_bounds.y_tile_max) * OSM_TILE_SIZE,
-        )
-
-    @property
-    def shape(self) -> tuple[int, int]:
-        return (
-            self.y_max - self.y_min,
-            self.x_max - self.x_min,
-        )
-
-
-def geo_bounds_from_tile_bounds(tile_bounds: TileBounds) -> GeoBounds:
-    lat_max, lon_min = get_tile_upper_left_lat_lon(
-        tile_bounds.x_tile_min, tile_bounds.y_tile_min, tile_bounds.zoom
-    )
-    lat_min, lon_max = get_tile_upper_left_lat_lon(
-        tile_bounds.x_tile_max, tile_bounds.y_tile_max, tile_bounds.zoom
-    )
-    return GeoBounds(lat_min, lon_min, lat_max, lon_max)
-
-
-def get_sensible_zoom_level(
-    bounds: GeoBounds, picture_size: tuple[int, int]
-) -> TileBounds:
-    zoom = OSM_MAX_ZOOM
-
-    while True:
-        x_tile_min, y_tile_max = map(
-            int, compute_tile_float(bounds.lat_min, bounds.lon_min, zoom)
-        )
-        x_tile_max, y_tile_min = map(
-            int, compute_tile_float(bounds.lat_max, bounds.lon_max, zoom)
-        )
-
-        x_tile_max += 1
-        y_tile_max += 1
-
-        if (x_tile_max - x_tile_min) * OSM_TILE_SIZE <= picture_size[0] and (
-            y_tile_max - y_tile_min
-        ) * OSM_TILE_SIZE <= picture_size[1]:
-            break
-
-        zoom -= 1
-
-    tile_count = (x_tile_max - x_tile_min) * (y_tile_max - y_tile_min)
-
-    if tile_count > MAX_TILE_COUNT:
-        raise RuntimeError("Zoom value too high, too many tiles to download")
-
-    return TileBounds(
-        zoom=zoom,
-        x_tile_min=x_tile_min,
-        x_tile_max=x_tile_max,
-        y_tile_min=y_tile_min,
-        y_tile_max=y_tile_max,
-    )
-
-
-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
-
-
-def convert_to_grayscale(image: np.ndarray) -> np.ndarray:
-    image = np.sum(image * [0.2126, 0.7152, 0.0722], axis=2)
-    image = np.dstack((image, image, image))
-    return image