sibi-dst 0.3.27__py3-none-any.whl → 0.3.29__py3-none-any.whl

sibi_dst/osmnx_helper/base_osm_map.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import html
+from abc import abstractmethod
+
+import folium
+import geopandas as gpd
+import numpy as np
+import osmnx as ox
+from folium.plugins import Fullscreen
+
+
+class BaseOsmMap:
+    tile_options = {
+        "OpenStreetMap": "OpenStreetMap",
+        "CartoDB": "cartodbpositron",
+        "CartoDB Voyager": "cartodbvoyager"
+    }
+    # Set default bounds for Costa Rica
+    bounds = [[8.0340, -85.9417], [11.2192, -82.5566]]
+
+    def __init__(self, osmnx_graph=None, df=None, **kwargs):
+        if osmnx_graph is None:
+            raise ValueError('osmnx_graph must be provided')
+        if df is None:
+            raise ValueError('df must be provided')
+        if df.empty:
+            raise ValueError('df must not be empty')
+        self.df = df.copy()
+        self.osmnx_graph = osmnx_graph
+        self.lat_col = kwargs.get('lat_col', 'latitude')
+        self.lon_col = kwargs.get('lon_col', 'longitude')
+        self.osm_map = None
+        self.G = None
+        self.map_html_title = self._sanitize_html(kwargs.get('map_html_title', 'OSM Basemap'))
+
+        self.zoom_start = kwargs.pop('zoom_start', 13)
+        self.fullscreen = kwargs.pop('fullscreen', True)
+        self.fullscreen_position = kwargs.pop('fullscreen_position', 'topright')
+        self.tiles = kwargs.pop('tiles', 'OpenStreetMap')
+        self.verbose = kwargs.pop('verbose', False)
+        self.sort_keys = kwargs.pop('sort_keys', None)
+        self.dt_field = kwargs.pop('dt_field', None)
+        self.dt = None
+        self.calc_nearest_nodes = kwargs.pop('calc_nearest_nodes', False)
+        self.nearest_nodes = None
+        self.max_bounds = kwargs.pop('max_bounds', False)
+        self._prepare_df()
+        self._initialise_map()
+
+
+    def _prepare_df(self):
+        if self.sort_keys:
+            self.df.sort_values(by=self.sort_keys, inplace=True)
+        self.df.reset_index(drop=True, inplace=True)
+        self.gps_points = self.df[[self.lat_col, self.lon_col]].values.tolist()
+        if self.dt_field is not None:
+            self.dt = self.df[self.dt_field].tolist()
+
+        if self.calc_nearest_nodes:
+            self.nearest_nodes = ox.distance.nearest_nodes(self.osmnx_graph, X=self.df[self.lon_col],
+                                                           Y=self.df[self.lat_col])
+
+
+    def _initialise_map(self):
+        gps_array = np.array(self.gps_points)
+        mean_latitude = np.mean(gps_array[:, 0])
+        mean_longitude = np.mean(gps_array[:, 1])
+        self.osm_map = folium.Map(location=[mean_latitude, mean_longitude], zoom_start=self.zoom_start,
+                                  tiles=self.tiles, max_bounds=self.max_bounds)
+        north, south, east, west = self._get_bounding_box_from_points(margin=0.001)
+        self.G = self._extract_subgraph(north, south, east, west)
+
+
+    def _attach_supported_tiles(self):
+        # Normalize the default tile name to lowercase for comparison
+        normalized_default_tile = self.tiles.lower()
+
+        # Filter out the default tile layer from the options to avoid duplication
+        tile_options_filtered = {k: v for k, v in self.tile_options.items() if v.lower() != normalized_default_tile}
+
+        for tile, description in tile_options_filtered.items():
+            folium.TileLayer(name=tile, tiles=description, show=False).add_to(self.osm_map)
+
+
+    def _get_bounding_box_from_points(self, margin=0.001):
+        latitudes = [point[0] for point in self.gps_points]
+        longitudes = [point[1] for point in self.gps_points]
+
+        north = max(latitudes) + margin
+        south = min(latitudes) - margin
+        east = max(longitudes) + margin
+        west = min(longitudes) - margin
+
+        return north, south, east, west
+
+
+    def _extract_subgraph(self, north, south, east, west):
+        # Create a bounding box polygon
+        # from osmnx v2 this is how it is done
+        if ox.__version__ >= '2.0':
+            bbox_poly = gpd.GeoSeries([ox.utils_geo.bbox_to_poly(bbox=(west, south, east, north))])
+        else:
+            bbox_poly = gpd.GeoSeries([ox.utils_geo.bbox_to_poly(north, south, east, west)])
+
+        # Get nodes GeoDataFrame
+        nodes_gdf = ox.graph_to_gdfs(self.osmnx_graph, nodes=True, edges=False)
+
+        # Find nodes within the bounding box
+        nodes_within_bbox = nodes_gdf[nodes_gdf.geometry.within(bbox_poly.geometry.unary_union)]
+
+        # Create subgraph
+        subgraph = self.osmnx_graph.subgraph(nodes_within_bbox.index)
+
+        return subgraph
+
+
+    @abstractmethod
+    def process_map(self):
+        # this is to be implemented at the subclass level
+        # implement here your specific map logic.
+        ...
+
+
+    def pre_process_map(self):
+        # this is to be implemented at the subclass level
+        # call super().pre_process_map first to inherit the following behaviour
+        ...
+
+
+    def _post_process_map(self):
+        self._attach_supported_tiles()
+        self.add_tile_layer()
+        self._add_fullscreen()
+        self._add_map_title()
+        if self.max_bounds:
+            self.osm_map.fit_bounds(self.bounds)
+
+
+    def add_tile_layer(self):
+        # Override in subclass and call super().add_tile_layer at the end
+        folium.LayerControl().add_to(self.osm_map)
+
+
+    def _add_fullscreen(self):
+        if self.fullscreen:
+            Fullscreen(position=self.fullscreen_position).add_to(self.osm_map)
+
+
+    def _add_map_title(self):
+        if self.map_html_title:
+            self.osm_map.get_root().html.add_child(folium.Element(self.map_html_title))
+
+
+    @staticmethod
+    def _sanitize_html(input_html):
+        return html.escape(input_html)
+
+
+    def generate_map(self):
+        self.pre_process_map()
+        self.process_map()
+        self._post_process_map()
+
+        return self.osm_map

sibi_dst/osmnx_helper/basemaps/calendar_html.py

@@ -0,0 +1,122 @@
+
+# HTML and CSS for the calendar button and popup
+calendar_html = """
+<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/flatpickr/dist/flatpickr.min.css">
+<script src="https://cdn.jsdelivr.net/npm/flatpickr"></script>
+
+<style>
+  /* Style for the calendar button */
+  .calendar-btn {
+    background-color: white;
+    border: 1px solid gray;
+    border-radius: 3px;
+    padding: 5px;
+    font-size: 16px;
+    cursor: pointer;
+    position: fixed;  /* Changed from absolute to fixed */
+    bottom: 50px;     /* Adjust position relative to the viewport */
+    left: 10px;       /* Adjust position relative to the viewport */
+    z-index: 10000;   /* Ensure it stays on top of other elements */
+  }
+
+  /* Calendar popup with sufficient size */
+  .calendar-popup {
+    display: none;
+    position: fixed;  /* Keep the popup fixed so it stays in view */
+    bottom: 100px;
+    left: 10px;
+    background-color: white;
+    padding: 10px;
+    border: 1px solid gray;
+    border-radius: 3px;
+    z-index: 10000;   /* Ensure it stays on top of other elements */
+    width: 250px;
+    height: 300px;
+  }
+
+  /* Ensure the calendar fits properly */
+  #calendar {
+    width: 100%;
+    height: auto;
+  }
+</style>
+
+<!-- Calendar Button -->
+<div class="calendar-btn">📅 Select Date</div>
+
+<!-- Calendar Popup -->
+<div class="calendar-popup" id="calendar-popup">
+  <div id="calendar"></div>
+</div>
+
+<script>
+  // Initialize Flatpickr calendar
+  const today = new Date().toISOString().split('T')[0];
+  // Function to show the "Please wait" message
+  function showLoadingMessage() {
+    let loadingMessage = document.createElement("div");
+    loadingMessage.id = "loading-message";
+    loadingMessage.style.position = "fixed";
+    loadingMessage.style.top = "50%";
+    loadingMessage.style.left = "50%";
+    loadingMessage.style.transform = "translate(-50%, -50%)";
+    loadingMessage.style.backgroundColor = "rgba(0, 0, 0, 0.8)";
+    loadingMessage.style.color = "white";
+    loadingMessage.style.padding = "20px";
+    loadingMessage.style.borderRadius = "5px";
+    loadingMessage.style.zIndex = "9999";
+    loadingMessage.innerText = "Please wait...";
+    document.body.appendChild(loadingMessage);
+  }
+
+  // Function to remove the "Please wait" message
+  function removeLoadingMessage() {
+    let loadingMessage = document.getElementById("loading-message");
+    if (loadingMessage) {
+      loadingMessage.remove();
+    }
+  }
+
+
+  flatpickr("#calendar", {
+    inline: true,  // Render the calendar inline within the container
+    maxDate: today,  // Disable future dates
+    onChange: function(selectedDates, dateStr, instance) {
+      console.log("Selected date: " + dateStr);  // Debugging: Log the selected date
+      // Get the current URL and create a URL object to manipulate the query parameters
+      // Get the current URL from the parent window
+      showLoadingMessage();
+      let currentUrl = window.parent.location.href;
+
+      // If the URL contains "srcdoc", remove it and use the correct base path
+      if (currentUrl.includes("srcdoc")) {
+        currentUrl = currentUrl.replace("srcdoc", "");
+      }
+
+      const url = new URL(currentUrl);
+
+      // Set or update the 'date' parameter while preserving existing parameters
+      url.searchParams.set('date', dateStr);
+
+      console.log("Updated URL: " + url.toString());  // Debugging: Log the updated URL
+
+      // Update the parent window's location with the new URL
+      window.parent.location.href = url.toString();
+    }
+  });
+  // Remove the "Please wait" message once the page has finished loading
+  window.addEventListener("load", function() {
+    removeLoadingMessage();
+  });
+
+  // Toggle the calendar popup when the button is clicked
+  document.querySelector(".calendar-btn").addEventListener("click", function() {
+    var popup = document.getElementById("calendar-popup");
+    if (popup.style.display === "none" || popup.style.display === "") {
+      popup.style.display = "block";
+    } else {
+      popup.style.display = "none";
+    }
+  });
+</script>
+"""

sibi_dst/osmnx_helper/basemaps/router_plotter.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+from sibi_dst.osmnx_helper.utils import get_distance_between_points, add_arrows
+from collections import defaultdict
+import folium
+from folium.plugins import AntPath
+import networkx as nx
+
+from sibi_dst.osmnx_helper import BaseOsmMap
+from sibi_dst.osmnx_helper.basemaps.calendar_html import calendar_html
+
+class RoutePlotter(BaseOsmMap):
+    def __init__(self, osmnx_graph, df, **kwargs):
+        self.action_field = kwargs.pop('action_field', '')
+        self.action_groups = kwargs.pop('action_groups', {})
+        self.action_styles = kwargs.pop('action_styles', {})
+        self.use_ant_path = kwargs.pop('use_ant_path', True)
+        self.show_calendar = kwargs.pop('show_calendar', True)
+        self.show_map_title = kwargs.pop('show_map_title', True)
+        self.sort_keys = kwargs.pop('sort_keys', None)
+        self.main_route_layer = folium.FeatureGroup(name="Main Route")
+        self.feature_groups = {}
+        self.feature_group_counts = {}
+        self.total_distance = 0.0
+        self.actions = []
+        self.action_group_counts = {action_group: 0 for action_group in self.action_groups}
+        self.marker_count = 1
+        kwargs.update({'calc_nearest_nodes': True})
+        kwargs['dt_field'] = 'date_time'
+        super().__init__(osmnx_graph, df, **kwargs)
+
+    def pre_process_map(self):
+        super().pre_process_map()
+        self.actions = self.df[self.action_field].tolist()
+
+    def process_map(self):
+        self._calculate_routes()
+        self._plot_routes()
+        self._add_markers()
+        self.main_route_layer.add_to(self.osm_map)
+        if self.show_calendar:
+            self._add_calendar()
+
+    def _calculate_routes(self):
+        if self.verbose:
+            print("Calculating routes and markers...")
+        distances = [
+            get_distance_between_points(tuple(self.gps_points[0]), tuple(coord), 'm')
+            for coord in self.gps_points
+        ]
+        self.max_distance_index = distances.index(max(distances))
+        self.max_time_index = self.dt.index(max(self.dt))
+        self.route_polylines = []
+        self.markers = defaultdict(list)  # Store markers for action groups
+        for i in range(len(self.gps_points) - 1):
+            polyline, color, markers = self._calculate_route(i)
+            if polyline:
+                self.route_polylines.append((polyline, color))
+                for action_group, action_markers in markers.items():
+                    self.markers[action_group].extend(action_markers)
+                    self.action_group_counts[action_group] += 1
+                    self.marker_count += 1
+        if self.verbose:
+            print("Route and marker calculation complete.")
+
+        for action_group in self.action_groups:
+            count = self.action_group_counts[action_group]
+            self.feature_groups[action_group] = folium.FeatureGroup(name=f"{action_group} ({count})").add_to(
+                self.osm_map)
+            self.osm_map.add_child(self.feature_groups[action_group])
+
+    def _calculate_route(self, i):
+        if self.verbose:
+            print(f"Calculating for item:{i}")
+        orig = self.nearest_nodes[i]
+        dest = self.nearest_nodes[i + 1]
+        try:
+            route = nx.shortest_path(self.G, orig, dest, weight='length')
+            route_length = sum(self.G[u][v][0]['length'] for u, v in zip(route[:-1], route[1:]))
+            self.total_distance += route_length
+            offset = 0 if i < self.max_distance_index else 0.0005
+            lats, lons = zip(*[(self.G.nodes[node]['y'] + offset, self.G.nodes[node]['x']) for node in route])
+            color = 'blue' if i < self.max_distance_index else 'red'
+            polyline = list(zip(lats, lons))
+            markers = self._calculate_markers(i)
+            return polyline, color, markers
+        except nx.NetworkXNoPath:
+            if self.verbose:
+                print(f"Item:{i}-No path found for {orig} to {dest}")
+            return None, None, {}
+        except nx.NodeNotFound:
+            if self.verbose:
+                print(f"Item:{i}-No path found for {orig} to {dest}")
+            return None, None, {}
+
+    def _calculate_markers(self, i):
+        # Calculate markers for action groups
+        markers = defaultdict(list)
+        for action_group in self.action_groups:
+            action_indices = [idx for idx, action in enumerate(self.actions) if action == action_group]
+            for idx in action_indices:
+                if idx == i:
+                    location = self.gps_points[i]
+                    tooltip = f"Result {self.marker_count}: {action_group}<br>Date/time:{self.dt[i]}"
+                    popup_data = self._get_data(i)
+                    action_style = self.action_styles.get(action_group,
+                                                          {'color': 'blue', 'icon': 'marker', 'prefix': 'fa'})
+                    markers[action_group].append((location, tooltip, popup_data, action_style))
+        return markers
+
+    def _plot_routes(self):
+        if self.verbose:
+            print("Plotting routes and markers...")
+        # self.action_group_counts = {action_group: 0 for action_group in self.feature_groups.keys()}
+        for polyline, color in self.route_polylines:
+            if self.use_ant_path:
+                AntPath(
+                    locations=polyline,
+                    color=color,
+                    weight=3,  # Increase line thickness
+                    opacity=10,  # Increase opacity
+                    # pulse_color=color,
+                    delay=1000,  # Slower animation to reduce flickering
+                    # dash_array=[20, 30]  # Adjust dash pattern if needed
+                ).add_to(self.main_route_layer)
+            else:
+                folium.PolyLine(locations=polyline, color=color).add_to(self.main_route_layer)
+                self.osm_map = add_arrows(self.osm_map, polyline, color, n_arrows=3)
+        # Plot markers for action groups
+        for action_group, action_markers in self.markers.items():
+            for location, tooltip, popup_data, action_style in action_markers:
+                folium.Marker(
+                    location=location,
+                    popup=folium.Popup(popup_data, max_width=600),
+                    tooltip=tooltip,
+                    icon=folium.Icon(
+                        icon=action_style.get("icon"),
+                        color=action_style.get("color"),
+                        prefix=action_style.get("prefix")
+                    )
+                ).add_to(self.feature_groups[action_group])
+
+        if self.verbose:
+            print("Route and marker plotting complete.")
+
+    def _add_markers(self):
+        if self.verbose:
+            print("Adding markers...")
+        # Add start marker
+        start_popup = folium.Popup(f"Start of route at {self.dt[0]}", max_width=300)
+        folium.Marker(location=self.gps_points[0], popup=start_popup,
+                      icon=folium.Icon(icon='flag-checkered', prefix='fa')).add_to(self.osm_map)
+        # Add total distance marker at the end
+        folium.Marker(
+            self.gps_points[-1],
+            popup=f"End of Route at {self.dt[self.max_time_index]}. Total Distance Travelled: {self.total_distance / 1000:.2f} km",
+            icon=folium.Icon(color="red", icon="flag-checkered", prefix="fa")
+        ).add_to(self.osm_map)
+        if self.verbose:
+            print("Marker addition complete.")
+
+    def _add_calendar(self):
+        calendar_element = folium.Element(calendar_html)
+        self.osm_map.get_root().html.add_child(calendar_element)
+
+    def _add_map_title(self):
+        if self.map_html_title and self.show_map_title:
+            title_html = f'''
+                 <div style="position: fixed; 
+                             top: 10px; 
+                             left: 50%; 
+                             transform: translate(-50%, 0%);
+                             z-index: 9999; 
+                             font-size: 24px; 
+                             font-weight: bold; 
+                             background-color: white; 
+                             padding: 10px; 
+                             border: 2px solid black;
+                             border-radius: 5px;">
+                    {self.map_html_title}
+                 </div>
+                 '''
+            self.osm_map.get_root().html.add_child(folium.Element(title_html))
+
+    def _get_data(self, index):
+        # implement in subclass to populate popups
+        ...