geo-activity-playground 0.15.2__tar.gz → 0.16.1__tar.gz

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.15.2
+Version: 0.16.1
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding
@@ -26,7 +26,6 @@ Requires-Dist: pandas (>=2.0,<3.0)
 Requires-Dist: pyarrow (>=12.0.1,<13.0.0)
 Requires-Dist: python-dateutil (>=2.8.2,<3.0.0)
 Requires-Dist: requests (>=2.28.1,<3.0.0)
-Requires-Dist: scikit-learn (>=1.3.2,<2.0.0)
 Requires-Dist: scipy (>=1.8.1,<2.0.0)
 Requires-Dist: stravalib (>=1.3.3,<2.0.0)
 Requires-Dist: tcxreader (>=0.4.5,<0.5.0)

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/__main__.py

@@ -6,6 +6,7 @@ import sys
 
 import coloredlogs
 
+from .importers.strava_checkout import convert_strava_checkout
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.core.activities import embellish_time_series
 from geo_activity_playground.core.cache_migrations import apply_cache_migrations
@@ -13,7 +14,6 @@ from geo_activity_playground.core.config import get_config
 from geo_activity_playground.explorer.tile_visits import compute_tile_evolution
 from geo_activity_playground.explorer.tile_visits import compute_tile_visits
 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
 from geo_activity_playground.importers.strava_api import import_from_strava_api
 from geo_activity_playground.webui.app import webui_main
@@ -53,13 +53,16 @@ def main() -> None:
     subparser.set_defaults(func=lambda options: explorer_video_main())
 
     subparser = subparsers.add_parser(
-        "heatmaps", help="Generate heatmaps from activities"
+        "convert-strava-checkout",
+        help="Converts a Strava checkout to the structure used by this program.",
     )
     subparser.set_defaults(
-        func=lambda options: generate_heatmaps_per_cluster(
-            make_activity_repository(options.basedir)
+        func=lambda options: convert_strava_checkout(
+            options.checkout_path, options.playground_path
         )
     )
+    subparser.add_argument("checkout_path", type=pathlib.Path)
+    subparser.add_argument("playground_path", type=pathlib.Path)
 
     subparser = subparsers.add_parser("serve", help="Launch webserver")
     subparser.set_defaults(

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/core/activities.py

@@ -138,6 +138,11 @@ def embellish_time_series(repository: ActivityRepository) -> None:
                 )
                 changed = True
 
+            potential_jumps = (df["speed"] > 40) & (df["speed"].diff() > 10)
+            if np.any(potential_jumps):
+                df = df.loc[~potential_jumps]
+                changed = True
+
         if "x" not in df.columns:
             x, y = compute_tile_float(df["latitude"], df["longitude"], 0)
             df["x"] = x

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/core/activity_parsers.py

@@ -1,7 +1,6 @@
 import datetime
 import gzip
 import pathlib
-import tempfile
 import xml
 
 import dateutil.parser
@@ -159,10 +158,12 @@ def read_tcx_activity(path: pathlib.Path, open) -> pd.DataFrame:
 
     with open(path, "rb") as f:
         content = f.read().strip()
-    with tempfile.NamedTemporaryFile("wb", suffix=".tcx") as f:
+
+    stripped_file = pathlib.Path("Cache/temp.tcx")
+    with open(stripped_file, "wb") as f:
         f.write(content)
-        f.flush()
-        data = tcx_reader.read(f.name)
+    data = tcx_reader.read(str(stripped_file))
+    stripped_file.unlink()
 
     for trackpoint in data.trackpoints:
         if trackpoint.latitude and trackpoint.longitude:

geo_activity_playground-0.16.1/geo_activity_playground/core/cache_migrations.py

@@ -0,0 +1,72 @@
+import json
+import logging
+import pathlib
+import shutil
+
+logger = logging.getLogger(__name__)
+
+
+def delete_activities_per_tile() -> None:
+    paths = [
+        pathlib.Path("Cache/activities-per-tile.pickle"),
+        pathlib.Path("Cache/activities-per-tile-task.json"),
+    ]
+    for path in paths:
+        path.unlink(missing_ok=True)
+
+
+def delete_work_tracker(name: str):
+    def migration() -> None:
+        path = pathlib.Path(f"Cache/work-tracker-{name}.pickle")
+        path.unlink(missing_ok=True)
+
+    return migration
+
+
+def reset_time_series_embellishment() -> None:
+    pathlib.Path("Cache/work-tracker-embellish-time-series.pickle").unlink(
+        missing_ok=True
+    )
+
+
+def delete_tile_visits() -> None:
+    paths = [
+        pathlib.Path("Cache/tile-evolution-state.pickle"),
+        pathlib.Path("Cache/tile-history.pickle"),
+        pathlib.Path("Cache/tile-visits.pickle"),
+        pathlib.Path("Cache/work-tracker-parse-activity-files.pickle"),
+        pathlib.Path("Cache/work-tracker-tile-visits.pickle"),
+    ]
+    for path in paths:
+        path.unlink(missing_ok=True)
+
+
+def delete_heatmap_cache() -> None:
+    path = pathlib.Path("Cache/Heatmap")
+    if path.exists():
+        shutil.rmtree(path)
+
+
+def apply_cache_migrations() -> None:
+    logger.info("Apply cache migration if needed …")
+    cache_status_file = pathlib.Path("Cache/status.json")
+    if cache_status_file.exists():
+        with open(cache_status_file) as f:
+            cache_status = json.load(f)
+    else:
+        cache_status = {"num_applied_migrations": 0}
+
+    migrations = [
+        delete_activities_per_tile,
+        reset_time_series_embellishment,
+        delete_tile_visits,
+        delete_heatmap_cache,
+    ]
+
+    for migration in migrations[cache_status["num_applied_migrations"] :]:
+        logger.info(f"Applying cache migration {migration.__name__} …")
+        migration()
+        cache_status["num_applied_migrations"] += 1
+        cache_status_file.parent.mkdir(exist_ok=True, parents=True)
+        with open(cache_status_file, "w") as f:
+            json.dump(cache_status, f)

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/core/heatmap.py

@@ -2,16 +2,11 @@
 This code is based on https://github.com/remisalmon/Strava-local-heatmap.
 """
 import dataclasses
-import functools
 import logging
-import pathlib
 
 import matplotlib.pyplot as pl
 import numpy as np
-import pandas as pd
 
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.tasks import work_tracker
 from geo_activity_playground.core.tiles import compute_tile_float
 from geo_activity_playground.core.tiles import get_tile
 from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
@@ -20,34 +15,6 @@ from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
 logger = logging.getLogger(__name__)
 
 
-@functools.cache
-def get_all_points(repository: ActivityRepository) -> pd.DataFrame:
-    logger.info("Gathering all points …")
-    all_points_path = pathlib.Path("Cache/all-points.parquet")
-    if all_points_path.exists():
-        all_points = pd.read_parquet(all_points_path)
-    else:
-        all_points = pd.DataFrame()
-    new_shards = []
-    with work_tracker(pathlib.Path("Cache/all-points-task.json")) as tracker:
-        for activity in repository.iter_activities():
-            if activity.id in tracker:
-                continue
-            tracker.add(activity.id)
-
-            logger.info(f"Parsing points from {activity.id} …")
-            time_series = repository.get_time_series(activity.id)
-            if len(time_series) == 0 or "latitude" not in time_series.columns:
-                continue
-            shard = time_series[["latitude", "longitude"]].copy()
-            shard["activity_id"] = activity.id
-            new_shards.append(shard)
-    logger.info("Concatenating shards …")
-    all_points = pd.concat([all_points] + new_shards)
-    all_points.to_parquet(all_points_path)
-    return all_points
-
-
 @dataclasses.dataclass
 class GeoBounds:
     lat_min: float
@@ -212,30 +179,28 @@ def gaussian_filter(image, sigma):
 
 
 def build_heatmap_image(
-    lat_lon_data: np.ndarray, num_activities: int, tile_bounds: TileBounds
+    xy_data: np.ndarray,
+    mean_latitude: float,
+    num_activities: int,
+    tile_bounds: TileBounds,
 ) -> np.ndarray:
-    # fill trackpoints
-    sigma_pixel = 1
+    assert xy_data.shape[1] == 2
 
     data = np.zeros(tile_bounds.shape)
 
-    xy_data = compute_tile_float(
-        lat_lon_data[:, 0], lat_lon_data[:, 1], tile_bounds.zoom
-    )
-    xy_data = np.array(xy_data).T
+    xy_data = np.array(xy_data)
     xy_data = np.round(
         (xy_data - [tile_bounds.x_tile_min, tile_bounds.y_tile_min]) * OSM_TILE_SIZE
-    )  # to supertile coordinates
+    )
 
+    sigma_pixel = 1
     for j, i in xy_data.astype(int):
         data[
             i - sigma_pixel : i + sigma_pixel, j - sigma_pixel : j + sigma_pixel
         ] += 1.0
 
     res_pixel = (
-        156543.03
-        * np.cos(np.radians(np.mean(lat_lon_data[:, 0])))
-        / (2.0**tile_bounds.zoom)
+        156543.03 * np.cos(np.radians(mean_latitude)) / (2.0**tile_bounds.zoom)
     )  # from https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
 
     # trackpoint max accumulation per pixel = 1/5 (trackpoint/meter) * res_pixel (meter/pixel) * activities
@@ -246,20 +211,15 @@ def build_heatmap_image(
 
     # equalize histogram and compute kernel density estimation
     data_hist, _ = np.histogram(data, bins=int(m + 1))
-
     data_hist = np.cumsum(data_hist) / data.size  # normalized cumulated histogram
-
     for i in range(data.shape[0]):
         for j in range(data.shape[1]):
-            data[i, j] = m * data_hist[int(data[i, j])]  # histogram equalization
+            data[i, j] = m * data_hist[int(data[i, j])]
 
-    data = gaussian_filter(
-        data, float(sigma_pixel)
-    )  # kernel density estimation with normal kernel
+    data = gaussian_filter(data, float(sigma_pixel))
 
-    data = (data - data.min()) / (data.max() - data.min())  # normalize to [0,1]
+    data = (data - data.min()) / (data.max() - data.min())
 
-    # colorize
     cmap = pl.get_cmap("hot")
 
     data_color = cmap(data)

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/explorer/tile_visits.py

@@ -44,7 +44,6 @@ def compute_tile_visits(repository: ActivityRepository) -> None:
                 tile = (tile_x, tile_y)
                 if tile in tile_visits[zoom]:
                     d = tile_visits[zoom][tile]
-                    d["count"] += 1
                     if d["first_time"] > time:
                         d["first_time"] = time
                         d["first_id"] = activity_id
@@ -54,7 +53,6 @@ def compute_tile_visits(repository: ActivityRepository) -> None:
                     d["activity_ids"].add(activity_id)
                 else:
                     tile_visits[zoom][tile] = {
-                        "count": 1,
                         "first_time": time,
                         "first_id": activity_id,
                         "last_time": time,

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/importers/directory.py

@@ -29,6 +29,7 @@ def import_from_directory() -> None:
     activity_paths = {
         int(hashlib.sha3_224(str(path).encode()).hexdigest(), 16) % 2**62: path
         for path in pathlib.Path("Activities").rglob("*.*")
+        if path.is_file()
     }
     activities_ids_to_parse = work_tracker.filter(activity_paths.keys())
 

geo_activity_playground-0.16.1/geo_activity_playground/importers/strava_checkout.py

@@ -0,0 +1,54 @@
+import pathlib
+import shutil
+
+import dateutil.parser
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+
+def nan_as_none(elem):
+    if isinstance(elem, float) and np.isnan(elem):
+        return None
+    else:
+        return elem
+
+
+def convert_strava_checkout(
+    checkout_path: pathlib.Path, playground_path: pathlib.Path
+) -> None:
+    activities = pd.read_csv(checkout_path / "activities.csv")
+    print(activities)
+
+    for _, row in tqdm(activities.iterrows(), desc="Import activity files"):
+        activity_date = dateutil.parser.parse(row["Activity Date"])
+        activity_name = row["Activity Name"]
+        activity_kind = row["Activity Type"]
+        is_commute = row["Commute"] == "true"
+        equipment = (
+            nan_as_none(row["Activity Gear"])
+            or nan_as_none(row["Bike"])
+            or nan_as_none(row["Gear"])
+            or ""
+        )
+        activity_file = checkout_path / row["Filename"]
+
+        activity_target = playground_path / "Activities" / str(activity_kind)
+        if equipment:
+            activity_target /= str(equipment)
+        if is_commute:
+            activity_target /= "Commute"
+
+        activity_target /= "".join(
+            [
+                f"{activity_date.year:04d}-{activity_date.month:02d}-{activity_date.day:02d}",
+                " ",
+                f"{activity_date.hour:02d}-{activity_date.minute:02d}-{activity_date.second:02d}",
+                " ",
+                activity_name,
+            ]
+            + activity_file.suffixes
+        )
+
+        activity_target.parent.mkdir(exist_ok=True, parents=True)
+        shutil.copy(activity_file, activity_target)

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/webui/app.py

@@ -1,7 +1,9 @@
 from flask import Flask
 from flask import render_template
+from flask import request
 from flask import Response
 
+from .search_controller import SearchController
 from geo_activity_playground.core.activities import ActivityRepository
 from geo_activity_playground.webui.activity_controller import ActivityController
 from geo_activity_playground.webui.calendar_controller import CalendarController
@@ -28,11 +30,20 @@ def webui_main(repository: ActivityRepository, host: str, port: int) -> None:
     heatmap_controller = HeatmapController(repository)
     grayscale_tile_controller = GrayscaleTileController()
     summary_controller = SummaryController(repository)
+    search_controller = SearchController(repository)
 
     @app.route("/")
     def index():
         return render_template("index.html.j2", **entry_controller.render())
 
+    @app.route("/search", methods=["POST"])
+    def search():
+        form_input = request.form
+        return render_template(
+            "search.html.j2",
+            **search_controller.render_search_results(form_input["name"])
+        )
+
     @app.route("/activity/<id>")
     def activity(id: str):
         return render_template(
@@ -126,6 +137,19 @@ def webui_main(repository: ActivityRepository, host: str, port: int) -> None:
             mimetype="image/png",
         )
 
+    @app.route("/heatmap-download/<north>/<east>/<south>/<west>")
+    def heatmap_download(north: str, east: str, south: str, west: str):
+        return Response(
+            heatmap_controller.download_heatmap(
+                float(north),
+                float(east),
+                float(south),
+                float(west),
+            ),
+            mimetype="image/png",
+            headers={"Content-disposition": 'attachment; filename="heatmap.png"'},
+        )
+
     @app.route("/grayscale-tile/<z>/<x>/<y>.png")
     def grayscale_tile(x: str, y: str, z: str):
         return Response(

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/webui/equipment_controller.py

@@ -3,6 +3,7 @@ import functools
 import altair as alt
 import pandas as pd
 
+from ..core.config import get_config
 from geo_activity_playground.core.activities import ActivityRepository
 
 
@@ -58,10 +59,18 @@ class EquipmentController:
             )
             .reset_index()
             .sort_values("last_use", ascending=False)
-            .to_dict(orient="records")
         )
 
+        config = get_config()
+        print(config)
+        if "offsets" in config:
+            print(equipment_summary)
+            for equipment, offset in config["offsets"].items():
+                equipment_summary.loc[
+                    equipment_summary["equipment"] == equipment, "total_distance"
+                ] += offset
+
         return {
             "total_distances_plot": plot,
-            "equipment_summary": equipment_summary,
+            "equipment_summary": equipment_summary.to_dict(orient="records"),
         }

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/webui/explorer_controller.py

@@ -40,14 +40,18 @@ def get_three_color_tiles(
     cmap_first = matplotlib.colormaps["plasma"]
     cmap_last = matplotlib.colormaps["plasma"]
     tile_dict = {}
-    for tile, row in tile_visits.items():
-        first_age_days = (today - row["first_time"].date()).days
-        last_age_days = (today - row["last_time"].date()).days
+    for tile, tile_data in tile_visits.items():
+        first_age_days = (today - tile_data["first_time"].date()).days
+        last_age_days = (today - tile_data["last_time"].date()).days
         tile_dict[tile] = {
-            "first_activity_id": str(row["first_id"]),
-            "first_activity_name": repository.get_activity_by_id(row["first_id"]).name,
-            "last_activity_id": str(row["last_id"]),
-            "last_activity_name": repository.get_activity_by_id(row["last_id"]).name,
+            "first_activity_id": str(tile_data["first_id"]),
+            "first_activity_name": repository.get_activity_by_id(
+                tile_data["first_id"]
+            ).name,
+            "last_activity_id": str(tile_data["last_id"]),
+            "last_activity_name": repository.get_activity_by_id(
+                tile_data["last_id"]
+            ).name,
             "first_age_days": first_age_days,
             "first_age_color": matplotlib.colors.to_hex(
                 cmap_first(max(1 - first_age_days / (2 * 365), 0.0))
@@ -58,9 +62,9 @@ def get_three_color_tiles(
             ),
             "cluster": False,
             "color": "#303030",
-            "first_visit": row["first_time"].date().isoformat(),
-            "last_visit": row["last_time"].date().isoformat(),
-            "num_visits": row["count"],
+            "first_visit": tile_data["first_time"].date().isoformat(),
+            "last_visit": tile_data["last_time"].date().isoformat(),
+            "num_visits": len(tile_data["activity_ids"]),
             "square": False,
         }
 

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/webui/heatmap_controller.py

@@ -13,7 +13,12 @@ from PIL import Image
 from PIL import ImageDraw
 
 from geo_activity_playground.core.activities import ActivityRepository
+from geo_activity_playground.core.heatmap import build_heatmap_image
+from geo_activity_playground.core.heatmap import build_map_from_tiles
 from geo_activity_playground.core.heatmap import convert_to_grayscale
+from geo_activity_playground.core.heatmap import crop_image_to_bounds
+from geo_activity_playground.core.heatmap import GeoBounds
+from geo_activity_playground.core.heatmap import get_sensible_zoom_level
 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
@@ -114,3 +119,44 @@ class HeatmapController:
         f = io.BytesIO()
         pl.imsave(f, map_tile, format="png")
         return bytes(f.getbuffer())
+
+    def download_heatmap(self, north, east, south, west) -> bytes:
+        geo_bounds = GeoBounds(south, west, north, east)
+        tile_bounds = get_sensible_zoom_level(geo_bounds, (2160, 3840))
+        background = build_map_from_tiles(tile_bounds)
+        background = convert_to_grayscale(background)
+        background = 1.0 - background
+
+        relevant_activities = set()
+
+        for tile_x in range(tile_bounds.x_tile_min, tile_bounds.x_tile_max):
+            for tile_y in range(tile_bounds.y_tile_min, tile_bounds.y_tile_max):
+                tile = (tile_x, tile_y)
+                if tile in self.tile_visits[tile_bounds.zoom]:
+                    relevant_activities |= self.tile_visits[tile_bounds.zoom][tile][
+                        "activity_ids"
+                    ]
+
+        points = pd.concat(map(self._repository.get_time_series, relevant_activities))
+        xy_data = np.array([points["x"], points["y"]]).T * 2**tile_bounds.zoom
+
+        within = (
+            (tile_bounds.x_tile_min <= xy_data[:, 0])
+            & (xy_data[:, 0] <= tile_bounds.x_tile_max)
+            & (tile_bounds.y_tile_min <= xy_data[:, 1])
+            & (xy_data[:, 1] <= tile_bounds.y_tile_max)
+        )
+        xy_data = xy_data[within]
+
+        data_color = build_heatmap_image(
+            xy_data, np.mean(points["latitude"]), len(relevant_activities), tile_bounds
+        )
+        for c in range(3):
+            background[:, :, c] = (1.0 - data_color[:, :, c]) * background[
+                :, :, c
+            ] + data_color[:, :, c]
+        background = crop_image_to_bounds(background, geo_bounds, tile_bounds)
+
+        f = io.BytesIO()
+        pl.imsave(f, background, format="png")
+        return bytes(f.getbuffer())

geo_activity_playground-0.16.1/geo_activity_playground/webui/search_controller.py

@@ -0,0 +1,29 @@
+import logging
+
+from ..core.activities import ActivityRepository
+
+logger = logging.getLogger(__name__)
+
+
+class SearchController:
+    def __init__(self, repository: ActivityRepository) -> None:
+        self._repository = repository
+
+    def render_search_results(self, name: str) -> dict:
+        logger.info(f"Searching for {name=}")
+        activities = []
+        for _, row in self._repository.meta.iterrows():
+            if name in row["name"]:
+                print(row["name"])
+                activities.append(
+                    {
+                        "name": row["name"],
+                        "start": row["start"].isoformat(),
+                        "kind": row["kind"],
+                        "distance/km": row["distance"],
+                        "elapsed_time": row["elapsed_time"],
+                        "commute": row["commute"],
+                    }
+                )
+
+        return {"activities": activities}

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/webui/templates/heatmap.html.j2

@@ -10,6 +10,7 @@
 <div class="row mb-3">
     <div class="col">
         <div id="heatmap" style="height: 800px;"></div>
+        <p><a href="#" onclick="downloadAs()">Download heatmap in visible area</a></p>
 
         <script>
             let map = L.map('heatmap', {
@@ -26,6 +27,13 @@
             if (bbox) {
                 map.fitBounds(L.geoJSON(bbox).getBounds())
             }
+
+
+            function downloadAs() {
+                bounds = map.getBounds()
+                window.location.href =
+                    `/heatmap-download/${bounds.getNorth()}/${bounds.getEast()}/${bounds.getSouth()}/${bounds.getWest()}`
+            }
         </script>
     </div>
 </div>

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/geo_activity_playground/webui/templates/index.html.j2

@@ -2,15 +2,20 @@
 
 {% block container %}
 <div class="row mb-3">
-    <div class="col">
-        <h2>Last 30 days</h2>
-    </div>
 </div>
 
 <div class="row mb-3">
-    <div class="col">
+    <div class="col-md-9">
+        <h2>Last 30 days</h2>
         {{ vega_direct("distance-last-30-days", distance_last_30_days_plot) }}
     </div>
+    <div class="col-md-3">
+        <h2>Search activities</h2>
+        <form method="post" action="/search">
+            <input type="search" name="name" />
+            <input type="submit" class="button" />
+        </form>
+    </div>
 </div>
 
 

geo_activity_playground-0.16.1/geo_activity_playground/webui/templates/search.html.j2

@@ -0,0 +1,38 @@
+{% extends "page.html.j2" %}
+
+{% block container %}
+<div class="row mb-3">
+    <div class="col">
+        <h1>Search Results</h1>
+    </div>
+</div>
+
+<div class="row mb-3">
+    <div class="col">
+        <table class="table">
+            <thead>
+                <tr>
+                    <th>Name</th>
+                    <th>Start</th>
+                    <th>Kind</th>
+                    <th>Distance</th>
+                    <th>Elapsed time</th>
+                    <th>Commute</th>
+                </tr>
+            </thead>
+            <tbody>
+                {% for activity in activities %}
+                <tr>
+                    <td>{{ activity.name }}</td>
+                    <td>{{ activity.start }}</td>
+                    <td>{{ activity.kind }}</td>
+                    <td>{{ '%.1f' % activity["distance/km"] }} km</td>
+                    <td>{{ activity.elapsed_time }}</td>
+                    <td>{{ activity.commute }}</td>
+                </tr>
+                {% endfor %}
+            </tbody>
+        </table>
+    </div>
+</div>
+{% endblock %}

{geo_activity_playground-0.15.2 → geo_activity_playground-0.16.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geo-activity-playground"
-version = "0.15.2"
+version = "0.16.1"
 description = "Analysis of geo data activities like rides, runs or hikes."
 authors = ["Martin Ueding <mu@martin-ueding.de>"]
 license = "MIT"
@@ -26,7 +26,6 @@ Pillow = "^9.2.0"
 pyarrow = "^12.0.1"
 python-dateutil = "^2.8.2"
 requests = "^2.28.1"
-scikit-learn = "^1.3.2"
 scipy = "^1.8.1"
 stravalib = "^1.3.3"
 tcxreader = "^0.4.5"

geo_activity_playground-0.15.2/geo_activity_playground/core/cache_migrations.py

@@ -1,34 +0,0 @@
-import json
-import logging
-import pathlib
-
-logger = logging.getLogger(__name__)
-
-
-def delete_activities_per_tile() -> None:
-    paths = [
-        pathlib.Path("Cache/activities-per-tile.pickle"),
-        pathlib.Path("Cache/activities-per-tile-task.json"),
-    ]
-    for path in paths:
-        path.unlink(missing_ok=True)
-
-
-def apply_cache_migrations() -> None:
-    logger.info("Apply cache migration if needed …")
-    cache_status_file = pathlib.Path("Cache/status.json")
-    if cache_status_file.exists():
-        with open(cache_status_file) as f:
-            cache_status = json.load(f)
-    else:
-        cache_status = {"num_applied_migrations": 0}
-
-    migrations = [delete_activities_per_tile]
-
-    for migration in migrations[cache_status["num_applied_migrations"] :]:
-        logger.info(f"Applying cache migration {migration.__name__} …")
-        migration()
-        cache_status["num_applied_migrations"] += 1
-        cache_status_file.parent.mkdir(exist_ok=True, parents=True)
-        with open(cache_status_file, "w") as f:
-            json.dump(cache_status, f)

geo_activity_playground-0.15.2/geo_activity_playground/heatmap.py

@@ -1,92 +0,0 @@
-import logging
-import pathlib
-
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import sklearn.cluster
-
-from .core.tiles import compute_tile
-from geo_activity_playground.core.activities import ActivityRepository
-from geo_activity_playground.core.heatmap import add_margin_to_geo_bounds
-from geo_activity_playground.core.heatmap import build_heatmap_image
-from geo_activity_playground.core.heatmap import build_map_from_tiles
-from geo_activity_playground.core.heatmap import convert_to_grayscale
-from geo_activity_playground.core.heatmap import crop_image_to_bounds
-from geo_activity_playground.core.heatmap import get_bounds
-from geo_activity_playground.core.heatmap import get_sensible_zoom_level
-
-
-logger = logging.getLogger(__name__)
-
-
-def render_heatmap(
-    lat_lon_data: np.ndarray, num_activities: int, arg_zoom: int = -1
-) -> np.ndarray:
-    geo_bounds = get_bounds(lat_lon_data)
-    geo_bounds = add_margin_to_geo_bounds(geo_bounds)
-    tile_bounds = get_sensible_zoom_level(geo_bounds, (2160, 3840))
-    background = build_map_from_tiles(tile_bounds)
-    background = convert_to_grayscale(background)
-    background = 1.0 - background
-    data_color = build_heatmap_image(lat_lon_data, num_activities, tile_bounds)
-    for c in range(3):
-        background[:, :, c] = (1.0 - data_color[:, :, c]) * background[
-            :, :, c
-        ] + data_color[:, :, c]
-    background = crop_image_to_bounds(background, geo_bounds, tile_bounds)
-    return background
-
-
-def generate_heatmaps_per_cluster(repository: ActivityRepository) -> None:
-    logger.info("Gathering data points …")
-    arrays = []
-    names = []
-    for activity in repository.iter_activities():
-        df = repository.get_time_series(activity.id)
-        if "latitude" in df.columns:
-            latlon = np.column_stack([df["latitude"], df["longitude"]])
-            names.extend([activity.id] * len(df))
-            arrays.append(latlon)
-    latlon = np.row_stack(arrays)
-    del arrays
-
-    logger.info("Compute tiles for each point …")
-    tiles = [compute_tile(lat, lon, 14) for lat, lon in latlon]
-
-    unique_tiles = set(tiles)
-    unique_tiles_array = np.array(list(unique_tiles))
-
-    logger.info("Run DBSCAN cluster finding algorithm …")
-    dbscan = sklearn.cluster.DBSCAN(eps=5, min_samples=3)
-    labels = dbscan.fit_predict(unique_tiles_array)
-
-    cluster_mapping = {
-        tuple(xy): label for xy, label in zip(unique_tiles_array, labels)
-    }
-
-    all_df = pd.DataFrame(latlon, columns=["lat", "lon"])
-    all_df["cluster"] = [cluster_mapping[xy] for xy in tiles]
-    all_df["activity"] = names
-
-    del labels
-    del names
-
-    output_dir = pathlib.Path("Heatmaps")
-    output_dir.mkdir(exist_ok=True)
-    for old_image in output_dir.glob("*.png"):
-        old_image.unlink()
-
-    logger.info(f"Found {len(all_df.cluster.unique())} clusters …")
-    for i, (cluster_id, group) in enumerate(
-        sorted(all_df.groupby("cluster"), key=lambda elem: len(elem[1]), reverse=True),
-        start=1,
-    ):
-        if cluster_id == -1:
-            continue
-        logger.info(
-            f"Rendering heatmap for cluster {cluster_id} with {len(group)} elements …"
-        )
-        latlon = np.column_stack([group.lat, group.lon])
-        heatmap = render_heatmap(latlon, num_activities=len(group.activity.unique()))
-        plt.imsave(output_dir / f"Cluster-{i}.png", heatmap)