geo-activity-playground 0.10.0__tar.gz → 0.12.0__tar.gz

geo_activity_playground-0.12.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Martin Ueding
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{geo_activity_playground-0.10.0 → geo_activity_playground-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.10.0
+Version: 0.12.0
 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.0,<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.10.0 → geo_activity_playground-0.12.0}/geo_activity_playground/core/activities.py

@@ -59,14 +59,15 @@ class ActivityRepository:
             df["time"] = [start + datetime.timedelta(seconds=t) for t in time]
         assert pd.api.types.is_dtype_equal(df["time"].dtype, "datetime64[ns, UTC]")
 
-        df["distance/km"] = df["distance"] / 1000
-
-        if "speed" not in df.columns:
-            df["speed"] = (
-                df["distance"].diff()
-                / (df["time"].diff().dt.total_seconds() + 1e-3)
-                * 3.6
-            )
+        if "distance" in df.columns:
+            df["distance/km"] = df["distance"] / 1000
+
+            if "speed" not in df.columns:
+                df["speed"] = (
+                    df["distance"].diff()
+                    / (df["time"].diff().dt.total_seconds() + 1e-3)
+                    * 3.6
+                )
 
         return df
 

{geo_activity_playground-0.10.0 → geo_activity_playground-0.12.0}/geo_activity_playground/core/activity_parsers.py

@@ -159,6 +159,12 @@ def read_activity(path: pathlib.Path) -> pd.DataFrame:
         except AttributeError as e:
             print(df)
             print(df.dtypes)
+            types = {}
+            for elem in df["time"]:
+                t = str(type(elem))
+                if t not in types:
+                    types[t] = elem
+            print(types)
             raise ActivityParseError(
                 "It looks like the date parsing has gone wrong."
             ) from e

geo_activity_playground-0.12.0/geo_activity_playground/core/heatmap.py

@@ -0,0 +1,292 @@
+"""
+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 get_tile
+from geo_activity_playground.core.tiles import get_tile_upper_left_lat_lon
+from geo_activity_playground.core.tiles import latlon_to_xy
+
+
+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/task_all_points.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
+            new_shards.append(time_series[["latitude", "longitude"]])
+    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
+    lon_min: float
+    lat_max: float
+    lon_max: float
+
+
+def get_bounds(lat_lon_data: np.array) -> GeoBounds:
+    return GeoBounds(*np.min(lat_lon_data, axis=0), *np.max(lat_lon_data, axis=0))
+
+
+def add_margin(lower: float, upper: float) -> tuple[float, float]:
+    spread = upper - lower
+    margin = spread / 20
+    return max(0, lower - margin), upper + margin
+
+
+def add_margin_to_geo_bounds(bounds: GeoBounds) -> GeoBounds:
+    lat_min, lat_max = add_margin(bounds.lat_min, bounds.lat_max)
+    lon_min, lon_max = add_margin(bounds.lon_min, bounds.lon_max)
+    return GeoBounds(lat_min, lon_min, lat_max, lon_max)
+
+
+OSM_TILE_SIZE = 256  # OSM tile size in pixel
+OSM_MAX_ZOOM = 19  # OSM maximum zoom level
+MAX_TILE_COUNT = 2000  # maximum number of tiles to download
+
+
+@dataclasses.dataclass
+class TileBounds:
+    zoom: int
+    x_tile_min: int
+    x_tile_max: int
+    y_tile_min: int
+    y_tile_max: int
+
+    @property
+    def shape(self) -> tuple[int, int]:
+        return (
+            (self.y_tile_max - self.y_tile_min) * OSM_TILE_SIZE,
+            (self.x_tile_max - self.x_tile_min) * OSM_TILE_SIZE,
+        )
+
+
+def geo_bounds_from_tile_bounds(tile_bounds: TileBounds) -> GeoBounds:
+    lat_max, lon_min = get_tile_upper_left_lat_lon(
+        tile_bounds.x_tile_min, tile_bounds.y_tile_min, tile_bounds.zoom
+    )
+    lat_min, lon_max = get_tile_upper_left_lat_lon(
+        tile_bounds.x_tile_max, tile_bounds.y_tile_max, tile_bounds.zoom
+    )
+    return GeoBounds(lat_min, lon_min, lat_max, lon_max)
+
+
+def get_sensible_zoom_level(
+    bounds: GeoBounds, picture_size: tuple[int, int]
+) -> TileBounds:
+    zoom = OSM_MAX_ZOOM
+
+    while True:
+        x_tile_min, y_tile_max = map(
+            int, latlon_to_xy(bounds.lat_min, bounds.lon_min, zoom)
+        )
+        x_tile_max, y_tile_min = map(
+            int, latlon_to_xy(bounds.lat_max, bounds.lon_max, zoom)
+        )
+
+        x_tile_max += 1
+        y_tile_max += 1
+
+        if (x_tile_max - x_tile_min) * OSM_TILE_SIZE <= picture_size[0] and (
+            y_tile_max - y_tile_min
+        ) * OSM_TILE_SIZE <= picture_size[1]:
+            break
+
+        zoom -= 1
+
+    tile_count = (x_tile_max - x_tile_min) * (y_tile_max - y_tile_min)
+
+    if tile_count > MAX_TILE_COUNT:
+        raise RuntimeError("Zoom value too high, too many tiles to download")
+
+    return TileBounds(
+        zoom=zoom,
+        x_tile_min=x_tile_min,
+        x_tile_max=x_tile_max,
+        y_tile_min=y_tile_min,
+        y_tile_max=y_tile_max,
+    )
+
+
+def build_map_from_tiles(tile_bounds: TileBounds) -> np.array:
+    background = np.zeros((*tile_bounds.shape, 3))
+
+    for x in range(tile_bounds.x_tile_min, tile_bounds.x_tile_max):
+        for y in range(tile_bounds.y_tile_min, tile_bounds.y_tile_max):
+            tile = np.array(get_tile(tile_bounds.zoom, x, y)) / 255
+
+            i = y - tile_bounds.y_tile_min
+            j = x - tile_bounds.x_tile_min
+
+            background[
+                i * OSM_TILE_SIZE : (i + 1) * OSM_TILE_SIZE,
+                j * OSM_TILE_SIZE : (j + 1) * OSM_TILE_SIZE,
+                :,
+            ] = tile[:, :, :3]
+
+    return background
+
+
+def convert_to_grayscale(image: np.ndarray) -> np.ndarray:
+    image = np.sum(image * [0.2126, 0.7152, 0.0722], axis=2)
+    image = np.dstack((image, image, image))
+    return image
+
+
+def crop_image_to_bounds(
+    image: np.ndarray, geo_bounds: GeoBounds, tile_bounds: TileBounds
+) -> np.ndarray:
+    min_x, min_y = latlon_to_xy(
+        geo_bounds.lat_max, geo_bounds.lon_min, tile_bounds.zoom
+    )
+    max_x, max_y = latlon_to_xy(
+        geo_bounds.lat_min, geo_bounds.lon_max, tile_bounds.zoom
+    )
+    min_x = int((min_x - tile_bounds.x_tile_min) * OSM_TILE_SIZE)
+    min_y = int((min_y - tile_bounds.y_tile_min) * OSM_TILE_SIZE)
+    max_x = int((max_x - tile_bounds.x_tile_min) * OSM_TILE_SIZE)
+    max_y = int((max_y - tile_bounds.y_tile_min) * OSM_TILE_SIZE)
+    image = image[min_y:max_y, min_x:max_x, :]
+    return image
+
+
+def gaussian_filter(image, sigma):
+    # returns image filtered with a gaussian function of variance sigma**2
+    #
+    # input: image = numpy.ndarray
+    #        sigma = float
+    # output: image = numpy.ndarray
+
+    i, j = np.meshgrid(
+        np.arange(image.shape[0]), np.arange(image.shape[1]), indexing="ij"
+    )
+
+    mu = (int(image.shape[0] / 2.0), int(image.shape[1] / 2.0))
+
+    gaussian = (
+        1.0
+        / (2.0 * np.pi * sigma * sigma)
+        * np.exp(-0.5 * (((i - mu[0]) / sigma) ** 2 + ((j - mu[1]) / sigma) ** 2))
+    )
+
+    gaussian = np.roll(gaussian, (-mu[0], -mu[1]), axis=(0, 1))
+
+    image_fft = np.fft.rfft2(image)
+    gaussian_fft = np.fft.rfft2(gaussian)
+
+    image = np.fft.irfft2(image_fft * gaussian_fft)
+
+    return image
+
+
+def build_heatmap_image(
+    lat_lon_data: np.ndarray, num_activities: int, tile_bounds: TileBounds
+) -> np.ndarray:
+    # fill trackpoints
+    sigma_pixel = 1
+
+    data = np.zeros(tile_bounds.shape)
+
+    xy_data = latlon_to_xy(lat_lon_data[:, 0], lat_lon_data[:, 1], tile_bounds.zoom)
+    xy_data = np.array(xy_data).T
+    xy_data = np.round(
+        (xy_data - [tile_bounds.x_tile_min, tile_bounds.y_tile_min]) * OSM_TILE_SIZE
+    )  # to supertile coordinates
+
+    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)
+    )  # from https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames
+
+    # trackpoint max accumulation per pixel = 1/5 (trackpoint/meter) * res_pixel (meter/pixel) * activities
+    # (Strava records trackpoints every 5 meters in average for cycling activites)
+    m = np.round((1.0 / 5.0) * res_pixel * num_activities)
+
+    data[data > m] = m
+
+    # 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 = gaussian_filter(
+        data, float(sigma_pixel)
+    )  # kernel density estimation with normal kernel
+
+    data = (data - data.min()) / (data.max() - data.min())  # normalize to [0,1]
+
+    # colorize
+    cmap = pl.get_cmap("hot")
+
+    data_color = cmap(data)
+    data_color[data_color == cmap(0.0)] = 0.0  # remove background color
+    return data_color
+
+
+def build_heatmap_tile(lat_lon_data: np.ndarray, tile_bounds: TileBounds) -> np.ndarray:
+    xy_data = latlon_to_xy(lat_lon_data[:, 0], lat_lon_data[:, 1], tile_bounds.zoom)
+    xy_data = np.array(xy_data).T
+
+    xy_data = np.round(
+        (xy_data - [tile_bounds.x_tile_min, tile_bounds.y_tile_min]) * OSM_TILE_SIZE
+    )
+    sigma_pixel = 1
+    data = np.zeros((OSM_TILE_SIZE, OSM_TILE_SIZE))
+    for j, i in xy_data.astype(int):
+        data[
+            i - sigma_pixel : i + sigma_pixel, j - sigma_pixel : j + sigma_pixel
+        ] += 1.0
+
+    np.log(data, where=data > 0, out=data)
+    data /= 6
+    data_max = data.max()
+    if data_max > 2:
+        logger.warning(f"Maximum data in tile: {data_max}")
+    data[data > 1.0] = 1.0
+
+    # colorize
+    cmap = pl.get_cmap("hot")
+
+    data_color = cmap(data)
+    data_color[data_color == cmap(0.0)] = 0.0  # remove background color
+    return data_color

geo_activity_playground-0.12.0/geo_activity_playground/core/test_tiles.py

@@ -0,0 +1,23 @@
+from .tiles import compute_tile
+from .tiles import get_tile_upper_left_lat_lon
+from .tiles import interpolate_missing_tile
+
+
+def test_rheinbach() -> None:
+    lat, lon = 50.6202, 6.9504
+    assert compute_tile(lat, lon, 14) == (8508, 5512)
+
+
+def test_back() -> None:
+    tile_x, tile_y = 8508, 5512
+    zoom = 14
+    lat, lon = get_tile_upper_left_lat_lon(tile_x, tile_y, zoom)
+    print(lat, lon)
+    assert compute_tile(lat, lon, zoom) == (tile_x, tile_y)
+
+
+def test_interpolate() -> None:
+    assert interpolate_missing_tile(1.25, 2.25, 2.5, 1.5) == (1, 1)
+    assert interpolate_missing_tile(2.5, 1.5, 1.25, 2.25) == (1, 1)
+    assert interpolate_missing_tile(2.25, 2.5, 1.75, 1.25) == (2, 1)
+    assert interpolate_missing_tile(1.25, 2.25, 2.25, 2.5) == None

{geo_activity_playground-0.10.0 → geo_activity_playground-0.12.0}/geo_activity_playground/core/tiles.py

@@ -3,6 +3,7 @@ import logging
 import math
 import pathlib
 import time
+from typing import Optional
 
 import numpy as np
 import requests
@@ -20,6 +21,15 @@ def compute_tile(lat: float, lon: float, zoom: int) -> tuple[int, int]:
     return int(x * n), int(y * n)
 
 
+def compute_tile_float(lat: float, lon: float, zoom: int) -> tuple[int, int]:
+    x = np.radians(lon)
+    y = np.arcsinh(np.tan(np.radians(lat)))
+    x = (1 + x / np.pi) / 2
+    y = (1 - y / np.pi) / 2
+    n = 2**zoom
+    return x * n, y * n
+
+
 def get_tile_upper_left_lat_lon(
     tile_x: int, tile_y: int, zoom: int
 ) -> tuple[float, float]:
@@ -79,3 +89,19 @@ def xy_to_latlon(x: float, y: float, zoom: int) -> tuple[float, float]:
     lat_rad = np.arctan(np.sinh(np.pi * (1.0 - 2.0 * y / n)))
     lat_deg = float(np.degrees(lat_rad))
     return lat_deg, lon_deg
+
+
+def interpolate_missing_tile(
+    x1: float, y1: float, x2: float, y2: float
+) -> Optional[tuple[int, int]]:
+    # We are only interested in diagonal tile combinations, therefore we skip adjacent ones.
+    if int(x1) == int(x2) or int(y1) == int(y2):
+        return None
+
+    x_hat = int(max(x1, x2))
+    l = (x_hat - x1) / (x2 - x1)
+    y_hat = int(y1 + l * (y2 - y1))
+    if y_hat == int(y1):
+        return (int(x2), y_hat)
+    else:
+        return (int(x1), y_hat)