def export_problem_to_directory(exit_on_success=False):
"""Populate directory with a shapefile representation of the problem.
Raises FileNotFoundError
"""
export_dir = utility.CLI.args().export_dir
problem = load_problem_file()
if not os.path.isdir(export_dir):
os.makedirs(export_dir)
temp_graph = nx.DiGraph()
temp_graph.add_node(
(problem['depot'][0]['longitude'], problem['depot'][0]['latitude']))
nx.write_shp(temp_graph, os.path.join(export_dir, 'depot.shp'))
for node_type in ('customer', 'station'):
temp_graph = nx.DiGraph()
for node in problem[node_type]:
temp_graph.add_node((node['longitude'], node['latitude']))
nx.write_shp(temp_graph, os.path.join(export_dir, node_type + '.shp'))
for ext in ('dbf', 'shp', 'shx'):
os.remove(os.path.join(export_dir, 'edges.' + ext))
Log.info(f'Exported correctly to \'{export_dir}\' '
'depot.shp, customers.shp and stations.shp\n')
if exit_on_success:
raise SystemExit(0)
def write_shp(g, out_file_path):
"""
This writes the DiGraph to GIS .shp project files.
Note 1: You will need to set the CRS manually in a GIS program;
that is not in this code as the processing can be too costly.
Note 2: Will only create one level of non-existent directories, else an OSError.
"""
#arr = self.splitpath(out_file_path)
#tmpstr = arr[0] + os.path.splitext(arr[1])[0]
#os.mkdir(tmpstr)
(path, filename) = validate_file(out_file_path, mode='write')
splitname = os.path.splitext(filename)
#create a directory with that path to avoid overwriting edges.shp
#when writing multiple networks out to the same directory
try:
os.mkdir(path + splitname[0])
print "made directory"
except OSError as exc:
if exc.errno != errno.EEXIST:
raise
pass
path_nofname = path + splitname[0]
fullpath = path + splitname[0] + '/' + filename
nx.write_shp(g, fullpath)
# rename edge files for clarity
for filename in os.listdir(path_nofname):
if filename.startswith("edges"):
os.rename(path_nofname + '/' + filename,
path_nofname + '/' + splitname[0] + '_' + filename)
def export_path_to_shp(path_dict, multy, multy_attribute, output_workspace, G):
new_graph = nx.MultiGraph()
a = 0
for node in path_dict:
path_list = path_dict[node]
path_list.insert(0, node)
b = 0
for edge in G.edges(keys=True):
c = 0
for i in range(len(path_list) - 1):
identifier = str(a) + str(b) + str(c)
if tuple([tuple(path_list[i]),
tuple(path_list[i + 1])
]) == tuple([edge[0], edge[1]]):
new_graph.add_edge(edge[0],
edge[1],
identifier,
Name=edge[2],
ident=identifier)
elif tuple([tuple(path_list[i + 1]),
tuple(path_list[i])]) == tuple([edge[0], edge[1]]):
new_graph.add_edge(edge[0],
edge[1],
identifier,
Name=edge[2],
ident=identifier)
c += 1
b += 1
a += 1
if multy == 'true':
nx_multi_shp.write_shp(new_graph, 'ident', output_workspace)
else:
nx.write_shp(new_graph, output_workspace)
def export_graph_to_shp(G, multy, output_workspace, multy_attribute=None):
"""Export networkx graph object to shapefile
Parameters
----------
G: networkx graph object
multy: str
If value is true – multigraph will be created
If value is false – simple graph will be created
output_workspace: str
path to the folder with output shapefile
multy_attribute: str
Field of the shapefile which allows to distinguish parallel edges.
Note that it could be a field of different types, but all values of this attribute should be filled
Returns
-------
None
"""
for item in ['edges.shp', 'nodes,shp']:
filename = os.path.join(output_workspace, item)
if os.path.exists(filename):
os.remove(filename)
if multy == 'true':
nx_multi_shp.write_shp(G, multy_attribute, output_workspace)
else:
nx.write_shp(G, output_workspace)
def edge_representation(row_from_label,
col_from_label,
row_to_label,
col_to_label,
distance_matrix,
node_label_list,
edge_list,
gt,
outDir,
epsg=3035):
rm_mk_dir(outDir)
G = nx.Graph()
x0, y0, w, h = gt[0], gt[3], gt[1], gt[5]
X0 = x0 + w / 2
Y0 = y0 + h / 2
for k in range(edge_list.shape[0]):
s, t, edge_weight = edge_list[k, :]
s, t = int(s), int(t)
py0_ind, px0_ind = row_from_label[s, t], col_from_label[s, t]
py1_ind, px1_ind = row_to_label[s, t], col_to_label[s, t]
px0, py0 = X0 + 100 * px0_ind, Y0 - 100 * py0_ind
px1, py1 = X0 + 100 * px1_ind, Y0 - 100 * py1_ind
# G.add_edge((px0, py0), (px1, py1), weight=distance_matrix[s, t])
G.add_edge((px0, py0), (px1, py1), weight=edge_weight)
nx.write_shp(G, outDir)
spatialRef = osr.SpatialReference()
spatialRef.ImportFromEPSG(epsg)
spatialRef.MorphToESRI()
for item in ['nodes', 'edges']:
prj_file = outDir + os.sep + item + '.prj'
with open(prj_file, 'w') as file:
file.write(spatialRef.ExportToWkt())
def disegna_soluzione(percorsi, punti, indici, n_veicoli):
# per ogni veicolo controllo che ci siano almeno tre elementi in indici altrimenti
# vuol dire che il veicolo rimane sempre in stazione: ogni percorso inizia
# con 0 id_clienti visitati 0 (parte e termina nella sorgente)
# n_veicoli=1
print n_veicoli
for i in range(0, n_veicoli):
if (len(indici[i]) == 2):
continue
filename = "./QGIS/output/v" + str(i)
Gsol = nx.DiGraph()
prec = 0
visita = 0
for j in range(1, len(indici[i])):
# voglio creare il cammino da punti[precedente] a punti[indici[j]]
# quindi:
# - prec corrisponde all'indice del veicolo da cui sto partendo
# (all'inizio la sorgente - 0)
# - devo andare al prossimo nodo (che è un cliente) visitato dal mio
# veicolo corrente, all'inizio sarà il secondo elemento del mio array
# di indici (array di visita del veicolo) recupero il nome completo
# da punti
# - creo la chiave
key = tuple([punti[prec], punti[indici[i][j]]])
# devo aggiungere un arco per ogni elenento della lista percorsi con chiave key
prev_point = percorsi[key][0]
for k in percorsi[key]:
if (k == percorsi[key][0]):
continue
Gsol.add_edge(prev_point, k, visita=visita)
visita = visita + 1
prev_point = k
# aggiorno precedente, il percorso continua
prec = indici[i][j]
nx.write_shp(Gsol, filename)
def test_geometryexport(self):
def testgeom(lyr, expected):
feature = lyr.GetNextFeature()
actualwkt = []
while feature:
actualwkt.append(feature.GetGeometryRef().ExportToWkt())
feature = lyr.GetNextFeature()
assert_equal(sorted(expected), sorted(actualwkt))
expectedpoints = (
"POINT (1 1)",
"POINT (2 2)",
"POINT (3 3)",
"POINT (0.9 0.9)",
"POINT (4 2)"
)
expectedlines = (
"LINESTRING (1 1,2 2)",
"LINESTRING (2 2,3 3)",
"LINESTRING (0.9 0.9,4 2)"
)
tpath = os.path.join(tempfile.gettempdir(),'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
testgeom(shpdir.GetLayerByName("nodes"), expectedpoints)
testgeom(shpdir.GetLayerByName("edges"), expectedlines)
def output(self, path):
out_results = 'sequenced-results.csv'
out_shp = 'sequenced-network'
# Write the shapefiles to path
nx.write_shp(self.networkplan.network, os.path.join(path, out_shp))
# Write the csv to path
cast = {
'Sequence..Vertex.id' : int,
'Sequence..Root.vertex.id' : int ,
'Sequence..Upstream.id' : int,
'Sequence..Far.sighted.sequence' : int}
for k,v in cast.iteritems():
self.output_frame[k] = self.output_frame[k].fillna(-9223372036854775807).astype(v)
self.output_frame.to_csv(os.path.join(path, 'temp.csv'), index=False, na_rep='NaN')
with open(os.path.join(path, 'temp.csv')) as f:
buff = f.read()
while True:
idx = buff.find('-9223372036854775807')
if idx != -1:
buff = buff.replace('-9223372036854775807', 'NaN', idx)
else:
break
with open(os.path.join(path, out_results), 'w') as f:
f.write(buff)
os.remove(os.path.join(path, 'temp.csv'))
# Trash the node shp files
[os.remove(os.path.join(os.path.join(path, out_shp), x))
for x in os.listdir(os.path.join(path, out_shp)) if 'node' in x]
def test_geometryexport(self):
expectedpoints_simple = ("POINT (1 1)", "POINT (2 2)", "POINT (3 3)",
"POINT (0.9 0.9)", "POINT (4 2)")
expectedlines_simple = ("LINESTRING (1 1,2 2)", "LINESTRING (2 2,3 3)",
"LINESTRING (0.9 0.9,4.0 0.9,4 2)")
expectedpoints = ("POINT (1 1)", "POINT (2 2)", "POINT (3 3)",
"POINT (0.9 0.9)", "POINT (4.0 0.9)", "POINT (4 2)")
expectedlines = ("LINESTRING (1 1,2 2)", "LINESTRING (2 2,3 3)",
"LINESTRING (0.9 0.9,4.0 0.9)",
"LINESTRING (4.0 0.9,4 2)")
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints_simple)
self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines_simple)
# Test unsimplified
# Nodes should have additional point,
# edges should be 'flattened'
G = nx.read_shp(self.shppath, simplify=False)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints)
self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines)
def run_script(iface):
catchment = []
r = 2000
i = 0
while i > len(cost):
if cost < r:
# next node
if cost(next) < r:
upperbound.append(i)
i = i + 1
G = nx.Graph() # creating an empty graph
nx.read_shp(str(iface.activeLayer().source()))
G.add_edge(1, 2, weight=4.7 )
M = nx.single_source_shortest_path_length(G,0,)
M = nx.ego_graph(G, (679980.26234586, 6059164.91455736), 1, center=True, undirected=False, distance=2000)
nx.write_shp()
layer = iface.mapCanvas().currentLayer()
for f in layer.getFeatures():
geom = f.geometry()
G.add_node(geom)
def shortestpath(STlist, filename, cwd):
if len(STlist) >= 2:
#SETup part for this function, it read in the the road shapefile, but only store four bounding
#box value
shxFile = open(filename + ".shx", "rb")
s = shxFile.read(28)
header = struct.unpack(">iiiiiii", s) # convert into 7 integers
s = shxFile.read(72)
header2 = struct.unpack("<iidddddddd", s)
minX, minY, maxX, maxY = header2[2], header2[3], header2[4], header2[5]
Arcxylist = []
windowWidth, windowHeight = 800, 600 # define window size
#calculate the ratio, same as 'openFile' function
ratiox = (maxX - minX) / windowWidth
ratioy = (maxY - minY) / windowHeight
ratio = ratiox
if ratioy > ratio:
ratio = ratioy
dsc = arcpy.Describe(filename + ".shp")
coord_sys = dsc.spatialReference
#The for loop below will convert Tkinter coordinates into Arcgis-real-world coorinates
for i in range(1, len(STlist), 2):
Arcxylist.append([
minX + STlist[i - 1][0] * ratio,
maxY - STlist[i - 1][1] * ratio
]) #[minX + source.x* ratio, maxY + source.y* ratio]
Arcxylist.append(
[minX + STlist[i][0] * ratio, maxY - STlist[i][1] * ratio])
#set up a relative small distance to compare
minD = 10000000
minD2 = 10000000
G = nx.read_shp("main_road_separte.shp")
Conlist = list(nx.connected_component_subgraphs(G.to_undirected()))
g = Conlist[0]
nodelist = g.nodes(data=True)
nodelist2 = g.nodes(data=True)
source = target = ()
for nodes in nodelist:
distance = Eucl(nodes[0][0], nodes[0][1], Arcxylist[i - 1][0],
Arcxylist[i - 1][1])
if distance < minD:
minD = distance
source = nodes[0]
for nodes2 in nodelist2:
distance2 = Eucl(nodes2[0][0], nodes2[0][1], Arcxylist[i][0],
Arcxylist[i][1])
if distance2 < minD2:
minD2 = distance2
target = nodes2[0]
result_graph = g.subgraph(nx.shortest_path(g, source, target))
directory = cwd + "sss" + "a" * i
if not os.path.exists(directory):
os.makedirs(directory)
nx.write_shp(result_graph, directory)
arcpy.DefineProjection_management(directory + "\\edges.shp",
coord_sys)
openFile(directory + "\\edges.shx", directory + "\\edges.shp",
"black")
else:
print "Selected Points not enough"
def create_island_to_island_graph(g: nx.DiGraph) -> nx.DiGraph:
GG = nx.DiGraph()
for node_a, node_b in g.edges_iter():
if node_a in g.edge[node_b]:
GG.add_edge((node_a, node_b), (node_b, node_a))
cab = g.edge[node_a][node_b]['region'].centroid
GG.node[(node_a, node_b)]['coord'] = (cab.x, cab.y)
nx.write_shp()
return GG
def remove_flood_data(graph, output):
"""
Intersects network routing graph with flood polygons and removes edges and nodes which are affected by the flood.
:param graph: graph of complete area
:type graph: osmnx or networkx network routing graph with edge and node file
:param output: folder path to save output
:type output: string
"""
flood_data = gpd.read_file(
path.join(DATA_DIR, SETTINGS['flood']['preprocessed']))
edge_data = list(graph.edges(data=True))
# create an empty spatial index object
index = rtree.index.Index()
counter = 0
for edge in range(len(edge_data)):
edge_geom = shape(
LineString([Point(edge_data[edge][0]),
Point(edge_data[edge][1])]))
index.insert(counter, edge_geom.bounds)
counter += 1
# check intersection and remove affected nodes
intersect_counter = 0
for poly in flood_data['geometry']:
for fid in list(index.intersection(shape(poly).bounds)):
edge_geom_shape = shape(
LineString(
[Point(edge_data[fid][0]),
Point(edge_data[fid][1])]))
if edge_geom_shape.intersects(shape(poly)):
e = edge_data[fid][0]
e_to = edge_data[fid][1]
# remove intersected edges
if graph.has_edge(e, e_to):
graph.remove_edge(e, e_to)
# remove intersected nodes
if Point(e).intersects(shape(poly)) and graph.has_node(e):
graph.remove_node(e)
intersect_counter += 1
if Point(e_to).intersects(
shape(poly)) and graph.has_node(e_to):
graph.remove_node(e_to)
intersect_counter += 1
print('Amount of intersected and removed nodes:', intersect_counter)
# save networkx graph with complete graph enum_id
try:
nx.write_shp(graph, output)
except Exception as err:
print(err)
print('Intersected networkx graph saved')
return graph
def export_path_to_shp(G, multy, output_workspace, path_dict_list):
"""Export of path (list of nodes) through graph to shapefile
Parameters
----------
G: networkx graph object
multy: str
If value is true – multigraph will be created
If value is false – simple graph will be created
output_workspace: str
path to the folder with output shapefile
path_dict_list: list
list of dicts kind of {start: [node1, node2, node3]}
Returns
-------
None
"""
new_graph = nx.MultiGraph(crs=G.graph['crs'])
e = 0
for path_dict in path_dict_list:
a = 0
for node in path_dict:
path_list = path_dict[node]
path_list.insert(0, node)
b = 0
for edge in G.edges(keys=True, data=True):
attribute_data = new_graph.get_edge_data(*edge)
new_attribute_data = {}
Wkt = attribute_data['Wkt']
c = 0
for i in range(len(path_list) - 1):
identifier = str(e) + str(a) + str(b) + str(c)
if tuple([tuple(path_list[i]), tuple(path_list[i + 1])]) == tuple(edge[:2])\
or tuple([tuple(path_list[i + 1]), tuple(path_list[i])]) == tuple(edge[:2]):
new_graph.add_edge(edge[0],
edge[1],
identifier,
Name=edge[2],
ident=identifier,
Wkt=Wkt)
new_attribute_data[edge[0], edge[1],
identifier] = attribute_data
nx.set_edge_attributes(new_graph, new_attribute_data)
c += 1
b += 1
a += 1
e += 1
if multy == 'true':
nx_multi_shp.write_shp(new_graph, 'ident', output_workspace)
else:
nx.write_shp(new_graph, output_workspace)
def degree_centrality(in_graph, multigraph, multi_attr, output, digraph):
G = aux_ie.convert_shp_to_graph(in_graph, digraph, multigraph, multi_attr)
if digraph == 'true':
in_deg_centrality = nx.in_degree_centrality(G)
out_deg_centrality = nx.out_degree_centrality(G)
nx.set_node_attributes(G, in_deg_centrality, 'in_DC')
nx.set_node_attributes(G, out_deg_centrality, 'out_DC')
else:
deg_centrality = nx.degree_centrality(G)
nx.set_node_attributes(G, deg_centrality, 'DC')
nx.write_shp(G, output)
def test_geometryexport(self):
expectedpoints = ("POINT (1 1)", "POINT (2 2)", "POINT (3 3)",
"POINT (0.9 0.9)", "POINT (4 2)")
expectedlines = ("LINESTRING (1 1,2 2)", "LINESTRING (2 2,3 3)",
"LINESTRING (0.9 0.9,4 2)")
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints)
self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines)
def read_shpfile(self,Path):
#read the shapefile
nx_load_shp=nx.read_shp('E:/data/bj/road_unsplit.shp')
self.nx_graph=nx_load_shp.to_undirected()
#find the largest connected subgraph
nx_list_subgraph=list(nx.connected_component_subgraphs(nx_load_shp.to_undirected()))[0]
# self.nx_graph=nx_list_subgraph
self.nx_nodes=np.array(nx_list_subgraph.nodes())
self.nx_edges=np.array(nx_list_subgraph.edges())
nx.write_shp(nx_list_subgraph,'C:/ww')
def store_shp(rn, target_path):
''' nodes: [lng, lat] '''
rn.remove_nodes_from(list(nx.isolates(rn)))
print('# of nodes:{}'.format(rn.number_of_nodes()))
print('# of edges:{}'.format(rn.number_of_edges()))
for _, _, data in rn.edges(data=True):
geo_line = ogr.Geometry(ogr.wkbLineString)
for coord in data['coords']:
geo_line.AddPoint(coord[0], coord[1])
data['Wkb'] = geo_line.ExportToWkb()
del data['coords']
nx.write_shp(rn, target_path)
def test_wkt_export(self):
G = nx.DiGraph()
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
points = ("POINT (0.9 0.9)", "POINT (4 2)")
line = ("LINESTRING (0.9 0.9,4 2)", )
G.add_node(1, Wkt=points[0])
G.add_node(2, Wkt=points[1])
G.add_edge(1, 2, Wkt=line[0])
try:
nx.write_shp(G, tpath)
except Exception, e:
assert False, e
def writeGraph(format, outfile): if format == 'gexf': nx.write_gexf(G, outfile) elif format == 'gml': nx.write_gml(G, outfile) elif format == 'graphml': nx.write_graphml(G, outfile) elif format == 'json': data = nx.node_link_data(G) with open(outfile, 'w') as of: json.dump(data, of) elif format == 'shp': nx.write_shp(G, outfile)
def calc_minimum_spanning_tree(input_network_shp, output_network_folder, building_nodes_shp, output_edges, output_nodes,
weight_field, type_mat_default, pipe_diameter_default):
# read shapefile into networkx format into a directed graph
graph = nx.read_shp(input_network_shp)
# transform to an undirected graph
iterator_edges = graph.edges(data=True)
G = nx.Graph()
# plant = (11660.95859999981, 37003.7689999986)
for (x, y, data) in iterator_edges:
G.add_edge(x, y, weight=data[weight_field])
# calculate minimum spanning tree of undirected graph
mst_non_directed = nx.minimum_spanning_edges(G, data=False)
# transform back directed graph and save:
mst_directed = nx.DiGraph()
mst_directed.add_edges_from(mst_non_directed)
nx.write_shp(mst_directed, output_network_folder)
# populate fields Type_mat, Name, Pipe_Dn
mst_edges = gdf.from_file(output_edges)
mst_edges['Type_mat'] = type_mat_default
mst_edges['Pipe_DN'] = pipe_diameter_default
mst_edges['Name'] = ["PIPE" + str(x) for x in mst_edges['FID']]
mst_edges.drop("FID", axis=1, inplace=True)
mst_edges.crs = gdf.from_file(input_network_shp).crs # to add coordinate system
mst_edges.to_file(output_edges, driver='ESRI Shapefile')
# populate fields Building, Type, Name
mst_nodes = gdf.from_file(output_nodes)
buiding_nodes_df = gdf.from_file(building_nodes_shp)
mst_nodes.crs = buiding_nodes_df.crs # to add same coordinate system
buiding_nodes_df['coordinates'] = buiding_nodes_df['geometry'].apply(
lambda x: (round(x.coords[0][0], 4), round(x.coords[0][1], 4)))
mst_nodes['coordinates'] = mst_nodes['geometry'].apply(
lambda x: (round(x.coords[0][0], 4), round(x.coords[0][1], 4)))
names_temporary = ["NODE" + str(x) for x in mst_nodes['FID']]
new_mst_nodes = mst_nodes.merge(buiding_nodes_df, suffixes=['', '_y'], on="coordinates", how='outer')
new_mst_nodes.fillna(value="NONE", inplace=True)
new_mst_nodes['Building'] = new_mst_nodes['Name']
new_mst_nodes['Name'] = names_temporary
new_mst_nodes['Type'] = new_mst_nodes['Building'].apply(lambda x: 'CONSUMER' if x != "NONE" else x)
new_mst_nodes.drop(["FID", "coordinates", 'floors_bg', 'floors_ag', 'height_bg', 'height_ag', 'geometry_y'], axis=1,
inplace=True)
new_mst_nodes.to_file(output_nodes, driver='ESRI Shapefile')
def test_attributeexport(self):
def testattributes(lyr, expected):
feature = lyr.GetNextFeature()
actualvalues = []
while feature:
actualvalues.append(feature.GetGeometryRef().ExportToWkt())
feature = lyr.GetNextFeature()
assert_equal(sorted(expected), sorted(actualvalues))
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
nodes = shpdir.GetLayerByName("nodes")
def test_attributeexport(self):
def testattributes(lyr, expected):
feature = lyr.GetNextFeature()
actualvalues = []
while feature:
actualvalues.append(feature.GetGeometryRef().ExportToWkt())
feature = lyr.GetNextFeature()
assert_equal(sorted(expected), sorted(actualvalues))
tpath = os.path.join(tempfile.gettempdir(),'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
nodes = shpdir.GetLayerByName("nodes")
def test_wkt_export(self):
G = nx.DiGraph()
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
points = ("POINT (0.9 0.9)", "POINT (4 2)")
line = ("LINESTRING (0.9 0.9,4 2)", )
G.add_node(1, Wkt=points[0])
G.add_node(2, Wkt=points[1])
G.add_edge(1, 2, Wkt=line[0])
try:
nx.write_shp(G, tpath)
except Exception as e:
assert False, e
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), points)
self.checkgeom(shpdir.GetLayerByName("edges"), line)
def test_missing_attributes(self):
G = nx.DiGraph()
A = (0, 0)
B = (1, 1)
C = (2, 2)
G.add_edge(A, B, foo=100)
G.add_edge(A, C)
nx.write_shp(G, self.path)
H = nx.read_shp(self.path)
for u, v, d in H.edges(data=True):
if u == A and v == B:
assert_equal(d['foo'], 100)
if u == A and v == C:
assert_equal(d['foo'], None)
def test_missing_attributes(self):
G = nx.DiGraph()
A = (0, 0)
B = (1, 1)
C = (2, 2)
G.add_edge(A, B, foo=100)
G.add_edge(A, C)
nx.write_shp(G, self.path)
H = nx.read_shp(self.path)
for u, v, d in H.edges(data=True):
if u == A and v == B:
assert_equal(d['foo'], 100)
if u == A and v == C:
assert_equal(d['foo'], None)
def store_rn_shp(rn, target_path):
print('# of nodes:{}'.format(rn.number_of_nodes()))
print('# of edges:{}'.format(rn.number_of_edges()))
for _, data in rn.nodes(data=True):
if 'pt' in data:
del data['pt']
for _, _, data in rn.edges(data=True):
geo_line = ogr.Geometry(ogr.wkbLineString)
for coord in data['coords']:
geo_line.AddPoint(coord.lng, coord.lat)
data['Wkb'] = geo_line.ExportToWkb()
del data['coords']
if 'length' in data:
del data['length']
if not rn.is_directed():
rn = rn.to_directed()
nx.write_shp(rn, target_path)
def test_nodeattributeexport(self):
tpath = os.path.join(tempfile.gettempdir(), "shpdir")
G = nx.DiGraph()
A = (0, 0)
B = (1, 1)
C = (2, 2)
G.add_edge(A, B)
G.add_edge(A, C)
label = "node_label"
for n, d in G.nodes(data=True):
d["label"] = label
nx.write_shp(G, tpath)
H = nx.read_shp(tpath)
for n, d in H.nodes(data=True):
assert d["label"] == label
def test_nodeattributeexport(self):
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
G = nx.DiGraph()
A = (0, 0)
B = (1, 1)
C = (2, 2)
G.add_edge(A, B)
G.add_edge(A, C)
label = 'node_label'
for n, d in G.nodes(data=True):
d['label'] = label
nx.write_shp(G, tpath)
H = nx.read_shp(tpath)
for n, d in H.nodes(data=True):
assert_equal(d['label'], label)
def edge_representation(row_from_label, col_from_label, row_to_label,
col_to_label, distance_matrix, node_label_list,
edge_list, gt, out_shp_edges, out_shp_nodes, outDir,
epsg=3035):
G = nx.Graph()
x0, y0 , w , h = gt[0], gt[3], gt[1], gt[5]
X0 = x0 + w/2
Y0 = y0 + h/2
for k in range(edge_list.shape[0]):
s, t, edge_weight = edge_list[k, :]
s, t = int(s), int(t)
py0_ind, px0_ind = row_from_label[s, t], col_from_label[s, t]
py1_ind, px1_ind = row_to_label[s, t], col_to_label[s, t]
px0, py0 = X0 + 100 * px0_ind, Y0 - 100 * py0_ind
px1, py1 = X0 + 100 * px1_ind, Y0 - 100 * py1_ind
# G.add_edge((px0, py0), (px1, py1), weight=distance_matrix[s, t])
G.add_edge((px0, py0), (px1, py1), capacity=str(round(edge_weight, 2)) + " MW")
nx.write_shp(G, outDir)
spatialRef = osr.SpatialReference()
spatialRef.ImportFromEPSG(epsg)
spatialRef.MorphToESRI()
for item in ['nodes', 'edges']:
prj_file = outDir + os.sep + item + '.prj'
with open(prj_file, 'w') as file:
file.write(spatialRef.ExportToWkt())
G = None
gdf = gpd.read_file(outDir + '/edges.shp')
#gdf['line'] = np.array([1]*edge_list.shape[0])
#gdf['color'] = np.array(["#ef3b2c"]*edge_list.shape[0])
#gdf['fillColor'] = np.array(["#ef3b2c"]*edge_list.shape[0])
#gdf['opacity'] = np.array(["0.7"]*edge_list.shape[0])
gdf.to_file(out_shp_edges)
gdf = None
for filename in os.listdir(outDir):
if filename.startswith("edges"):
os.remove(outDir + os.sep + filename)
if filename.startswith("nodes"):
os.remove(outDir + os.sep + filename)
'''
def test_geometryexport(self):
expectedpoints_simple = (
"POINT (1 1)",
"POINT (2 2)",
"POINT (3 3)",
"POINT (0.9 0.9)",
"POINT (4 2)"
)
expectedlines_simple = (
"LINESTRING (1 1,2 2)",
"LINESTRING (2 2,3 3)",
"LINESTRING (0.9 0.9,4.0 0.9,4 2)"
)
expectedpoints = (
"POINT (1 1)",
"POINT (2 2)",
"POINT (3 3)",
"POINT (0.9 0.9)",
"POINT (4.0 0.9)",
"POINT (4 2)"
)
expectedlines = (
"LINESTRING (1 1,2 2)",
"LINESTRING (2 2,3 3)",
"LINESTRING (0.9 0.9,4.0 0.9)",
"LINESTRING (4.0 0.9,4 2)"
)
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints_simple)
self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines_simple)
# Test unsimplified
# Nodes should have additional point,
# edges should be 'flattened'
G = nx.read_shp(self.shppath, simplify=False)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints)
self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines)
def edge_representation_old(label_raster,
dh_bool_raster,
distance_matrix,
node_label_list,
edge_list,
outDir,
epsg=3035):
rm_mk_dir(outDir)
G = nx.Graph()
label_ds = gdal.Open(label_raster)
label_band = label_ds.GetRasterBand(1)
label_arr = label_band.ReadAsArray()
bool_ds = gdal.Open(dh_bool_raster)
bool_band = bool_ds.GetRasterBand(1)
bool_arr = bool_band.ReadAsArray()
numLabels = np.max(label_arr)
coords = measurements.center_of_mass(bool_arr,
label_arr,
index=np.arange(1, numLabels + 1))
gt = label_ds.GetGeoTransform()
x0, y0, w, h = gt[0], gt[3], gt[1], gt[5]
bool_ds = label_ds = gt = None
X0 = x0 + w / 2
Y0 = y0 + h / 2
x = []
y = []
for i, item in enumerate(coords):
x.append(X0 + 100 * item[1])
y.append(Y0 - 100 * item[0])
if node_label_list[i]:
G.add_node((x[i], y[i]))
for k in range(edge_list.shape[0]):
s, t, edge_weight = edge_list[k, :]
s, t = int(s), int(t)
# G.add_edge((x[s], y[s]), (x[t], y[t]), weight=distance_matrix[s, t])
G.add_edge((x[s], y[s]), (x[t], y[t]), weight=edge_weight)
nx.write_shp(G, outDir)
spatialRef = osr.SpatialReference()
spatialRef.ImportFromEPSG(epsg)
spatialRef.MorphToESRI()
for item in ['nodes', 'edges']:
prj_file = outDir + os.sep + item + '.prj'
with open(prj_file, 'w') as file:
file.write(spatialRef.ExportToWkt())
def test_geometryexport(self):
expectedpoints = (
"POINT (1 1)",
"POINT (2 2)",
"POINT (3 3)",
"POINT (0.9 0.9)",
"POINT (4 2)"
)
expectedlines = (
"LINESTRING (1 1,2 2)",
"LINESTRING (2 2,3 3)",
"LINESTRING (0.9 0.9,4 2)"
)
tpath = os.path.join(tempfile.gettempdir(),'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), expectedpoints)
self.checkgeom(shpdir.GetLayerByName("edges"), expectedlines)
def test_attributeexport(self):
def testattributes(lyr, graph):
feature = lyr.GetNextFeature()
while feature:
coords = []
ref = feature.GetGeometryRef()
last = ref.GetPointCount() - 1
edge_nodes = (ref.GetPoint_2D(0), ref.GetPoint_2D(last))
name = feature.GetFieldAsString('Name')
assert_equal(graph.get_edge_data(*edge_nodes)['Name'], name)
feature = lyr.GetNextFeature()
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
G = nx.read_shp(self.shppath)
nx.write_shp(G, tpath)
shpdir = ogr.Open(tpath)
edges = shpdir.GetLayerByName("edges")
testattributes(edges, G)
def test_wkt_export(self):
G = nx.DiGraph()
tpath = os.path.join(tempfile.gettempdir(), 'shpdir')
points = (
"POINT (0.9 0.9)",
"POINT (4 2)"
)
line = (
"LINESTRING (0.9 0.9,4 2)",
)
G.add_node(1, Wkt=points[0])
G.add_node(2, Wkt=points[1])
G.add_edge(1, 2, Wkt=line[0])
try:
nx.write_shp(G, tpath)
except Exception as e:
assert False, e
shpdir = ogr.Open(tpath)
self.checkgeom(shpdir.GetLayerByName("nodes"), points)
self.checkgeom(shpdir.GetLayerByName("edges"), line)
def import_shapefile_to_workspace(exit_on_success=False):
"""Populate workspace with translation of import_shapefile into a graph.
Raises NameError
"""
import_file = utility.CLI.args().import_file
ws = utility.CLI.args().workspace
imported_graph = nx.read_shp(path=import_file, simplify=True)
Log.info(f'File \'{import_file}\' imported correctly')
if not ws:
raise NameError('Please set workspace dir')
nx.write_shp(imported_graph, ws)
Log.info(f'Exported correctly to \'{ws}\' nodes.shp and edges.shp\n')
Log.info('PLEASE ADD TO \'{}\' ELEVATION '
'INFORMATION !'.format(os.path.join(ws, 'nodes.shp')))
Log.info('(Open with QGIS the node.shp and a dem.tif')
Log.info('then with Point Sampling Tool Plugin create a new node.shp)')
if exit_on_success:
raise SystemExit(0)
def runNetwork(job, options):
coords = np.load("FNodes.npy")
labels, cluster_centers = doCluster(coords)
nodosByLabel = getNodes(coords, labels, 4)
###Saving info nodes for QGIS app
with job.fileStore.writeGlobalFileStream() as (fileHandle, outID):
fileHandle.write("lat,long,frec\n")
for idx, key in enumerate(nodosByLabel.keys()):
fileHandle.write("%s,%s,%s,%i\n" %
(idx, cluster_centers[key][0],
cluster_centers[key][1], len(nodosByLabel[key])))
job.fileStore.exportFile(
outID,
'file:///Users/isaac/IdeaProjects/Network_Workflow/qgis_stats_nodes.csv'
)
seq = getEdges(coords, labels)
G = createGraph(nodosByLabel, cluster_centers, seq)
#==============================================================================
# Save: shaping file
#==============================================================================
# BUG of NX library
mapping = {}
counter = 0
for idx, d in enumerate(G.nodes):
co_od = (G.node[d]["lat"], G.node[d]["lng"])
mapping[counter] = co_od
counter += 1
G = nx.relabel_nodes(G, mapping)
with job.fileStore.writeGlobalFileStream() as (fileHandle, outID):
nx.write_shp(G, fileHandle)
job.fileStore.exportFile(
outID, 'file:///Users/isaac/IdeaProjects/Network_Workflow/shape')
def write_shp(geograph, shp_dir):
""" writes a shapefile from a networkx based GeoGraph object
Args:
geograph: GeoGraph object
shp_dir: string path to dir to write shape files
"""
assert geograph.is_aligned()
# looks like networkx wants us to relabel nodes by their coords
tup_map = {i: tuple(coords) for i, coords in geograph.coords.items()}
# copy geograph to plain networkx graph
# (relabeling a GeoGraph doesn't seem to work)
nx_coord_graph = nx.Graph(data=geograph)
nx.relabel_nodes(nx_coord_graph, tup_map, copy=False)
nx.write_shp(nx_coord_graph, shp_dir)
if geograph.srs:
# write srs info to prj file (nx seems to miss this)
sr = osr.SpatialReference()
sr.ImportFromProj4(geograph.srs)
main_prj_filename = shp_dir + '.prj'
edge_prj_filename = os.path.join(shp_dir, 'edges.prj')
node_prj_filename = os.path.join(shp_dir, 'nodes.prj')
def write_prj(prj_filename):
out = open(prj_filename, 'w')
out.write(sr.ExportToWkt())
out.close()
write_prj(main_prj_filename)
write_prj(edge_prj_filename)
write_prj(node_prj_filename)
# for i in EffectivePathIndex:
# SelectNodesGraph = createSelectNodesGraph(CandidateNodesList, i, ScoreMatrix)
# MaxScorePath = findMaxScorePath(CandidateNodesList, SelectNodesGraph, i)
# EffectivePath = findEffectivePath(MaxScorePath, CandidateNodesList, MatchedNodesList, Graph, i)
# TheLastPath = findTheLastPath(MaxScorePath, EffectivePath)
# for j in range(len(TheLastPath)-1):
# Road.append((TheLastPath[j],TheLastPath[j+1]))
# del SelectNodesGraph
# return Road
def mappingOneTaxi(filename, Graph, G):
TaxiDataList = readTaxiData(filename)
for i in TaxiDataList:
try:
mappingOnePath(i, Graph)
# Road = mappingOnePath(i, Graph)
# G.add_edges_from(Road)
# del Road
except Exception,e:
fp = open('log.txt','a')
fp.write(str(e)+'\t'+str(i)+'\n\n')
fp.close()
nx.write_shp(G, './Graph')
return
#Get shapefile directory
shp = str(arcpy.GetParameterAsText(0))
simplify = False
#Convert shapefile to networkx graph
arcpy.AddMessage("Converting to NetworkX Graph")
G = nx.read_shp(shp, simplify)
undinet = G.to_undirected()
#Clear edge dictionary
arcpy.AddMessage("Clearing attribute dictionary for ~performace~")
for u,v,a in undinet.edges(data=True):
a.clear()
#Get connected components subgraphs
arcpy.AddMessage("Finding low-stress islands")
concomponents = list(nx.connected_component_subgraphs(undinet))
entries = len(concomponents)
arcpy.AddMessage(entries)
##Loop through subgraphs
arcpy.AddMessage("Exporting to thousands of shapefiles")
for subgraphs in range(0, entries):
path = "C:\Users\zmer\Documents\Network Wzrd\Scripts\NetworkX\SubNet_Workspace\Export_Shapefiles\\" + str(subgraphs+1) + ".shp"
Graph = concomponents[subgraphs]
nx.write_shp(Graph, path)
arcpy.AddMessage(subgraphs)
def write_shp(G, outdir):
""" Active development for shp write is now done in networkx. This function left in for compatibilty purposes.
"""
nx.write_shp(G, outdir)
