geo-activity-playground 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

geo_activity_playground/webui/heatmap/heatmap_controller.py

@@ -1,6 +1,8 @@
+import datetime
 import io
 import logging
 import pathlib
+from typing import Optional
 
 import matplotlib.pylab as pl
 import numpy as np
@@ -9,12 +11,13 @@ 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 OSM_TILE_SIZE
+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 (
@@ -25,9 +28,6 @@ from geo_activity_playground.webui.explorer.controller import (
 logger = logging.getLogger(__name__)
 
 
-OSM_TILE_SIZE = 256  # OSM tile size in pixel
-
-
 class HeatmapController:
     def __init__(
         self,
@@ -48,7 +48,12 @@ class HeatmapController:
             "activities_per_tile"
         ]
 
-    def render(self, kinds: list[str] = []) -> dict:
+    def render(
+        self,
+        kinds: list[int],
+        date_start: Optional[datetime.date],
+        date_end: Optional[datetime.date],
+    ) -> dict:
         zoom = 14
         tiles = self.tile_histories[zoom]
         medians = tiles.median(skipna=True)
@@ -60,9 +65,17 @@ class HeatmapController:
         available_kinds = sorted(self._repository.meta["kind"].unique())
 
         if not kinds:
-            kinds = available_kinds
+            kinds = list(range(len(available_kinds)))
+
+        extra_args = []
+        if date_start is not None:
+            extra_args.append(f"date-start={date_start.isoformat()}")
+        if date_end is not None:
+            extra_args.append(f"date-end={date_end.isoformat()}")
+        for kind in kinds:
+            extra_args.append(f"kind={kind}")
 
-        return {
+        values = {
             "center": {
                 "latitude": median_lat,
                 "longitude": median_lon,
@@ -76,71 +89,117 @@ class HeatmapController:
             },
             "kinds": kinds,
             "available_kinds": available_kinds,
-            "kinds_str": ";".join(kinds),
+            "extra_args": "&".join(extra_args),
         }
+        if date_start is not None:
+            values["date_start"] = date_start.date().isoformat()
+        if date_end is not None:
+            values["date_end"] = date_end.date().isoformat()
 
-    def _get_counts(self, x: int, y: int, z: int, kind: str) -> np.ndarray:
+        return values
+
+    def _get_counts(
+        self,
+        x: int,
+        y: int,
+        z: int,
+        kind: str,
+        date_start: Optional[datetime.date],
+        date_end: Optional[datetime.date],
+    ) -> np.ndarray:
         tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
-        tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{kind}/{z}/{x}/{y}.npy")
-        if tile_count_cache_path.exists():
-            try:
-                tile_counts = np.load(tile_count_cache_path)
-            except ValueError:
-                logger.warning(
-                    f"Heatmap count file {tile_count_cache_path} is corrupted, deleting."
-                )
-                tile_count_cache_path.unlink()
-                tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-        else:
-            tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-        tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
-        activity_ids = self.activities_per_tile[z].get((x, y), set())
-        activity_ids_kind = set()
-        for activity_id in activity_ids:
-            activity = self._repository.get_activity_by_id(activity_id)
-            if activity["kind"] == kind:
-                activity_ids_kind.add(activity_id)
-        if activity_ids_kind:
-            with work_tracker(
-                tile_count_cache_path.with_suffix(".json")
-            ) as parsed_activities:
-                if parsed_activities - activity_ids_kind:
+        tile_counts = np.zeros(tile_pixels, dtype=np.int32)
+        if date_start is None and date_end is None:
+            tile_count_cache_path = pathlib.Path(
+                f"Cache/Heatmap/{kind}/{z}/{x}/{y}.npy"
+            )
+            if tile_count_cache_path.exists():
+                try:
+                    tile_counts = np.load(tile_count_cache_path)
+                except ValueError:
                     logger.warning(
-                        f"Resetting heatmap cache for {kind=}/{x=}/{y=}/{z=} because activities have been removed."
+                        f"Heatmap count file {tile_count_cache_path} is corrupted, deleting."
                     )
+                    tile_count_cache_path.unlink()
                     tile_counts = np.zeros(tile_pixels, dtype=np.int32)
-                    parsed_activities.clear()
-                for activity_id in activity_ids_kind:
-                    if activity_id in parsed_activities:
-                        continue
-                    parsed_activities.add(activity_id)
-                    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
-                            * OSM_TILE_SIZE
+            tile_count_cache_path.parent.mkdir(parents=True, exist_ok=True)
+            activity_ids = self.activities_per_tile[z].get((x, y), set())
+            activity_ids_kind = set()
+            for activity_id in activity_ids:
+                activity = self._repository.get_activity_by_id(activity_id)
+                if activity["kind"] == kind:
+                    activity_ids_kind.add(activity_id)
+            if activity_ids_kind:
+                with work_tracker(
+                    tile_count_cache_path.with_suffix(".json")
+                ) as parsed_activities:
+                    if parsed_activities - activity_ids_kind:
+                        logger.warning(
+                            f"Resetting heatmap cache for {kind=}/{x=}/{y=}/{z=} because activities have been removed."
                         )
-                        im = Image.new("L", tile_pixels)
-                        draw = ImageDraw.Draw(im)
-                        pixels = list(map(int, xy_pixels.flatten()))
-                        draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
-                        aim = np.array(im)
-                        tile_counts += aim
-            tmp_path = tile_count_cache_path.with_suffix(".tmp.npy")
-            np.save(tmp_path, tile_counts)
-            tile_count_cache_path.unlink(missing_ok=True)
-            tmp_path.rename(tile_count_cache_path)
+                        tile_counts = np.zeros(tile_pixels, dtype=np.int32)
+                        parsed_activities.clear()
+                    for activity_id in activity_ids_kind:
+                        if activity_id in parsed_activities:
+                            continue
+                        parsed_activities.add(activity_id)
+                        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
+                                * OSM_TILE_SIZE
+                            )
+                            im = Image.new("L", tile_pixels)
+                            draw = ImageDraw.Draw(im)
+                            pixels = list(map(int, xy_pixels.flatten()))
+                            draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
+                            aim = np.array(im)
+                            tile_counts += aim
+                tmp_path = tile_count_cache_path.with_suffix(".tmp.npy")
+                np.save(tmp_path, tile_counts)
+                tile_count_cache_path.unlink(missing_ok=True)
+                tmp_path.rename(tile_count_cache_path)
+        else:
+            activity_ids = self.activities_per_tile[z].get((x, y), set())
+            for activity_id in activity_ids:
+                activity = self._repository.get_activity_by_id(activity_id)
+                if not activity["kind"] == kind:
+                    continue
+                if date_start is not None and activity["start"] < date_start:
+                    continue
+                if date_end is not None and date_end < activity["start"]:
+                    continue
+                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
+                        * OSM_TILE_SIZE
+                    )
+                    im = Image.new("L", tile_pixels)
+                    draw = ImageDraw.Draw(im)
+                    pixels = list(map(int, xy_pixels.flatten()))
+                    draw.line(pixels, fill=1, width=max(3, 6 * (z - 17)))
+                    aim = np.array(im)
+                    tile_counts += aim
         return tile_counts
 
     def _render_tile_image(
-        self, x: int, y: int, z: int, kinds: list[str]
+        self,
+        x: int,
+        y: int,
+        z: int,
+        kinds_ids: list[int],
+        date_start: Optional[datetime.date],
+        date_end: Optional[datetime.date],
     ) -> np.ndarray:
         tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
         tile_counts = np.zeros(tile_pixels)
-        for kind in kinds:
-            tile_counts += self._get_counts(x, y, z, kind)
+        available_kinds = sorted(self._repository.meta["kind"].unique())
+        for kind_id in kinds_ids:
+            kind = available_kinds[kind_id]
+            tile_counts += self._get_counts(x, y, z, kind, date_start, date_end)
 
         tile_counts = np.sqrt(tile_counts) / 5
         tile_counts[tile_counts > 1.0] = 1.0
@@ -158,21 +217,40 @@ class HeatmapController:
             ] + data_color[:, :, c]
         return map_tile
 
-    def render_tile(self, x: int, y: int, z: int, kinds: list[str]) -> bytes:
+    def render_tile(
+        self,
+        x: int,
+        y: int,
+        z: int,
+        kind_ids: list[int],
+        date_start: Optional[datetime.date],
+        date_end: Optional[datetime.date],
+    ) -> bytes:
         f = io.BytesIO()
-        pl.imsave(f, self._render_tile_image(x, y, z, kinds), format="png")
+        pl.imsave(
+            f,
+            self._render_tile_image(x, y, z, kind_ids, date_start, date_end),
+            format="png",
+        )
         return bytes(f.getbuffer())
 
     def download_heatmap(
-        self, north: float, east: float, south: float, west: float, kinds: list[str]
+        self,
+        north: float,
+        east: float,
+        south: float,
+        west: float,
+        kind_ids: list[int],
+        date_start: Optional[datetime.date],
+        date_end: Optional[datetime.date],
     ) -> bytes:
         geo_bounds = GeoBounds(south, west, north, east)
         tile_bounds = get_sensible_zoom_level(geo_bounds, (4000, 4000))
         pixel_bounds = PixelBounds.from_tile_bounds(tile_bounds)
 
         background = np.zeros((*pixel_bounds.shape, 3))
-        for x in range(tile_bounds.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,14 +258,16 @@ 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,
                     j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
                     :,
-                ] = self._render_tile_image(x, y, tile_bounds.zoom, kinds)
+                ] = self._render_tile_image(
+                    x, y, tile_bounds.zoom, kind_ids, date_start, date_end
+                )
 
         f = io.BytesIO()
         pl.imsave(f, background, format="png")

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

@@ -7,20 +7,38 @@
     </div>
 </div>
 
-<div class="row mb-3">
-    <div class="col">
-        <form action="" method="GET">
+<form action="" method="GET">
+
+    <div class="row mb-3">
+        <label class="col-sm-2 col-form-label">Kinds</label>
+
+        <div class="col-sm-10">
             {% for kind in available_kinds %}
-            <div class="form-check form-check-inline form-switch">
-                <input class="form-check-input" type="checkbox" role="switch" id="{{ kind }}" name="kind"
-                    value="{{ kind }}" {{ 'checked' if kind in kinds else '' }} />
-                <label class="form-check-label" for="{{ kind }}">{{ kind }}</label>
+            <div class="form-check form-check-inline form-switch ">
+                <input class="form-check-input" type="checkbox" role="switch" id="kind{{ loop.index0 }}" name="kind"
+                    value="{{ loop.index0 }}" {{ 'checked' if loop.index0 in kinds else '' }} />
+                <label class="form-check-label" for="kind{{ loop.index0 }}">{{ kind }}</label>
             </div>
             {% endfor %}
-            <button type="submit" class="btn btn-primary">Show selected kinds</button>
-        </form>
+        </div>
     </div>
-</div>
+
+    <div class="row mb-3">
+        <label class="col-sm-2 col-form-label">Date range</label>
+        <div class="col-sm-5">
+            <input type="date" id="date-start" name="date-start" value="{{ date_start }}" />
+            <label for="date-start" class="form-label">Start date</label>
+        </div>
+        <div class="col-sm-5">
+            <input type="date" id="date-end" name="date-end" value="{{ date_end }}" />
+            <label for="date-start" class="form-label">End date</label>
+        </div>
+    </div>
+
+    <div class="mb-3">
+        <button type="submit" class="btn btn-primary">Filter heatmap</button>
+    </div>
+</form>
 
 <div class="row mb-3">
     <div class="col">
@@ -33,7 +51,7 @@
                 center: [{{ center.latitude }}, {{ center.longitude }}],
             zoom: 12
             });
-            L.tileLayer('/heatmap/tile/{z}/{x}/{y}/{{ kinds_str }}.png', {
+            L.tileLayer('/heatmap/tile/{z}/{x}/{y}.png?{{ extra_args|safe }}', {
                 maxZoom: 19,
                 attribution: '{{ map_tile_attribution|safe }}'
             }).addTo(map)
@@ -47,7 +65,7 @@
             function downloadAs() {
                 bounds = map.getBounds()
                 window.location.href =
-                    `/heatmap/download/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}/{{ kinds_str }}`
+                    `/heatmap/download/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}/heatmap.png?{{ extra_args|safe }}`
             }
         </script>
     </div>

geo_activity_playground/webui/{search/blueprint.py → search_blueprint.py}

@@ -7,7 +7,7 @@ from flask import render_template
 from flask import request
 from flask import Response
 
-from ...core.activities import ActivityRepository
+from ..core.activities import ActivityRepository
 
 
 def reduce_or(selections):

geo_activity_playground/webui/settings/blueprint.py

@@ -58,8 +58,7 @@ def int_or_none(s: str) -> Optional[int]:
             return int(s)
         except ValueError as e:
             flash(f"Cannot parse integer from {s}: {e}", category="danger")
-    else:
-        return None
+    return None
 
 
 def make_settings_blueprint(

geo_activity_playground/webui/square_planner_blueprint.py

@@ -0,0 +1,118 @@
+import geojson
+from flask import Blueprint
+from flask import redirect
+from flask import render_template
+from flask import Response
+from flask import url_for
+
+from geo_activity_playground.explorer.grid_file import make_explorer_rectangle
+from geo_activity_playground.explorer.grid_file import make_explorer_tile
+from geo_activity_playground.explorer.grid_file import make_grid_file_geojson
+from geo_activity_playground.explorer.grid_file import make_grid_file_gpx
+from geo_activity_playground.explorer.grid_file import make_grid_points
+from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
+
+
+def make_square_planner_blueprint(tile_visit_accessor: TileVisitAccessor) -> Blueprint:
+    tile_visits = tile_visit_accessor.tile_state["tile_visits"]
+
+    blueprint = Blueprint("square_planner", __name__, template_folder="templates")
+
+    @blueprint.route("/<int:zoom>")
+    def landing(zoom: int):
+        explored = tile_visit_accessor.tile_state["evolution_state"][zoom]
+        return redirect(
+            url_for(
+                "square_planner.index",
+                zoom=zoom,
+                x=explored.square_x,
+                y=explored.square_y,
+                size=explored.max_square_size,
+            )
+        )
+
+    @blueprint.route("/<int:zoom>/<int:x>/<int:y>/<int:size>")
+    def index(zoom: int, x: int, y: int, size: int):
+        square_geojson = geojson.dumps(
+            geojson.FeatureCollection(
+                features=[
+                    make_explorer_rectangle(
+                        x,
+                        y,
+                        x + size,
+                        y + size,
+                        zoom,
+                    )
+                ]
+            )
+        )
+
+        missing_geojson = geojson.dumps(
+            geojson.FeatureCollection(
+                features=[
+                    make_explorer_tile(
+                        tile_x,
+                        tile_y,
+                        {},
+                        zoom,
+                    )
+                    for tile_x in range(x, x + size)
+                    for tile_y in range(y, y + size)
+                    if (tile_x, tile_y) not in set(tile_visits[zoom].keys())
+                ]
+            )
+        )
+
+        return render_template(
+            "square_planner/index.html.j2",
+            explored_geojson=_get_explored_geojson(tile_visits[zoom].keys(), zoom),
+            missing_geojson=missing_geojson,
+            square_geojson=square_geojson,
+            zoom=zoom,
+            square_x=x,
+            square_y=y,
+            square_size=size,
+        )
+
+    @blueprint.route("/<int:zoom>/<int:x>/<int:y>/<int:size>/missing.<suffix>")
+    def square_planner_missing(zoom: int, x: int, y: int, size: int, suffix: str):
+        points = make_grid_points(
+            (
+                (tile_x, tile_y)
+                for tile_x in range(x, x + size)
+                for tile_y in range(y, y + size)
+                if (tile_x, tile_y) not in set(tile_visits[zoom].keys())
+            ),
+            zoom,
+        )
+        if suffix == "geojson":
+            response = make_grid_file_geojson(points)
+        elif suffix == "gpx":
+            response = make_grid_file_gpx(points)
+        else:
+            raise RuntimeError(f"Unsupported suffix {suffix}.")
+
+        mimetypes = {"geojson": "application/json", "gpx": "application/xml"}
+        return Response(
+            response,
+            mimetype=mimetypes[suffix],
+            headers={"Content-disposition": "attachment"},
+        )
+
+    return blueprint
+
+
+def _get_explored_geojson(tile_visits: list[tuple[int, int]], zoom: int) -> str:
+    return geojson.dumps(
+        geojson.FeatureCollection(
+            features=[
+                make_explorer_tile(
+                    tile_x,
+                    tile_y,
+                    {},
+                    zoom,
+                )
+                for tile_x, tile_y in tile_visits
+            ]
+        )
+    )

geo_activity_playground/webui/{summary/controller.py → summary_blueprint.py}

@@ -1,10 +1,10 @@
 import collections
 import datetime
-import functools
-from typing import Optional
 
 import altair as alt
 import pandas as pd
+from flask import Blueprint
+from flask import render_template
 
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.activities import make_geojson_from_time_series
@@ -12,15 +12,13 @@ from geo_activity_playground.core.config import Config
 from geo_activity_playground.webui.plot_util import make_kind_scale
 
 
-class SummaryController:
-    def __init__(self, repository: ActivityRepository, config: Config) -> None:
-        self._repository = repository
-        self._config = config
+def make_summary_blueprint(repository: ActivityRepository, config: Config) -> Blueprint:
+    blueprint = Blueprint("summary", __name__, template_folder="templates")
 
-    @functools.cache
-    def render(self) -> dict:
-        kind_scale = make_kind_scale(self._repository.meta, self._config)
-        df = embellished_activities(self._repository.meta)
+    @blueprint.route("/")
+    def index():
+        kind_scale = make_kind_scale(repository.meta, config)
+        df = embellished_activities(repository.meta)
         # df = df.loc[df["consider_for_achievements"]]
 
         year_kind_total = (
@@ -30,28 +28,29 @@ class SummaryController:
             .reset_index()
         )
 
-        return {
-            "plot_distance_heatmaps": plot_distance_heatmaps(df, self._config),
-            "plot_monthly_distance": plot_monthly_distance(df, kind_scale),
-            "plot_yearly_distance": plot_yearly_distance(year_kind_total, kind_scale),
-            "plot_year_cumulative": plot_year_cumulative(df),
-            "tabulate_year_kind_mean": tabulate_year_kind_mean(df)
+        return render_template(
+            "summary/index.html.j2",
+            plot_distance_heatmaps=plot_distance_heatmaps(df, config),
+            plot_monthly_distance=plot_monthly_distance(df, kind_scale),
+            plot_yearly_distance=plot_yearly_distance(year_kind_total, kind_scale),
+            plot_year_cumulative=plot_year_cumulative(df),
+            tabulate_year_kind_mean=tabulate_year_kind_mean(df)
             .reset_index()
             .to_dict(orient="split"),
-            "plot_weekly_distance": plot_weekly_distance(df, kind_scale),
-            "nominations": [
+            plot_weekly_distance=plot_weekly_distance(df, kind_scale),
+            nominations=[
                 (
-                    self._repository.get_activity_by_id(activity_id),
+                    repository.get_activity_by_id(activity_id),
                     reasons,
                     make_geojson_from_time_series(
-                        self._repository.get_time_series(activity_id)
+                        repository.get_time_series(activity_id)
                     ),
                 )
-                for activity_id, reasons in nominate_activities(
-                    self._repository.meta
-                ).items()
+                for activity_id, reasons in nominate_activities(repository.meta).items()
             ],
-        }
+        )
+
+    return blueprint
 
 
 def nominate_activities(meta: pd.DataFrame) -> dict[int, list[str]]:

geo_activity_playground/webui/templates/page.html.j2

@@ -97,6 +97,17 @@
                                         Tiles (Zoom 14)</a></li>
                                 <li><a class="dropdown-item" href="{{ url_for('explorer.map', zoom=17) }}">Squadratinhos
                                         (Zoom 17)</a></li>
+
+                                <li>
+                                    <hr class="dropdown-divider">
+                                </li>
+
+                                <li><a class="dropdown-item"
+                                        href="{{ url_for('square_planner.landing', zoom=14) }}">Square Planner
+                                        (Zoom 14)</a></li>
+                                <li><a class="dropdown-item"
+                                        href="{{ url_for('square_planner.landing', zoom=17) }}">Square Planner
+                                        (Zoom 17)</a></li>
                             </ul>
                         </li>
 

geo_activity_playground/webui/tile_blueprint.py

@@ -0,0 +1,42 @@
+import io
+
+import matplotlib.pyplot as pl
+import numpy as np
+from flask import Blueprint
+from flask import Response
+
+from geo_activity_playground.core.config import Config
+from geo_activity_playground.core.raster_map import get_tile
+
+
+def make_tile_blueprint(config: Config) -> Blueprint:
+    blueprint = Blueprint("tiles", __name__, template_folder="templates")
+
+    @blueprint.route("/color/<int:z>/<int:x>/<int:y>.png")
+    def tile_color(x: int, y: int, z: int):
+        map_tile = np.array(get_tile(z, x, y, config.map_tile_url)) / 255
+        f = io.BytesIO()
+        pl.imsave(f, map_tile, format="png")
+        return Response(bytes(f.getbuffer()), mimetype="image/png")
+
+    @blueprint.route("/grayscale/<int:z>/<int:x>/<int:y>.png")
+    def tile_grayscale(x: int, y: int, z: int):
+        map_tile = np.array(get_tile(z, x, y, config.map_tile_url)) / 255
+        map_tile = np.sum(map_tile * [0.2126, 0.7152, 0.0722], axis=2)  # to grayscale
+        map_tile = np.dstack((map_tile, map_tile, map_tile))  # to rgb
+        f = io.BytesIO()
+        pl.imsave(f, map_tile, format="png")
+        return Response(bytes(f.getbuffer()), mimetype="image/png")
+
+    @blueprint.route("/pastel/<int:z>/<int:x>/<int:y>.png")
+    def tile_pastel(x: int, y: int, z: int):
+        map_tile = np.array(get_tile(z, x, y, config.map_tile_url)) / 255
+        averaged_tile = np.sum(map_tile * [0.2126, 0.7152, 0.0722], axis=2)
+        grayscale_tile = np.dstack((averaged_tile, averaged_tile, averaged_tile))
+        factor = 0.7
+        pastel_tile = factor * grayscale_tile + (1 - factor) * map_tile
+        f = io.BytesIO()
+        pl.imsave(f, pastel_tile, format="png")
+        return Response(bytes(f.getbuffer()), mimetype="image/png")
+
+    return blueprint

geo_activity_playground/webui/upload_blueprint.py

@@ -108,9 +108,7 @@ def scan_for_activities(
     skip_strava: bool = False,
 ) -> None:
     if pathlib.Path("Activities").exists():
-        import_from_directory(
-            config.metadata_extraction_regexes, config.num_processes, config
-        )
+        import_from_directory(config.metadata_extraction_regexes, config)
     if pathlib.Path("Strava Export").exists():
         import_from_strava_checkout()
     if config.strava_client_code and not skip_strava: