def test_network_saving_loading():
# save/load graph as shapefile and graphml file
G = ox.graph_from_place('Piedmont, California, USA')
G_projected = ox.project_graph(G)
ox.save_graph_shapefile(G_projected)
ox.save_graphml(G_projected)
ox.save_graphml(G_projected, filename='gephi.graphml', gephi=True)
G2 = ox.load_graphml('graph.graphml')
G3 = ox.load_graphml('graph.graphml', node_type=str)
# convert graph to node/edge GeoDataFrames and back again
gdf_edges = ox.graph_to_gdfs(G, nodes=False, edges=True, fill_edge_geometry=False)
gdf_nodes, gdf_edges = ox.graph_to_gdfs(G, nodes=True, edges=True, node_geometry=True, fill_edge_geometry=True)
G4 = ox.gdfs_to_graph(gdf_nodes, gdf_edges)
# find graph nodes nearest to some set of points
X = gdf_nodes['x'].head()
Y = gdf_nodes['y'].head()
nn1 = ox.get_nearest_nodes(G, X, Y)
nn2 = ox.get_nearest_nodes(G, X, Y, method='kdtree')
nn3 = ox.get_nearest_nodes(G, X, Y, method='balltree')
# find graph edges nearest to some set of points
ne1 = ox.get_nearest_edges(G, X, Y)
ne2 = ox.get_nearest_edges(G, X, Y, method='kdtree')
ne3 = ox.get_nearest_edges(G, X, Y, method='kdtree', dist=50)
def test_network_saving_loading():
# save/load graph as shapefile and graphml file
G = ox.graph_from_place('Piedmont, California, USA')
G_projected = ox.project_graph(G)
ox.save_graph_shapefile(G_projected)
ox.save_graphml(G_projected)
ox.save_graphml(G_projected, filename='gephi.graphml', gephi=True)
G2 = ox.load_graphml('graph.graphml')
# convert graph to node/edge GeoDataFrames and back again
gdf_edges = ox.graph_to_gdfs(G,
nodes=False,
edges=True,
fill_edge_geometry=False)
gdf_nodes, gdf_edges = ox.graph_to_gdfs(G,
nodes=True,
edges=True,
node_geometry=True,
fill_edge_geometry=True)
G3 = ox.gdfs_to_graph(gdf_nodes, gdf_edges)
# find graph nodes nearest to some set of points
X = gdf_nodes['x'].head()
Y = gdf_nodes['y'].head()
nn1 = ox.get_nearest_nodes(G, X, Y)
nn2 = ox.get_nearest_nodes(G, X, Y, method='kdtree')
nn3 = ox.get_nearest_nodes(G, X, Y, method='balltree')
def test_find_nearest():
# get graph
G = ox.graph_from_point(location_point, dist=500, network_type="drive")
# convert graph to node/edge GeoDataFrames and back again
gdf_nodes, gdf_edges = ox.graph_to_gdfs(
G, nodes=True, edges=True, node_geometry=True, fill_edge_geometry=True
)
assert len(gdf_nodes) == len(G)
assert len(gdf_edges) == len(G.edges(keys=True))
G = ox.graph_from_gdfs(gdf_nodes, gdf_edges)
assert len(gdf_nodes) == len(G)
assert len(gdf_edges) == len(G.edges(keys=True))
# get nearest node
nn, d = ox.get_nearest_node(G, location_point, method="euclidean", return_dist=True)
# get nearest nodes: haversine, kdtree, balltree
X = gdf_nodes["x"].head()
Y = gdf_nodes["y"].head()
nn1 = ox.get_nearest_nodes(G, X, Y)
nn2 = ox.get_nearest_nodes(G, X, Y, method="kdtree")
nn3 = ox.get_nearest_nodes(G, X, Y, method="balltree")
# get nearest edge
u, v, k, g, d = ox.get_nearest_edge(G, location_point, return_geom=True, return_dist=True)
# get nearest edges: haversine, kdtree, balltree
ne1 = ox.get_nearest_edges(G, X, Y)
ne2 = ox.get_nearest_edges(G, X, Y, method="kdtree")
ne3 = ox.get_nearest_edges(G, X, Y, method="balltree", dist=0.0001)
def import_networks(networks, topology, tesselation):
"""
Import the transportation networks into an empty topology.
:param networks: a dictionary of transport networks as returned by
:py:func:`fetch_osm_data`.
:param topology: a topology instance.
:param tesselation: plane tesselation.
"""
# We process the networks one by one. Pedestrian paths, bike paths
# and roads need only a simple downsampling.
walk_network = None
for transport_type in TRANSPORT_TO_NETWORK:
network = downsample_network(tesselation, networks[transport_type])
copy_network_to_topology(transport_type, network, topology)
if transport_type == TransportType.WALK:
walk_network = network
# Public transport routes are a bit different. While they go
# through the same points on the map as the previously processed
# networks, they should not go through the same graph nodes. They
# exist in a parallel plane in some sense, and you can enter that
# plain only at specific points -- the public transportation
# platforms. In those points we will create a zero-length
# connection between the node on the route and the node on the
# path.
locations = []
for layer, transport_type in enumerate(TRANSPORT_TO_ROUTE, start=1):
if transport_type not in networks:
continue
transport_network = combine_network_lines(networks[transport_type])
offset = layer * tesselation.ncells
platforms = extract_platforms(transport_network)
transport_network = downsample_network(tesselation,
transport_network,
offset=offset)
copy_network_to_topology(transport_type, transport_network, topology)
px = [p["x"] for p in platforms]
py = [p["y"] for p in platforms]
transport_nodes = osmnx.get_nearest_nodes(transport_network, px, py)
walk_nodes = osmnx.get_nearest_nodes(walk_network, px, py)
for tn, wn, platform in zip(transport_nodes, walk_nodes, platforms):
with contextlib.suppress(RuntimeError):
topology.add_edge(tn, wn, TransportType.WALK, distance=0)
location = extract_route_location(platform)
location["node"] = tn
locations.append(location)
return locations
def assign_osm(dataframe, mode='all'):
"""Assigns an OSM node by taking the average location of the two datasets and finding the nearest node present in the
mode layer.
Parameters
----------
dataframe : pandas DataFrame
The data records to be used to find the nearest OSM node
mode : str
Mode choice of {‘walk’, ‘bike’, ‘drive’, ‘drive_service’, ‘all’, ‘all_private’, ‘none’}
Returns
-------
df_osm_location : pandas DataFrame
Data records with the OSM ID of the nearest node and its respective lat/lon
"""
max_lat = dataframe[['lat1', 'lat2']].max().max()
min_lat = dataframe[['lat1', 'lat2']].min().min()
max_lon = dataframe[['lon1', 'lon2']].max().max()
min_lon = dataframe[['lon1', 'lon2']].min().min()
osm_layer = osm_download.download_osm_layer([max_lat, min_lat, max_lon, min_lon], mode)
osm_nodes = pd.DataFrame([[node[0], node[1]['y'], node[1]['x']] for node in osm_layer.nodes(data=True)],
columns=['osm_id', 'lat', 'lon']).set_index('osm_id')
dataframe['avg_lat'] = dataframe[['lat1', 'lat2']].mean(axis=1)
dataframe['avg_lon'] = dataframe[['lon1', 'lon2']].mean(axis=1)
nearest_node = ox.get_nearest_nodes(osm_layer, dataframe['avg_lon'], dataframe['avg_lat'], method='balltree')
dataframe['osm_id'] = nearest_node
df_osm_location = dataframe.join(osm_nodes, on=['osm_id']).drop(columns=['lat1', 'lon1', 'lat2', 'lon2', 'avg_lat', 'avg_lon'])
return df_osm_location
def get_nearest_streetnames(location_tuple, distFromPoint=50):
"""This function retrieves the nearest streets of a coordinate tuple (lat, lon). Currently set to drive network. Edit the parameters in line 40 to fit your preferences."""
try:
G = ox.graph_from_point(location_tuple,
network_type='drive',
distance=distFromPoint)
G = ox.project_graph(G)
ints = ox.clean_intersections(G)
gdf = gpd.GeoDataFrame(ints, columns=['geometry'], crs=G.graph['crs'])
X = gdf['geometry'].map(lambda pt: pt.coords[0][0])
Y = gdf['geometry'].map(lambda pt: pt.coords[0][1])
nodes = ox.get_nearest_nodes(G, X, Y, method='kdtree')
streetnames = []
for n in nodes:
for nbr in nx.neighbors(G, n):
for d in G.get_edge_data(n, nbr).values():
if 'name' in d:
if type(d['name']) == str:
streetnames.append(d['name'])
elif type(d['name']) == list:
for name in d['name']:
streetnames.append(name)
streetnames = list(set(streetnames))
except:
streetnames = []
return streetnames
def localisations_nearest_nodes(self, x_coordinates, y_coordinates, method="balltree"):
# convert coordinate lists to np.array
x_array = np.array(x_coordinates, dtype=np.float32)
y_array = np.array(y_coordinates, dtype=np.float32)
# we use osmnx get_nearest_nodes function, with method='balltree' [uses scikit_learn]
return ox.get_nearest_nodes(self.graph, x_array, y_array, method=method)
def map_matching_node(
move_data: Union[PandasMoveDataFrame, DaskMoveDataFrame, PandasDiscreteMoveDataFrame],
inplace: Optional[bool] = True,
bbox: Optional[Tuple[float, float, float, float]] = None,
place: Optional[Text] = None,
G: Optional[MultiDiGraph] = None
) -> Optional[DataFrame]:
"""
Generate Map matching using the graph nodes
Parameters
----------
move_data : MoveDataFrame
The input trajectories data
inplace: bool, optional
if set to true the original dataframe will be altered,
otherwise the alteration will be made in a copy, that will be returned,
by default True
bbox : tuple, optional
The bounding box as (north, east, south, west), by default None
place : string, optional
The query to geocode to get place boundary polygon, by default None
G : MultiDiGraph, optional
The input graph, by default None
Returns
-------
move_data : MoveDataFrame
A copy of the original dataframe or None
"""
if(G is None):
if(bbox is None):
bbox = move_data.get_bbox()
G = ox.graph_from_bbox(
bbox[0], bbox[2], bbox[1], bbox[3], network_type='all_private'
)
elif(place is not None):
G = ox.footprints_from_place(query=place, tags={'network_type': 'all_private'})
if not inplace:
move_data = move_data[:]
nodes = ox.get_nearest_nodes(
G, X=move_data['lon'], Y=move_data['lat'], method='kdtree'
)
gdf_nodes = ox.graph_to_gdfs(G, edges=False)
df_nodes = gdf_nodes.loc[nodes]
move_data['lat'] = list(df_nodes.y)
move_data['lon'] = list(df_nodes.x)
move_data['geometry'] = list(df_nodes.geometry)
if not inplace:
return move_data
def generate_distances(move_data: DataFrame,
inplace: Optional[bool] = False) -> Optional[DataFrame]:
"""Use generate columns distFromTrajStartToCurrPoint and edgeDistance.
Parameters
----------
move_data : dataframe
The input trajectories data
inplace: boolean, optional
if set to true the original dataframe will be altered,
otherwise the alteration will be made in a copy, that will be returned,
by default True
Returns
-------
DataFrame
A copy of the original dataframe or None
"""
if not inplace:
move_data = move_data.copy()
bbox = move_data.get_bbox()
G = ox.graph_from_bbox(bbox[0], bbox[2], bbox[1], bbox[3])
nodes = ox.get_nearest_nodes(G,
X=move_data['lon'],
Y=move_data['lat'],
method='kdtree')
distances = []
edgeDistance = []
dist = 0.0
node_ant = nodes[0]
distances.append(dist)
edgeDistance.append(dist)
gdf_edges = ox.graph_to_gdfs(G, nodes=False)
for node in nodes[1:]:
df_u = gdf_edges[gdf_edges.index.get_level_values('u') == node_ant]
df_edge = df_u[df_u.index.get_level_values('v') == node]
if (len(df_edge) == 0):
dist += 0
edgeDistance.append(dist)
else:
dist += df_edge['length'].values[0]
edgeDistance.append(df_edge['length'].values[0])
distances.append(dist)
node_ant = node
move_data['edgeDistance'] = edgeDistance
move_data['distFromTrajStartToCurrPoint'] = distances
if not inplace:
return move_data
def connections(place):
'''
inputs - textual query specifying spatial boundaries of some geocodeable place(s)
returns - tuples of street intersections using OSM data
'''
# Create a networkx graph from OSM data within the spatial boundaries of geocodable place(s).
G = ox.graph_from_place(place, network_type='drive', timeout=3600)
# Project a graph from lat-long to the UTM zone appropriate for its geographic location.
# https://en.wikipedia.org/wiki/Universal_Transverse_Mercator_coordinate_system
Gp = ox.project_graph(G)
# Clean-up intersections comprising clusters of nodes by merging them and returning their centroids
ints = ox.clean_intersections(Gp)
# create a dataframe of intersections
gdf = gpd.GeoDataFrame(ints, columns=['geometry'], crs=Gp.graph['crs'])
# generate lists of X, Y locations (UTM zone)
X = gdf['geometry'].map(lambda pt: pt.coords[0][0])
Y = gdf['geometry'].map(lambda pt: pt.coords[0][1])
nodes = ox.get_nearest_nodes(Gp, X, Y, method='kdtree')
connections = {}
intersections = []
for n in nodes:
dict = {
'osmid': G.nodes()[n]['osmid'],
'latitude': G.nodes()[n]['y'],
'longitude': G.nodes()[n]['x']
}
# print(dict)
connections[n] = set([])
for nbr in nx.neighbors(G, n):
for d in G.get_edge_data(n, nbr).values():
if 'name' in d:
if type(d['name']) == str:
connections[n].add(d['name'])
elif type(d['name']) == list:
for name in d['name']:
connections[n].add(name)
else:
connections[n].add(None)
else:
connections[n].add(None)
if len(connections) > 0:
dict['streets'] = list(connections[n])
print(dict)
intersections.append(dict)
return intersections
def pt_network(G, G_s):
'''
Create a public transportation network matching the bus stops to the clossest intersection to be used in the analysis of multilayer urban networks.
Parameters
------
G: networkx MultiDiGraph
Public transport graph generated from a GTF with peartree
G_s: networkx MultiDiGraph
Streets network, generated using OSMnx
Returns
------
G_pt: networkx MultiDigraph
Graph where the nodes are the clossest street intersections to bus stops and the edges the public transportation routes
'''
G_pt = copy.deepcopy(G_s)
G = pt.reproject(G, to_epsg=4326)
G_s = pt.reproject(G_s, to_epsg=4326)
# 1.- Get a list of nodes, x's and y's
nodes = []
x_s = []
y_s = []
for n, data in G.nodes(data=True):
nodes.append(n)
x_s.append(data['x'])
y_s.append(data['y'])
# Get the closest intersections as a numpy array of ID's
match_nodes = ox.get_nearest_nodes(G_s, x_s, y_s, method='kdtree')
# Pair the bus stop with its closest intersection
pairs = {}
for i, i_s in zip(nodes, match_nodes):
pairs[i] = i_s
# Remove all the edges from the public transport graph
G_pt.remove_edges_from(list(G_pt.edges()))
# Remove the unmatched intersections
remove = [i for i in G_pt.nodes() if i not in match_nodes]
G_pt.remove_nodes_from(remove)
# Add the bus routes (edges)
edges = [(pairs[i], pairs[j], d) for i, j, d in G.edges(data=True)
if pairs[i] != pairs[j]]
G_pt.add_edges_from(edges)
for i, j, data in G_pt.edges(data=True):
data['oneway'] = False
return G_pt
def test_find_nearest():
# get graph
G = ox.graph_from_point(location_point, dist=500, network_type="drive")
# get nearest node
nn, d = ox.get_nearest_node(G, location_point, method="euclidean", return_dist=True)
# get nearest nodes: haversine, kdtree, balltree
gdf_nodes = ox.graph_to_gdfs(G, edges=False)
X = gdf_nodes["x"].head()
Y = gdf_nodes["y"].head()
nn1, dist1 = ox.get_nearest_nodes(G, X, Y, return_dist=True)
nn2, dist2 = ox.get_nearest_nodes(G, X, Y, method="kdtree", return_dist=True)
nn3, dist3 = ox.get_nearest_nodes(G, X, Y, method="balltree", return_dist=True)
nn4 = ox.get_nearest_nodes(G, X, Y)
nn5 = ox.get_nearest_nodes(G, X, Y, method="kdtree")
nn6 = ox.get_nearest_nodes(G, X, Y, method="balltree")
# get nearest edge
u, v, k, g, d = ox.get_nearest_edge(G, location_point, return_geom=True, return_dist=True)
# get nearest edges: haversine, kdtree, balltree
ne1 = ox.get_nearest_edges(G, X, Y)
ne2 = ox.get_nearest_edges(G, X, Y, method="kdtree")
ne3 = ox.get_nearest_edges(G, X, Y, method="balltree", dist=0.0001)
def test_find_nearest():
# get graph and x/y coords to search
G = ox.graph_from_point(location_point, dist=500, network_type="drive")
Gp = ox.project_graph(G)
points = ox.utils_geo.sample_points(ox.get_undirected(Gp), 5)
X = points.x
Y = points.y
# get nearest node
nn, d = ox.get_nearest_node(Gp, location_point, method="euclidean", return_dist=True)
nn = ox.get_nearest_node(Gp, location_point, method="euclidean", return_dist=False)
# get nearest nodes
nn1, dist1 = ox.get_nearest_nodes(G, X, Y, return_dist=True)
nn2, dist2 = ox.get_nearest_nodes(Gp, X, Y, method="kdtree", return_dist=True)
nn3, dist3 = ox.get_nearest_nodes(G, X, Y, method="balltree", return_dist=True)
nn4 = ox.get_nearest_nodes(G, X, Y)
nn5 = ox.get_nearest_nodes(Gp, X, Y, method="kdtree")
nn6 = ox.get_nearest_nodes(G, X, Y, method="balltree")
# get nearest edge
u, v, k, g, d = ox.get_nearest_edge(Gp, location_point, return_geom=True, return_dist=True)
u, v, k, g = ox.get_nearest_edge(Gp, location_point, return_geom=True)
u, v, k, d = ox.get_nearest_edge(Gp, location_point, return_dist=True)
u, v, k = ox.get_nearest_edge(Gp, location_point)
# get nearest edges
ne0 = ox.distance.nearest_edges(Gp, X, Y, interpolate=50)
ne1 = ox.get_nearest_edges(Gp, X, Y)
ne2 = ox.get_nearest_edges(Gp, X, Y, method="kdtree")
ne3 = ox.get_nearest_edges(G, X, Y, method="balltree", dist=0.0001)
def find_nearest_nodes_in_network(road_network,
tdf,
return_tdf_with_new_col=False):
"""Map-matching.
For each point in a TrajDataFrame, it finds the nearest node in a road network.
Parameters:
----------
road_network : networkx MultiDiGraph
the road network on which to map the points.
tdf : TrajDataFrame
the trajectories of the individuals.
return_tdf_with_new_col : boolean
if False (default), returns the list of the nearest nodes (as OSM IDs);
if True, returns a copy of the original TrajDataFrame with one more column called 'node_id'.
Returns
-------
list (if return_tdf_with_new_col = True)
list of the nearest nodes.
TrajDataFrame (if return_tdf_with_new_col = False)
the TrajDataFrame with 1 more column collecting the nearest node's ID for each point.
"""
tdf.sort_by_uid_and_datetime()
# extracting arrays of lat and lng for the vehicle:
vec_of_longitudes = np.array(tdf['lng'])
vec_of_latitudes = np.array(tdf['lat'])
# for each (lat,lon), find the nearest node in the road network:
list_of_nearest_nodes = ox.get_nearest_nodes(road_network,
X=vec_of_longitudes,
Y=vec_of_latitudes,
method='balltree')
###
# method (str {None, 'kdtree', 'balltree'}) – Which method to use for finding nearest node to each point.
# If None, we manually find each node one at a time using osmnx.utils.get_nearest_node and haversine.
# If ‘kdtree’ we use scipy.spatial.cKDTree for very fast euclidean search.
# If ‘balltree’, we use sklearn.neighbors.BallTree for fast haversine search.
###
if return_tdf_with_new_col:
tdf_with_nearest_nodes = tdf.copy() #.drop(columns=['lat', 'lng'])
tdf_with_nearest_nodes['node_id'] = list_of_nearest_nodes
return tdf_with_nearest_nodes
return list_of_nearest_nodes
def load_trips(G, path_to_trips, polygon=None):
"""
Loads the trips and maps lat/long of start and end station to node in
graph G.
:param G: graph used vor lat/long to node mapping
:param path_to_trips: path to the compacted trips csv.
:type path_to_trips: str
:param polygon: If only trips inside a polygon should be considered,
pass it here.
:type polygon: Shapely Polygon
:return: dict with trip info and set of stations used.
trip_nbrs structure: key=(origin node, end node), value=# of cyclists
"""
nn_method = 'kdtree'
nbr_of_trips, start_lat, start_long, end_lat, end_long = \
get_lat_long_trips(path_to_trips, polygon)
start_nodes = list(
ox.get_nearest_nodes(G, start_long, start_lat, method=nn_method))
end_nodes = list(
ox.get_nearest_nodes(G, end_long, end_lat, method=nn_method))
trip_nbrs = {}
for trip in range(len(nbr_of_trips)):
trip_nbrs[(int(start_nodes[trip]), int(end_nodes[trip]))] = \
int(nbr_of_trips[trip])
stations = set()
for k, v in trip_nbrs.items():
stations.add(k[0])
stations.add(k[1])
print('Number of trips: {}'.format(sum(trip_nbrs.values())))
return trip_nbrs, stations
def find_nearest(G, gdf, amenity_name):
"""
Find the nearest graph nodes to the points in a GeoDataFrame
Arguments:
G {networkx.Graph} -- Graph created with OSMnx that contains geographic information (Lat,Lon, etc.)
gdf {geopandas.GeoDataFrame} -- GeoDataFrame with the points to locate
amenity_name {str} -- string with the name of the amenity that is used as seed (pharmacy, hospital, shop, etc.)
Returns:
geopandas.GeoDataFrame -- GeoDataFrame original dataframe with a new column call 'nearest' with the node id closser to the point
"""
gdf['x'] = gdf['geometry'].apply(lambda p: p.x)
gdf['y'] = gdf['geometry'].apply(lambda p: p.y)
gdf[f'nearest_{amenity_name}'] = ox.get_nearest_nodes(
G, list(gdf['x']), list(gdf['y']))
return gdf
def ksi_data_preprocessing(G, filter_df):
ksi_df = gpd.read_file("https://opendata.arcgis.com/datasets/cc17cc27ee5a4989b78d9a3810c6c007_0.geojson")
ksi_df["INJ_INDEX"] = ksi_df["INJURY"].apply(lambda x: assign_injury_index(x))
index_df = ksi_df[["ACCNUM", "INJ_INDEX"]].groupby(by="ACCNUM").sum()
cols_to_keep = ["LATITUDE", "LONGITUDE", "ACCNUM", "YEAR", "TIME", "VISIBILITY", "LIGHT", "RDSFCOND"]
ksi_df = ksi_df[cols_to_keep]
fatalities = ksi_df["ACCNUM"].value_counts()
ksi_df["FATALITIES"] = ksi_df["ACCNUM"].apply(lambda x : fatalities[x])
ksi_df = ksi_df.drop_duplicates()
ksi_df.reset_index(drop=True, inplace=True)
ksi_df["G_NODE"]= ox.get_nearest_nodes(G, ksi_df["LONGITUDE"], ksi_df["LATITUDE"], method="balltree")
ksi_df.drop(["LATITUDE", "LONGITUDE"], axis=1, inplace=True)
ksi_df = ksi_df.merge(index_df, on="ACCNUM")
ksi_df = ksi_df.infer_objects()
ksi_df["ACCIDENT"] = ksi_df.apply(lambda x: ACCIDENT(x["ACCNUM"], x["YEAR"], x["TIME"], x["VISIBILITY"], x["LIGHT"], x["RDSFCOND"], x["FATALITIES"], x["INJ_INDEX"]), axis=1)
if filter_df == "VIS-CLEAR":
return ksi_df.loc[ksi_df.VISIBILITY.isin(["Clear"])]
if filter_df == "VIS-RAIN":
return ksi_df.loc[ksi_df.VISIBILITY.isin(["Rain"])]
if filter_df == "VIS-SNOW":
return ksi_df.loc[ksi_df.VISIBILITY.isin(["Snow"])]
elif filter_df == "VIS-NCLEAR":
return ksi_df.loc[~ksi_df.VISIBILITY.isin(["Clear"])]
elif filter_df == "RD-DRY":
return ksi_df.loc[ksi_df.RDSFCOND.isin(["Dry"])]
elif filter_df == "RD-WET":
return ksi_df.loc[ksi_df.RDSFCOND.isin(["Wet"])]
elif filter_df == "RD-OTHER":
return ksi_df.loc[~ksi_df.RDSFCOND.isin(["Dry", "Wet"])]
elif filter_df == "TIME-RUSH":
ksi_df['TIME'] = ksi_df['TIME'].astype('int')
return ksi_df.loc[(ksi_df.TIME.between(630,930, inclusive=True)) | (ksi_df.TIME.between(1500,1900, inclusive=True))]
elif filter_df == "TIME-NRUSH":
ksi_df['TIME'] = ksi_df['TIME'].astype('int')
return ksi_df.loc[(ksi_df.TIME.between(0,629, inclusive=True)) | (ksi_df.TIME.between(1901,2400, inclusive=True)) | (ksi_df.TIME.between(931,1499, inclusive=True))]
elif filter_df == "TIME-DAY":
ksi_df['TIME'] = ksi_df['TIME'].astype('int')
return ksi_df.loc[ksi_df.TIME.between(701,1900, inclusive=True)]
elif filter_df == "TIME-NIGHT":
ksi_df['TIME'] = ksi_df['TIME'].astype('int')
return ksi_df.loc[(ksi_df.TIME.between(1901,2400, inclusive=True)) | (ksi_df.TIME.between(0,700, inclusive=True))]
else:
return ksi_df
def __init__(
self,
G,
trip_times,
distance_buffer,
pts = [],
palette=Viridis,
epsgs={
"origin":"4326",
"metric":"2154",
"vis":"3857"
},
center_nodes=[]
):
"""
"""
if center_nodes == [] and pts != []:
xs, ys = map(list, zip(*pts))
self.center_nodes = ox.get_nearest_nodes(
G,
xs,
ys,
method="kdtree"
)
else:
self.center_nodes = center_nodes
self.colors = {
trip_time:color for trip_time,color in zip(
trip_times,
palette[len(trip_times)]
)
}
self.G = G
self.trip_times = trip_times
self.distance_buffer = distance_buffer
self.epsgs = EPSG(
epsgs["origin"],
epsgs["metric"],
epsgs["vis"]
)
async def _construct_isochrones(self) -> None:
"""
TODO: Add docstring
"""
(ys, xs) = list(zip(*self._facilities))
nodes = osmnx.get_nearest_nodes(self._graph, xs, ys)
# Projects the graph to UTM
self._graph = osmnx.project_graph(self._graph)
# Adds an edge attribute for time in minutes required to traverse each
# edge
meters_per_minute = TRAVEL_SPEED * 1000 / 60 # km/hour to m/minute
for (u, v, k, data) in self._graph.edges(data=True, keys=True):
data['time'] = data['length'] / meters_per_minute
# Makes the isochrone polygons for isochrone map
self._isochrones = []
for found_node in nodes:
subgraph = networkx.ego_graph(self._graph,
found_node,
radius=self._trip_time,
distance='time')
node_points = [
Point((data['x'], data['y']))
for (node, data) in subgraph.nodes(data=True)
]
bounding_poly = geopandas.GeoSeries(
node_points).unary_union.convex_hull
self._isochrones.append(bounding_poly)
self._clean_isochrones_state()
# Causes the `isochrones_constructed` event
await self.isochrones_constructed()
# Saves data of isochrones
await self._save_isochrones()
def plot_map_with_probs_routes(
unique_roads_with_weather,
origin=[43.663389, -79.461929],
destination=[43.650854, -79.377587],
filename=''): # each input is a list with [lat, lon]
lats = [origin[1], destination[1]]
lons = [origin[0], destination[0]]
#load the city network for plotting
filein = '%s/data/cleaned/Toronto_large.graphml' % (local_path)
G = ox.load_graphml(filein)
df_roads = unique_roads_with_weather
df_roads = df_roads[['u', 'v', 'collision_yn']]
df_roads['colour'] = 'red'
df_roads['weights'] = df_roads['collision_yn'] * 10000
nearest_nodes = ox.get_nearest_nodes(G, lats, lons, method=None)
#add colour to the edges that have a crash risk
nodes, edges = ox.graph_to_gdfs(G)
edges = edges.merge(df_roads, on=['u', 'v'], how='left')
edges.colour[edges.colour.isna()] = 'grey'
edges.weights[edges.weights.isna()] = 1
edges.weights[edges.weights == 0] = 1
#add the weights to the edge attributes as impedance
i = 0
for u, v, k, data in G.edges(keys=True, data=True):
# print(data)
data['impedance'] = edges['weights'][i]
# print(data['length'])
# print(data['impedance'])
# print(edges['weights'][i])
# print(edges['weights'][i])
i = i + 1
#calculate the routes
route_by_weight = nx.shortest_path(G,
source=nearest_nodes[0],
target=nearest_nodes[1],
weight='impedance')
route_by_length = nx.shortest_path(G,
source=nearest_nodes[0],
target=nearest_nodes[1],
weight='length')
routes = [route_by_weight, route_by_length]
# create route colors
rc1 = ['green'] * (len(route_by_weight))
rc2 = ['blue'] * len(route_by_length)
route_colours = rc1 + rc2
# save the figure as a png
filename_save = filename
fig, ax = ox.plot_graph_routes(G,
routes,
node_size=0,
route_color=route_colours,
orig_dest_node_color='green',
edge_color=edges.colour,
fig_height=8.8,
fig_width=12,
margin=0,
axis_off=True,
show=False,
save=True,
file_format='png',
filename=filename_save)
return
#origin = [43.681641, -79.423906]
origin = [43.663389, -79.461929]
destination = [43.650854, -79.377587]
#origin = [43.6949, -79.453]
#destination = [43.6966, -79.4453]
lats = [origin[1], destination[1]]
lons = [origin[0], destination[0]]
G = ox.load_graphml('/Users/niall/saferoute/data/cleaned/Toronto.graphml')
df = pd.read_csv('/Users/niall/insight_project/data/processed/unique_roads_collision_yn_RF.csv')
df = df[['u', 'v', 'collision_yn']]
df['colour'] = 'red'
df['weights'] = df['collision_yn'] * 100000
nearest_nodes = ox.get_nearest_nodes(G, lats, lons, method=None)
#add colour to the edges that have a crash risk
nodes, edges = ox.graph_to_gdfs(G)
edges = edges.merge(df, on=['u', 'v'], how='left')
edges.colour[edges.colour.isna()] = 'grey'
edges.weights[edges.weights.isna()] = 1
edges.weights[edges.weights == 0] = 1
#edges.weights = edges.weights.values * edges.length.values
i = 0
for u, v, k, data in G.edges(keys=True, data=True):
# print(data)
data['impedance'] = edges['weights'][i]
# print(data['length'])
south,
east,
west,
network_type='drive',
retain_all=True)
G = nx.convert_node_labels_to_integers(G)
nodes, edges = ox.graph_to_gdfs(G)
# Concatenate lats and longs to save time
lats = queries.start_lat
lats = lats.append(queries.end_lat, ignore_index=True)
longs = queries.start_long
longs = longs.append(queries.end_long, ignore_index=True)
# Find nearest nodes
nearest_node_ids = ox.get_nearest_nodes(G, X=longs, Y=lats, method='balltree')
# Extract nearest node ids
start_nn = nearest_node_ids[0:nRecords]
end_nn = nearest_node_ids[nRecords:2 * nRecords]
queries['start_nn'] = start_nn
queries['end_nn'] = end_nn
queries.to_csv(path_or_buf=fnameQueries, index=False)
# Pickle graph and save as shapefile
file = open(fnamePickle, 'wb')
pickle.dump(G, file)
file.close()
ox.save_graph_shapefile(G, filename=fnameShape)
def main(N=100,M=10,k=6,X=5000,choice=0):
global G, G_o
global healthcare, fire, shops
global objects
global objects_nodes
global house_nodes
global NearestObjectsTo, NearestObjectsFrom, ThereAndBack, IsReachableObjects, IsReachableHouses, IsReachableThereAndBack, dist2objects, dist2houses
global A, B, C, a, b, c, km
global D
global E
global Xm
global srcs, dstns, srcs1, dstns1, srcs2, dstns2
global new_object, tree, tree_weight, sum_dist
global tree, tree_weight, sum_dis, Clustering, Cl, Z, Z1
global Clusters, Clusters1, TreeFromObject, Trees, center_nd, tree_weight1, sum_dist1, treedist
if (G is None):
load_graph(0)
#fig, ax = ox.plot_graph(G_simple)
t0 = tm.time()
largest = max(nx.strongly_connected_components(G), key=len)
G = G.subgraph(largest) # to work with only strongly connected graph
if G_o is None:
G_o = G
G = G.to_directed()
G = nx.DiGraph(G) # to work with DiGraphs only
# search
#healthcare = ox.pois_from_place('Ижевск, Россия', amenities=healthcare_list, which_result=1)
## healthcare = ox.pois_from_place('Ижевск, Россия', {'amenity':healthcare_list}, which_result=1)
## fire = ox.pois_from_place('Ижевск, Россия', {'amenity':fire_list}, which_result=1)
## shops = ox.pois_from_place('Ижевск, Россия', {'shop':shop_list}, which_result=1)
if (healthcare is None or fire is None or shops is None):
load_objects(0)
if (choice == 0):
objects = healthcare
elif (choice == 1):
objects = fire
else:
objects = shops
# get objects coordinates
objects = objects.centroid
objects_coord = (np.array([objects.x,objects.y]))
# get subset of objects
objects_coord = objects_coord[:,np.random.choice(len(objects_coord[0]),size = M, replace = False)]
#find nodes near coordinates
objects_nodes = ox.get_nearest_nodes(G, objects_coord[0],objects_coord[1])
# ? maybe merge close nodes ?
# get houses
##houses = ox.footprints.footprints_from_place(place='Ижевск, Россия')
###gdf_proj = ox.project_gdf(houses)
####fig, ax = ox.footprints.plot_footprints(gdf_proj, bgcolor='#333333', color='w',
### save=True, show=False, close=True, filename='piedmont_bldgs', dpi=40)
##houses = houses.centroid
##houses_coord = (np.array([houses.x,houses.y]))
### get subset of houses
##houses_coord = houses_coord[:,np.random.choice(len(houses_coord[0]),size = 100, replace = False)]
##
##house_nodes = ox.get_nearest_nodes(G, houses_coord[0],houses_coord[1])
house_nodes = np.random.choice(list(G.nodes), size = N, replace = False) # get houses as random nodes
adjust_weights(house_nodes,objects_nodes) # adjust weights
t1 = tm.time()
Xm = X
km=k
NearestObjectsTo, NearestObjectsFrom, ThereAndBack, IsReachableObjects, IsReachableHouses, IsReachableThereAndBack, dist2objects, dist2houses = Part1_1(house_nodes,objects_nodes,X=Xm)
t2 = tm.time()
print(t2-t0,' ',t2-t1)
t1 = tm.time()
A, B, C, a, b, c = Part1_2(house_nodes,objects_nodes, dist2objects, dist2houses)
t2 = tm.time()
print(t2-t0,' ',t2-t1)
t1 = tm.time()
D = Part1_3(house_nodes,objects_nodes, dist2houses)
t2 = tm.time()
print(t2-t0,' ',t2-t1)
t1 = tm.time()
E = Part1_4(house_nodes,objects_nodes)
t2 = tm.time()
print(t2-t0,' ',t2-t1)
srcs, dstns = boolMat2Pairs(IsReachableObjects,house_nodes,objects_nodes)
srcs1, dstns1 = boolMat2Pairs(IsReachableHouses,objects_nodes,house_nodes,)
srcs2, dstns2 = boolMat2Pairs(IsReachableThereAndBack,house_nodes,objects_nodes)
#------------------------------------------------------------part 2
new_object = np.random.choice(list(G.nodes), size = 1, replace = False)[0]
t1 = tm.time()
tree, tree_weight, sum_dist = Part2_1(house_nodes,new_object)
t2 = tm.time()
print(t2-t0,' ',t2-t1)
t1 = tm.time()
dist_hous2house = getDistHouse2House(house_nodes)
Z1 = Part2_2(house_nodes,dist_hous2house) # this one is used
Z = Part2_2_scipy(house_nodes,dist_hous2house) #is not used
t2 = tm.time()
print(t2-t0,' ',t2-t1)
t1 = tm.time()
Clusters = getClusters(k, house_nodes, Z = Z1)
Clusters1 = getClusters(k, house_nodes, Z = Z)
TreeFromObject, Trees, center_nd, tree_weight1, sum_dist1, treedist = Part2_3(Clusters,house_nodes,new_object)
t2 = tm.time()
print(t2-t0,' ',t2-t1)
print ('calculations done')
#G = G_o
return
#G = ox.graph_from_address('350 5th Ave, New York, New York', network_type='drive')
#ox.plot_graph(G)
#north, east, south, west = 33.798, -84.378, 33.763, -84.422
# Downloading the map as a graph object
#G =ox.graph_from_address('Plaça de Sants, Barcelona', network_type='walk')
location_point = (41.372925, 2.121151)
G = ox.graph_from_point(location_point,
network_type='walk',
dist=500,
simplify=True)
areaX = [location_point[0], location_point[0] + 1]
areaY = [location_point[1], location_point[1] + 1]
nearestnodes = ox.get_nearest_nodes(
G, areaX, areaY) #ox.get_nearest_nodes(G, (location_point))
print(nearestnodes)
"""
origin_point = (33.787201, -84.405076)
origin_node = ox.get_nearest_node(G, origin_point)
print("origin_node",origin_node)
ox.plot_graph(G)
for n in list(G.nodes(data=True)):
print ("node",n)
"""
fig, ax = ox.plot_graph(G, show=False, close=False)
ax.scatter(location_point[1], location_point[0], c='red')
for n in nearestnodes:
print(G.nodes[n]['x'])
def dist_mat(tim_loc_data,main_lat,main_long):
print('\nCreating Distance Matrix......')
# Get the pair of customer locations latitude and longitude
service_pos_arr = tim_loc_data[:,1:3]
# Loac the graph
fp = 'VKI.graphml'
graph = ox.load_graphml(fp)
# Get nodes closes to the required locations of depot and customers
main_node = ox.get_nearest_node(graph,(main_lat,main_long),method='haversine')
ids = ox.get_nearest_nodes(graph,service_pos_arr[:,1],service_pos_arr[:,0],method='balltree')
ids = np.asarray(ids)
# Create an empty distance matrix
matr = np.zeros((np.size(tim_loc_data,0)+1,np.size(tim_loc_data,0)+1))
# Looping over the matrix rowwise
for x in range(np.size(matr,0)):
# Looping over matrix columnwise
for y in range(x+1):
# If the column equal row, distance is zero
if y == x:
matr[x][y] = 0
continue
else:
# If the column for depot i.e. first column
if y == 0:
# Get the minimum distance using the graph
try:
matr[x][y] = nx.shortest_path_length(graph,source=main_node,target=ids[x-1],weight='length')#cost_calc(main_lat,main_long,service_pos_arr[x-1,0],service_pos_arr[x-1,1])
# If path is not found, use default value
except nx.exception.NetworkXNoPath:
avgValue = 3500
print('No Direct Path was found. Taking distance as average value of 3500 units')
matr[x][y] = 3500
# If the column is not of depot
else:
# Get the minimum distance using the graph
try:
matr[x][y] = nx.shortest_path_length(graph,source=ids[x-1],target=ids[y-1],weight='length')#cost_calc(service_pos_arr[x-1,0],service_pos_arr[x-1,1],service_pos_arr[y-1,0],service_pos_arr[y-1,1])
# If path is not found, use default value
except nx.exception.NetworkXNoPath:
avgValue = 3500
print('No Direct Path was found. Taking distance as average value of 3500 units')
matr[x][y] = 3500
# Get the indices of a upper triangular traingular matrix
ul = np.triu_indices(np.size(matr,0))
# Store the distance values in those indices, thus making the distance matrix symmetric
matr[ul] = matr.T[ul]
# Save the distance matrix and return it
np.savetxt('Dist_Matrix.csv',matr,delimiter=",",header='Distance Matrix')
print('Distance Matrix Created and Saved......')
return matr
def origindestination(originPath, destinationPath, networkType="all"):
"""
Create a bounding box from user entered origin and destination points, \
get the corresponding road network
and form the origin destination cost matrix.
Parameters
----------
originPath: string
absolute path of the origin shapefile to be used
destinationPath: string
absolute path of the destination shapefile to be used
networkType: string
what type of street network to get
Returns
-------
route_gdf: GeoDataFrame
geopandas dataframe of routes
nodes: GeoDataFrame
geopandas dataframe of nodes
G_proj: networkx multidigraph
road network of closed region that is reprojected in corresponding \
UTM zone
"""
origins = gpd.read_file(originPath)
destinations = gpd.read_file(destinationPath)
origins["geometry"] = origins["geometry"].to_crs(epsg=4326)
destinations["geometry"] = destinations["geometry"].to_crs(epsg=4326)
origins.crs = from_epsg(4326)
destinations.crs = from_epsg(4326)
points_concat = gpd.GeoDataFrame(
pd.concat([origins, destinations], ignore_index=True, sort=True))
minx, miny, maxx, maxy = points_concat.geometry.total_bounds
G = ox.graph_from_bbox(maxy + 0.005,
miny - 0.005,
maxx + 0.005,
minx - 0.005,
clean_periphery=False,
network_type=str(networkType))
G_proj = nx.MultiGraph(ox.project_graph(G))
nodes, edges = ox.graph_to_gdfs(G_proj)
nodes["x"] = nodes["x"].astype(float)
origins = origins.to_crs(nodes.crs)
destinations = destinations.to_crs(nodes.crs)
origins["x"] = origins.geometry.x
origins["y"] = origins.geometry.y
destinations["x"] = destinations.geometry.x
destinations["y"] = destinations.geometry.y
orignodes = list(
ox.get_nearest_nodes(G_proj,
origins["x"],
origins["y"],
method="kdtree"))
destnodes = list(
ox.get_nearest_nodes(G_proj,
destinations["x"],
destinations["y"],
method="kdtree"))
routelinelist = []
fromlist = []
tolist = []
for dest in destnodes:
for org in orignodes:
try:
route = nx.shortest_path(G_proj, org, dest, weight="length")
route_nodes = nodes.loc[route]
fromlist.append(route[0])
tolist.append(route[-1])
route_line = LineString(list(route_nodes.geometry.values))
routelinelist.append(route_line)
except:
pass
route_gdf = gpd.GeoDataFrame(crs=edges.crs)
route_gdf["geometry"] = routelinelist
route_gdf["length"] = route_gdf.length
route_gdf["from_id"] = fromlist
route_gdf["to_id"] = tolist
return route_gdf, nodes, G_proj, origins, destinations
