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

geo_activity_playground/core/activities.py

@@ -3,6 +3,7 @@ import functools
 import json
 import logging
 import pickle
+from collections.abc import Callable
 from typing import Any
 from typing import Iterator
 from typing import Optional
@@ -180,41 +181,48 @@ def make_geojson_from_time_series(time_series: pd.DataFrame) -> str:
     return geojson.dumps(fc)
 
 
-def make_geojson_color_line(time_series: pd.DataFrame) -> str:
-    speed_without_na = time_series["speed"].dropna()
-    low = min(speed_without_na)
-    high = max(speed_without_na)
-    clamp_speed = lambda speed: min(max((speed - low) / (high - low), 0.0), 1.0)
+def inter_quartile_range(values):
+    return np.quantile(values, 0.75) - np.quantile(values, 0.25)
+
 
+def make_geojson_color_line(time_series: pd.DataFrame) -> str:
+    low, high, clamp_speed = _make_speed_clamp(time_series["speed"])
     cmap = matplotlib.colormaps["viridis"]
     features = [
         geojson.Feature(
             geometry=geojson.LineString(
                 coordinates=[
                     [row["longitude"], row["latitude"]],
-                    [next["longitude"], next["latitude"]],
+                    [next_row["longitude"], next_row["latitude"]],
                 ]
             ),
             properties={
-                "speed": next["speed"] if np.isfinite(next["speed"]) else 0.0,
-                "color": matplotlib.colors.to_hex(cmap(clamp_speed(next["speed"]))),
+                "speed": next_row["speed"] if np.isfinite(next_row["speed"]) else 0.0,
+                "color": matplotlib.colors.to_hex(cmap(clamp_speed(next_row["speed"]))),
             },
         )
         for _, group in time_series.groupby("segment_id")
-        for (_, row), (_, next) in zip(group.iterrows(), group.iloc[1:].iterrows())
+        for (_, row), (_, next_row) in zip(group.iterrows(), group.iloc[1:].iterrows())
     ]
     feature_collection = geojson.FeatureCollection(features)
     return geojson.dumps(feature_collection)
 
 
 def make_speed_color_bar(time_series: pd.DataFrame) -> dict[str, Any]:
-    speed_without_na = time_series["speed"].dropna()
-    low = min(speed_without_na)
-    high = max(speed_without_na)
+    low, high, clamp_speed = _make_speed_clamp(time_series["speed"])
     cmap = matplotlib.colormaps["viridis"]
-    clamp_speed = lambda speed: min(max((speed - low) / (high - low), 0.0), 1.0)
     colors = [
         (f"{speed:.1f}", matplotlib.colors.to_hex(cmap(clamp_speed(speed))))
         for speed in np.linspace(low, high, 10)
     ]
     return {"low": low, "high": high, "colors": colors}
+
+
+def _make_speed_clamp(speeds: pd.Series) -> tuple[float, float, Callable]:
+    speed_without_na = speeds.dropna()
+    low = min(speed_without_na)
+    high = min(
+        max(speed_without_na),
+        np.median(speed_without_na) + 1.5 * inter_quartile_range(speed_without_na),
+    )
+    return low, high, lambda speed: min(max((speed - low) / (high - low), 0.0), 1.0)

geo_activity_playground/core/raster_map.py

@@ -42,17 +42,17 @@ class GeoBounds:
 @dataclasses.dataclass
 class TileBounds:
     zoom: int
-    x1: int
-    y1: int
-    x2: int
-    y2: int
+    x1: float
+    y1: float
+    x2: float
+    y2: float
 
     @property
-    def width(self) -> int:
+    def width(self) -> float:
         return self.x2 - self.x1
 
     @property
-    def height(self) -> int:
+    def height(self) -> float:
         return self.y2 - self.y1
 
 
@@ -91,12 +91,6 @@ class RasterMapImage:
 ## 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),
@@ -204,7 +198,9 @@ def map_image_from_tile_bounds(tile_bounds: TileBounds, config: Config) -> np.nd
     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)
+    pixel_anchor: np.ndarray = 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

geo_activity_playground/importers/directory.py

@@ -25,7 +25,7 @@ ACTIVITY_DIR = pathlib.Path("Activities")
 
 
 def import_from_directory(
-    metadata_extraction_regexes: list[str], num_processes: Optional[int], config: Config
+    metadata_extraction_regexes: list[str], config: Config
 ) -> None:
 
     activity_paths = [
@@ -63,20 +63,11 @@ def import_from_directory(
             del file_hashes[deleted_file]
             work_tracker.discard(deleted_file)
 
-    if num_processes == 1:
-        paths_with_errors = []
-        for path in tqdm(new_activity_paths, desc="Parse activity metadata (serially)"):
-            errors = _cache_single_file(path)
-            if errors:
-                paths_with_errors.append(errors)
-    else:
-        with multiprocessing.Pool(num_processes) as pool:
-            paths_with_errors = tqdm(
-                pool.imap(_cache_single_file, new_activity_paths),
-                desc="Parse activity metadata (concurrently)",
-                total=len(new_activity_paths),
-            )
-            paths_with_errors = [error for error in paths_with_errors if error]
+    paths_with_errors = []
+    for path in tqdm(new_activity_paths, desc="Parse activity metadata (serially)"):
+        errors = _cache_single_file(path)
+        if errors:
+            paths_with_errors.append(errors)
 
     for path in tqdm(new_activity_paths, desc="Collate activity metadata"):
         activity_id = get_file_hash(path)

geo_activity_playground/webui/app.py

@@ -9,34 +9,29 @@ import urllib.parse
 from flask import Flask
 from flask import render_template
 
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.config import Config
-from geo_activity_playground.core.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
+from ..core.activities import ActivityRepository
+from ..core.config import Config
+from ..core.config import ConfigAccessor
+from ..explorer.tile_visits import TileVisitAccessor
+from .activity.blueprint import make_activity_blueprint
+from .activity.controller import ActivityController
+from .auth_blueprint import make_auth_blueprint
+from .authenticator import Authenticator
+from .calendar.blueprint import make_calendar_blueprint
+from .calendar.controller import CalendarController
+from .eddington_blueprint import make_eddington_blueprint
+from .entry_controller import EntryController
+from .equipment.blueprint import make_equipment_blueprint
+from .equipment.controller import EquipmentController
+from .explorer.blueprint import make_explorer_blueprint
+from .explorer.controller import ExplorerController
+from .heatmap.blueprint import make_heatmap_blueprint
+from .search_blueprint import make_search_blueprint
+from .settings.blueprint import make_settings_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
 
 
 def route_start(app: Flask, repository: ActivityRepository, config: Config) -> None:
@@ -87,12 +82,9 @@ 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
     )
@@ -108,7 +100,7 @@ def web_ui_main(
         make_calendar_blueprint(calendar_controller), url_prefix="/calendar"
     )
     app.register_blueprint(
-        make_eddington_blueprint(eddington_controller), url_prefix="/eddington"
+        make_eddington_blueprint(repository), url_prefix="/eddington"
     )
     app.register_blueprint(
         make_equipment_blueprint(equipment_controller), url_prefix="/equipment"
@@ -125,7 +117,7 @@ def web_ui_main(
         url_prefix="/settings",
     )
     app.register_blueprint(
-        make_square_planner_blueprint(repository, tile_visit_accessor),
+        make_square_planner_blueprint(tile_visit_accessor),
         url_prefix="/square-planner",
     )
     app.register_blueprint(
@@ -133,10 +125,10 @@ def web_ui_main(
         url_prefix="/search",
     )
     app.register_blueprint(
-        make_summary_blueprint(summary_controller), url_prefix="/summary"
+        make_summary_blueprint(repository, config), url_prefix="/summary"
     )
 
-    app.register_blueprint(make_tile_blueprint(tile_controller), url_prefix="/tile")
+    app.register_blueprint(make_tile_blueprint(config), url_prefix="/tile")
     app.register_blueprint(
         make_upload_blueprint(
             repository, tile_visit_accessor, config_accessor(), authenticator

geo_activity_playground/webui/{auth/blueprint.py → auth_blueprint.py}

@@ -4,7 +4,7 @@ from flask import render_template
 from flask import request
 from flask import url_for
 
-from geo_activity_playground.webui.authenticator import Authenticator
+from .authenticator import Authenticator
 
 
 def make_auth_blueprint(authenticator: Authenticator) -> Blueprint:

geo_activity_playground/webui/{eddington/controller.py → eddington_blueprint.py}

@@ -1,17 +1,19 @@
 import altair as alt
 import numpy as np
 import pandas as pd
+from flask import Blueprint
+from flask import render_template
 
-from ...core.activities import ActivityRepository
+from geo_activity_playground.core.activities import ActivityRepository
 
 
-class EddingtonController:
-    def __init__(self, repository: ActivityRepository) -> None:
-        self._repository = repository
+def make_eddington_blueprint(repository: ActivityRepository) -> Blueprint:
+    blueprint = Blueprint("eddington", __name__, template_folder="templates")
 
-    def render(self) -> dict:
-        activities = self._repository.meta.loc[
-            self._repository.meta["consider_for_achievements"]
+    @blueprint.route("/")
+    def index():
+        activities = repository.meta.loc[
+            repository.meta["consider_for_achievements"]
         ].copy()
         activities["day"] = [start.date() for start in activities["start"]]
 
@@ -67,11 +69,13 @@ class EddingtonController:
             .interactive()
             .to_json(format="vega")
         )
-
-        return {
-            "eddington_number": en,
-            "logarithmic_plot": logarithmic_plot,
-            "eddington_table": eddington.loc[
+        return render_template(
+            "eddington/index.html.j2",
+            eddington_number=en,
+            logarithmic_plot=logarithmic_plot,
+            eddington_table=eddington.loc[
                 (eddington["distance_km"] > en) & (eddington["distance_km"] <= en + 10)
             ].to_dict(orient="records"),
-        }
+        )
+
+    return blueprint

geo_activity_playground/webui/heatmap/blueprint.py

@@ -1,12 +1,13 @@
+import dateutil.parser
 from flask import Blueprint
 from flask import render_template
 from flask import request
 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.activities import ActivityRepository
 from geo_activity_playground.core.config import Config
+from geo_activity_playground.explorer.tile_visits import TileVisitAccessor
+from geo_activity_playground.webui.heatmap.heatmap_controller import HeatmapController
 
 
 def make_heatmap_blueprint(
@@ -21,21 +22,46 @@ def make_heatmap_blueprint(
     def index():
         return render_template(
             "heatmap/index.html.j2",
-            **heatmap_controller.render(request.args.getlist("kind"))
+            **heatmap_controller.render(
+                [int(k) for k in request.args.getlist("kind")],
+                request.args.get(
+                    "date-start", type=dateutil.parser.parse, default=None
+                ),
+                request.args.get("date-end", type=dateutil.parser.parse, default=None),
+            )
         )
 
-    @blueprint.route("/tile/<z>/<x>/<y>/<kinds>.png")
-    def tile(x: str, y: str, z: str, kinds: str):
+    @blueprint.route("/tile/<int:z>/<int:x>/<int:y>.png")
+    def tile(x: int, y: int, z: int):
         return Response(
-            heatmap_controller.render_tile(int(x), int(y), int(z), kinds.split(";")),
+            heatmap_controller.render_tile(
+                x,
+                y,
+                z,
+                [int(k) for k in request.args.getlist("kind")],
+                request.args.get(
+                    "date-start", type=dateutil.parser.parse, default=None
+                ),
+                request.args.get("date-end", type=dateutil.parser.parse, default=None),
+            ),
             mimetype="image/png",
         )
 
-    @blueprint.route("/download/<north>/<east>/<south>/<west>/<kinds>")
-    def download(north: str, east: str, south: str, west: str, kinds: str):
+    @blueprint.route(
+        "/download/<float:north>/<float:east>/<float:south>/<float:west>/heatmap.png"
+    )
+    def download(north: float, east: float, south: float, west: float):
         return Response(
             heatmap_controller.download_heatmap(
-                float(north), float(east), float(south), float(west), kinds.split(";")
+                north,
+                east,
+                south,
+                west,
+                [int(k) for k in request.args.getlist("kind")],
+                request.args.get(
+                    "date-start", type=dateutil.parser.parse, default=None
+                ),
+                request.args.get("date-end", type=dateutil.parser.parse, default=None),
             ),
             mimetype="image/png",
             headers={"Content-disposition": 'attachment; filename="heatmap.png"'},

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
@@ -13,6 +15,7 @@ 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_upper_left_lat_lon
@@ -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,69 +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
@@ -156,13 +217,32 @@ 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))
@@ -185,7 +265,9 @@ class HeatmapController:
                     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")