def render_sub_graphs(og_graph, sub_graphs): node_colors_dict = dict.fromkeys(og_graph.nodes) edge_colors_dict = dict.fromkeys(og_graph.edges) colors = [ 'darkviolet', 'blue', 'deeppink', 'lime', 'indigo', 'deepskyblue', 'green', 'maroon', 'teal', 'yellow', 'fuchsia', 'gold', 'orange', 'aqua', 'red', 'mint' ] for i, g in enumerate(sub_graphs): color = colors[i % len(colors)] for node in g.nodes: node_colors_dict[node] = color for edge in g.edges: edge_colors_dict[edge] = color node_colors = [node_colors_dict.get(node, 0) for node in og_graph.nodes] edge_colors = [edge_colors_dict.get(edge, 0) for edge in og_graph.edges] edge_colors = [c if c is not None else 'white' for c in edge_colors] ox.plot_graph(og_graph, node_size=0, node_zorder=2, node_color=node_colors, edge_linewidth=0.1, edge_color=edge_colors, show=False, close=True, save=True, filepath='zones.png') print('Zone rendering available at "zones.png"')
def crop_and_save_graph(self, save=False): if save: fig, ax = ox.plot_graph(self.graph, save=True, show=False, filename='Ekb_graph', file_format='png', node_alpha=0, edge_color='b', edge_linewidth=0.6, dpi=200) ox.core.remove_isolated_nodes(self.graph) self.update_nodes_list() self.set_non_oriented_adj_list() removing_nodes = [] distances, preds = distances_fwd(self.non_oriented_adj_list, [self.inf_objs[0]], self.nodes, self.weights) dists = distances[self.inf_objs[0]] for i in dists: if dists[i] == float('inf'): removing_nodes.append(i) self.graph.remove_nodes_from(removing_nodes) self.update_nodes_list() dists, _ = dijkstra(self.graph.adj, 175246547, self.weights) inf_arr = [] for id_ in dists: if dists[id_] == float('inf'): inf_arr.append(id_) self.graph.remove_nodes_from(inf_arr) self.update_nodes_list() self.set_non_oriented_adj_list() inf_objs_set = set(self.inf_objs) self.objs = list(filter(lambda x: x not in inf_objs_set, self.nodes)) if save: fig, ax = ox.plot_graph(self.graph, save=True, show=False, filename='Ekb_graph_cropped', dpi=200, file_format='png', node_alpha=0, edge_color='b', edge_linewidth=0.6)
def make_graph(lat, lng, distance): ''' Make initial graph of accident area from lat, lng, return graph, plot, and bounding box of area plotted ''' # get graph of accident area G = ox.graph_from_point((lat, lng), dist=distance, dist_type='bbox', network_type='drive', retain_all=True, simplify=False) #create fig my_dpi = 192 pixels = 400 fig = plt.figure(figsize=(pixels / my_dpi, pixels / my_dpi), dpi=my_dpi, constrained_layout=True) ax = fig.add_subplot() #add graph to plot ox.plot_graph(G, node_size=0, edge_color='black', ax=ax, show=False) bbox = get_bbox(ax) return fig, ax, G, bbox
def plot(g, fig_height, node_size, point, text, color, save): # Don't show plot until point is added to graph if point: fig, ax = ox.plot_graph(g, fig_height=fig_height, node_size=node_size, edge_color=color, node_color=color, show=False, close=False) ax.scatter(x=point[1], y=point[0], c=[color]) if save: ox.save_and_show(fig=fig, ax=ax, save=True, show=False, close=False, filename=text, file_format='jpg', dpi=None, axis_off=True) else: return plt else: fig, ax = ox.plot_graph(g, fig_height=fig_height, node_size=node_size, edge_color=color, node_color=color)
def get_network_info(city_str, verbose=False, draw=False, downloaded=False): if verbose == True: print("city:", city_str) start = datetime.now() #First we must get the graph from Open Street Maps. Either we already have # it on our system or we need to run getdata script: if downloaded == True: pass else: graph = getdata.get_graph(city_str) #Maybe there was a problem in finding the graph, in which case this city # is not good and we have to do something else with it. if graph == None: if verbose == True: print("We couldn't find a graph for this city.") return None, None, None, None, None if draw == True: ox.plot_graph(graph) if verbose == True: print("Took", datetime.now()-start, "seconds to get the graph") n = graph.order() m = graph.size() sl = nx.number_of_selfloops(graph) #Now we prepare the graph for our data through removing multiple edges # and self-loops: new_graph = nx.Graph(graph) new_graph.remove_edges_from(nx.selfloop_edges(new_graph)) #We collect the new number of edges and the motif vector: m_simp = new_graph.size() motif_vector = mcount.get_motifvector(new_graph) if verbose == True: print("Took", datetime.now()-start, "seconds for everything") return n, m, m_simp, sl, motif_vector
def project_and_plot(g, fig_height, node_size, point=None, text='test', color=None, save=False): if point: # Don't show plot until point is added to graph fig, ax = ox.plot_graph(g, fig_height=fig_height, node_size=node_size, edge_color=color, node_color=color, show=False, close=False) ax.scatter(x=point[1], y=point[0], c=['#00688B']) if save: ox.save_and_show(fig=fig, ax=ax, save=True, show=True, close=False, filename=text, file_format='svg', dpi=None, axis_off=True) else: plt.show() else: fig, ax = ox.plot_graph(g, fig_height=fig_height, node_size=node_size, edge_color=color, node_color=color)
def test_plots(): G = ox.graph_from_place('Piedmont, California, USA', network_type='drive', simplify=False) G2 = ox.simplify_graph(G, strict=False) # test getting colors co = ox.get_colors(n=5, return_hex=True) nc = ox.get_node_colors_by_attr(G2, 'osmid') ec = ox.get_edge_colors_by_attr(G2, 'length') # save a plot to disk as png fig, ax = ox.plot_graph(G, save=True, file_format='png') # save a plot to disk as svg G_simplified = ox.simplify_graph(G) fig, ax = ox.plot_graph(G_simplified, show=False, save=True, close=True, file_format='svg') G_projected = ox.project_graph(G_simplified) fig, ax = ox.plot_graph(G_projected) fig, ax = ox.plot_graph(G_projected, fig_height=5, fig_width=5, margin=0.05, axis_off=False, bgcolor='y', file_format='png', filename='x', dpi=180, annotate=True, node_color='k', node_size=5, node_alpha=0.1, node_edgecolor='b', node_zorder=5, edge_color='r', edge_linewidth=2, edge_alpha=0.1, use_geom=False, show=False, save=True, close=True) fig, ax = ox.plot_figure_ground(G=G_simplified, file_format='png') fig, ax = ox.plot_figure_ground(point=(33.694981, -117.841375), file_format='png') fig, ax = ox.plot_figure_ground(address='Denver, Colorado, USA', file_format='png')
def test_line_to_nodes(self): """ Do: - Make new TramLine object - Show it`s default route - Convert default_route to list of nodes and siplay as subgraph Expected: - Both LineString and subgraph are displayed - User manually verifies whether conversion is correct or not """ # Load data dl = DataLoader() G = dl.graph lines_table = dl.load_all_lines() for line in lines_table: # Create TramLine object tram_line = TramLine(str(line[0]), line[1], dl) tram_line.show() # Convert line to nodes in order to verify graph before edges deletion nodes = GraphConverter.line_to_nodes_precise(G, tram_line) sub_graph = G.subgraph(nodes) ox.plot_graph(sub_graph) tram_line.current_route = GraphConverter.route_to_line_string( sub_graph) print(tram_line.current_route.contains(tram_line.stops[0])) tram_line.show() self.assertTrue(True)
def loadOSMnxMap(file=None, download=False, saveMap=False): point1 = (45.1904, 5.7607) #todo load point from given gpx distance = 1000 distance_type_var = 'network' network_type_var = 'walk' print("============== Loading map ==================") if (not file and not download): print('No map specified') elif (file): graph = osmnx.load_graphml(filename=file, folder=None) print("Map loaded") g, a = osmnx.plot_graph(graph, show=False, close=False) return g, a elif (download): graph = osmnx.graph_from_point(point1, distance, distance_type=distance_type_var, network_type=network_type_var) if (saveMap): osmnx.save_graphml(graph, filename='map.hraphml') print('Map saved') print("Map loaded") return osmnx.plot_graph(graph, show=False, close=False) return None, None
def voronoi_plot(self, save=False, seed=None): voronoi_df = self.voronoi_cells_df() number_of_colors = self.size random.seed(seed) color = ["#" + ''.join([random.choice('0123456789ABCDEF') for j in range(6)]) for i in range(number_of_colors)] nc = ['gray'] * len(self.graph_nodes) for index, closest_station_data in voronoi_df.iterrows(): nc[index] = color[int(closest_station_data['nearest station']) - 1] ox.plot_graph( G=self.location_graph, fig_height=50, node_size=100, node_color=nc, node_zorder=2, edge_alpha=0.5, save=save, filename='voronoi_cdmx', dpi=100, edge_color='white', bgcolor='black' ) return None
def plotG(self,G,colored=False, save=False, filepath=False): if colored: ec=[] for _,_,_, d in G.edges(keys=True, data=True): bi = False if "bicycle" in d: if d['bicycle']=='designated' or d['bicycle']=='official' or d['bicycle']=='track' or d['bicycle']=='use_sidepath': bi = True if "bicycle:lanes" in d: if "designated" in d['bicycle:lanes']: bi = True if d['highway']=='cycleway': ec.append('#3366e6') elif 'cycleway' in d and d['cycleway'] != "no" and d['cycleway'] != "opposite": ec.append('#3366e6') elif bi: ec.append('#3366e6') elif 'cycleway:right' in d and d['cycleway:right'] != "no": ec.append('#3366e6') elif 'cycleway:left' in d and d['cycleway:left'] != "no": ec.append('#3366e6') elif 'bicycle_road' in d and d['bicycle_road'] == "yes": ec.append('#3366e6') else: ec.append('#d4d4d4') fig, ax = ox.plot_graph(G, edge_color=ec, save=save, show=True, filepath=filepath, node_color='#7d7d7d', edge_alpha=0.6, node_size=0, figsize=(37.5590551,18.7795276), dpi=1200, bgcolor="#FFFFFF", edge_linewidth=3) else: fig, ax = ox.plot_graph(G)
def plot_community_bus_routes(G): nodes, edges = ox.graph_to_gdfs(G) # get nodes that are on the routes # and create a graph containing only those route_nodes = nodes[(nodes["community_route"])] route_nodes_graph = ox.graph_from_gdfs(route_nodes, edges) # convert community labels to integers so that get_node_colors_by_attr # can use the community attribute for x, y in route_nodes_graph.nodes(data=True): if "community" in y: y["community"] = int(y["community"]) node_colours = ox.plot.get_node_colors_by_attr(route_nodes_graph, attr="community", cmap="tab20") # graph_from_gdfs creates empty nodes so need # to update node_colours to include those so # that plot graph function will work correctly other_nodes = { x: (0, 0, 0, 0) for x, y in G.nodes(data=True) if x not in node_colours.index } series = pd.Series(other_nodes) node_colours = node_colours.append(series) ox.plot_graph(route_nodes_graph, node_color=node_colours, edge_color="w", node_size=15)
def __init__(self, geopostion=None, name=None): if geopostion: self.geo = geopostion if name: self.nameFile = name try: self.settings = dict(bgcolor="white", equal_aspect=False, node_size=30, node_color='#1f78b4', node_edgecolor="none", node_zorder=2, axis_off=False, edge_color="#555555", edge_linewidth=1.5, edge_alpha=1, show=False, close=False, save=False) self.Graph = self.load_darmstadt(self.nameFile) self.sparse_adj = self.extract_adjencecacy() self.figCityMap, self.cityMap = ox.plot_graph( self.Graph, **self.settings) except FileNotFoundError: print("Could not find file ... redownload") self.Graph = self.download_darmstadt(self.geo, self.nameFile, self.locationFile, show=False) self.sparse_adj = self.extract_adjencecacy() self.figCityMap, self.cityMap = ox.plot_graph( self.Graph, **self.settings)
def download_darmstadt(self, geo, name, loc, show=True): """ This functions downloads and save the network city map of darmstadt\n @param:\n geo {dict}: [Dictionary of latitude and longitude GPS coordinates]\n name {String}: [name of graphml file]\n loc {String}: [save location]\n show {bool}: [flag which plots the downloaded network city map] (default: {True}) """ if all(k in geo for k in ("north", "south", "west", "east")): print("Load Darmstadt from Openstreetmap ... ") G = ox.core.graph_from_bbox(north=geo["north"], south=geo["south"], west=geo["west"], east=geo["east"], network_type='drive') print("Save Darmstadt ... ") ox.save_load.save_graphml(G, filename="{}.graphml".format(name), folder=loc) print("Saved") else: print("Geoposition is missing an entity e.g. north,south, etc. ") if show: print("Plot Darmstadt ... ") ox.plot_graph(G, show=True, close=False) return G
def graph_with_edge_pollution(graph): ec = [] pollutionPerEdge = [] edgePolList = [] for e in graph.edges(): if 'pollution_amount' in graph.edge[e[0]][e[1]][0]: pollutionPerEdge.append( graph.edge[e[0]][e[1]][0]['pollution_amount']) edgePolList.append(e) norm = cm.colors.Normalize(vmin=0, vmax=max(pollutionPerEdge)) cmap = cm.ScalarMappable(norm=norm, cmap=cm.GnBu) for e in graph.edges(): if 'pollution_amount' in graph.edge[e[0]][e[1]][0]: ec.append( cmap.to_rgba(graph.edge[e[0]][e[1]][0]['pollution_amount'], alpha=0)) else: ec.append(( 1, 0, 0, 0, )) ox.plot_graph(graph, edge_color=ec, edge_linewidth=2.5) return ec
def InitialSetup(): custom_walk = ('["area"!~"yes"]["highway"="footway"]["foot"!~"no"]["service"!~"private"]{}').format(ox.settings.default_access) global factor, img,image_map_horizontal,image_map_vertical ,nodes,edges, fig,ax,G_projected,threshold,G G = ox.graph_from_bbox(top, bottom,right, left,custom_filter= custom_walk)#network_type="walk")# ## G_projected = ox.core.graph_from_file("centralcampus.xml", network_type = 'walk',simplify=True,retain_all=False) ##Uncomment this for the original stuff G_projected = ox.project_graph(G) ox.plot_graph(G_projected,save = True,filename = "maps", show = False, node_color='#999999',node_edgecolor='#999999',edge_color='#999999',bgcolor = "#000000", node_zorder=3,dpi=200, edge_linewidth=8,use_geom=True) ox.simplify.clean_intersections(G,tolerance=100) nodes, edges = ox.graph_to_gdfs(G) fig,ax = pyplot.subplots() ax.axis ('OFF') img = Image.open('images/maps.png').convert('L').rotate(angle) img.save('lowered.png') height_compensation = 0 width_compensation = 0 w,h = img.size image_size_w,image_size_h=img.size image_map_horizontal = float(left-right)/image_size_w image_map_vertical = float(top-bottom)/image_size_h if img.width >= image_size and img.height >= image_size: if img.height < img.width: print "factor denom height is ",str(img.height) factor = float(image_size) / img.height else: print "factor denom width is ",str(img.width) factor = float(image_size) / img.width PrintImg(img)
def graph(place_country, distance, filter): # filter # filter out some attributes # filter = ('["highway"!~"residential|unclassified|living_street|track|abandoned|path|footway|service|pedestrian|road|' # 'raceway|cycleway|steps|construction"]') # filter = ( # '["highway"!~"residential|unclassified|living_street|track|abandoned|path|footway|service|pedestrian|road|' # 'raceway|cycleway|steps|construction|primary|secondary|tertiary"]') # filter = filter # import grapho (graphml) G = ox.graph_from_address(str(place_country), distance=distance, network_type='drive', custom_filter=filter) # custom_filter=filter ## import shapefile # G_shp = ox.gdf_from_place(place_country) ## import shapefile with edges and nodes ## as the data is in WGS84 format, we might first want to reproject our data into metric system ## so that our map looks better with the projection of the graph data in UTM format # G_projected = ox.project_graph(G) ## save street network as ESRI shapefile (includes NODES and EDGES) name_place_country = re.sub('[/," ",:]', '_', place_country) # ox.save_graph_shapefile(G_projected, filename='network_' + name_place_country + '-shape') ox.save_graphml(G, filename = name_place_country + '.graphml') # ox.save_gdf_shapefile(G_shp) ox.plot_graph(G)
def plot_map(self, fig_height: int = 10): """Helper function to the initial Args: fig_height (int, optional): Defaults to 10. [description] """ ox.plot_graph(self.g_init, fig_height=fig_height)
def map(self, c='r', s=100, save=False): """ Plot containing the geographic area with the stations' locations contained in self.location_graph :param c: color code, optional Color for the stations :param s: int, optional Dot size for the stations :param save: bool, optional, default False Whether to save the graph to a file :return: None """ # selects nodes belonging or not to the stations and colors and scales them differently nc = np.where(self.graph_nodes.isin(self.network_df['node']), c, 'g') ns = np.where(self.graph_nodes.isin(self.network_df['node']), s, 0) ox.plot_graph( self.location_graph, fig_height=50, node_size=ns, node_color=nc, node_zorder=2, edge_alpha=0.5, save=save, filename=self.name + '_map', dpi=100, edge_color='white', bgcolor='black') return None
def Save_OSM_G_proj(placename=placename, network_type= 'walk', suffix=suffix, folder=OSM_folder, to_crs=None): """ save a projected graphml from graphml file Parameters ---------- network_type : string what type of street network to get. Default type is pedestrain network placename: string place name suffix: string output data date folder : string where to save the shapefile, specify local folder path for OSM resource Returns ------- none """ G = ox.load_graphml(filename='{studyregion}_{network_type}{suffix}.graphml'.format( studyregion = placename, network_type=network_type, suffix = suffix), folder=folder) #set up project projection, and save the projected graph (project to UTM so we can use metres as a unit when buffering) G_proj = ox.project_graph(G, to_crs=to_crs) ox.save_graphml(G_proj, filename='{studyregion}_proj_{network_type}{suffix}.graphml'.format( studyregion = placename, network_type=network_type, suffix = suffix), folder=folder) ox.plot_graph(G_proj)
def remove_deadends(g, plot_all=False): """ Reduce the number of nodes and edges in g by iteratively removing every node with degree one, and the connected vertex. Args: g (networkx.classes.multidigraph): Street graph from osmnx. Returns: networkx.classes.multidigraph: The simplified street graph. """ simpler = g.to_undirected().copy() while True: nc = [ 'r' if degree <= 1 else 'b' for node, degree in simpler.degree().items() ] n_nodes = len(simpler.nodes()) n_removed = len(list(filter(lambda x: x == 'r', nc))) if plot_all: print( 'number of nodes in graph: {}, and number of nodes that will be removed: {}' .format(n_nodes, n_removed)) ox.plot_graph(simpler, node_color=nc, node_zorder=3) for node, degree in simpler.degree().items(): if degree <= 1: simpler.remove_node(node) if len(simpler.nodes()) == n_nodes: break return simpler
def Save_OSM_G(polygon, network_type= 'walk', placename=placename, suffix=suffix, folder=OSM_folder): """ save a graphml from a single polygon. Parameters ---------- polygon : shapely Polygon or MultiPolygon the shape to get network data within. coordinates should be in units of latitude-longitude degrees. network_type : string what type of street network to get. Default type is pedestrain network placename: string place name suffix: string output data date folder : string where to save the shapefile, specify local folder path for OSM resource Returns ------- none """ #The graph_from_polygon function requires a polygon in units of lat-long (epsg 4326) G = ox.graph_from_polygon(polygon, network_type=network_type, retain_all = True) #save network as graphml ox.save_graphml(G, filename='{studyregion}_{network_type}{suffix}.graphml'.format( studyregion = placename, network_type=network_type, suffix = suffix), folder=folder) ox.plot_graph(G)
def test_plots(): G = ox.graph_from_point(location_point, dist=500, network_type="drive") # test getting colors co = ox.plot.get_colors(n=5, return_hex=True) nc = ox.plot.get_node_colors_by_attr(G, "x") ec = ox.plot.get_edge_colors_by_attr(G, "length", num_bins=5) # plot and save to disk filepath = Path(ox.settings.data_folder) / "test.svg" fig, ax = ox.plot_graph(G, show=False, save=True, close=True, filepath=filepath) fig, ax = ox.plot_graph( G, figsize=(5, 5), bgcolor="y", dpi=180, node_color="k", node_size=5, node_alpha=0.1, node_edgecolor="b", node_zorder=5, edge_color="r", edge_linewidth=2, edge_alpha=0.1, show=False, save=True, close=True, ) # figure-ground plots fig, ax = ox.plot_figure_ground(G=G) fig, ax = ox.plot_figure_ground(point=location_point, dist=500, network_type="drive") fig, ax = ox.plot_figure_ground(address=address, dist=500, network_type="bike")
def getChangchunTreet(): treet = ox.graph_from_place( ['南关区,长春,中国', '朝阳区,长春,中国', '二道区,长春,中国', '绿园区,长春,中国', '宽城区,长春,中国'], network_type='drive') treet = ox.project_graph(treet) ox.save_graph_shapefile(treet, filename='test2') ox.plot_graph(treet)
def main(data_prefix, ona_csv_path, ids, geometry_column, settlement_name_column, output_filename, network_search_buffer = 0.001, parcel_files=None, export_shapefile=False): # network_search_buffer: suggest 0.001 for single-settlement zoom-ins, 0.01 for graph construction print("reading data") ona = pd.read_csv(data_prefix/ona_csv_path) ona = ona.loc[ona["_id"].isin(ids)] ona = ona[["_id", settlement_name_column, geometry_column]] ona[geometry_column] = ona[geometry_column].apply(geometry_text_to_polygon) original_polygons = list(ona[geometry_column]) multipolygon = cascaded_union(original_polygons) buffered_multipolygon = multipolygon.buffer(network_search_buffer) print("getting graph") road_network = ox.graph_from_polygon(buffered_multipolygon, network_type="all_private", retain_all=True)#, clean_periphery=False, simplify=True) print("parsing graph") linestrings = linestrings_from_network(road_network) polygons = diff_polygonize(buffered_multipolygon, linestrings) print("plotting") fig, ax = ox.plot_graph(road_network, close=False, show=False, node_color='black', node_size=1)#, edge_color="white") # for polygon in original_polygons: # ax.add_patch(PolygonPatch(polygon, fc='#bb5a40', ec='k', linewidth=0, alpha=0.6, zorder=10)) plt.autoscale() plt.savefig(output_filename.replace(".shp", "_network.png"), bbox_inches="tight", dpi=300, transparent=True) plt.show() fig, ax = ox.plot_graph(road_network, close=False, show=False, node_alpha=0, edge_alpha=0) mp_border = buffered_multipolygon.boundary filtered_polygons = [] for (polygon, color) in zip(polygons, colors): # ax.add_patch(PolygonPatch(polygon, fc=color, ec='white', linewidth=0.5, zorder=10)) if not mp_border.intersects(polygon): filtered_polygons.append(polygon) ax.add_patch(PolygonPatch(polygon, fc=color, ec='white', linewidth=0.5, zorder=10)) if parcel_files is not None: for pf in parcel_files: with shapefile.Reader(pf) as shp: for sr in shp.shapeRecords(): # print(sr.record) ax.add_patch(PolygonPatch(sr.shape, fc="white", ec='white', linewidth=0.5, alpha=0.2, zorder=10)) plt.autoscale() ax.axis('off') ax.margins(0) ax.tick_params(which='both', direction='in') ax.get_xaxis().set_visible(False) ax.get_yaxis().set_visible(False) plt.savefig(output_filename.replace(".shp", "_blocks.png"), bbox_inches="tight", dpi=300, transparent=True) plt.show() if export_shapefile: print("exporting shapefile") with shapefile.Writer(data_prefix/output_filename) as shp: shp.field("index", "N") for (index, polygon) in enumerate(filtered_polygons): shp.record(index) shp.shape(mapping(polygon))
def plot_graph (self): """ This method provides a representation of the map downloaded. Further packages by Geopython might be used to improve the representation, but, for the moment I kept it simple. :return: None """ ox.plot_graph(self.graph)
def plot_streetnumber(self, positions, City=None, settings=None): if City: if settings: fig, ax = ox.plot_graph(City.Graph, **settings) else: fig, ax = ox.plot_graph(City.Graph, **City.settings) nx.draw_networkx(City.Graph, pos=positions, node_size=0, node_color="white", with_labels=False, edge_linewidth=1) nx.draw_networkx_nodes(City.Graph, pos=positions, nodelist=City.Graph.nodes(), node_color="none", node_edgecolor="black", with_labels=False, node_size=100, ax=ax) nx.draw_networkx_labels( City.Graph, pos=positions, labels=dict( zip(City.Graph.nodes(), range(City.Graph.number_of_nodes()))), font_size=18) plt.tight_layout() plt.show() else: if settings: fig, ax = ox.plot_graph(self.Graph, **settings) else: fig, ax = ox.plot_graph(self.Graph, **self.settings) nx.draw_networkx(self.Graph, pos=positions, node_size=0, node_color="white", with_labels=False, edge_linewidth=1) nx.draw_networkx_nodes(self.Graph, pos=positions, nodelist=self.Graph.nodes(), node_color="none", node_edgecolor="black", with_labels=False, node_size=100, ax=ax) nx.draw_networkx_labels( self.Graph, pos=positions, labels=dict( zip(self.Graph.nodes(), range(self.Graph.number_of_nodes()))), font_size=18) plt.tight_layout() plt.show()
def obtain_map(self, plot=False, **args): if plot: import matplotlib.pyplot as plt ox.plot_graph(self._map, bgcolor='white', edge_color='black', edge_linewidth=1.0) plt.show() return self._map
def getGraphs(G, fileToSave): N = G.number_of_nodes() numToRemove = int(N * 0.05) order = createOrder(G) counter = 0 for i in range(18): print(i) nodesList = list(G.nodes()) conn = list(nx.connected_component_subgraphs(G)) biconn = list(nx.biconnected_component_subgraphs(G)) GC = max(conn, key=len) GBC = max(biconn, key=len) GCnodes = list(GC.nodes()) GBCnodes = list(GBC.nodes()) try: fig, ax = ox.plot_graph(G, fig_height=30, fig_width=30) except: break for n in GCnodes: dictInfo = G.node[n] ax.scatter(dictInfo['x'], dictInfo['y'], c='green') GCName = fileToSave + "_Deg_GCPlot_%d.png" % (i) GBCName = fileToSave + "_Deg_GBCPlot_%d.png" % (i) plt.savefig(GCName) plt.clf() try: fig, ax = ox.plot_graph(G, fig_height=30, fig_width=30) except: break for n in GBCnodes: dictInfo = G.node[n] ax.scatter(dictInfo['x'], dictInfo['y'], c='red') plt.savefig(GBCName) plt.clf() startIndex = counter * numToRemove endIndex = startIndex + numToRemove nodesToRemove = order[startIndex:endIndex] G.remove_nodes_from(nodesToRemove) counter = counter + 1
def wkt_to_graph(wkt_list, im_file, conf, out_graph_file): min_subgraph_length_pix = 300 verbose = False super_verbose = False make_plots = False save_shapefiles = False pickle_protocol = 4 if (len(wkt_list) == 0) or (wkt_list[0] == 'LINESTRING EMPTY'): return None try: G = wkt_to_G(wkt_list, im_file=im_file, min_subgraph_length_pix=min_subgraph_length_pix, verbose=super_verbose) if len(G.nodes()) == 0: return None except Exception as e: print('Exception in wkt_to_G: {}, {}'.format(str(e), out_graph_file)) return None node = list(G.nodes())[-1] if verbose: print(node, 'random node props:', G.nodes[node]) # print an edge edge_tmp = list(G.edges())[-1] if verbose: print(edge_tmp, "random edge props:", G.edges([edge_tmp[0], edge_tmp[1]])) #G.edge[edge_tmp[0]][edge_tmp[1]]) nx.write_gpickle(G, out_graph_file, protocol=pickle_protocol) # save shapefile as well? if save_shapefiles: ox.save_graph_shapefile(G, filename=image_id.split('.')[0], folder=graph_dir, encoding='utf-8') # plot, if desired if make_plots: outfile_plot = 'debug_ox.png' if verbose: print("Plotting graph...") print("outfile_plot:", outfile_plot) ox.plot_graph( G, fig_height=9, fig_width=9, #save=True, filename=outfile_plot, margin=0.01) ) #plt.tight_layout() plt.savefig(outfile_plot, dpi=400)
place_names = ['Ho Chi Minh City, Vietnam', #'Beijing, China', #'Jakarta, Indonesia', 'London, UK', 'Los Angeles, California, USA', 'Manila, Philippines', #'Mexico City, Mexico', 'New Delhi, India', 'Sao Paulo, Brazil', 'New York, New York, USA', 'Seoul', 'Singapore', #'Tokyo, Japan', #'Nairobi, Kenya', #'Bangalore, India' ] # In this for-loop, we save all the shapefiles for the valid cities. for city in place_names: city_admin_20kmbuff = ox.gdf_from_place(city, gdf_name = 'global_cities', buffer_dist = 20000) fig, ax = ox.plot_shape(city_admin_20kmbuff) ox.save_gdf_shapefile(city_admin_20kmbuff, filename = city) # In this for-loop, we save all the street networks for the valid cities. for city in place_names: grid = ox.graph_from_place(city, network_type = 'drive', retain_all = True) grid_projected = ox.project_graph(grid) ox.save_graph_shapefile(grid_projected, filename = city + '_grid') ox.plot_graph(grid_projected)