geo-activity-playground 0.16.0__tar.gz → 0.16.2__tar.gz

{geo_activity_playground-0.16.0 → geo_activity_playground-0.16.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geo-activity-playground
-Version: 0.16.0
+Version: 0.16.2
 Summary: Analysis of geo data activities like rides, runs or hikes.
 License: MIT
 Author: Martin Ueding

{geo_activity_playground-0.16.0 → geo_activity_playground-0.16.2}/geo_activity_playground/core/activity_parsers.py

@@ -1,8 +1,7 @@
 import datetime
 import gzip
-import os
+import logging
 import pathlib
-import tempfile
 import xml
 
 import dateutil.parser
@@ -12,6 +11,8 @@ import pandas as pd
 import tcxreader.tcxreader
 import xmltodict
 
+logger = logging.getLogger(__name__)
+
 
 class ActivityParseError(BaseException):
     pass
@@ -45,7 +46,7 @@ def read_activity(path: pathlib.Path) -> pd.DataFrame:
     elif file_type in [".kml", ".kmz"]:
         df = read_kml_activity(path, opener)
     else:
-        raise ActivityParseError(f"Unsupported file format with {path=}: {file_type}")
+        raise ActivityParseError(f"Unsupported file format: {file_type}")
 
     if len(df):
         try:
@@ -161,10 +162,11 @@ def read_tcx_activity(path: pathlib.Path, open) -> pd.DataFrame:
     with open(path, "rb") as f:
         content = f.read().strip()
 
-    with tempfile.NamedTemporaryFile("wb", dir=os.getcwd(), 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.0 → geo_activity_playground-0.16.2}/geo_activity_playground/core/heatmap.py

@@ -176,52 +176,3 @@ def gaussian_filter(image, sigma):
     image = np.fft.irfft2(image_fft * gaussian_fft)
 
     return image
-
-
-def build_heatmap_image(
-    xy_data: np.ndarray,
-    mean_latitude: float,
-    num_activities: int,
-    tile_bounds: TileBounds,
-) -> np.ndarray:
-    assert xy_data.shape[1] == 2
-
-    data = np.zeros(tile_bounds.shape)
-
-    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
-    )
-
-    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(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
-    # (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])]
-
-    data = gaussian_filter(data, float(sigma_pixel))
-
-    data = (data - data.min()) / (data.max() - data.min())
-
-    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.16.0 → geo_activity_playground-0.16.2}/geo_activity_playground/importers/directory.py

@@ -45,6 +45,9 @@ def import_from_directory() -> None:
             traceback.print_exc()
             paths_with_errors.append((path, str(e)))
             continue
+        except:
+            logger.error(f"Encountered a problem with {path=}, see details below.")
+            raise
 
         work_tracker.mark_done(activity_id)
 

{geo_activity_playground-0.16.0 → geo_activity_playground-0.16.2}/geo_activity_playground/webui/explorer_controller.py

@@ -122,20 +122,20 @@ def get_three_color_tiles(
     else:
         square_geojson = "{}"
 
+    try:
+        feature_collection = geojson.FeatureCollection(
+            features=[
+                make_explorer_tile(x, y, v, zoom) for (x, y), v in tile_dict.items()
+            ]
+        )
+        explored_geojson = geojson.dumps(feature_collection)
+    except TypeError as e:
+        logger.error(f"Encountered TypeError while building GeoJSON: {e=}")
+        logger.error(f"{tile_dict = }")
+        raise
+
     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()
-                ]
-            )
-        ),
+        "explored_geojson": explored_geojson,
         "max_cluster_size": max_cluster_size,
         "num_cluster_tiles": num_cluster_tiles,
         "num_tiles": len(tile_dict),

{geo_activity_playground-0.16.0 → geo_activity_playground-0.16.2}/geo_activity_playground/webui/heatmap_controller.py

@@ -13,10 +13,7 @@ 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
@@ -69,7 +66,7 @@ class HeatmapController:
             }
         }
 
-    def render_tile(self, x: int, y: int, z: int) -> bytes:
+    def _render_tile_image(self, x: int, y: int, z: int) -> np.ndarray:
         tile_pixels = (OSM_TILE_SIZE, OSM_TILE_SIZE)
         tile_count_cache_path = pathlib.Path(f"Cache/Heatmap/{z}/{x}/{y}.npy")
         if tile_count_cache_path.exists():
@@ -115,47 +112,30 @@ class HeatmapController:
             map_tile[:, :, c] = (1.0 - data_color[:, :, c]) * map_tile[
                 :, :, c
             ] + data_color[:, :, c]
+        return map_tile
 
+    def render_tile(self, x: int, y: int, z: int) -> bytes:
         f = io.BytesIO()
-        pl.imsave(f, map_tile, format="png")
+        pl.imsave(f, self._render_tile_image(x, y, z), 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]
+        tile_bounds = get_sensible_zoom_level(geo_bounds, (4000, 4000))
 
-        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)
+        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,
+                    :,
+                ] = self._render_tile_image(x, y, tile_bounds.zoom)
 
         f = io.BytesIO()
         pl.imsave(f, background, format="png")

{geo_activity_playground-0.16.0 → geo_activity_playground-0.16.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "geo-activity-playground"
-version = "0.16.0"
+version = "0.16.2"
 description = "Analysis of geo data activities like rides, runs or hikes."
 authors = ["Martin Ueding <mu@martin-ueding.de>"]
 license = "MIT"