Merge pull request #175 from clintonsteiner/NREL#166_automatically_download_road_network_if_doesnt_exist

#166 automatically download road network if doesnt exist

Author: nreinicke

nrel/hive/initialization/initialize_simulation.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import csv
 import functools as ft
 import logging
@@ -37,7 +38,6 @@
 
 log = logging.getLogger(__name__)
 
-
 # All initialization functions must adhere to the following type signature.
 # These functions are called to initialize the simulation state and the environment
 # and are abstracted such that an external init function can be added to enable custom
@@ -227,7 +227,10 @@ def default_init_functions() -> Iterable[InitFunction]:
 
 
 def osm_init_function(
-    config: HiveConfig, simulation_state: SimulationState, environment: Environment
+    config: HiveConfig,
+    simulation_state: SimulationState,
+    environment: Environment,
+    cache_dir=Path.home(),
 ) -> Tuple[SimulationState, Environment]:
     """
     Initialize an OSMRoadNetwork and add to the simulation
@@ -240,14 +243,34 @@ def osm_init_function(
 
     :raises Exception: from IOErrors parsing the road network
     """
-    if config.input_config.road_network_file is None:
-        raise IOError("Must supply a road network file when using the osm_network")
 
-    road_network = OSMRoadNetwork.from_file(
-        sim_h3_resolution=config.sim.sim_h3_resolution,
-        road_network_file=Path(config.input_config.road_network_file),
-        default_speed_kmph=config.network.default_speed_kmph,
-    )
+    if config.input_config.road_network_file:
+        road_network = OSMRoadNetwork.from_file(
+            sim_h3_resolution=config.sim.sim_h3_resolution,
+            road_network_file=config.input_config.road_network_file,
+            default_speed_kmph=config.network.default_speed_kmph,
+        )
+    elif config.input_config.geofence_file:
+        try:
+            import geopandas
+        except ImportError as e:
+            raise ImportError(
+                "Must have geopandas installed if you want to load from geofence file"
+            ) from e
+
+        dataframe = geopandas.read_file(config.input_config.geofence_file)
+        polygon_union = dataframe["geometry"].unary_union
+
+        road_network = OSMRoadNetwork.from_polygon(
+            sim_h3_resolution=config.sim.sim_h3_resolution,
+            default_speed_kmph=config.network.default_speed_kmph,
+            polygon=polygon_union,
+            cache_dir=cache_dir,
+        )
+    else:
+        raise IOError(
+            "Must supply either a road network or geofence file when using the osm_network"
+        )
 
     sim_w_osm = simulation_state._replace(road_network=road_network)
 

nrel/hive/model/roadnetwork/osm/osm_builders.py

@@ -1,4 +1,7 @@
-def osm_graph_from_polygon(polygon):
+from typing import TYPE_CHECKING
+
+
+def osm_graph_from_polygon(polygon, cache_folder):
     """
     builds a OSM networkx graph using a shapely polygon and the osmnx package
     """
@@ -10,6 +13,7 @@ def osm_graph_from_polygon(polygon):
         ) from e
 
     ox.settings.all_oneway = True
+    ox.settings.cache_folder = cache_folder
 
     G = ox.graph_from_polygon(polygon, network_type="drive")
 

nrel/hive/model/roadnetwork/osm/osm_roadnetwork.py

@@ -99,6 +99,7 @@ def from_polygon(
         polygon,
         sim_h3_resolution: H3Resolution = 15,
         default_speed_kmph: Kmph = 40.0,
+        cache_dir=Path.home(),
     ) -> OSMRoadNetwork:
         """
         Build an OSMRoadNetwork from a shapely polygon
@@ -107,7 +108,7 @@ def from_polygon(
         :param sim_h3_resolution: The h3 resolution of the simulation
         :param default_speed_kmph: The network will fill in missing speed values with this
         """
-        graph = osm_graph_from_polygon(polygon)
+        graph = osm_graph_from_polygon(polygon, cache_dir)
         return OSMRoadNetwork(graph, sim_h3_resolution, default_speed_kmph)
 
     @classmethod

tests/test_initialize_simulation.py

@@ -1,7 +1,12 @@
-from unittest import TestCase
+import unittest
 
 from nrel.hive.config.network import Network
-from nrel.hive.initialization.initialize_simulation import initialize, default_init_functions
+from nrel.hive.initialization.load import load_simulation
+from nrel.hive.initialization.initialize_simulation import (
+    initialize,
+    default_init_functions,
+    osm_init_function,
+)
 from nrel.hive.initialization.initialize_simulation_with_sampling import (
     initialize_simulation_with_sampling,
 )
@@ -10,7 +15,7 @@
 import nrel.hive.state.simulation_state.simulation_state_ops as sso
 
 
-class TestInitializeSimulation(TestCase):
+class TestInitializeSimulation(unittest.TestCase):
     def test_initialize_simulation(self):
         conf = mock_config().suppress_logging()
 
@@ -79,3 +84,34 @@ def test_initialize_simulation_with_sampling(self):
         self.assertEqual(len(sim.vehicles), 20, "should have loaded 20 vehicles")
         self.assertEqual(len(sim.stations), 4, "should have loaded 4 stations")
         self.assertEqual(len(sim.bases), 2, "should have loaded 2 bases")
+
+    @unittest.skip("makes API call to OpenStreetMaps via osmnx")
+    def test_initialize_simulation_load_from_geofence_file(self):
+        """Move this to long running if it gets to be out of hand"""
+        conf = (
+            mock_config()
+            ._replace(
+                network=Network(
+                    network_type="osm_network",
+                    default_speed_kmph=40,
+                )
+            )
+            .suppress_logging()
+        )
+
+        new_input = conf.input_config._replace(
+            geofence_file=Path(
+                resource_filename(
+                    "nrel.hive.resources.scenarios.denver_downtown.geofence",
+                    "downtown_denver.geojson",
+                )
+            ),
+            road_network_file=None,
+        )
+
+        conf = conf._replace(input_config=new_input)
+
+        runnerPayload = load_simulation(
+            config=conf,
+        )
+        self.assertIsNotNone(runnerPayload.s.road_network)