def load_graph(a): global G if (a==0): try: G = ox.load_graphml('network.graphml') #load print("loaded from graphml file") except: pass elif (a==1): try: G = ox.graph_from_xml('network.osm', bidirectional=False, simplify=True, retain_all=False) e = list(G.edges(data=True)) sub_ed = [] for el in e: if 'highway' in el[2]: if (el[2]['highway'] in ['primary','motorway','trunk','secondary','tertiary','residential','road','unclassified']): sub_ed.append(tuple([el[0],el[1],0])) G = nx.edge_subgraph(G,sub_ed) print("loaded from osm xml") except: pass if (G is None): try: G = ox.graph_from_place('Ижевск, Россия', network_type='drive',simplify=True) print("downloaded from internet") except: pass if (G is None): print('failed to load map. To download network from internet check internet connection. To load from file it\'s name should be \'network.graphml\' or \'network.xml\'') raise 0 return
def load_drive_graph(path='db/shenzhen20170701-all.osm', ): """ load original open street map data of a city and extract drivable road network :param path: original osm xml format data :return: drivable graph """ shenzhen_all = ox.graph_from_xml(path) sz_nodes, sz_edges = ox.graph_to_gdfs(shenzhen_all, fill_edge_geometry=True) not_valid_highway = 'cycleway|footway|path|pedestrian|steps|track|corridor|elevator' \ '|escalator|proposed|construction|bridleway|abandoned|platform' \ '|raceway|service'.split('|') not_valid_service = 'parking|parking_aisle|driveway|private|emergency_access'.split( '|') print('original_edges', sz_edges.shape) sz_gdfs = sz_edges.loc[((sz_edges['highway'].notna()) & (sz_edges['area'] != 'yes') & (sz_edges['access'] != 'private') & (~sz_edges['service'].isin(not_valid_service)))] for tag in not_valid_highway: sz_gdfs = sz_gdfs.loc[sz_gdfs['highway'] != tag].copy(deep=True) print('drivable_edges:', sz_gdfs.shape) shenzhen_drive = ox.graph_from_gdfs(sz_nodes, sz_gdfs) return shenzhen_drive
def _affine_transformation_and_graph(self): """Performs initial conversion of the lat lon to cartesian """ # Graph read_path = '/'.join([ self.config['urdf_data_path'], self.config['simulation']['map_to_use'], 'map.osm' ]) G = ox.graph_from_xml(read_path, simplify=True, bidirectional='walk') self.G = nx.convert_node_labels_to_integers(G) # Transformation matrix read_path = '/'.join([ self.config['urdf_data_path'], self.config['simulation']['map_to_use'], 'coordinates.csv' ]) points = pd.read_csv(read_path) target = points[['x', 'z']].values source = points[['lat', 'lon']].values # Pad the points with ones X = np.hstack((source, np.ones((source.shape[0], 1)))) Y = np.hstack((target, np.ones((target.shape[0], 1)))) self.A, res, rank, s = np.linalg.lstsq(X, Y, rcond=None) return None
def __init__(self, config): read_path = '/'.join([ config['urdf_data_path'], config['simulation']['map_to_use'], 'map.osm' ]) self.G = ox.graph_from_xml(read_path, simplify=True, bidirectional='walk') self.A = self.find_homogenous_affine_transformation(config) return None
def preprocess(): # Create the 3D world from the map.osm file os.system( "java -jar OSM2World.jar --config texture_config.properties -i map.osm -o map.obj" # noqa ) # Save OSMNX graph G = ox.graph_from_xml('map.osm', simplify=True, bidirectional='walk') G = nx.convert_node_labels_to_integers(G) # Use the blender to bake the texture blender_path = "/Applications/blender.app/Contents/MacOS/blender" os.system(blender_path + " --background --python bake_texture.py") # Tidy up things and move the files to respective folders print('---------------------------------------') print('Preprocessing completed successfully') print('---------------------------------------') name = input("Please provide a name for the new asset: ") # Create a directory parent_folder = name meshes_folder = name + '/meshes' Path(parent_folder).mkdir(parents=True, exist_ok=True) Path(meshes_folder).mkdir(parents=True, exist_ok=True) # Move map.osm and coordinates inside the parent folder def move_files(file_name, directory): try: shutil.copy(file_name, directory + '/' + file_name) except FileNotFoundError: pass files = [ 'map.osm', 'coordinates.csv', 'environment.urdf', 'environment_collision_free.urdf' ] for file in files: move_files(file, parent_folder) files = ['map.obj', 'map.png', 'map.mtl'] for file in files: move_files(file, meshes_folder) # Finaly move the whole folder to data folder shutil.move(name, '../data/assets/')
def test_osm_xml(): # test loading a graph from a local .osm xml file node_id = 53098262 neighbor_ids = 53092170, 53060438, 53027353, 667744075 with bz2.BZ2File("tests/input_data/West-Oakland.osm.bz2") as f: handle, temp_filename = tempfile.mkstemp(suffix=".osm") os.write(handle, f.read()) os.close(handle) for filename in ("tests/input_data/West-Oakland.osm.bz2", temp_filename): G = ox.graph_from_xml(filename) assert node_id in G.nodes for neighbor_id in neighbor_ids: edge_key = (node_id, neighbor_id, 0) assert neighbor_id in G.nodes assert edge_key in G.edges assert G.edges[edge_key]["name"] in ("8th Street", "Willow Street") os.remove(temp_filename) # test .osm xml saving default_all_oneway = ox.settings.all_oneway ox.settings.all_oneway = True G = ox.graph_from_point(location_point, dist=500, network_type="drive") ox.io.save_graph_xml(G, merge_edges=False) # test osm xml output merge edges ox.io.save_graph_xml(G, merge_edges=True, edge_tag_aggs=[("length", "sum")]) # test osm xml output from gdfs nodes, edges = ox.graph_to_gdfs(G) ox.io.save_graph_xml([nodes, edges]) # test ordered nodes from way df = pd.DataFrame({ "u": [54, 2, 5, 3, 10, 19, 20], "v": [76, 3, 8, 10, 5, 20, 15] }) ordered_nodes = ox.osm_xml._get_unique_nodes_ordered_from_way(df) assert ordered_nodes == [2, 3, 10, 5, 8] ox.settings.all_oneway = default_all_oneway
def _initial_buildings_setup(self): """Perfrom initial building setup. """ read_path = '/'.join([ self.config['urdf_data_path'], self.config['simulation']['map_to_use'], 'buildings.csv' ]) # Check if building information is already generated if Path(read_path).is_file(): buildings = pd.read_csv(read_path) else: read_path = '/'.join([ self.config['urdf_data_path'], self.config['simulation']['map_to_use'], 'map.osm' ]) G = ox.graph_from_xml(read_path) # TODO: This method doesn't work if the building info is not there in OSM nodes, streets = ox.graph_to_gdfs(G) west, north, east, south = nodes.geometry.total_bounds polygon = ox.utils_geo.bbox_to_poly(north, south, east, west) gdf = ox.footprints.footprints_from_polygon(polygon) buildings_proj = ox.project_gdf(gdf) # Save the dataframe representing buildings buildings = pd.DataFrame() buildings['lon'] = gdf['geometry'].centroid.x buildings['lat'] = gdf['geometry'].centroid.y buildings['area'] = buildings_proj.area buildings['perimeter'] = buildings_proj.length try: buildings['height'] = buildings_proj['height'] except KeyError: buildings['height'] = 10 # assumption buildings['id'] = np.arange(len(buildings_proj)) # Save the building info save_path = read_path = '/'.join([ self.config['urdf_data_path'], self.config['simulation']['map_to_use'], 'buildings.csv' ]) buildings.to_csv(save_path, index=False) self.buildings = buildings return None
def test_graph_from_xml(): # test loading a graph from a local .osm xml file node_id = 53098262 neighbor_ids = 53092170, 53060438, 53027353, 667744075 with bz2.BZ2File("tests/input_data/West-Oakland.osm.bz2") as f: handle, temp_filename = tempfile.mkstemp(suffix=".osm") os.write(handle, f.read()) os.close(handle) for filename in ("tests/input_data/West-Oakland.osm.bz2", temp_filename): G = ox.graph_from_xml(filename) assert node_id in G.nodes for neighbor_id in neighbor_ids: edge_key = (node_id, neighbor_id, 0) assert neighbor_id in G.nodes assert edge_key in G.edges assert G.edges[edge_key]["name"] in ("8th Street", "Willow Street") os.remove(temp_filename)
def pedestrians_first(boundaries, id_code, name, folder_name='', buffer_dist=100,#m headway_threshold=10,#min to_test = [ 'healthcare', 'schools', 'h+s', 'libraries', 'carfree', 'blocks', 'density', 'transit', 'pnb', #'special', ], distances = { #network buffers, in meters 'healthcare': 1000, 'schools': 1000, 'libraries': 1000, 'transit': 500, 'special': 500, 'pnb': 250, }, overpass = False, patch_length = 5, #km boundary_buffer = 0, #km blocks_simplification = 15, #m gtfs_files = [], ): dt = datetime.datetime.now() logger = logging.getLogger() logger.setLevel(logging.CRITICAL) formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') fh = logging.FileHandler('log_filename.txt') fh.setLevel(logging.DEBUG) fh.setFormatter(formatter) logger.addHandler(fh) ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) ch.setFormatter(formatter) logger.addHandler(ch) useful_tags = ox.settings.useful_tags_way + ['cycleway', 'cycleway:left', 'cycleway:right'] ox.config(use_cache=True, log_console=True, useful_tags_way=useful_tags) if folder_name != '' and not folder_name[-1:] == '/': folder_name += '/' if boundary_buffer > 0: bound_latlon = gpd.GeoDataFrame(geometry = [boundaries]) bound_latlon.crs = {'init':'epsg:4326'} longitude = round(numpy.mean(bound_latlon.geometry.centroid.x),10) utm_zone = int(math.floor((longitude + 180) / 6) + 1) utm_crs = '+proj=utm +zone={} +ellps=WGS84 +datum=WGS84 +units=m +no_defs'.format(utm_zone) bound_utm = bound_latlon.to_crs(utm_crs) bound_utm.geometry = bound_utm.geometry.buffer(boundary_buffer*1000) bound_latlon = bound_utm.to_crs(epsg=4326) boundaries = bound_latlon.geometry.unary_union bbox = boundaries.bounds crs = None if type(boundaries) == shapely.geometry.multipolygon.MultiPolygon: patches = [] for poly in list(boundaries): patches += make_patches(poly, patch_length=patch_length) else: patches = make_patches(boundaries, patch_length=patch_length) longitude_factor = 0.00898 # degrees per km longitude_factor_m = 0.00898 / 1000 # degrees per m latitude_factor = (math.cos(abs(boundaries.bounds[1])*0.0174533))/111.319 latitude_factor_m = latitude_factor / 1000 print('Evaluating Pedestrians First indicators in',name) print('Measuring',str(to_test)) quilt_isochrone_polys = {} quilt_center_nodes = {} for service in to_test: quilt_isochrone_polys[service] = False quilt_center_nodes[service] = [] patch_times = [] all_coords={} testing_services = [] for service in ['healthcare', 'schools', 'libraries']: if service in to_test: testing_services.append(service) #all_coords[service] = get_point_locations(boundaries, queries[service]) if len(testing_services) > 0: handler = get_service_locations.ServiceHandler() handler.apply_file(folder_name+'/city.o5m', locations=True) for service in testing_services: all_coords[service] = handler.locationlist[service] citywide_carfree = handler.carfreelist #should I finish this? if 'highways' in to_test: highway_filter = '["area"!~"yes"]["highway"~"motorway|trunk"]' G_hwys = ox.graph_from_polygon(boundaries, custom_filter=highway_filter, retain_all=True) G_hwys = ox.project_graph(G_hwys) edges_hwys = ox.utils_graph.graph_to_gdfs(G_hwys, nodes=False) edges_polyline = edges_hwys.geometry.unary_union increment_dist = 25 distances = np.arange(0, edges_polyline.length, increment_dist) points = [edges_polyline.interpolate(distance) for distance in distances] + [edges_polyline.boundary[1]] multipoint = unary_union(points) #need to switch back to latlon and put in all_coords['highway'] if 'special' in to_test: if os.path.isfile(folder_name+'/special.shp'): testing_services.append('special') special = gpd.read_file(folder_name+'/special.shp') all_coords['special'] = [(pt.y, pt.x) for pt in special.geometry] if 'transit' in to_test: testing_services.append('transit') #this approach does not let us combine OpenMobilityData files with local files. if len(gtfs_files) == 0: sources = gtfs_parser.get_feed_infos(gtfs_parser.get_relevant_locs(bbox)) #note! This doesn't reflect a buffered boundary if boundary_buffer > 0 transit_stop_sets = gtfs_parser.count_all_sources(sources, source_type = 'openmobilitydata', headwaylim = headway_threshold * 2) else: transit_stop_sets = gtfs_parser.count_all_sources(gtfs_files, source_type = 'local_files', headwaylim = headway_threshold * 2) if 'pnb' in to_test: testing_services.append('pnb') if len(to_test) > 0 and to_test != ["blocks"]: for p_idx, patch in enumerate(patches): try: patch_start = datetime.datetime.now() unbuffered_patch = patch max_service_dist_km = max(distances.values())/1000 patch = shapely.geometry.box( patch.bounds[0] - (max_service_dist_km * longitude_factor), patch.bounds[1] - (max_service_dist_km * latitude_factor), patch.bounds[2] + (max_service_dist_km * longitude_factor), patch.bounds[3] + (max_service_dist_km * latitude_factor) ) walk_filter = ('["area"!~"yes"]["highway"!~"link|motor' '|proposed|construction|abandoned' '|platform|raceway"]' '["service"!~"parking_aisle|driveway"]' '["foot"!~"no"]["service"!~"private"]' '{}').format(ox.settings.default_access) if overpass: G = ox.graph_from_polygon(patch, custom_filter=walk_filter, simplify=False, retain_all=True) else: boundingarg = '-b=' boundingarg += str(patch.bounds[0])+',' boundingarg += str(patch.bounds[1])+',' boundingarg += str(patch.bounds[2])+',' boundingarg += str(patch.bounds[3]) subprocess.check_call(['osmconvert', str(folder_name)+'/citywalk.o5m', boundingarg, #'--complete-ways', '--drop-broken-refs', '-o=patch.osm']) G = ox.graph_from_xml('patch.osm', simplify=False, retain_all=True) os.remove('patch.osm') if 'pnb' in to_test: subprocess.check_call(['osmconvert', str(folder_name)+'/cityhighways.o5m', boundingarg, #'--complete-ways', '--drop-broken-refs', '-o=allhwyspatch.osm']) G_allhwys = ox.graph_from_xml('allhwyspatch.osm', simplify=False, retain_all=True) os.remove('allhwyspatch.osm') G.remove_nodes_from(list(nx.isolates(G))) G_allhwys.remove_nodes_from(list(nx.isolates(G_allhwys))) simple_G = ox.simplify_graph(G) center_nodes = {} for service in all_coords.keys(): if service in ['healthcare','schools','libraries','special']: center_nodes[service] = [] for coord in all_coords[service]: lat = coord[0] lon = coord[1] if unbuffered_patch.bounds[0] < lon < unbuffered_patch.bounds[2] and unbuffered_patch.bounds[1] < lat < unbuffered_patch.bounds[3]: point = shapely.geometry.Point(lon,lat) nearest = ox.get_nearest_node(simple_G, coord) if not nearest in center_nodes[service]: center_nodes[service].append(nearest) if 'pnb' in to_test: center_nodes['pnb'] = [] allhwys_gdf = ox.graph_to_gdfs(G_allhwys, nodes=False) print(allhwys_gdf.columns) waytypes = [] if 'highway' in allhwys_gdf.columns: waytypes.append(allhwys_gdf[allhwys_gdf['highway'] == 'cycleway']) if 'cycleway' in allhwys_gdf.columns: waytypes.append(allhwys_gdf[allhwys_gdf['cycleway'] == 'track']) if 'cycleway:left' in allhwys_gdf.columns: waytypes.append(allhwys_gdf[allhwys_gdf['cycleway:left'] == 'track']) if 'cycleway:right' in allhwys_gdf.columns: waytypes.append(allhwys_gdf[allhwys_gdf['cycleway:right'] == 'track']) cycletracknodes = [] for waytype in waytypes: for edge in waytype.index: if not edge[0] in cycletracknodes: cycletracknodes.append(edge[0]) if not edge[1] in cycletracknodes: cycletracknodes.append(edge[1]) for node in cycletracknodes: if node in simple_G.nodes: center_nodes['pnb'].append(node) if 'transit' in to_test: center_nodes['transit'] = [] transit_centers = {} for service_idx, service in enumerate(transit_stop_sets): for stop_id in service.keys(): lat = float(service[stop_id][1]) lon = float(service[stop_id][2]) headway = float(service[stop_id][0]) if unbuffered_patch.bounds[0] < lon < unbuffered_patch.bounds[2] and unbuffered_patch.bounds[1] < lat < unbuffered_patch.bounds[3]: center_node = ox.get_nearest_node(simple_G, (lat, lon)) if center_node not in transit_centers: transit_centers[center_node] = {service_idx : headway} #store the headway value elif service_idx not in transit_centers[center_node].keys(): transit_centers[center_node][service_idx] = headway elif headway < transit_centers[center_node][service_idx]: transit_centers[center_node][service_idx] = headway for center_node in transit_centers.keys(): if len(transit_centers[center_node]) > 0: inv_headway = 0 min_hw = 100 for service_idx in transit_centers[center_node].keys(): inv_headway += 1 / transit_centers[center_node][service_idx] if transit_centers[center_node][service_idx] < min_hw: min_hw = transit_centers[center_node][service_idx] headway = 1 / inv_headway if headway <= headway_threshold: center_nodes['transit'].append(center_node) # Project Graph if not crs: #this only runs once, crs is invariable over patches G = ox.project_graph(G) crs = G.graph['crs'] else: G = ox.project_graph(G, to_crs=crs) G = ox.simplify_graph(G) isochrone_polys = {} failures = {} for service in to_test: failures[service] = 0 # Get polygons for service in testing_services: isochrone_polys[service], fails = isochrones.make_iso_polys(G, center_nodes[service], distance=distances[service], edge_buff=buffer_dist) failures[service] += fails for service in isochrone_polys.keys(): if service not in quilt_isochrone_polys.keys() or not quilt_isochrone_polys[service]: quilt_isochrone_polys[service] = isochrone_polys[service] elif isochrone_polys[service]: quilt_isochrone_polys[service] = shapely.ops.cascaded_union([quilt_isochrone_polys[service],isochrone_polys[service]]) for service in center_nodes.keys(): quilt_center_nodes[service] = quilt_center_nodes[service] + center_nodes[service] patch_time = datetime.datetime.now() - patch_start print("finished patch #",p_idx,'out of', len(patches),"in",str(patch_time)) patch_times.append(patch_time) except ox._errors.EmptyOverpassResponse: pass except ValueError: pass #sorry #except: # print("GOT SOME ERROR FOR PATCH", p_idx) # except ValueError: # print('ValueError') # now = str(datetime.datetime.now()) # with open('error'+now+'.txt','w') as errout: # traceback.print_exc(limit=3,file=errout) # print('saved to error'+now+'.txt') #epsg = 32600+int(crs.split(' ')[1].split('=')[1]) #This is wild -- #osmnx seems to just give all data in northern-hemisphere format #Sorry about the stupid parsing of the projection definition, I'm lazy results = {'name':name,'id_code':id_code} if not os.path.exists(folder_name): os.makedirs(folder_name) boundaries_latlon = gpd.GeoDataFrame(geometry=[boundaries]) boundaries_latlon.crs = {'init':'epsg:4326'} try: boundaries_utm = boundaries_latlon.to_crs(crs) except ValueError: longitude = round(numpy.mean(boundaries_latlon.geometry.centroid.x),10) utm_zone = int(math.floor((longitude + 180) / 6) + 1) utm_crs = '+proj=utm +zone={} +ellps=WGS84 +datum=WGS84 +units=m +no_defs'.format(utm_zone) crs = utm_crs boundaries_utm = boundaries_latlon.to_crs(crs) stats = rasterstats.zonal_stats(boundaries_latlon, 'pop_dens.tif', stats=['sum']) total_pop = stats[0]['sum'] for service in testing_services: if quilt_isochrone_polys[service]: service_utm = gpd.GeoDataFrame(geometry = [quilt_isochrone_polys[service]]) service_utm.crs = crs#{'init':'epsg:'+str(epsg)} service_utm.geometry = service_utm.geometry.simplify(15) #maybe this should be after the population calculation service_utm = gpd.overlay(service_utm ,boundaries_utm, how='intersection') service_latlon = service_utm.to_crs(epsg=4326) service_latlon.to_file(folder_name+service+'latlon'+'.geojson', driver='GeoJSON') stats = rasterstats.zonal_stats(service_latlon, 'pop_dens.tif', stats=['sum']) total_PNS = stats[0]['sum'] print("\n") print('Total People Near Service for', service, ":", total_PNS) print(100*total_PNS/total_pop,"% of",total_pop) results[service] = total_PNS / total_pop else: print ('NO SERVICE FOR', service) results[service] = 0 if 'carfree' in to_test: print("getting carfree") if citywide_carfree: carfree_latlon = gpd.GeoDataFrame(geometry = citywide_carfree) #just a latlon list of points carfree_latlon.crs = {'init':'epsg:4326'} carfree_utm = carfree_latlon.to_crs(crs) carfree_utm.geometry = carfree_utm.geometry.buffer(100) #this is the analysis, the 100m buffer carfree_utm = gpd.GeoDataFrame(geometry = [shapely.ops.cascaded_union(carfree_utm.geometry)]) carfree_utm.geometry = carfree_utm.geometry.simplify(10) carfree_utm = gpd.overlay(carfree_utm ,boundaries_utm, how='intersection') carfree_utm.crs = crs carfree_latlon = carfree_utm.to_crs('epsg:4326') stats = rasterstats.zonal_stats(carfree_latlon, 'pop_dens.tif', stats=['sum']) total_carfree = stats[0]['sum'] print("\n") print('Total People Near Service for carfree', ":", total_carfree) print(100*total_carfree/total_pop,"% of",total_pop) results['carfree'] = total_carfree / total_pop carfree_latlon = carfree_utm.to_crs('epsg:4326') carfree_latlon.to_file(folder_name+'carfreelatlon'+'.geojson', driver='GeoJSON') else: print ('NO SERVICE FOR carfree') results['carfree'] = 0 if 'h+s' in to_test: if quilt_isochrone_polys['healthcare'] and quilt_isochrone_polys['schools']: service = 'h+s' intersect = quilt_isochrone_polys['healthcare'].intersection(quilt_isochrone_polys['schools']) if type(intersect) == shapely.geometry.collection.GeometryCollection: intersect = [obj for obj in intersect if type(obj) == shapely.geometry.polygon.Polygon] intersect = shapely.geometry.MultiPolygon(intersect) hs_utm = gpd.GeoDataFrame(geometry = [intersect]) hs_utm.crs = crs#{'init':'epsg:'+str(epsg)} #maybe this should be after the population calculation if hs_utm.geometry.area.sum() != 0: hs_utm = gpd.overlay(hs_utm ,boundaries_utm, how='intersection') hs_utm.geometry = hs_utm.geometry.simplify(15) hs_latlon = hs_utm.to_crs(epsg=4326) hs_latlon.to_file(folder_name+service+'latlon'+'.geojson', driver='GeoJSON') stats = rasterstats.zonal_stats(hs_latlon, 'pop_dens.tif', stats=['sum']) total_PNS = stats[0]['sum'] print("\n") print('Total People Near Service for', service, ":", total_PNS) print(100*total_PNS/total_pop,"% of",total_pop) results[service] = total_PNS / total_pop else: print ('NO SERVICE FOR h+s') results['h+s'] = 0 else: print ('NO SERVICE FOR h+s') results['h+s'] = 0 if 'density' in to_test: density = rasterstats.zonal_stats(boundaries, 'pop_dens.tif', stats = [], add_stats={'weighted': weighted_pop_density} )[0]['weighted'] results['density'] = density / 0.0625 #km^2 / pixel print('weighted pop density', results['density']) with rasterio.open('pop_dens.tif') as dataset: out_image, out_transform = rasterio.mask.mask(dataset, [boundaries], crop=True) out_meta = dataset.meta out_meta.update({"driver": "GTiff", "height": out_image.shape[1], "width": out_image.shape[2], "transform": out_transform}) with rasterio.open(folder_name+"pop_dens.tif", "w", **out_meta) as dest: dest.write(out_image) #garbage collection quilt_isochrone_polys = None isochrone_polys = None out_image = None dest = None dataset = None a = None b = None import gc gc.collect() if 'blocks' in to_test: print("getting blocks") patches = make_patches(boundaries, patch_length=patch_length) print ("cut", len(list(patches)),"patches for block size in",name) outblocks = [] block_counts = [] for n, patch in enumerate(patches): print("patch"+str(n)+" of "+str(len(patches)) ) unbuffered_patch = gpd.GeoSeries(patch, crs={'init':'epsg:4326'}) unbuffered_patch = unbuffered_patch.to_crs(crs)[0] buffer_dist = 1 patch = shapely.geometry.box( patch.bounds[0] - (buffer_dist * longitude_factor), patch.bounds[1] - (buffer_dist * latitude_factor), patch.bounds[2] + (buffer_dist * longitude_factor), patch.bounds[3] + (buffer_dist * latitude_factor) ) if overpass: G = ox.graph_from_polygon(patch, custom_filter=walk_filter, simplify=False, retain_all=True) else: boundingarg = '-b=' boundingarg += str(patch.bounds[0])+',' boundingarg += str(patch.bounds[1])+',' boundingarg += str(patch.bounds[2])+',' boundingarg += str(patch.bounds[3]) subprocess.check_call(['osmconvert', folder_name+'/citywalk.o5m', boundingarg, #'--complete-ways', '--drop-broken-refs', '-o=patch.osm']) try: G = ox.graph_from_xml('patch.osm', simplify=False, retain_all=True) except: G = False if G: try: G = ox.project_graph(G, to_crs=crs) G = ox.simplify_graph(G) streets = ox.utils_graph.graph_to_gdfs(G, nodes = False) if not streets.empty: streets = shapely.geometry.MultiLineString(list(streets.geometry)) merged = shapely.ops.linemerge(streets) if merged: borders = shapely.ops.unary_union(merged) blocks = list(shapely.ops.polygonize(borders)) all_blocks = [] selected_areas = [] for block in blocks: if 500 < block.area: #< 200000000: if block.interiors: block = shapely.geometry.Polygon(block.exterior) if block.centroid.within(unbuffered_patch): area = round(block.area, 3) perim = round(block.length, 3) lemgth = round((perim * perim) / area, 3) if blocks_simplification: block = block.simplify(blocks_simplification) all_blocks.append((block, area, perim, lemgth)) if (lemgth < 50) and (1000 < area < 1000000): selected_areas.append(area) outblocks += all_blocks block_counts.append(len(all_blocks)) else: block_counts.append(0) print('not merged!') else: block_counts.append(0) except: print('Hawassa Error') block_counts.append(0) else: block_counts.append(0) #export patch_densities = gpd.GeoDataFrame(geometry = list(patches)) patch_densities['block_count'] = block_counts patch_densities.crs = {'init':'epsg:4326'} patch_densities_utm = patch_densities.to_crs(crs) patch_densities_utm['density'] = patch_densities_utm.block_count / (patch_densities_utm.area /1000000) patch_densities_latlon = patch_densities_utm.to_crs(epsg=4326) patch_densities_latlon.to_file(folder_name+'patch_densities'+'latlon'+'.geojson', driver='GeoJSON') a = gpd.GeoDataFrame(geometry=[block[0] for block in outblocks]) a.crs = crs#{'init':'epsg:'+str(epsg)} a['area'] = [block[1] for block in outblocks] a['perim'] = [block[2] for block in outblocks] a['lemgth'] = [block[3] for block in outblocks] a['density'] = [1000000/block[1] for block in outblocks] b = a.to_crs(epsg=4326) b.to_file(folder_name+'blocks'+'latlon'+'.geojson', driver='GeoJSON') #b.to_file(folder_name+'blocks'+'latlon'+'.shp') filtered_blocks = [] for block in outblocks: if block[3] < 50: if 1000 < block[1] < 1000000: filtered_blocks.append(block) c = gpd.GeoDataFrame(geometry=[block[0] for block in outblocks]) c.crs = crs#{'init':'epsg:'+str(epsg)} c['area'] = [block[1] for block in outblocks] c['perim'] = [block[2] for block in outblocks] c['lemgth'] = [block[3] for block in outblocks] try: blockmedian = statistics.median([block[1] for block in filtered_blocks]) print('median block density') results['blockmedian_density'] = 1000000 / blockmedian print(results['blockmedian_density']) except: results['blockmedian_density'] = 0 print('BLOCK MEDIAN COULD NOT BE CALCULATED') try: blockmean = statistics.mean([block[1] for block in filtered_blocks]) print('mean block density') results['blockmean_density'] = 1000000 / blockmean print(results['blockmean_density']) except: results['blockmean_density'] = 0 print('BLOCK MEAN COULD NOT BE CALCULATED') ft = datetime.datetime.now() print("total", str(ft-dt)) results['calctime'] = str(ft-dt) results['total_pop'] = total_pop with open(folder_name+"results.json","w") as output: output.write(json.dumps(results)) for file in ['city.o5m','cityhighways.o5m','citywalk.o5m']: if os.path.exists(folder_name+'/'+file): os.remove(folder_name+'/'+file) return results
import osmnx as ox G = ox.graph_from_xml('extract.osm', bidirectional=True) ox.save_graphml(G, 'out.graphml')
end = graph.nodes(data=True)[b] # compute forward and back azimuths, plus distance azf, azb, distance = g.inv(start['x'], start['y'], end['x'], end['y']) # return only the distance we are only interested in the distance return distance # LOAD DATA IN XML (.osm) FORMAT AND CREATE GRAPH (from the xml dataset) # downloaded as .osm file for greater manchester (GM) # renamed .osm with .xml before loading data # convert the graph into a DiGraph (to permit duplicate edges - EXPLAIN WHY) # store the result in the variable 'graph' # use relative file path to load the data into the graph graph = DiGraph(graph_from_xml("mcr_osm.xml")) # print to check that the .xml file loaded correctly (remove this later) - doesnt work # # print(graph) plt.plot(graph) plt.show() # CALCULATE A SPATIAL INDEX FROM THE DIGRAPH build a spatial index - needed to take locations and find the nearest # node in the graph (one to define the start point and one to define the end point of the route) idx = index.Index() for _id, data in list(graph.nodes(data=True)): # convert the id to a number using int(id) idx.insert(int(_id), (data['x'], data['y'], data['x'], data['y'])) # CALCULATE NEAREST NODE TO THE START AND END POINT Just assign two random points for purposes of development # calculate the 'from' and 'to' node as the nearest to the specified coordinates rtree spatial indexes think about