geo-activity-playground 0.7.0__tar.gz → 0.8.0__tar.gz

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/PKG-INFO

@@ -1,13 +1,14 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.7.0
+Version: 0.8.0
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding
 Author-email: mu@martin-ueding.de
-Requires-Python: >=3.10,<3.12
+Requires-Python: >=3.9,<3.12
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Dist: Pillow (>=9.2.0,<10.0.0)
@@ -27,6 +28,7 @@ Requires-Dist: requests (>=2.28.1,<3.0.0)
 Requires-Dist: scikit-learn (>=1.3.0,<2.0.0)
 Requires-Dist: scipy (>=1.8.1,<2.0.0)
 Requires-Dist: stravalib (>=1.3.3,<2.0.0)
+Requires-Dist: tomli (>=2.0.1,<3.0.0) ; python_version < "3.11"
 Requires-Dist: tqdm (>=4.64.0,<5.0.0)
 Requires-Dist: vegafusion (>=1.4.3,<2.0.0)
 Requires-Dist: vegafusion-python-embed (>=1.4.3,<2.0.0)

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/__main__.py

@@ -1,16 +1,11 @@
 import argparse
 import os
 import pathlib
-import tomllib
 
 import coloredlogs
 
 from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.sources import TimeSeriesSource
-from geo_activity_playground.explorer.grid_file import get_border_tiles
-from geo_activity_playground.explorer.grid_file import get_explored_tiles
-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.core.config import get_config
 from geo_activity_playground.explorer.video import explorer_video_main
 from geo_activity_playground.heatmap import generate_heatmaps_per_cluster
 from geo_activity_playground.importers.directory import import_from_directory
@@ -78,11 +73,10 @@ def main() -> None:
 
 def make_activity_repository(basedir: pathlib.Path) -> ActivityRepository:
     os.chdir(basedir)
+    config = get_config()
     if pathlib.Path("Activities").exists():
         import_from_directory()
-    elif pathlib.Path("config.toml").exists():
-        with open("config.toml", "rb") as f:
-            config = tomllib.load(f)
+    elif config:
         if "strava" in config:
             import_from_strava_api()
     return ActivityRepository()

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/core/activities.py

@@ -2,16 +2,15 @@ import dataclasses
 import datetime
 import functools
 import logging
-import pathlib
-import tomllib
 from typing import Iterator
 from typing import Optional
 
 import geojson
 import matplotlib
-import numpy as np
 import pandas as pd
 
+from geo_activity_playground.core.config import get_config
+
 
 logger = logging.getLogger(__name__)
 
@@ -105,25 +104,35 @@ def make_geojson_color_line(time_series: pd.DataFrame) -> str:
 def extract_heart_rate_zones(time_series: pd.DataFrame) -> Optional[pd.DataFrame]:
     if "heartrate" not in time_series:
         return None
-    config_path = pathlib.Path("config.toml")
-    if not config_path.exists():
-        logger.warning("Missing a config, cannot extract heart rate zones.")
-        return None
-    with open(config_path, "rb") as f:
-        config = tomllib.load(f)
-
+    config = get_config()
     try:
-        birthyear = config["heart"]["birthyear"]
+        heart_config = config["heart"]
     except KeyError:
         logger.warning(
-            "Missing config entry `heart.birthyear`, cannot determine heart rate zones."
+            "Missing config entry `heart`, cannot determine heart rate zones."
+        )
+        return None
+
+    birthyear = heart_config.get("birthyear", None)
+    maximum = heart_config.get("maximum", None)
+    resting = heart_config.get("resting", None)
+
+    if not maximum and birthyear:
+        age = time_series["time"].iloc[0].year - birthyear
+        maximum = 220 - age
+    if not resting:
+        resting = 0
+    if not maximum:
+        logger.warning(
+            "Missing config entry `heart.maximum` or `heart.birthyear`, cannot determine heart rate zones."
         )
         return None
 
-    age = time_series["time"].iloc[0].year - birthyear
-    max_rate = 220 - age
-    zones: pd.Series = time_series["heartrate"] * 10 // max_rate - 4
+    zones: pd.Series = (time_series["heartrate"] - resting) * 10 // (
+        maximum - resting
+    ) - 4
     zones.loc[zones < 0] = 0
+    zones.loc[zones > 5] = 5
     df = pd.DataFrame({"heartzone": zones, "step": time_series["time"].diff()}).dropna()
     duration_per_zone = df.groupby("heartzone").sum()["step"].dt.total_seconds() / 60
     duration_per_zone.name = "minutes"

geo_activity_playground-0.8.0/geo_activity_playground/core/config.py

@@ -0,0 +1,22 @@
+import functools
+import logging
+import pathlib
+
+
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+
+logger = logging.getLogger(__name__)
+
+
+@functools.cache
+def get_config() -> dict:
+    config_path = pathlib.Path("config.toml")
+    if not config_path.exists():
+        logger.warning("Missing a config, some features might be missing.")
+        return {}
+    with open(config_path, "rb") as f:
+        return tomllib.load(f)

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/explorer/grid_file.py

@@ -1,3 +1,4 @@
+import logging
 import pathlib
 from typing import Iterator
 
@@ -6,12 +7,16 @@ import gpxpy
 import numpy as np
 import pandas as pd
 import scipy.ndimage
+import sklearn.cluster
 
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
 from geo_activity_playground.explorer.converters import get_tile_history
 
 
+logger = logging.getLogger(__name__)
+
+
 def get_three_color_tiles(
     tiles: pd.DataFrame, repository: ActivityRepository, zoom: int
 ) -> str:
@@ -19,7 +24,10 @@ def get_three_color_tiles(
     a = np.zeros((2**zoom, 2**zoom), dtype=np.int8)
     a[tiles["tile_x"], tiles["tile_y"]] = 1
 
-    tile_dict = {elem: 1 for elem in zip(tiles["tile_x"], tiles["tile_y"])}
+    tile_dict = {
+        elem: {"cluster": False, "square": False}
+        for elem in zip(tiles["tile_x"], tiles["tile_y"])
+    }
 
     for x, y in tile_dict.keys():
         if (
@@ -28,7 +36,7 @@ def get_three_color_tiles(
             and (x, y + 1) in tile_dict
             and (x, y - 1) in tile_dict
         ):
-            tile_dict[(x, y)] = 2
+            tile_dict[(x, y)]["cluster"] = True
 
     # Compute biggest square.
     square_size = 1
@@ -52,43 +60,75 @@ def get_three_color_tiles(
         square_x, square_y, square_size = biggest
         for x in range(square_x, square_x + square_size):
             for y in range(square_y, square_y + square_size):
-                tile_dict[(x, y)] = 3
-
-    tile_metadata = {
-        (row["tile_x"], row["tile_y"]): {
-            "first_visit": row["time"].date().isoformat(),
-            "activity_id": row["activity_id"],
-            "activity_name": repository.get_activity_by_id(row["activity_id"]).name,
-        }
-        for index, row in tiles.iterrows()
-    }
-
-    # Find non-zero tiles.
-    return geojson.dumps(
-        geojson.FeatureCollection(
-            features=[
-                make_explorer_tile(
-                    x,
-                    y,
-                    {
-                        "color": {1: "red", 2: "green", 3: "blue"}[v],
-                        **tile_metadata[(x, y)],
-                    },
-                    zoom,
-                )
-                for (x, y), v in tile_dict.items()
-            ]
+                tile_dict[(x, y)]["square"] = True
+
+    for index, row in tiles.iterrows():
+        tile_dict[(row["tile_x"], row["tile_y"])].update(
+            {
+                "first_visit": row["time"].date().isoformat(),
+                "activity_id": row["activity_id"],
+                "activity_name": repository.get_activity_by_id(row["activity_id"]).name,
+                "color": map_color(tile_dict[(row["tile_x"], row["tile_y"])]),
+            }
         )
+
+    num_cluster_tiles = sum(value["cluster"] for value in tile_dict.values())
+
+    cluster_tiles = np.array(
+        [tile for tile, value in tile_dict.items() if value["cluster"]]
     )
 
+    logger.info("Run DBSCAN cluster finding algorithm …")
+    dbscan = sklearn.cluster.DBSCAN(eps=1.1, min_samples=1)
+    labels = dbscan.fit_predict(cluster_tiles)
+    label_counts = dict(zip(*np.unique(labels, return_counts=True)))
+    max_cluster_size = max(
+        count for label, count in label_counts.items() if label != -1
+    )
+    for xy, label in zip(cluster_tiles, labels):
+        tile_dict[tuple(xy)]["cluster_id"] = int(label)
+        tile_dict[tuple(xy)]["this_cluster_size"] = int(label_counts[label])
+
+    # Find non-zero tiles.
+    result = {
+        "explored_geojson": geojson.dumps(
+            geojson.FeatureCollection(
+                features=[
+                    make_explorer_tile(
+                        x,
+                        y,
+                        tile_dict[(x, y)],
+                        zoom,
+                    )
+                    for (x, y), v in tile_dict.items()
+                ]
+            )
+        ),
+        "max_cluster_size": max_cluster_size,
+        "num_cluster_tiles": num_cluster_tiles,
+        "num_tiles": len(tile_dict),
+        "square_size": square_size,
+    }
+    return result
+
+
+def map_color(tile_meta: dict) -> str:
+    if tile_meta["square"]:
+        return "blue"
+    elif tile_meta["cluster"]:
+        return "green"
+    else:
+        return "red"
+
 
 def get_border_tiles(tiles: pd.DataFrame, zoom: int) -> list[list[list[float]]]:
-    a = np.zeros((2**zoom, 2**zoom), dtype=np.int8)
-    a[tiles["tile_x"], tiles["tile_y"]] = 1
-    dilated = scipy.ndimage.binary_dilation(a, iterations=2)
-    border = dilated - a
-    border_x, border_y = np.where(border)
-    return make_grid_points(zip(border_x, border_y), zoom)
+    tile_set = set(zip(tiles["tile_x"], tiles["tile_y"]))
+    border_tiles = set()
+    for x, y in tile_set:
+        for neighbor in [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]:
+            if neighbor not in tile_set:
+                border_tiles.add(neighbor)
+    return make_grid_points(border_tiles, zoom)
 
 
 def get_explored_tiles(tiles: pd.DataFrame, zoom: int) -> list[list[list[float]]]:

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/importers/strava_api.py

@@ -4,22 +4,16 @@ import json
 import logging
 import pathlib
 import pickle
-import tomllib
 from typing import Any
 
 import pandas as pd
 from stravalib import Client
 from stravalib.exc import RateLimitExceeded
 
-
-logger = logging.getLogger(__name__)
+from geo_activity_playground.core.config import get_config
 
 
-@functools.cache
-def get_config() -> dict:
-    config_path = pathlib.Path("config.toml")
-    with open(config_path, "rb") as f:
-        return tomllib.load(f)
+logger = logging.getLogger(__name__)
 
 
 def get_state(path: pathlib.Path) -> Any:

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/webui/activity_controller.py

@@ -19,6 +19,7 @@ class ActivityController:
         activity = self._repository.get_activity_by_id(id)
 
         time_series = self._repository.get_time_series(id)
+        time_series["distance/km"] = time_series["distance"] / 1000
         line_json = make_geojson_from_time_series(time_series)
 
         result = {
@@ -40,7 +41,9 @@ def distance_time_plot(time_series: pd.DataFrame) -> str:
     return (
         alt.Chart(time_series, title="Distance")
         .mark_line()
-        .encode(alt.X("time", title="Time"), alt.Y("distance", title="Distance / km"))
+        .encode(
+            alt.X("time", title="Time"), alt.Y("distance/km", title="Distance / km")
+        )
         .interactive()
         .to_json(format="vega")
     )

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/webui/explorer_controller.py

@@ -1,6 +1,7 @@
 import functools
 
 from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
 from geo_activity_playground.explorer.converters import get_tile_history
 from geo_activity_playground.explorer.grid_file import get_border_tiles
 from geo_activity_playground.explorer.grid_file import get_explored_geojson
@@ -17,21 +18,26 @@ class ExplorerController:
     @functools.cache
     def render(self, zoom: int) -> dict:
         tiles = get_tile_history(self._repository, zoom)
+        medians = tiles.median()
+        median_lat, median_lon = get_tile_upper_left_lat_lon(
+            medians["tile_x"], medians["tile_y"], zoom
+        )
 
-        explored_geojson = get_three_color_tiles(tiles, self._repository, zoom)
+        explored = get_three_color_tiles(tiles, self._repository, zoom)
 
-        if zoom <= 14:
-            points = get_border_tiles(tiles, zoom)
-            missing_tiles_geojson = make_grid_file_geojson(points, "missing_tiles")
-            make_grid_file_gpx(points, "missing_tiles")
+        points = get_border_tiles(tiles, zoom)
+        missing_tiles_geojson = make_grid_file_geojson(points, "missing_tiles")
+        make_grid_file_gpx(points, "missing_tiles")
 
-            points = get_explored_tiles(tiles, zoom)
-            explored_tiles_geojson = make_grid_file_geojson(points, "explored")
-            make_grid_file_gpx(points, "explored")
-        else:
-            missing_tiles_geojson = {}
+        points = get_explored_tiles(tiles, zoom)
+        explored_tiles_geojson = make_grid_file_geojson(points, "explored")
+        make_grid_file_gpx(points, "explored")
 
         return {
-            "explored_geojson": explored_geojson,
+            "center": {
+                "latitude": median_lat,
+                "longitude": median_lon,
+            },
+            "explored": explored,
             "missing_tiles_geojson": missing_tiles_geojson,
         }

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/webui/templates/explorer.html.j2

@@ -4,6 +4,11 @@
 <div class="row mb-3">
     <div class="col">
         <h1>Explorer Tiles</h1>
+        <p>You have {{ explored.num_tiles }} explored tiles. There are {{ explored.num_cluster_tiles }} cluster tiles in
+            total. Your largest cluster consists of {{ explored.max_cluster_size }} tiles. Your largest square has size
+            {{
+            explored.square_size }}².
+        </p>
     </div>
 </div>
 
@@ -22,14 +27,21 @@
         <script>
             function onEachFeature(feature, layer) {
                 if (feature.properties && feature.properties.first_visit) {
-                    layer.bindPopup(`First visited on ${feature.properties.first_visit} as part of <a href=/activity/${feature.properties.activity_id}>${feature.properties.activity_name}</a>.`)
+                    let lines = [`First visit: ${feature.properties.first_visit}`,
+                    `First activity: <a href=/activity/${feature.properties.activity_id}>${feature.properties.activity_name}</a>`]
+                    if (feature.properties.this_cluster_size) {
+                        lines.push(`This cluster size: ${feature.properties.this_cluster_size}`)
+                    }
+                    layer.bindPopup(lines.join('<br />'))
                 }
             }
 
-            let explorer_geojson = {{ explored_geojson| safe}}
+            let explorer_geojson = {{ explored.explored_geojson| safe}}
             let map = L.map('explorer-map', {
-                fullscreenControl: true
-            });
+                fullscreenControl: true,
+                center: [{{ center.latitude }}, {{ center.longitude }}],
+            zoom: 10
+            })
             L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
                 maxZoom: 19,
                 attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
@@ -38,7 +50,6 @@
                 style: function (feature) { return { color: feature.properties.color, fillColor: feature.properties.color, weight: 1 } },
                 onEachFeature: onEachFeature
             }).addTo(map)
-            map.fitBounds(explorer_layer.getBounds())
         </script>
     </div>
 </div>
@@ -59,14 +70,15 @@
         <script>
             let missing_geojson = {{ missing_tiles_geojson| safe}}
             let missing_map = L.map('missing-map', {
-                fullscreenControl: true
+                fullscreenControl: true,
+                center: [{{ center.latitude }}, {{ center.longitude }}],
+            zoom: 10
             });
             L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
                 maxZoom: 19,
                 attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a>'
             }).addTo(missing_map)
             let missing_layer = L.geoJSON(missing_geojson).addTo(missing_map)
-            missing_map.fitBounds(missing_layer.getBounds())
         </script>
     </div>
 </div>

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/geo_activity_playground/webui/templates/heatmap.html.j2

@@ -15,7 +15,7 @@
             let map = L.map('heatmap', {
                 fullscreenControl: true,
                 center: [{{ center.latitude }}, {{ center.longitude }}],
-            zoom: 12
+                zoom: 12
             });
             L.tileLayer('/heatmap/tile/{z}/{x}/{y}.png', {
                 maxZoom: 19,

{geo_activity_playground-0.7.0 → geo_activity_playground-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geo-activity-playground"
-version = "0.7.0"
+version = "0.8.0"
 description = "Analysis of geo data activities like rides, runs or hikes."
 authors = ["Martin Ueding <mu@martin-ueding.de>"]
 license = "MIT"
@@ -9,7 +9,7 @@ license = "MIT"
 geo-activity-playground = "geo_activity_playground.__main__:main"
 
 [tool.poetry.dependencies]
-python = "^3.10,<3.12"
+python = "^3.9,<3.12"
 
 altair = "^5.1.2"
 appdirs = "^1.4.4"
@@ -28,6 +28,7 @@ requests = "^2.28.1"
 scikit-learn = "^1.3.0"
 scipy = "^1.8.1"
 stravalib = "^1.3.3"
+tomli = { version = "^2.0.1", python = "<3.11" }
 tqdm = "^4.64.0"
 vegafusion = "^1.4.3"
 vegafusion-python-embed = "^1.4.3"