geo-activity-playground 0.27.1__py3-none-any.whl → 0.29.0__py3-none-any.whl

geo_activity_playground/__main__.py

@@ -109,10 +109,9 @@ def make_activity_repository(
 
 
 def main_cache(basedir: pathlib.Path) -> None:
-    repository, tile_visit_accessor, config_accessor = make_activity_repository(
+    (repository, tile_visit_accessor, config_accessor) = make_activity_repository(
         basedir, False
     )
-    scan_for_activities(repository, tile_visit_accessor, config_accessor())
 
 
 if __name__ == "__main__":

geo_activity_playground/core/activities.py

@@ -128,11 +128,11 @@ class ActivityRepository:
         else:
             return None
 
-    def get_activity_ids(self, only_achievements: bool = False) -> set[int]:
+    def get_activity_ids(self, only_achievements: bool = False) -> list[int]:
         if only_achievements:
-            return set(self.meta.loc[self.meta["consider_for_achievements"]].index)
+            return list(self.meta.loc[self.meta["consider_for_achievements"]].index)
         else:
-            return set(self.meta.index)
+            return list(self.meta.index)
 
     def iter_activities(self, new_to_old=True, dropna=False) -> Iterator[ActivityMeta]:
         direction = -1 if new_to_old else 1

geo_activity_playground/core/config.py

@@ -21,6 +21,8 @@ logger = logging.getLogger(__name__)
 @dataclasses.dataclass
 class Config:
     birth_year: Optional[int] = None
+    color_scheme_for_counts: str = "viridis"
+    color_scheme_for_kind: str = "category10"
     equipment_offsets: dict[str, float] = dataclasses.field(default_factory=dict)
     explorer_zoom_levels: list[int] = dataclasses.field(
         default_factory=lambda: [14, 17]
@@ -33,6 +35,7 @@ class Config:
     privacy_zones: dict[str, list[list[float]]] = dataclasses.field(
         default_factory=dict
     )
+    sharepic_suppressed_fields: list[str] = dataclasses.field(default_factory=list)
     strava_client_id: int = 131693
     strava_client_secret: str = "0ccc0100a2c218512a7ef0cea3b0e322fb4b4365"
     strava_client_code: Optional[str] = None
@@ -51,6 +54,7 @@ class ConfigAccessor:
         return self._config
 
     def save(self) -> None:
+        print(self._config)
         with open(new_config_file(), "w") as f:
             json.dump(
                 dataclasses.asdict(self._config),

geo_activity_playground/core/paths.py

@@ -1,6 +1,7 @@
 """
 Paths within the playground and cache.
 """
+import contextlib
 import functools
 import pathlib
 import typing
@@ -24,6 +25,15 @@ def file_wrapper(path: pathlib.Path) -> typing.Callable[[], pathlib.Path]:
     return wrapper
 
 
+@contextlib.contextmanager
+def atomic_open(path: pathlib.Path, mode: str):
+    temp_path = path.with_stem(path.stem + "-temp")
+    with open(temp_path, mode) as f:
+        yield f
+    path.unlink(missing_ok=True)
+    temp_path.rename(path)
+
+
 _cache_dir = pathlib.Path("Cache")
 
 _activity_dir = _cache_dir / "Activity"

geo_activity_playground/core/tasks.py

@@ -8,6 +8,7 @@ from typing import Generic
 from typing import Sequence
 from typing import TypeVar
 
+from geo_activity_playground.core.paths import atomic_open
 from geo_activity_playground.core.paths import cache_dir
 
 
@@ -24,11 +25,8 @@ def stored_object(path: pathlib.Path, default):
 
     yield payload
 
-    temp_location = path.with_suffix(".tmp")
-    with open(temp_location, "wb") as f:
+    with atomic_open(path, "wb") as f:
         pickle.dump(payload, f)
-    path.unlink(missing_ok=True)
-    temp_location.rename(path)
 
 
 def work_tracker_path(name: str) -> pathlib.Path:
@@ -59,8 +57,8 @@ class WorkTracker:
         else:
             self._done = set()
 
-    def filter(self, ids: Iterable) -> set:
-        return set(ids) - self._done
+    def filter(self, ids: Iterable) -> list:
+        return [elem for elem in ids if elem not in self._done]
 
     def mark_done(self, id: int) -> None:
         self._done.add(id)
@@ -68,6 +66,9 @@ class WorkTracker:
     def discard(self, id) -> None:
         self._done.discard(id)
 
+    def reset(self) -> None:
+        self._done = set()
+
     def close(self) -> None:
         with open(self._path, "wb") as f:
             pickle.dump(self._done, f)

geo_activity_playground/explorer/tile_visits.py

@@ -14,6 +14,7 @@ from tqdm import tqdm
 
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.config import Config
+from geo_activity_playground.core.paths import atomic_open
 from geo_activity_playground.core.paths import tiles_per_time_series
 from geo_activity_playground.core.tasks import try_load_pickle
 from geo_activity_playground.core.tasks import work_tracker_path
@@ -25,139 +26,192 @@ from geo_activity_playground.core.tiles import interpolate_missing_tile
 logger = logging.getLogger(__name__)
 
 
+class TileInfo(TypedDict):
+    activity_ids: set[int]
+    first_time: datetime.datetime
+    first_id: int
+    last_time: datetime.datetime
+    last_id: int
+
+
 class TileHistoryRow(TypedDict):
+    activity_id: int
     time: datetime.datetime
     tile_x: int
     tile_y: int
 
 
+class TileEvolutionState:
+    def __init__(self) -> None:
+        self.num_neighbors: dict[tuple[int, int], int] = {}
+        self.memberships: dict[tuple[int, int], tuple[int, int]] = {}
+        self.clusters: dict[tuple[int, int], list[tuple[int, int]]] = {}
+        self.cluster_evolution = pd.DataFrame()
+        self.square_start = 0
+        self.cluster_start = 0
+        self.max_square_size = 0
+        self.visited_tiles: set[tuple[int, int]] = set()
+        self.square_evolution = pd.DataFrame()
+        self.square_x: Optional[int] = None
+        self.square_y: Optional[int] = None
+
+
+class TileState(TypedDict):
+    tile_visits: dict[int, dict[tuple[int, int], TileInfo]]
+    tile_history: dict[int, pd.DataFrame]
+    activities_per_tile: dict[int, set[int]]
+    processed_activities: set[int]
+    evolution_state: dict[int, TileEvolutionState]
+    version: int
+
+
+TILE_STATE_VERSION = 2
+
+
 class TileVisitAccessor:
-    TILE_EVOLUTION_STATES_PATH = pathlib.Path("Cache/tile-evolution-state.pickle")
-    TILE_HISTORIES_PATH = pathlib.Path(f"Cache/tile-history.pickle")
-    TILE_VISITS_PATH = pathlib.Path(f"Cache/tile-visits.pickle")
-    ACTIVITIES_PER_TILE_PATH = pathlib.Path(f"Cache/activities-per-tile.pickle")
+    PATH = pathlib.Path("Cache/tile-state-2.pickle")
 
     def __init__(self) -> None:
-        self.visits: dict[int, dict[tuple[int, int], dict[str, Any]]] = try_load_pickle(
-            self.TILE_VISITS_PATH
-        ) or collections.defaultdict(dict)
-        "zoom → (tile_x, tile_y) → tile_info"
-
-        self.histories: dict[int, pd.DataFrame] = try_load_pickle(
-            self.TILE_HISTORIES_PATH
-        ) or collections.defaultdict(pd.DataFrame)
-
-        self.states = try_load_pickle(
-            self.TILE_EVOLUTION_STATES_PATH
-        ) or collections.defaultdict(TileEvolutionState)
-
-        self.activities_per_tile: dict[
-            int, dict[tuple[int, int], set[int]]
-        ] = try_load_pickle(self.ACTIVITIES_PER_TILE_PATH) or collections.defaultdict(
-            dict
-        )
+        self.tile_state: TileState = try_load_pickle(self.PATH)
+        if (
+            self.tile_state is None
+            or self.tile_state.get("version", None) != TILE_STATE_VERSION
+        ):
+            self.tile_state = make_tile_state()
+            # TODO: Reset work tracker
+
+    def reset(self) -> None:
+        self.tile_state = make_tile_state()
 
     def save(self) -> None:
-        with open(self.TILE_VISITS_PATH, "wb") as f:
-            pickle.dump(self.visits, f)
+        with atomic_open(self.PATH, "wb") as f:
+            pickle.dump(self.tile_state, f)
+
+
+def make_defaultdict_dict():
+    return collections.defaultdict(dict)
+
+
+def make_defaultdict_set():
+    return collections.defaultdict(set)
+
+
+def make_tile_state() -> TileState:
+    tile_state: TileState = {
+        "tile_visits": collections.defaultdict(make_defaultdict_dict),
+        "tile_history": collections.defaultdict(pd.DataFrame),
+        "activities_per_tile": collections.defaultdict(make_defaultdict_set),
+        "processed_activities": set(),
+        "evolution_state": collections.defaultdict(TileEvolutionState),
+        "version": TILE_STATE_VERSION,
+    }
+    return tile_state
 
-        with open(self.TILE_HISTORIES_PATH, "wb") as f:
-            pickle.dump(self.histories, f)
 
-        with open(self.TILE_EVOLUTION_STATES_PATH, "wb") as f:
-            pickle.dump(self.states, f)
+def _consistency_check(
+    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
+) -> bool:
+    present_activity_ids = set(repository.get_activity_ids())
 
-        with open(self.ACTIVITIES_PER_TILE_PATH, "wb") as f:
-            pickle.dump(self.activities_per_tile, f)
+    for zoom, activities_per_tile in tile_visit_accessor.tile_state[
+        "activities_per_tile"
+    ].items():
+        for tile, tile_activity_ids in activities_per_tile.items():
+            deleted_activity_ids = tile_activity_ids - present_activity_ids
+            if deleted_activity_ids:
+                logger.info(f"Activities {deleted_activity_ids} have been deleted.")
+                return False
 
+    for zoom, tile_visits in tile_visit_accessor.tile_state["tile_visits"].items():
+        for tile, meta in tile_visits.items():
+            if meta["first_id"] not in present_activity_ids:
+                logger.info(f"Activity {meta['first_id']} have been deleted.")
+                return False
+            if meta["last_id"] not in present_activity_ids:
+                logger.info(f"Activity {meta['last_id']} have been deleted.")
+                return False
 
-def compute_tile_visits(
-    repository: ActivityRepository, tile_visits_accessor: TileVisitAccessor
+    return True
+
+
+def compute_tile_visits_new(
+    repository: ActivityRepository, tile_visit_accessor: TileVisitAccessor
 ) -> None:
-    present_activity_ids = repository.get_activity_ids()
-    work_tracker = WorkTracker(work_tracker_path("tile-visits"))
-
-    changed_zoom_tile = collections.defaultdict(set)
-
-    # Delete visits from removed activities.
-    for zoom, activities_per_tile in tile_visits_accessor.activities_per_tile.items():
-        for tile, activity_ids in activities_per_tile.items():
-            deleted_ids = activity_ids - present_activity_ids
-            if deleted_ids:
-                logger.debug(
-                    f"Removing activities {deleted_ids} from tile {tile} at {zoom=}."
-                )
-                for activity_id in deleted_ids:
-                    activity_ids.remove(activity_id)
-                    work_tracker.discard(activity_id)
-                    changed_zoom_tile[zoom].add(tile)
+    work_tracker = WorkTracker(work_tracker_path("tile-state"))
+
+    if not _consistency_check(repository, tile_visit_accessor):
+        logger.warning("Need to recompute Explorer Tiles due to deleted activities.")
+        tile_visit_accessor.reset()
+        work_tracker.reset()
 
-    # Add visits from new activities.
-    activity_ids_to_process = work_tracker.filter(repository.get_activity_ids())
     for activity_id in tqdm(
-        activity_ids_to_process, desc="Extract explorer tile visits"
+        work_tracker.filter(repository.get_activity_ids()), desc="Tile visits"
     ):
-        for zoom in range(20):
-            for time, tile_x, tile_y in _tiles_from_points(
-                repository.get_time_series(activity_id), zoom
-            ):
-                tile = (tile_x, tile_y)
-                if tile not in tile_visits_accessor.activities_per_tile[zoom]:
-                    tile_visits_accessor.activities_per_tile[zoom][tile] = set()
-                tile_visits_accessor.activities_per_tile[zoom][tile].add(activity_id)
-                changed_zoom_tile[zoom].add(tile)
+        _process_activity(repository, tile_visit_accessor.tile_state, activity_id)
         work_tracker.mark_done(activity_id)
-
-    # Update tile visits structure.
-    for zoom, changed_tiles in tqdm(
-        changed_zoom_tile.items(), desc="Incorporate changes in tiles"
-    ):
-        soa = {"activity_id": [], "time": [], "tile_x": [], "tile_y": []}
-
-        for tile in changed_tiles:
-            activity_ids = tile_visits_accessor.activities_per_tile[zoom][tile]
-            activities = [
-                repository.get_activity_by_id(activity_id)
-                for activity_id in activity_ids
-            ]
-            activities_to_consider = [
-                activity
-                for activity in activities
-                if activity["consider_for_achievements"]
-            ]
-            activities_to_consider.sort(key=lambda activity: activity["start"])
-
-            if activities_to_consider:
-                tile_visits_accessor.visits[zoom][tile] = {
-                    "first_time": activities_to_consider[0]["start"],
-                    "first_id": activities_to_consider[0]["id"],
-                    "last_time": activities_to_consider[-1]["start"],
-                    "last_id": activities_to_consider[-1]["id"],
-                    "activity_ids": {
-                        activity["id"] for activity in activities_to_consider
-                    },
-                }
-
-                soa["activity_id"].append(activities_to_consider[0]["id"])
-                soa["time"].append(activities_to_consider[0]["start"])
-                soa["tile_x"].append(tile[0])
-                soa["tile_y"].append(tile[1])
-            else:
-                if tile in tile_visits_accessor.visits[zoom]:
-                    del tile_visits_accessor.visits[zoom][tile]
-
-        df = pd.DataFrame(soa)
-        if len(df) > 0:
-            df = pd.concat([tile_visits_accessor.histories[zoom], df])
-            df.sort_values("time", inplace=True)
-            tile_visits_accessor.histories[zoom] = df.groupby(
-                ["tile_x", "tile_y"]
-            ).head(1)
-
-    tile_visits_accessor.save()
+    tile_visit_accessor.save()
     work_tracker.close()
 
 
+def _process_activity(
+    repository: ActivityRepository, tile_state: TileState, activity_id: int
+) -> None:
+    activity = repository.get_activity_by_id(activity_id)
+    time_series = repository.get_time_series(activity_id)
+
+    activity_tiles = pd.DataFrame(
+        _tiles_from_points(time_series, 19), columns=["time", "tile_x", "tile_y"]
+    )
+    for zoom in reversed(range(20)):
+        activities_per_tile = tile_state["activities_per_tile"][zoom]
+
+        new_tile_history_soa = {
+            "activity_id": [],
+            "time": [],
+            "tile_x": [],
+            "tile_y": [],
+        }
+
+        activity_tiles = activity_tiles.groupby(["tile_x", "tile_y"]).head(1)
+
+        for time, tile in zip(
+            activity_tiles["time"],
+            zip(activity_tiles["tile_x"], activity_tiles["tile_y"]),
+        ):
+            if activity["consider_for_achievements"]:
+                if tile not in tile_state["tile_visits"][zoom]:
+                    new_tile_history_soa["activity_id"].append(activity_id)
+                    new_tile_history_soa["time"].append(time)
+                    new_tile_history_soa["tile_x"].append(tile[0])
+                    new_tile_history_soa["tile_y"].append(tile[1])
+
+                tile_visit = tile_state["tile_visits"][zoom][tile]
+                if not tile_visit:
+                    tile_visit["activity_ids"] = {activity_id}
+                else:
+                    tile_visit["activity_ids"].add(activity_id)
+
+                first_time = tile_visit.get("first_time", None)
+                last_time = tile_visit.get("last_time", None)
+                if first_time is None or time < first_time:
+                    tile_visit["first_id"] = activity_id
+                    tile_visit["first_time"] = time
+                if last_time is None or time > last_time:
+                    tile_visit["last_id"] = activity_id
+                    tile_visit["last_time"] = time
+
+            activities_per_tile[tile].add(activity_id)
+
+        if new_tile_history_soa["activity_id"]:
+            tile_state["tile_history"][zoom] = pd.concat(
+                [tile_state["tile_history"][zoom], pd.DataFrame(new_tile_history_soa)]
+            )
+
+        # Move up one layer in the quad-tree.
+        activity_tiles["tile_x"] //= 2
+        activity_tiles["tile_y"] //= 2
+
+
 def _tiles_from_points(
     time_series: pd.DataFrame, zoom: int
 ) -> Iterator[tuple[datetime.datetime, int, int]]:
@@ -181,38 +235,19 @@ def _tiles_from_points(
                 yield (t1,) + interpolated
 
 
-class TileEvolutionState:
-    def __init__(self) -> None:
-        self.num_neighbors: dict[tuple[int, int], int] = {}
-        self.memberships: dict[tuple[int, int], tuple[int, int]] = {}
-        self.clusters: dict[tuple[int, int], list[tuple[int, int]]] = {}
-        self.cluster_evolution = pd.DataFrame()
-        self.square_start = 0
-        self.cluster_start = 0
-        self.max_square_size = 0
-        self.visited_tiles: set[tuple[int, int]] = set()
-        self.square_evolution = pd.DataFrame()
-        self.square_x: Optional[int] = None
-        self.square_y: Optional[int] = None
-
-
-def compute_tile_evolution(
-    tile_visits_accessor: TileVisitAccessor, config: Config
-) -> None:
+def compute_tile_evolution(tile_state: TileState, config: Config) -> None:
     for zoom in config.explorer_zoom_levels:
         _compute_cluster_evolution(
-            tile_visits_accessor.histories[zoom],
-            tile_visits_accessor.states[zoom],
+            tile_state["tile_history"][zoom],
+            tile_state["evolution_state"][zoom],
             zoom,
         )
         _compute_square_history(
-            tile_visits_accessor.histories[zoom],
-            tile_visits_accessor.states[zoom],
+            tile_state["tile_history"][zoom],
+            tile_state["evolution_state"][zoom],
             zoom,
         )
 
-    tile_visits_accessor.save()
-
 
 def _compute_cluster_evolution(
     tiles: pd.DataFrame, s: TileEvolutionState, zoom: int

geo_activity_playground/webui/activity/controller.py

@@ -12,6 +12,8 @@ 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
@@ -61,12 +63,32 @@ class ActivityController:
 
         new_tiles = {
             zoom: sum(
-                self._tile_visit_accessor.histories[zoom]["activity_id"]
+                self._tile_visit_accessor.tile_state["tile_history"][zoom][
+                    "activity_id"
+                ]
                 == activity["id"]
             )
-            for zoom in [14, 17]
+            for zoom in sorted(self._config.explorer_zoom_levels)
         }
 
+        new_tiles_geojson = {}
+        for zoom in sorted(self._config.explorer_zoom_levels):
+            new_tiles = self._tile_visit_accessor.tile_state["tile_history"][zoom].loc[
+                self._tile_visit_accessor.tile_state["tile_history"][zoom][
+                    "activity_id"
+                ]
+                == activity["id"]
+            ]
+            if len(new_tiles):
+                points = make_grid_points(
+                    (
+                        (row["tile_x"], row["tile_y"])
+                        for index, row in new_tiles.iterrows()
+                    ),
+                    zoom,
+                )
+                new_tiles_geojson[zoom] = make_grid_file_geojson(points)
+
         result = {
             "activity": activity,
             "line_json": line_json,
@@ -79,6 +101,7 @@ class ActivityController:
             "date": activity["start"].date(),
             "time": activity["start"].time(),
             "new_tiles": new_tiles,
+            "new_tiles_geojson": new_tiles_geojson,
         }
         if (
             heart_zones := _extract_heart_rate_zones(
@@ -100,7 +123,9 @@ class ActivityController:
             time_series = privacy_zone.filter_time_series(time_series)
         if len(time_series) == 0:
             time_series = self._repository.get_time_series(id)
-        return make_sharepic(activity, time_series)
+        return make_sharepic(
+            activity, time_series, self._config.sharepic_suppressed_fields
+        )
 
     def render_day(self, year: int, month: int, day: int) -> dict:
         meta = self._repository.meta
@@ -411,7 +436,11 @@ def pixels_in_bounds(bounds: PixelBounds) -> int:
     return (bounds.x_max - bounds.x_min) * (bounds.y_max - bounds.y_min)
 
 
-def make_sharepic(activity: ActivityMeta, time_series: pd.DataFrame) -> bytes:
+def make_sharepic(
+    activity: ActivityMeta,
+    time_series: pd.DataFrame,
+    sharepic_suppressed_fields: list[str],
+) -> bytes:
     lat_lon_data = np.array([time_series["latitude"], time_series["longitude"]]).T
 
     geo_bounds = get_bounds(lat_lon_data)
@@ -448,19 +477,27 @@ def make_sharepic(activity: ActivityMeta, time_series: pd.DataFrame) -> bytes:
         draw.line(yx, fill="red", width=4)
 
     draw.rectangle([0, img.height - 70, img.width, img.height], fill=(0, 0, 0, 128))
-    facts = [
-        f"{activity['kind']}",
-        f"{activity['start'].date()}",
-        f"{activity['equipment']}",
-        f"\n{activity['distance_km']:.1f} km",
-        re.sub(r"^0 days ", "", f"{activity['elapsed_time']}"),
-    ]
+
+    facts = {
+        "kind": f"{activity['kind']}",
+        "start": f"{activity['start'].date()}",
+        "equipment": f"{activity['equipment']}",
+        "distance_km": f"\n{activity['distance_km']:.1f} km",
+        "elapsed_time": re.sub(r"^0 days ", "", f"{activity['elapsed_time']}"),
+    }
+
     if activity.get("calories", 0) and not pd.isna(activity["calories"]):
-        facts.append(f"{activity['calories']:.0f} kcal")
+        facts["calories"] = f"{activity['calories']:.0f} kcal"
     if activity.get("steps", 0) and not pd.isna(activity["steps"]):
-        facts.append(f"{activity['steps']:.0f} steps")
+        facts["steps"] = f"{activity['steps']:.0f} steps"
+
+    facts = {
+        key: value
+        for key, value in facts.items()
+        if not key in sharepic_suppressed_fields
+    }
 
-    draw.text((35, img.height - 70 + 10), "      ".join(facts), font_size=20)
+    draw.text((35, img.height - 70 + 10), "      ".join(facts.values()), font_size=20)
 
     # img_array = np.array(img) / 255
 

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

@@ -111,11 +111,7 @@
 </div>
 
 {% if heartrate_time_plot is defined %}
-<div class="row mb-3">
-    <div class="col">
-        <h2>Heart rate</h2>
-    </div>
-</div>
+<h2>Heart rate</h2>
 
 <div class="row mb-3">
     <div class="col-md-4">
@@ -133,13 +129,45 @@
 </div>
 {% endif %}
 
-<div class="row mb-3">
-    <div class="col">
-        <h2>Share picture</h2>
+<h2>Share picture</h2>
+
+<p><img src="{{ url_for('.sharepic', id=activity.id) }}" /></p>
+
+<p>Not happy with the displayed data? <a href="{{ url_for('settings.sharepic') }}">Change share picture
+        settings</a>.</p>
+
+{% if new_tiles_geojson %}
+<h2>New explorer tiles</h2>
+<p>With this activity you have explored new explorer tiles. The following maps show the new tiles on the respective zoom
+    levels.</p>
+<script>
+    function add_map(id, geojson) {
+        let map = L.map(`map-${id}`, {
+            fullscreenControl: true
+        })
+        L.tileLayer('/tile/color/{z}/{x}/{y}.png', {
+            maxZoom: 19,
+            attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
+        }).addTo(map)
+
+        let geojson_layer = L.geoJSON(geojson).addTo(map)
+        map.fitBounds(geojson_layer.getBounds())
+        return map
+    }
+</script>
 
-        <img src="{{ url_for('.sharepic', id=activity.id) }}" />
+<div class="row mb-3">
+    {% for zoom, geojson in new_tiles_geojson.items() %}
+    <div class="col-md-6">
+        <h3>Zoom {{ zoom }}</h3>
+        <div id="map-{{ zoom }}" style="height: 300px; width: 100%;"></div>
+        <script>
+            let map{{ zoom }} = add_map("{{ zoom }}", {{ geojson | safe }})
+        </script>
     </div>
+    {% endfor %}
 </div>
+{% endif %}
 
 {% if similar_activites|length > 0 %}
 <div class="row mb-3">