def build_graphs(self) -> None:
"""Builds graphs for all modes currently available in the model
When called, it overwrites all graphs previously created and stored in the networks'
dictionary of graphs
"""
curr = self.conn.cursor()
curr.execute('PRAGMA table_info(links);')
field_names = curr.fetchall()
ignore_fields = ['ogc_fid', 'geometry']
all_fields = [f[1] for f in field_names if f[1] not in ignore_fields]
raw_links = curr.execute(
f"select {','.join(all_fields)} from links").fetchall()
links = []
for l in raw_links:
lk = list(map(lambda x: np.nan if x is None else x, l))
links.append(lk)
data = np.core.records.fromrecords(links, names=all_fields)
valid_fields = []
removed_fields = []
for f in all_fields:
if np.issubdtype(data[f].dtype, np.floating) or np.issubdtype(
data[f].dtype, np.integer):
valid_fields.append(f)
else:
removed_fields.append(f)
if len(removed_fields) > 1:
warn(
f'Fields were removed form Graph for being non-numeric: {",".join(removed_fields)}'
)
curr.execute('select node_id from nodes where is_centroid=1;')
centroids = np.array([i[0] for i in curr.fetchall()], np.uint32)
modes = curr.execute('select mode_id from modes;').fetchall()
modes = [m[0] for m in modes]
for m in modes:
w = np.core.defchararray.find(data['modes'], m)
net = np.array(data[valid_fields], copy=True)
net['b_node'][w < 0] = net['a_node'][w < 0]
g = Graph()
g.mode = m
g.network = net
g.network_ok = True
g.status = 'OK'
g.prepare_graph(centroids)
g.set_blocked_centroid_flows(True)
self.graphs[m] = g
def assign_matrix(self, matrix: AequilibraeMatrix, result_name: str):
conn = database_connection()
sql = f"select link_id, direction, a_node, b_node, distance, 1 capacity from {DELAUNAY_TABLE}"
df = pd.read_sql(sql, conn)
centroids = np.array(np.unique(np.hstack((df.a_node.values, df.b_node.values))), int)
g = Graph()
g.mode = 'delaunay'
g.network = df
g.prepare_graph(centroids)
g.set_blocked_centroid_flows(True)
tc = TrafficClass('delaunay', g, matrix)
ta = TrafficAssignment()
ta.set_classes([tc])
ta.set_time_field('distance')
ta.set_capacity_field('capacity')
ta.set_vdf('BPR')
ta.set_vdf_parameters({"alpha": 0, "beta": 1.0})
ta.set_algorithm('all-or-nothing')
ta.execute()
report = {"setup": str(ta.info())}
data = [result_name, "Delaunay assignment", self.procedure_id, str(report), ta.procedure_date, '']
conn.execute("""Insert into results(table_name, procedure, procedure_id, procedure_report, timestamp,
description) Values(?,?,?,?,?,?)""", data)
conn.commit()
conn.close()
cols = []
for x in matrix.view_names:
cols.extend([f'{x}_ab', f'{x}_ba', f'{x}_tot'])
df = ta.results()[cols]
conn = sqlite3.connect(join(environ[ENVIRON_VAR], "results_database.sqlite"))
df.to_sql(result_name, conn)
conn.close()
class TestGraph(TestCase):
def test_create_from_geography(self):
self.graph = Graph()
self.graph.create_from_geography(
test_network, 'link_id', 'dir', 'distance', centroids=centroids, skim_fields = [], anode="A_NODE",
bnode="B_NODE")
self.graph.set_graph(cost_field='distance', block_centroid_flows=True)
def test_load_network_from_csv(self):
pass
def test_prepare_graph(self):
self.test_create_from_geography()
self.graph.prepare_graph(centroids)
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
if not np.array_equal(self.graph.graph, reference_graph.graph):
self.fail('Reference graph and newly-prepared graph are not equal')
def test_set_graph(self):
self.test_prepare_graph()
self.graph.set_graph(cost_field='distance',block_centroid_flows=True)
if self.graph.num_zones != centroids.shape[0]:
self.fail('Number of centroids not properly set')
if self.graph.num_links != 222:
self.fail('Number of links not properly set')
if self.graph.num_nodes != 93:
self.fail('Number of nodes not properly set - ' + str(self.graph.num_nodes))
def test_save_to_disk(self):
self.test_create_from_geography()
self.graph.save_to_disk(join(path_test, 'aequilibrae_test_graph.aeg'))
self.graph_id = self.graph.__id__
self.graph_version = self.graph.__version__
def test_load_from_disk(self):
self.test_save_to_disk()
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
new_graph = Graph()
new_graph.load_from_disk(join(path_test, 'aequilibrae_test_graph.aeg'))
comparisons = [('Graph', new_graph.graph, reference_graph.graph),
('b_nodes', new_graph.b_node, reference_graph.b_node),
('Forward-Star', new_graph.fs, reference_graph.fs),
('cost', new_graph.cost, reference_graph.cost),
('centroids', new_graph.centroids, reference_graph.centroids),
('skims', new_graph.skims, reference_graph.skims),
('link ids', new_graph.ids, reference_graph.ids),
('Network', new_graph.network, reference_graph.network),
('All Nodes', new_graph.all_nodes, reference_graph.all_nodes),
('Nodes to indices', new_graph.nodes_to_indices, reference_graph.nodes_to_indices)]
for comparison, newg, refg in comparisons:
if not np.array_equal(newg, refg):
self.fail('Reference %s and %s created and saved to disk are not equal' %(comparison, comparison))
comparisons = [('nodes', new_graph.num_nodes, reference_graph.num_nodes),
('links', new_graph.num_links, reference_graph.num_links),
('zones', new_graph.num_zones, reference_graph.num_zones),
('block through centroids', new_graph.block_centroid_flows, reference_graph.block_centroid_flows),
('Graph ID', new_graph.__id__, self.graph_id),
('Graph Version', new_graph.__version__, self.graph_version)]
for comparison, newg, refg in comparisons:
if newg != refg:
self.fail('Reference %s and %s created and saved to disk are not equal' %(comparison, comparison))
def test_reset_single_fields(self):
pass
def test_add_single_field(self):
pass
def test_available_skims(self):
self.test_set_graph()
if self.graph.available_skims() != ['distance']:
self.fail('Skim availability with problems')
class GraphCreation(WorkerThread):
def __init__(self, parentThread, net_layer, link_id, direction_field, fields_to_add, selected_only):
WorkerThread.__init__(self, parentThread)
self.net_layer = net_layer
self.link_id = link_id
self.direction_field = direction_field
self.fields_to_add = fields_to_add
self.selected_only = selected_only
self.features = None
self.error = None
self.report = []
self.feat_count = 0
self.bi_directional = False
if direction_field is not None:
self.bi_directional = True
def doWork(self):
if self.selected_only:
self.features = self.net_layer.selectedFeatures()
self.feat_count = self.net_layer.selectedFeatureCount()
else:
self.features = self.net_layer.getFeatures()
self.feat_count = self.net_layer.featureCount()
# Checking ID uniqueness
self.report.append(reporter("Checking ID uniqueness", 0))
self.emit(SIGNAL("ProgressText ( PyQt_PyObject )"),"Checking ID uniqueness. Please wait")
all_ids = self.net_layer.uniqueValues(self.link_id)
if NULL in all_ids:
self.error = "ID field has NULL values"
self.report.append(self.error)
else:
if len(all_ids) < self.feat_count:
self.error = 'IDs are not unique.'
self.report.append(self.error)
if self.error is None:
self.report.append(reporter('Loading data from layer', 0))
self.emit(SIGNAL("ProgressText ( PyQt_PyObject )"),"Loading data from layer")
self.emit(SIGNAL("ProgressValue( PyQt_PyObject )"), 0)
self.emit(SIGNAL("ProgressMaxValue( PyQt_PyObject )"), self.feat_count)
self.graph = Graph()
all_types = [np.int32, np.int32, np.int32, np.int8]
all_titles = [reserved_fieds.link_id, reserved_fieds.a_node, reserved_fieds.b_node, reserved_fieds.direction]
for name_field, values in self.fields_to_add.iteritems():
all_titles.append((name_field + '_ab').encode('ascii','ignore'))
all_types.append(np.float64)
all_titles.append((name_field + '_ba').encode('ascii','ignore'))
all_types.append(np.float64)
dt = [(t, d) for t, d in zip(all_titles, all_types)]
a_node = self.net_layer.fieldNameIndex(reserved_fieds.a_node)
b_node = self.net_layer.fieldNameIndex(reserved_fieds.b_node)
data = []
for p, feat in enumerate(self.features):
line = []
line.append(feat.attributes()[self.link_id])
line.append(feat.attributes()[a_node])
line.append(feat.attributes()[b_node])
if self.bi_directional:
line.append(feat.attributes()[self.direction_field])
else:
line.append(1)
# We append the data fields now
for k, v in self.fields_to_add.iteritems():
a, b = v
line.append(feat.attributes()[a])
if self.bi_directional:
line.append(feat.attributes()[b])
else:
line.append(-1)
for k in line:
if k == NULL:
t = ','.join([str(x) for x in line])
self.error = 'Field with NULL value - ID:' + str(line[0]) + " / " + t
break
if self.error is not None:
break
data.append(line)
if p % 50 == 0:
self.emit(SIGNAL("ProgressValue( PyQt_PyObject )"), p)
if self.error is None:
self.report.append(reporter('Converting data to graph', 0))
network = np.asarray(data)
self.graph.network = np.zeros(network.shape[0], dtype=dt)
for k, t in enumerate(dt):
self.graph.network[t[0]] = network[:,k].astype(t[1])
del network
self.graph.type_loaded = 'NETWORK'
self.graph.status = 'OK'
self.graph.network_ok = True
self.graph.prepare_graph()
self.graph.__source__ = None
self.graph.__field_name__ = None
self.graph.__layer_name__ = None
self.report.append(reporter('Process finished', 0))
self.emit(SIGNAL("finished_threaded_procedure( PyQt_PyObject )"), None)
class GraphCreation(WorkerThread):
def __init__(self, parentThread, netlayer, linkid, ablength, bidirectional,
directionfield, balength, skims, selected_only, featcount):
WorkerThread.__init__(self, parentThread)
self.netlayer = netlayer
self.linkid = linkid
self.ablength = ablength
self.balength = balength
self.bidirectional = bidirectional
self.directionfield = directionfield
self.skims = skims
self.selected_only = selected_only
self.features = None
self.featcount = featcount
self.error = None
def doWork(self):
# Checking ID uniqueness
self.emit(SIGNAL("ProgressText ( PyQt_PyObject )"),
"Checking ID uniqueness")
self.emit(SIGNAL("ProgressMaxValue( PyQt_PyObject )"), self.featcount)
a = []
all_ids = np.zeros(self.featcount, dtype=np.int_)
if self.selected_only:
self.features = self.netlayer.selectedFeatures()
else:
self.features = self.netlayer.getFeatures()
p = 0
for feat in self.features:
k = feat.attributes()[self.linkid]
if k == NULL:
self.error = "ID field has NULL values"
break
else:
all_ids[p] = k
p += 1
if p % 50 == 0:
self.emit(SIGNAL("ProgressValue( PyQt_PyObject )"), p)
self.emit(SIGNAL("ProgressValue( PyQt_PyObject )"), self.featcount)
if self.error is None:
# Checking uniqueness
y = np.bincount(all_ids)
if np.max(y) > 1:
self.error = 'IDs are not unique.'
if self.error is None:
self.emit(SIGNAL("ProgressText ( PyQt_PyObject )"),
"Loading data from layer")
self.emit(SIGNAL("ProgressValue( PyQt_PyObject )"), 0)
self.graph = Graph()
all_types = [
np.int64, np.int64, np.int64, np.float64, np.float64, np.int64
]
all_titles = [
'link_id', 'a_node', 'b_node', 'length_ab', 'length_ba',
'direction'
]
dict_field = {}
for k in self.skims:
a, b, t = self.skims[k]
all_types.append(np.float64)
all_types.append(np.float64)
all_titles.append((k + '_ab').encode('ascii', 'ignore'))
all_titles.append((k + '_ba').encode('ascii', 'ignore'))
dict_field[k + '_ab'] = a
if self.bidirectional:
dict_field[k + '_ba'] = b
else:
dict_field[k + '_ba'] = -1
dt = [(t, d) for t, d in zip(all_titles, all_types)]
anode = self.netlayer.fieldNameIndex('A_Node')
bnode = self.netlayer.fieldNameIndex('B_Node')
data = []
if self.selected_only:
self.features = self.netlayer.selectedFeatures()
else:
self.features = self.netlayer.getFeatures()
p = 0
for feat in self.features:
line = []
line.append(feat.attributes()[self.linkid])
line.append(feat.attributes()[anode])
line.append(feat.attributes()[bnode])
line.append(feat.attributes()[self.ablength])
if self.bidirectional:
line.append(feat.attributes()[self.balength])
line.append(feat.attributes()[self.directionfield])
else:
line.append(-1)
line.append(1)
# We append the skims now
for k in all_titles:
if k in dict_field:
if dict_field[k] >= 0:
line.append(feat.attributes()[dict_field[k]])
else:
line.append(-1)
for k in line:
if k == NULL:
t = ''
for j in line:
t = t + ',' + str(j)
self.error = 'Field with NULL value - ID:' + str(
line[0]) + " / " + t
break
if self.error is not None:
break
data.append(line)
p += 1
if p % 50 == 0:
self.emit(SIGNAL("ProgressValue( PyQt_PyObject )"), p)
if self.error is None:
network = np.asarray(data)
del data
self.graph.network = np.zeros(network.shape[0], dtype=dt)
for k, t in enumerate(dt):
self.graph.network[t[0]] = network[:, k].astype(t[1])
del network
self.graph.type_loaded = 'NETWORK'
self.graph.status = 'OK'
self.graph.network_ok = True
self.graph.prepare_graph()
self.graph.__source__ = None
self.graph.__field_name__ = None
self.graph.__layer_name__ = None
self.emit(SIGNAL("FinishedThreadedProcedure( PyQt_PyObject )"), None)
class TestGraph(TestCase):
def test_create_from_geography(self):
self.graph = Graph()
self.graph.create_from_geography(
test_network,
"link_id",
"dir",
"distance",
centroids=centroids,
skim_fields=[],
anode="A_NODE",
bnode="B_NODE",
)
self.graph.set_graph(cost_field="distance")
self.graph.set_blocked_centroid_flows(block_centroid_flows=True)
self.graph.set_skimming("distance")
def test_prepare_graph(self):
self.test_create_from_geography()
self.graph.prepare_graph(centroids)
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
if not np.array_equal(self.graph.graph, reference_graph.graph):
self.fail("Reference graph and newly-prepared graph are not equal")
def test_set_graph(self):
self.test_prepare_graph()
self.graph.set_graph(cost_field="distance")
self.graph.set_blocked_centroid_flows(block_centroid_flows=True)
if self.graph.num_zones != centroids.shape[0]:
self.fail("Number of centroids not properly set")
if self.graph.num_links != 222:
self.fail("Number of links not properly set")
if self.graph.num_nodes != 93:
self.fail("Number of nodes not properly set - " +
str(self.graph.num_nodes))
def test_save_to_disk(self):
self.test_create_from_geography()
self.graph.save_to_disk(join(path_test, "aequilibrae_test_graph.aeg"))
self.graph_id = self.graph.__id__
self.graph_version = self.graph.__version__
def test_load_from_disk(self):
self.test_save_to_disk()
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
new_graph = Graph()
new_graph.load_from_disk(join(path_test, "aequilibrae_test_graph.aeg"))
comparisons = [
("Graph", new_graph.graph, reference_graph.graph),
("b_nodes", new_graph.b_node, reference_graph.b_node),
("Forward-Star", new_graph.fs, reference_graph.fs),
("cost", new_graph.cost, reference_graph.cost),
("centroids", new_graph.centroids, reference_graph.centroids),
("skims", new_graph.skims, reference_graph.skims),
("link ids", new_graph.ids, reference_graph.ids),
("Network", new_graph.network, reference_graph.network),
("All Nodes", new_graph.all_nodes, reference_graph.all_nodes),
("Nodes to indices", new_graph.nodes_to_indices,
reference_graph.nodes_to_indices),
]
for comparison, newg, refg in comparisons:
if not np.array_equal(newg, refg):
self.fail(
"Reference %s and %s created and saved to disk are not equal"
% (comparison, comparison))
comparisons = [
("nodes", new_graph.num_nodes, reference_graph.num_nodes),
("links", new_graph.num_links, reference_graph.num_links),
("zones", new_graph.num_zones, reference_graph.num_zones),
("block through centroids", new_graph.block_centroid_flows,
reference_graph.block_centroid_flows),
("Graph ID", new_graph.__id__, self.graph_id),
("Graph Version", new_graph.__version__, self.graph_version),
]
for comparison, newg, refg in comparisons:
if newg != refg:
self.fail(
"Reference %s and %s created and saved to disk are not equal"
% (comparison, comparison))
def test_available_skims(self):
self.test_set_graph()
if self.graph.available_skims() != ["distance"]:
self.fail("Skim availability with problems")
def test_exclude_links(self):
p = Project()
p.load(siouxfalls_project)
p.network.build_graphs()
g = p.network.graphs['c'] # type: Graph
# excludes a link before any setting or preparation
g.exclude_links([12])
g.set_graph('distance')
r1 = PathResults()
r1.prepare(g)
r1.compute_path(1, 14)
self.assertEqual(list(r1.path), [2, 6, 10, 34])
# We exclude one link that we know was part of the last shortest path
g.exclude_links([10])
r2 = PathResults()
r2.prepare(g)
r2.compute_path(1, 14)
self.assertEqual(list(r2.path), [2, 7, 36, 34])
p.conn.close()
class ImpedanceMatrixDialog(QtGui.QDialog, FORM_CLASS):
def __init__(self, iface):
QDialog.__init__(self)
self.iface = iface
self.setupUi(self)
self.result = SkimResults()
self.validtypes = integer_types + float_types
self.tot_skims = 0
self.name_skims = 0
self.graph = None
self.skimmeable_fields = []
self.skim_fields = []
self.error = None
# FIRST, we connect slot signals
# For loading a new graph
self.load_graph_from_file.clicked.connect(
self.loaded_new_graph_from_file)
# For adding skims
# self.bt_add_skim.clicked.connect(self.add_to_skim_list)
self.but_adds_to_links.clicked.connect(self.append_to_list)
self.but_removes_from_links.clicked.connect(self.removes_fields)
self.do_dist_matrix.clicked.connect(self.run_skimming)
# SECOND, we set visibility for sections that should not be shown when the form opens (overlapping items)
# and re-dimension the items that need re-dimensioning
self.hide_all_progress_bars()
self.available_skims_table.setColumnWidth(0, 245)
self.skim_list.setColumnWidth(0, 245)
self.available_skims_table.setEditTriggers(
QtGui.QAbstractItemView.NoEditTriggers)
self.skim_list.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
# loads default path from parameters
self.path = standard_path()
def removes_fields(self):
table = self.available_skims_table
final_table = self.skim_list
for i in final_table.selectedRanges():
old_fields = [
final_table.item(row, 0).text()
for row in xrange(i.topRow(),
i.bottomRow() + 1)
]
for row in xrange(i.bottomRow(), i.topRow() - 1, -1):
final_table.removeRow(row)
counter = table.rowCount()
for field in old_fields:
table.setRowCount(counter + 1)
item1 = QTableWidgetItem(field)
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
table.setItem(counter, 0, item1)
counter += 1
def append_to_list(self):
table = self.available_skims_table
final_table = self.skim_list
for i in table.selectedRanges():
new_fields = [
table.item(row, 0).text()
for row in xrange(i.topRow(),
i.bottomRow() + 1)
]
for f in new_fields:
self.skim_fields.append(f.encode('utf-8'))
for row in xrange(i.bottomRow(), i.topRow() - 1, -1):
table.removeRow(row)
counter = final_table.rowCount()
for field in new_fields:
final_table.setRowCount(counter + 1)
item1 = QTableWidgetItem(field)
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
final_table.setItem(counter, 0, item1)
counter += 1
def hide_all_progress_bars(self):
self.progressbar.setVisible(False)
self.progress_label.setVisible(False)
self.progressbar.setValue(0)
self.progress_label.setText('')
def loaded_new_graph_from_file(self):
file_types = ["AequilibraE graph(*.aeg)"]
new_name, file_type = GetOutputFileName(self, 'Graph file', file_types,
".aeg", self.path)
self.cb_minimizing.clear()
self.available_skims_table.clearContents()
self.block_paths.setChecked(False)
self.graph = None
if new_name is not None:
self.graph_file_name.setText(new_name)
self.graph = Graph()
self.graph.load_from_disk(new_name)
self.block_paths.setChecked(self.graph.block_centroid_flows)
graph_fields = list(self.graph.graph.dtype.names)
self.skimmeable_fields = self.graph.available_skims()
self.available_skims_table.setRowCount(len(self.skimmeable_fields))
for q in self.skimmeable_fields:
self.cb_minimizing.addItem(q)
self.available_skims_table.setItem(0, 0, QTableWidgetItem(q))
def browse_outfile(self):
self.imped_results = None
new_name, extension = GetOutputFileName(
self, 'AequilibraE impedance computation', matrix_export_types,
'.aem', self.path)
if new_name is not None:
self.imped_results = new_name.encode('utf-8')
def run_thread(self):
self.do_dist_matrix.setVisible(False)
self.progressbar.setRange(0, self.graph.num_zones)
QObject.connect(self.worker_thread, SIGNAL("skimming"),
self.signal_handler)
self.worker_thread.start()
self.exec_()
def signal_handler(self, val):
if val[0] == 'zones finalized':
self.progressbar.setValue(val[1])
elif val[0] == 'text skimming':
self.progress_label.setText(val[1])
elif val[0] == 'finished_threaded_procedure':
self.finished_threaded_procedure()
def finished_threaded_procedure(self):
self.report = self.worker_thread.report
self.result.skims.export(self.imped_results)
self.exit_procedure()
def run_skimming(self): # Saving results
if self.error is None:
self.browse_outfile()
cost_field = self.cb_minimizing.currentText().encode('utf-8')
# We prepare the graph to set all nodes as centroids
if self.rdo_all_nodes.isChecked():
self.graph.prepare_graph(self.graph.all_nodes)
self.graph.set_graph(
cost_field=cost_field,
skim_fields=self.skim_fields,
block_centroid_flows=self.block_paths.isChecked())
self.result.prepare(self.graph)
self.funding1.setVisible(False)
self.funding2.setVisible(False)
self.progressbar.setVisible(True)
self.progress_label.setVisible(True)
self.worker_thread = NetworkSkimming(self.graph, self.result)
try:
self.run_thread()
except ValueError as error:
qgis.utils.iface.messageBar().pushMessage("Input error",
error.message,
level=3)
else:
qgis.utils.iface.messageBar().pushMessage("Error:",
self.error,
level=3)
def check_inputs(self):
self.error = None
if self.rdo_all_nodes.isChecked() and self.block_paths.isChecked():
self.error = 'It is not possible to trace paths between all nodes while blocking flows through centroids'
if self.graph is None:
self.error = 'No graph loaded'
if len(self.skim_fields) < 1:
self.error = 'No skim fields provided'
def exit_procedure(self):
self.close()
if self.report:
dlg2 = ReportDialog(self.iface, self.report)
dlg2.show()
dlg2.exec_()
class DesireLinesProcedure(WorkerThread):
def __init__(self, parentThread, layer: str, id_field: int, matrix: AequilibraeMatrix, matrix_hash: dict,
dl_type: str) -> None:
WorkerThread.__init__(self, parentThread)
self.layer = layer
self.id_field = id_field
self.matrix = matrix
self.dl_type = dl_type
self.error = None
self.matrix_hash = matrix_hash
self.report = []
self.logger = logging.getLogger('aequilibrae')
self.nodes_to_indices = {matrix.index[x]: x for x in range(matrix.zones)}
self.python_version = (8 * struct.calcsize("P"))
if error:
self.error = 'Scipy and/or Numpy not installed'
self.report.append(self.error)
self.procedure = "ASSIGNMENT"
def doWork(self):
if self.error is None:
# In case we have only one class
unnasigned = 0
classes = self.matrix.matrix_view.shape[2]
layer = get_vector_layer_by_name(self.layer)
idx = layer.dataProvider().fieldNameIndex(self.id_field)
feature_count = layer.featureCount()
self.desire_lines.emit(('job_size_dl', feature_count))
all_centroids = {}
for P, feat in enumerate(layer.getFeatures()):
geom = feat.geometry()
if geom is not None:
point = list(geom.centroid().asPoint())
centroid_id = feat.attributes()[idx]
all_centroids[centroid_id] = point
self.desire_lines.emit(('jobs_done_dl', P))
self.desire_lines.emit(('text_dl', "Loading Layer Features: " + str(P) + "/" + str(feature_count)))
# Creating resulting layer
EPSG_code = int(layer.crs().authid().split(":")[1])
desireline_layer = QgsVectorLayer("LineString?crs=epsg:" + str(EPSG_code), self.dl_type, "memory")
dlpr = desireline_layer.dataProvider()
base_dl_fields = [QgsField("link_id", QVariant.Int),
QgsField("A_Node", QVariant.Int),
QgsField("B_Node", QVariant.Int),
QgsField("direct", QVariant.Int),
QgsField("distance", QVariant.Double)]
if self.dl_type == "DesireLines":
items = []
for i, j in all_centroids.items():
items.append((i, j[0], j[1]))
coords = np.array(items)
coord_index = np.zeros((self.matrix.index[:].max().astype(np.int64) + 1, 2))
coord_index[coords[:, 0].astype(np.int64), 0] = coords[:, 1]
coord_index[coords[:, 0].astype(np.int64), 1] = coords[:, 2]
self.desire_lines.emit(('text_dl', "Manipulating matrix indices"))
zones = self.matrix.index[:].shape[0]
a = np.array(self.matrix.index[:], np.int64)
ij, ji = np.meshgrid(a, a, sparse=False, indexing='ij')
ij = ij.flatten()
ji = ji.flatten()
arrays = [ij, ji]
self.desire_lines.emit(('text_dl', "Collecting all matrices"))
self.desire_lines.emit(('job_size_dl', len(self.matrix.view_names)))
total_mat = np.zeros((zones, zones), np.float64)
for i, mat in enumerate(self.matrix.view_names):
arrays.append(self.matrix.matrix[mat].flatten())
total_mat += self.matrix.matrix[mat]
self.desire_lines.emit(('jobs_done_dl', i + 1))
# Eliminates the cells for which we don't have geography
self.desire_lines.emit(('text_dl', "Filtering zones with no geography available"))
zones_with_no_geography = [x for x in self.matrix.index[:] if x not in all_centroids]
if zones_with_no_geography:
self.desire_lines.emit(('job_size_dl', len(zones_with_no_geography)))
for k, z in enumerate(zones_with_no_geography):
i = self.matrix.matrix_hash[z]
t = np.nansum(total_mat[i, :]) + np.nansum(total_mat[:, i])
unnasigned += t
self.report.append(
'Zone {} does not have a corresponding centroid/zone. Total flow {}'.format(z, t))
total_mat[i, :] = 0
total_mat[:, i] = 0
self.desire_lines.emit(('jobs_done_dl', k + 1))
self.desire_lines.emit(('text_dl', "Filtering down to OD pairs with flows"))
field_names = [x for x in self.matrix.view_names]
nonzero = np.nonzero(total_mat.flatten())
arrays = np.vstack(arrays).transpose()
arrays = arrays[nonzero, :]
arrays = arrays.reshape(arrays.shape[1], arrays.shape[2])
base_types = [(x, np.float64) for x in ['from', 'to']]
base_types = base_types + [(x + '_AB', np.float64) for x in field_names]
dtypes_ab = [(x, np.int64) for x in ['from', 'to']] + [(x + '_AB', float) for x in field_names]
dtypes_ba = [(x, np.int64) for x in ['to', 'from']] + [(x + '_BA', float) for x in field_names]
ab_mat = np.array(arrays[arrays[:, 0] > arrays[:, 1], :])
ba_mat = np.array(arrays[arrays[:, 0] < arrays[:, 1], :])
flows_ab = ab_mat.view(base_types)
flows_ab = flows_ab.reshape(flows_ab.shape[:-1])
flows_ab = flows_ab.astype(dtypes_ab)
flows_ba = ba_mat.view(base_types)
flows_ba = flows_ba.reshape(flows_ba.shape[:-1])
flows_ba = flows_ba.astype(dtypes_ba)
defaults1 = {x + '_AB': 0.0 for x in field_names}
defaults = {x + '_BA': 0.0 for x in field_names}
defaults = {**defaults, **defaults1}
self.desire_lines.emit(('text_dl', "Concatenating AB & BA flows"))
flows = rfn.join_by(['from', 'to'], flows_ab, flows_ba, jointype='outer', defaults=defaults,
usemask=True, asrecarray=True)
flows = flows.filled()
flows_ab = 0
flows_ba = 0
for f in flows.dtype.names[2:]:
base_dl_fields.extend([QgsField(f, QVariant.Double)])
dlpr.addAttributes(base_dl_fields)
desireline_layer.updateFields()
self.desire_lines.emit(('text_dl', "Creating Desire Lines"))
self.desire_lines.emit(('job_size_dl', flows.shape[0]))
all_features = []
for i, rec in enumerate(flows):
a_node = rec[0]
b_node = rec[1]
a_point = QgsPointXY(*all_centroids[a_node])
b_point = QgsPointXY(*all_centroids[b_node])
dist = QgsGeometry().fromPointXY(a_point).distance(
QgsGeometry().fromPointXY(b_point))
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolylineXY([a_point, b_point]))
attrs = [i + 1, int(a_node), int(b_node), 0, dist]
attrs.extend([float(x) for x in list(rec)[2:]])
feature.setAttributes(attrs)
all_features.append(feature)
self.desire_lines.emit(('jobs_done_dl', i))
if unnasigned > 0:
self.report.append('Total non assigned flows (not counting intrazonals):' + str(unnasigned))
if flows.shape[0] > 1:
a = dlpr.addFeatures(all_features)
self.result_layer = desireline_layer
else:
self.report.append('Nothing to show')
elif self.dl_type == "DelaunayLines":
for f in self.matrix.view_names:
base_dl_fields.extend([QgsField(f + '_ab', QVariant.Double),
QgsField(f + '_ba', QVariant.Double),
QgsField(f + '_tot', QVariant.Double)])
dlpr.addAttributes(base_dl_fields)
desireline_layer.updateFields()
self.desire_lines.emit(('text_dl', "Building Delaunay dataset"))
points = []
node_id_in_delaunay_results = {}
i = 0
self.desire_lines.emit(('job_size_dl', len(all_centroids)))
for k, v in all_centroids.items():
self.desire_lines.emit(('jobs_done_dl', i))
points.append(v)
node_id_in_delaunay_results[i] = k
i += 1
self.desire_lines.emit(('text_dl', "Computing Delaunay Triangles"))
tri = Delaunay(np.array(points))
# We process all the triangles to only get each edge once
self.desire_lines.emit(('text_dl', "Building Delaunay Network: Collecting Edges"))
edges = []
if self.python_version == 32:
all_edges = tri.vertices
else:
all_edges = tri.simplices
self.desire_lines.emit(('job_size_dl', len(all_edges)))
for j, triangle in enumerate(all_edges):
self.desire_lines.emit(('jobs_done_dl', j))
links = list(itertools.combinations(triangle, 2))
for i in links:
edges.append([min(i[0], i[1]), max(i[0], i[1])])
self.desire_lines.emit(('text_dl', "Building Delaunay Network: Getting unique edges"))
edges = OrderedDict((str(x), x) for x in edges).values()
# Writing Delaunay layer
self.desire_lines.emit(('text_dl', "Building Delaunay Network: Assembling Layer"))
desireline_link_id = 1
data = []
dl_ids_on_links = {}
self.desire_lines.emit(('job_size_dl', len(edges)))
for j, edge in enumerate(edges):
self.desire_lines.emit(('jobs_done_dl', j))
a_node = node_id_in_delaunay_results[edge[0]]
a_point = all_centroids[a_node]
a_point = QgsPointXY(a_point[0], a_point[1])
b_node = node_id_in_delaunay_results[edge[1]]
b_point = all_centroids[b_node]
b_point = QgsPointXY(b_point[0], b_point[1])
dist = QgsGeometry().fromPointXY(a_point).distance(QgsGeometry().fromPointXY(b_point))
line = []
line.append(desireline_link_id)
line.append(a_node)
line.append(b_node)
line.append(dist)
line.append(dist)
line.append(0)
data.append(line)
dl_ids_on_links[desireline_link_id] = [a_node, b_node, 0, dist]
desireline_link_id += 1
self.desire_lines.emit(('text_dl', "Building graph"))
network = np.asarray(data)
del data
# types for the network
self.graph = Graph()
itype = self.graph.default_types('int')
ftype = self.graph.default_types('float')
all_types = [itype, itype, itype, ftype, ftype, np.int8]
all_titles = ['link_id', 'a_node', 'b_node', 'distance_ab', 'distance_ba', 'direction']
dt = [(t, d) for t, d in zip(all_titles, all_types)]
self.graph.network = np.zeros(network.shape[0], dtype=dt)
for k, t in enumerate(dt):
self.graph.network[t[0]] = network[:, k].astype(t[1])
del network
self.graph.type_loaded = 'NETWORK'
self.graph.status = 'OK'
self.graph.network_ok = True
self.graph.prepare_graph(self.matrix.index.astype(np.int64))
self.graph.set_graph(cost_field='distance', skim_fields=False, block_centroid_flows=False)
self.results = AssignmentResults()
self.results.prepare(self.graph, self.matrix)
self.desire_lines.emit(('text_dl', "Assigning demand"))
self.desire_lines.emit(('job_size_dl', self.matrix.index.shape[0]))
assigner = allOrNothing(self.matrix, self.graph, self.results)
assigner.execute()
self.report = assigner.report
print(self.results.link_loads)
self.desire_lines.emit(('text_dl', "Collecting results"))
self.desire_lines.emit(('text_dl', "Building resulting layer"))
features = []
max_edges = len(edges)
self.desire_lines.emit(('job_size_dl', max_edges))
link_loads = self.results.save_to_disk()
for i, link_id in enumerate(link_loads.index):
self.desire_lines.emit(('jobs_done_dl', i))
a_node, b_node, direct, dist = dl_ids_on_links[link_id]
attr = [int(link_id), a_node, b_node, direct, dist]
a_point = all_centroids[a_node]
a_point = QgsPointXY(a_point[0], a_point[1])
b_point = all_centroids[b_node]
b_point = QgsPointXY(b_point[0], b_point[1])
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolylineXY([a_point, b_point]))
for c in self.matrix.view_names:
attr.extend([float(link_loads.data[c + '_ab'][i]),
float(link_loads.data[c + '_ba'][i]),
float(link_loads.data[c + '_tot'][i])])
feature.setAttributes(attr)
features.append(feature)
a = dlpr.addFeatures(features)
self.result_layer = desireline_layer
self.desire_lines.emit(('finished_desire_lines_procedure', 0))
class TestGraph(TestCase):
def test_create_from_geography(self):
self.graph = Graph()
self.graph.create_from_geography(test_network,
'link_id',
'dir',
'distance',
centroids=centroids,
skim_fields=[],
anode="A_NODE",
bnode="B_NODE")
self.graph.set_graph(cost_field='distance', block_centroid_flows=True)
def test_load_network_from_csv(self):
pass
def test_prepare_graph(self):
self.test_create_from_geography()
self.graph.prepare_graph(centroids)
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
if not np.array_equal(self.graph.graph, reference_graph.graph):
self.fail('Reference graph and newly-prepared graph are not equal')
def test_set_graph(self):
self.test_prepare_graph()
self.graph.set_graph(cost_field='distance', block_centroid_flows=True)
if self.graph.num_zones != centroids.shape[0]:
self.fail('Number of centroids not properly set')
if self.graph.num_links != 222:
self.fail('Number of links not properly set')
if self.graph.num_nodes != 93:
self.fail('Number of nodes not properly set - ' +
str(self.graph.num_nodes))
def test_save_to_disk(self):
self.test_create_from_geography()
self.graph.save_to_disk(join(path_test, 'aequilibrae_test_graph.aeg'))
self.graph_id = self.graph.__id__
self.graph_version = self.graph.__version__
def test_load_from_disk(self):
self.test_save_to_disk()
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
new_graph = Graph()
new_graph.load_from_disk(join(path_test, 'aequilibrae_test_graph.aeg'))
comparisons = [
('Graph', new_graph.graph, reference_graph.graph),
('b_nodes', new_graph.b_node, reference_graph.b_node),
('Forward-Star', new_graph.fs, reference_graph.fs),
('cost', new_graph.cost, reference_graph.cost),
('centroids', new_graph.centroids, reference_graph.centroids),
('skims', new_graph.skims, reference_graph.skims),
('link ids', new_graph.ids, reference_graph.ids),
('Network', new_graph.network, reference_graph.network),
('All Nodes', new_graph.all_nodes, reference_graph.all_nodes),
('Nodes to indices', new_graph.nodes_to_indices,
reference_graph.nodes_to_indices)
]
for comparison, newg, refg in comparisons:
if not np.array_equal(newg, refg):
self.fail(
'Reference %s and %s created and saved to disk are not equal'
% (comparison, comparison))
comparisons = [
('nodes', new_graph.num_nodes, reference_graph.num_nodes),
('links', new_graph.num_links, reference_graph.num_links),
('zones', new_graph.num_zones, reference_graph.num_zones),
('block through centroids', new_graph.block_centroid_flows,
reference_graph.block_centroid_flows),
('Graph ID', new_graph.__id__, self.graph_id),
('Graph Version', new_graph.__version__, self.graph_version)
]
for comparison, newg, refg in comparisons:
if newg != refg:
self.fail(
'Reference %s and %s created and saved to disk are not equal'
% (comparison, comparison))
def test_reset_single_fields(self):
pass
def test_add_single_field(self):
pass
def test_available_skims(self):
self.test_set_graph()
if self.graph.available_skims() != ['distance']:
self.fail('Skim availability with problems')
class TestGraph(TestCase):
def test_create_from_geography(self):
self.graph = Graph()
self.graph.create_from_geography(
test_network,
"link_id",
"dir",
"distance",
centroids=centroids,
skim_fields=[],
anode="A_NODE",
bnode="B_NODE",
)
self.graph.set_graph(cost_field="distance", block_centroid_flows=True)
def test_load_network_from_csv(self):
pass
def test_prepare_graph(self):
self.test_create_from_geography()
self.graph.prepare_graph(centroids)
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
if not np.array_equal(self.graph.graph, reference_graph.graph):
self.fail("Reference graph and newly-prepared graph are not equal")
def test_set_graph(self):
self.test_prepare_graph()
self.graph.set_graph(cost_field="distance", block_centroid_flows=True)
if self.graph.num_zones != centroids.shape[0]:
self.fail("Number of centroids not properly set")
if self.graph.num_links != 222:
self.fail("Number of links not properly set")
if self.graph.num_nodes != 93:
self.fail("Number of nodes not properly set - " + str(self.graph.num_nodes))
def test_save_to_disk(self):
self.test_create_from_geography()
self.graph.save_to_disk(join(path_test, "aequilibrae_test_graph.aeg"))
self.graph_id = self.graph.__id__
self.graph_version = self.graph.__version__
def test_load_from_disk(self):
self.test_save_to_disk()
reference_graph = Graph()
reference_graph.load_from_disk(test_graph)
new_graph = Graph()
new_graph.load_from_disk(join(path_test, "aequilibrae_test_graph.aeg"))
comparisons = [
("Graph", new_graph.graph, reference_graph.graph),
("b_nodes", new_graph.b_node, reference_graph.b_node),
("Forward-Star", new_graph.fs, reference_graph.fs),
("cost", new_graph.cost, reference_graph.cost),
("centroids", new_graph.centroids, reference_graph.centroids),
("skims", new_graph.skims, reference_graph.skims),
("link ids", new_graph.ids, reference_graph.ids),
("Network", new_graph.network, reference_graph.network),
("All Nodes", new_graph.all_nodes, reference_graph.all_nodes),
(
"Nodes to indices",
new_graph.nodes_to_indices,
reference_graph.nodes_to_indices,
),
]
for comparison, newg, refg in comparisons:
if not np.array_equal(newg, refg):
self.fail(
"Reference %s and %s created and saved to disk are not equal"
% (comparison, comparison)
)
comparisons = [
("nodes", new_graph.num_nodes, reference_graph.num_nodes),
("links", new_graph.num_links, reference_graph.num_links),
("zones", new_graph.num_zones, reference_graph.num_zones),
(
"block through centroids",
new_graph.block_centroid_flows,
reference_graph.block_centroid_flows,
),
("Graph ID", new_graph.__id__, self.graph_id),
("Graph Version", new_graph.__version__, self.graph_version),
]
for comparison, newg, refg in comparisons:
if newg != refg:
self.fail(
"Reference %s and %s created and saved to disk are not equal"
% (comparison, comparison)
)
def test_reset_single_fields(self):
pass
def test_add_single_field(self):
pass
def test_available_skims(self):
self.test_set_graph()
if self.graph.available_skims() != ["distance"]:
self.fail("Skim availability with problems")
def build_graphs(self, fields: list = None, modes: list = None) -> None:
"""Builds graphs for all modes currently available in the model
When called, it overwrites all graphs previously created and stored in the networks'
dictionary of graphs
Args:
*fields* (:obj:`list`, optional): When working with very large graphs with large number of fields in the
database, it may be useful to specify which fields to use
*modes* (:obj:`list`, optional): When working with very large graphs with large number of fields in the
database, it may be useful to generate only those we need
To use the *fields* parameter, a minimalistic option is the following
::
p = Project()
p.open(nm)
fields = ['distance']
p.network.build_graphs(fields, modes = ['c', 'w'])
"""
curr = self.conn.cursor()
if fields is None:
curr.execute("PRAGMA table_info(links);")
field_names = curr.fetchall()
ignore_fields = ["ogc_fid", "geometry"]
all_fields = [
f[1] for f in field_names if f[1] not in ignore_fields
]
else:
fields.extend(
["link_id", "a_node", "b_node", "direction", "modes"])
all_fields = list(set(fields))
if modes is None:
modes = curr.execute("select mode_id from modes;").fetchall()
modes = [m[0] for m in modes]
elif isinstance(modes, str):
modes = [modes]
sql = f"select {','.join(all_fields)} from links"
df = pd.read_sql(sql, self.conn).fillna(value=np.nan)
valid_fields = list(df.select_dtypes(np.number).columns) + ["modes"]
curr.execute(
"select node_id from nodes where is_centroid=1 order by node_id;")
centroids = np.array([i[0] for i in curr.fetchall()], np.uint32)
data = df[valid_fields]
for m in modes:
net = pd.DataFrame(data, copy=True)
net.loc[~net.modes.str.contains(m),
"b_node"] = net.loc[~net.modes.str.contains(m), "a_node"]
g = Graph()
g.mode = m
g.network = net
g.prepare_graph(centroids)
g.set_blocked_centroid_flows(True)
self.graphs[m] = g
class DesireLinesProcedure(WorkerThread):
def __init__(self, parentThread, layer, id_field, matrix, dl_type):
WorkerThread.__init__(self, parentThread)
self.layer = layer
self.id_field = id_field
self.matrix = matrix
self.dl_type = dl_type
self.error = None
if error:
self.error = 'Scipy and/or Numpy not installed'
self.procedure = "ASSIGNMENT"
def doWork(self):
if self.error is None:
layer = get_vector_layer_by_name(self.layer)
idx = layer.fieldNameIndex(self.id_field)
matrix = self.matrix
featcount = layer.featureCount()
self.emit(SIGNAL("ProgressMaxValue(PyQt_PyObject)"),
(0, featcount))
P = 0
points = []
point_ids = []
for feat in layer.getFeatures():
P += 1
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"), (0, int(P)))
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Loading Layer Features: " + str(P) + "/" +
str(featcount)))
geom = feat.geometry()
if geom is not None:
point = list(geom.centroid().asPoint())
points.append(point)
point_ids.append(feat.attributes()[idx])
points = np.array(points)
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"), (0, featcount))
self.emit(
SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Preparing consistency check Matrix Vs. Zoning layer"))
vector1 = np.nonzero(np.sum(matrix, axis=0))[0]
vector2 = np.nonzero(np.sum(matrix, axis=1))[0]
nonzero = np.hstack((vector1, vector2))
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"),
(0, nonzero.shape[0]))
for i, zone in enumerate(nonzero):
if zone not in point_ids:
self.error = 'Zone ' + str(
zone) + ' with positive flow not in zoning file'
break
self.emit(SIGNAL("ProgressMaxValue(PyQt_PyObject)"),
(0, i + 1))
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"),
(0, nonzero.shape[0]))
if self.error is None:
#Creating resulting layer
EPSG_code = int(layer.crs().authid().split(":")[1])
desireline_layer = QgsVectorLayer(
"LineString?crs=epsg:" + str(EPSG_code), self.dl_type,
"memory")
dlpr = desireline_layer.dataProvider()
dlpr.addAttributes([
QgsField("link_id", QVariant.Int),
QgsField("A_Node", QVariant.Int),
QgsField("B_Node", QVariant.Int),
QgsField("direct", QVariant.Int),
QgsField("length", QVariant.Double),
QgsField("AB_FLOW", QVariant.Double),
QgsField("BA_FLOW", QVariant.Double),
QgsField("TOT_FLOW", QVariant.Double)
])
desireline_layer.updateFields()
if self.dl_type == "DesireLines":
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Creating Desire Lines"))
self.emit(SIGNAL("ProgressMaxValue(PyQt_PyObject)"),
(0, self.matrix.shape[0] * self.matrix.shape[1] / 2))
#We create the dictionary with point information
all_points = {}
point_ids = np.array(point_ids).astype(np.int)
for i in range(point_ids.shape[0]):
all_points[point_ids[i]] = points[i]
# We are assuming that the matrix is square here. Maybe we could add more general code layer
desireline_link_id = 1
q = 0
all_features = []
for i in range(self.matrix.shape[0]):
for j in xrange(i + 1, self.matrix.shape[1]):
q += 1
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"),
(0, q))
if self.matrix[i, j] + self.matrix[j, i] > 0:
a_node = i
a_point = QgsPoint(all_points[a_node][0],
all_points[a_node][1])
b_node = j
b_point = QgsPoint(all_points[b_node][0],
all_points[b_node][1])
dist = QgsGeometry().fromPoint(a_point).distance(
QgsGeometry().fromPoint(b_point))
feature = QgsFeature()
feature.setGeometry(
QgsGeometry.fromPolyline([a_point, b_point]))
feature.setAttributes([
desireline_link_id, a_node, b_node, 0, dist,
float(self.matrix[i, j]),
float(self.matrix[j, i]),
float(self.matrix[i, j] + self.matrix[j, i])
])
all_features.append(feature)
desireline_link_id += 1
a = dlpr.addFeatures(all_features)
self.result_layer = desireline_layer
elif self.dl_type == "DelaunayLines":
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Computing Delaunay Triangles"))
tri = Delaunay(points)
#We process all the triangles to only get each edge once
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Building Delaunay Network: Collecting Edges"))
edges = []
for triangle in tri.simplices:
links = list(itertools.combinations(triangle, 2))
for i in links:
l = [min(i[0], i[1]), max(i[0], i[1])]
if l not in edges:
edges.append(l)
#Writing Delaunay layer
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Building Delaunay Network: Assembling Layer"))
desireline_link_id = 1
data = []
for edge in edges:
a_node = edge[0]
a_point = QgsPoint(points[a_node][0], points[a_node][1])
b_node = edge[1]
b_point = QgsPoint(points[b_node][0], points[b_node][1])
dist = QgsGeometry().fromPoint(a_point).distance(
QgsGeometry().fromPoint(b_point))
line = []
line.append(desireline_link_id)
line.append(point_ids[a_node])
line.append(point_ids[b_node])
line.append(dist)
line.append(dist)
line.append(0)
data.append(line)
desireline_link_id += 1
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Building graph"))
network = np.asarray(data)
del data
#types for the network
all_types = [
np.int64, np.int64, np.int64, np.float64, np.float64,
np.int64
]
all_titles = [
'link_id', 'a_node', 'b_node', 'length_ab', 'length_ba',
'direction'
]
dt = [(t, d) for t, d in zip(all_titles, all_types)]
self.graph = Graph()
self.graph.network = np.zeros(network.shape[0], dtype=dt)
for k, t in enumerate(dt):
self.graph.network[t[0]] = network[:, k].astype(t[1])
del network
# Here we transform the network to go from node 1 to N
max_node = max(np.max(self.graph.network['a_node']),
np.max(self.graph.network['b_node']))
max_node = max(max_node, self.matrix.shape[0],
self.matrix.shape[1]) + 1
self.hash = np.zeros(max_node, np.int)
# Checks if any zone from the matrix is not present in the areas/node layer
t1 = np.sum(self.matrix, axis=0)
t2 = np.sum(self.matrix, axis=1)
if t1.shape[0] > t2.shape[0]:
t2.resize(t1.shape)
elif t2.shape[0] > t1.shape[0]:
t1.resize(t2.shape)
totals = t1 + t2
all_nodes = np.bincount(self.graph.network['a_node'])
for i in range(totals.shape[0]):
if totals[i]:
if not all_nodes[i]:
qgis.utils.iface.messageBar().pushMessage(
"Matrix has demand for zones that do not exist "
"in the zones/nodes provided. Demand for those"
"ones were ignored. e.g. " + str(i),
'',
level=3)
break
h = 1
for i in range(self.graph.network.shape[0]):
a_node = self.graph.network['a_node'][i]
if self.hash[a_node] == 0:
self.hash[a_node] = h
h += 1
b_node = self.graph.network['b_node'][i]
if self.hash[b_node] == 0:
self.hash[b_node] = h
h += 1
self.graph.network['a_node'][i] = self.hash[a_node]
self.graph.network['b_node'][i] = self.hash[b_node]
# End of network transformation
#Now we transform the matrix appropriately
self.matrix = reblocks_matrix(self.matrix, self.hash, h)
self.graph.type_loaded = 'NETWORK'
self.graph.status = 'OK'
self.graph.network_ok = True
self.graph.prepare_graph()
self.graph.set_graph(h - 1,
cost_field='length',
block_centroid_flows=False)
self.results = AssignmentResults()
self.results.prepare(self.graph)
self.results.set_cores(1)
# Do the assignment
all_or_nothing(self.matrix, self.graph, self.results)
f = self.results.link_loads[:, 0]
link_loads = np.zeros((f.shape[0] + 1, 2))
for i in range(f.shape[0] - 1):
direction = self.graph.graph['direction'][i]
link_id = self.graph.graph['link_id'][i]
flow = f[i]
if direction == 1:
link_loads[link_id, 0] = flow
else:
link_loads[link_id, 1] = flow
desireline_link_id = 1
for edge in edges:
a_node = edge[0]
a_point = QgsPoint(points[a_node][0], points[a_node][1])
b_node = edge[1]
b_point = QgsPoint(points[b_node][0], points[b_node][1])
dist = QgsGeometry().fromPoint(a_point).distance(
QgsGeometry().fromPoint(b_point))
feature = QgsFeature()
feature.setGeometry(
QgsGeometry.fromPolyline([a_point, b_point]))
feature.setAttributes([
desireline_link_id, point_ids[a_node],
point_ids[b_node], 0, dist,
float(link_loads[desireline_link_id, 0]),
float(link_loads[desireline_link_id, 1]),
float(link_loads[desireline_link_id, 0] +
link_loads[desireline_link_id, 1])
])
a = dlpr.addFeatures([feature])
desireline_link_id += 1
self.result_layer = desireline_layer
self.emit(SIGNAL("finished_threaded_procedure( PyQt_PyObject )"), True)
class DesireLinesProcedure(WorkerThread):
def __init__(self, parentThread, layer, id_field, matrix, matrix_hash, dl_type):
WorkerThread.__init__(self, parentThread)
self.layer = layer
self.id_field = id_field
self.matrix = matrix
self.dl_type = dl_type
self.error = None
self.matrix_hash = matrix_hash
self.report = []
self.nodes_to_indices = {matrix.index[x]: x for x in range(matrix.zones)}
self.python_version = (8 * struct.calcsize("P"))
if error:
self.error = 'Scipy and/or Numpy not installed'
self.report.append(self.error)
self.procedure = "ASSIGNMENT"
def doWork(self):
if self.error is None:
# In case we have only one class
unnasigned = 0
classes = self.matrix.matrix_view.shape[2]
layer = get_vector_layer_by_name(self.layer)
idx = layer.fieldNameIndex(self.id_field)
feature_count = layer.featureCount()
self.emit(SIGNAL("desire_lines"), ('job_size_dl', feature_count))
all_centroids = {}
P = 0
for feat in layer.getFeatures():
P += 1
self.emit(SIGNAL("desire_lines"), ('jobs_done_dl', P))
self.emit(SIGNAL("desire_lines"), ('text_dl',"Loading Layer Features: " + str(P) + "/" + str(feature_count)))
geom = feat.geometry()
if geom is not None:
point = list(geom.centroid().asPoint())
centroid_id = feat.attributes()[idx]
all_centroids[centroid_id] = point
#Creating resulting layer
EPSG_code = int(layer.crs().authid().split(":")[1])
desireline_layer = QgsVectorLayer("LineString?crs=epsg:" + str(EPSG_code), self.dl_type, "memory")
dlpr = desireline_layer.dataProvider()
fields = [QgsField("link_id", QVariant.Int),
QgsField("A_Node", QVariant.Int),
QgsField("B_Node", QVariant.Int),
QgsField("direct", QVariant.Int),
QgsField("distance", QVariant.Double)]
for f in self.matrix.view_names:
fields.extend([QgsField(f + '_ab', QVariant.Double),
QgsField(f + '_ba', QVariant.Double),
QgsField(f + '_tot', QVariant.Double)])
dlpr.addAttributes(fields)
desireline_layer.updateFields()
if self.dl_type == "DesireLines":
self.emit(SIGNAL("desire_lines"), ('text_dl',"Creating Desire Lines"))
self.emit(SIGNAL("desire_lines"), ('job_size_dl', self.matrix.zones ** 2 / 2))
desireline_link_id = 1
q = 0
all_features = []
for i in range(self.matrix.zones):
a_node = self.matrix.index[i]
if a_node in all_centroids.keys():
if np.sum(self.matrix.matrix_view[i, :, :]) + np.sum(self.matrix.matrix_view[:, i, :]) > 0:
columns_with_filled_cells = np.nonzero(np.sum(self.matrix.matrix_view[i, :, :], axis=1))
for j in columns_with_filled_cells[0]:
if np.sum(self.matrix.matrix_view[i, j, :]) + np.sum(self.matrix.matrix_view[j, i, :]) > 0:
b_node = self.matrix.index[j]
if a_node in all_centroids.keys() and b_node in all_centroids.keys():
a_point = all_centroids[a_node]
a_point = QgsPoint(a_point[0], a_point[1])
b_point = all_centroids[b_node]
b_point = QgsPoint(b_point[0], b_point[1])
dist = QgsGeometry().fromPoint(a_point).distance(QgsGeometry().fromPoint(b_point))
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolyline([a_point, b_point]))
attrs = [desireline_link_id, int(a_node), int(b_node), 0, dist]
for c in range(classes):
attrs.extend([float(self.matrix.matrix_view[i, j, c]),
float(self.matrix.matrix_view[j, i, c]),
float(self.matrix.matrix_view[i, j, c]) +
float(self.matrix.matrix_view[j, i, c])])
feature.setAttributes(attrs)
all_features.append(feature)
desireline_link_id += 1
else:
tu = (a_node, b_node, np.sum(self.matrix.matrix_view[i, j, :]),
np.sum(self.matrix.matrix_view[j, i, :]))
self.report.append('No centroids available to depict flow between node {0} and node'
'{1}. Total AB flow was equal to {2} and total BA flow was '
'equal to {3}'.format(*tu))
unnasigned += np.sum(self.matrix.matrix_view[i, j, :]) + \
np.sum(self.matrix.matrix_view[j, i, :])
else:
tu = (a_node, np.sum(self.matrix.matrix_view[i, :, :]))
self.report.append('No centroids available to depict flows from node {0} to all the others.'
'Total flow from this zone is equal to {1}'.format(*tu))
unnasigned += np.sum(self.matrix.matrix_view[i, :, :])
q += self.matrix.zones
self.emit(SIGNAL("desire_lines"), ('jobs_done_dl', q))
if unnasigned > 0:
self.report.append('Total non assigned flows (not counting intrazonals):' + str(unnasigned))
if desireline_link_id > 1:
a = dlpr.addFeatures(all_features)
self.result_layer = desireline_layer
else:
self.report.append('Nothing to show')
elif self.dl_type == "DelaunayLines":
self.emit(SIGNAL("desire_lines"), ('text_dl', "Building Delaunay dataset"))
points = []
node_id_in_delaunay_results = {}
i = 0
self.emit(SIGNAL("desire_lines"), ('job_size_dl', len(all_centroids)))
for k, v in all_centroids.iteritems():
self.emit(SIGNAL("desire_lines"), ('jobs_done_dl', i))
points.append(v)
node_id_in_delaunay_results[i] = k
i += 1
self.emit(SIGNAL("desire_lines"), ('text_dl', "Computing Delaunay Triangles"))
tri = Delaunay(np.array(points))
# We process all the triangles to only get each edge once
self.emit(SIGNAL("desire_lines"), ('text_dl', "Building Delaunay Network: Collecting Edges"))
edges = []
if self.python_version == 32:
all_edges = tri.vertices
else:
all_edges = tri.simplices
self.emit(SIGNAL("desire_lines"), ('job_size_dl', len(all_edges)))
for j, triangle in enumerate(all_edges):
self.emit(SIGNAL("desire_lines"), ('jobs_done_dl', j))
links = list(itertools.combinations(triangle, 2))
for i in links:
edges.append([min(i[0],i[1]), max(i[0],i[1])])
self.emit(SIGNAL("desire_lines"), ('text_dl', "Building Delaunay Network: Getting unique edges"))
edges = OrderedDict((str(x), x) for x in edges).values()
# Writing Delaunay layer
self.emit(SIGNAL("desire_lines"), ('text_dl', "Building Delaunay Network: Assembling Layer"))
desireline_link_id = 1
data = []
dl_ids_on_links = {}
self.emit(SIGNAL("desire_lines"), ('job_size_dl', len(edges)))
for j, edge in enumerate(edges):
self.emit(SIGNAL("desire_lines"), ('jobs_done_dl', j))
a_node = node_id_in_delaunay_results[edge[0]]
a_point = all_centroids[a_node]
a_point = QgsPoint(a_point[0], a_point[1])
b_node = node_id_in_delaunay_results[edge[1]]
b_point = all_centroids[b_node]
b_point = QgsPoint(b_point[0], b_point[1])
dist = QgsGeometry().fromPoint(a_point).distance(QgsGeometry().fromPoint(b_point))
line = []
line.append(desireline_link_id)
line.append(a_node)
line.append(b_node)
line.append(dist)
line.append(dist)
line.append(0)
data.append(line)
dl_ids_on_links[desireline_link_id] = [a_node, b_node, 0, dist]
desireline_link_id += 1
self.emit(SIGNAL("desire_lines"), ('text_dl', "Building graph"))
network = np.asarray(data)
del data
#types for the network
self.graph = Graph()
itype = self.graph.default_types('int')
ftype = self.graph.default_types('float')
all_types = [itype, itype, itype, ftype, ftype, np.int8]
all_titles = ['link_id', 'a_node', 'b_node', 'distance_ab', 'distance_ba', 'direction']
dt = [(t, d) for t, d in zip(all_titles, all_types)]
self.graph.network = np.zeros(network.shape[0], dtype=dt)
for k, t in enumerate(dt):
self.graph.network[t[0]] = network[:, k].astype(t[1])
del network
self.graph.type_loaded = 'NETWORK'
self.graph.status = 'OK'
self.graph.network_ok = True
try:
self.graph.prepare_graph(self.matrix.index.astype(np.int64))
self.graph.set_graph(cost_field='distance', skim_fields=False, block_centroid_flows=False)
self.results = AssignmentResults()
self.results.prepare(self.graph, self.matrix)
self.emit(SIGNAL("desire_lines"), ('text_dl', "Assigning demand"))
self.emit(SIGNAL("desire_lines"), ('job_size_dl', self.matrix.index.shape[0]))
assigner = allOrNothing(self.matrix, self.graph, self.results)
assigner.execute()
self.report = assigner.report
self.emit(SIGNAL("desire_lines"), ('text_dl', "Collecting results"))
link_loads = self.results.save_to_disk()
self.emit(SIGNAL("desire_lines"), ('text_dl', "Building resulting layer"))
features = []
max_edges = len(edges)
self.emit(SIGNAL("desire_lines"), ('job_size_dl', max_edges))
for i, link_id in enumerate(link_loads.index):
self.emit(SIGNAL("desire_lines"), ('jobs_done_dl', i))
a_node, b_node, direct, dist = dl_ids_on_links[link_id]
attr = [int(link_id), a_node, b_node, direct, dist]
a_point = all_centroids[a_node]
a_point = QgsPoint(a_point[0], a_point[1])
b_point = all_centroids[b_node]
b_point = QgsPoint(b_point[0], b_point[1])
feature = QgsFeature()
feature.setGeometry(QgsGeometry.fromPolyline([a_point, b_point]))
for c in self.matrix.view_names:
attr.extend([float(link_loads.data[c + '_ab'][i]),
float(link_loads.data[c + '_ba'][i]),
float(link_loads.data[c + '_tot'][i])])
feature.setAttributes(attr)
features.append(feature)
a = dlpr.addFeatures(features)
self.result_layer = desireline_layer
except ValueError as error:
self.report = [error.message]
self.emit(SIGNAL("desire_lines"), ('finished_desire_lines_procedure', 0))
class DesireLinesProcedure(WorkerThread):
def __init__(self, parentThread, layer, id_field, matrix, matrix_hash,
dl_type):
WorkerThread.__init__(self, parentThread)
self.layer = layer
self.id_field = id_field
self.matrix = matrix
self.dl_type = dl_type
self.error = None
self.matrix_hash = matrix_hash
self.report = []
self.python_version = (8 * struct.calcsize("P"))
if error:
self.error = 'Scipy and/or Numpy not installed'
self.procedure = "ASSIGNMENT"
def doWork(self):
if self.error is None:
layer = get_vector_layer_by_name(self.layer)
idx = layer.fieldNameIndex(self.id_field)
matrix = self.matrix
matrix_nodes = max(self.matrix_hash.values()) + 1
featcount = layer.featureCount()
self.emit(SIGNAL("ProgressMaxValue(PyQt_PyObject)"),
(0, featcount))
all_centroids = {}
P = 0
for feat in layer.getFeatures():
P += 1
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"), (0, int(P)))
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Loading Layer Features: " + str(P) + "/" +
str(featcount)))
geom = feat.geometry()
if geom is not None:
point = list(geom.centroid().asPoint())
centroid_id = feat.attributes()[idx]
all_centroids[centroid_id] = point
if centroid_id not in self.matrix_hash.keys():
self.matrix_hash[centroid_id] = matrix_nodes
matrix_nodes += 1
reverse_hash = {v: k for k, v in self.matrix_hash.iteritems()}
#Creating resulting layer
EPSG_code = int(layer.crs().authid().split(":")[1])
desireline_layer = QgsVectorLayer(
"LineString?crs=epsg:" + str(EPSG_code), self.dl_type,
"memory")
dlpr = desireline_layer.dataProvider()
dlpr.addAttributes([
QgsField("link_id", QVariant.Int),
QgsField("A_Node", QVariant.Int),
QgsField("B_Node", QVariant.Int),
QgsField("direct", QVariant.Int),
QgsField("length", QVariant.Double),
QgsField("ab_flow", QVariant.Double),
QgsField("ba_flow", QVariant.Double),
QgsField("tot_flow", QVariant.Double)
])
desireline_layer.updateFields()
if self.dl_type == "DesireLines":
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Creating Desire Lines"))
self.emit(SIGNAL("ProgressMaxValue(PyQt_PyObject)"),
(0, self.matrix.shape[0] * self.matrix.shape[1] / 2))
desireline_link_id = 1
q = 0
all_features = []
for i in range(self.matrix.shape[0]):
if np.sum(self.matrix[i, :]) > 0:
a_node = reverse_hash[i]
for j in xrange(i + 1, self.matrix.shape[1]):
q += 1
b_node = reverse_hash[j]
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"),
(0, q))
if self.matrix[i, j] + self.matrix[j, i] > 0:
if a_node in all_centroids.keys(
) and b_node in all_centroids.keys():
a_point = all_centroids[a_node]
a_point = QgsPoint(a_point[0], a_point[1])
b_point = all_centroids[b_node]
b_point = QgsPoint(b_point[0], b_point[1])
dist = QgsGeometry().fromPoint(
a_point).distance(
QgsGeometry().fromPoint(b_point))
feature = QgsFeature()
feature.setGeometry(
QgsGeometry.fromPolyline(
[a_point, b_point]))
feature.setAttributes([
desireline_link_id,
int(a_node),
int(b_node), 0, dist,
float(self.matrix[i, j]),
float(self.matrix[j, i]),
float(self.matrix[i, j] +
self.matrix[j, i])
])
all_features.append(feature)
desireline_link_id += 1
else:
tu = (a_node, b_node, self.matrix[i, j],
self.matrix[j, i])
self.report.append(
'No centroids available to depict flow between node {0} and node {1}. AB flow was equal to {2} and BA flow was equal to {3}'
.format(*tu))
else:
q += self.matrix.shape[1]
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"),
(0, q))
if desireline_link_id > 1:
a = dlpr.addFeatures(all_features)
self.result_layer = desireline_layer
else:
self.error = 'Nothing to show'
elif self.dl_type == "DelaunayLines":
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Computing Delaunay Triangles"))
points = []
seccond_relation = {}
i = 0
for k, v in all_centroids.iteritems():
points.append(v)
seccond_relation[i] = k
i += 1
tri = Delaunay(np.array(points))
#We process all the triangles to only get each edge once
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Building Delaunay Network: Collecting Edges"))
edges = []
if self.python_version == 32:
all_edges = tri.vertices
else:
all_edges = tri.simplices
for triangle in all_edges:
links = list(itertools.combinations(triangle, 2))
for i in links:
l = [min(i[0], i[1]), max(i[0], i[1])]
if l not in edges:
edges.append(l)
#Writing Delaunay layer
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Building Delaunay Network: Assembling Layer"))
desireline_link_id = 1
data = []
dl_link_ids = {}
for edge in edges:
a_node = seccond_relation[edge[0]]
a_point = all_centroids[a_node]
a_point = QgsPoint(a_point[0], a_point[1])
b_node = seccond_relation[edge[1]]
b_point = all_centroids[b_node]
b_point = QgsPoint(b_point[0], b_point[1])
dist = QgsGeometry().fromPoint(a_point).distance(
QgsGeometry().fromPoint(b_point))
line = []
line.append(desireline_link_id)
line.append(self.matrix_hash[a_node])
line.append(self.matrix_hash[b_node])
line.append(dist)
line.append(dist)
line.append(0)
data.append(line)
if a_node not in dl_link_ids.keys():
dl_link_ids[a_node] = {}
dl_link_ids[a_node][b_node] = desireline_link_id
desireline_link_id += 1
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Building graph"))
network = np.asarray(data)
del data
#types for the network
all_types = [
np.int64, np.int64, np.int64, np.float64, np.float64,
np.int64
]
all_titles = [
'link_id', 'a_node', 'b_node', 'length_ab', 'length_ba',
'direction'
]
dt = [(t, d) for t, d in zip(all_titles, all_types)]
self.graph = Graph()
self.graph.network = np.zeros(network.shape[0], dtype=dt)
for k, t in enumerate(dt):
self.graph.network[t[0]] = network[:, k].astype(t[1])
del network
self.graph.type_loaded = 'NETWORK'
self.graph.status = 'OK'
self.graph.network_ok = True
self.graph.prepare_graph()
self.graph.set_graph(matrix_nodes,
cost_field='length',
block_centroid_flows=False)
self.results = AssignmentResults()
self.results.prepare(self.graph)
# self.results.set_cores(1)
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Assigning demand"))
# Do the assignment
#self.all_or_nothing(self.matrix, self.graph, self.results)
self.report = all_or_nothing(self.matrix, self.graph,
self.results)
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Collecting results"))
f = self.results.link_loads
link_loads = np.zeros((f.shape[0] + 1, 2))
self.emit(SIGNAL("ProgressMaxValue(PyQt_PyObject)"),
(0, f.shape[0] - 1))
for i in range(f.shape[0] - 1):
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"), (0, i))
direction = self.graph.graph['direction'][i]
link_id = self.graph.graph['link_id'][i]
flow = f[i]
if direction == 1:
link_loads[link_id, 0] = flow
else:
link_loads[link_id, 1] = flow
self.emit(SIGNAL("ProgressText (PyQt_PyObject)"),
(0, "Building resulting layer"))
features = []
max_edges = len(edges)
self.emit(SIGNAL("ProgressMaxValue(PyQt_PyObject)"),
(0, max_edges))
for i, edge in enumerate(edges):
self.emit(SIGNAL("ProgressValue(PyQt_PyObject)"), (0, i))
a_node = seccond_relation[edge[0]]
a_point = all_centroids[a_node]
a_point = QgsPoint(a_point[0], a_point[1])
b_node = seccond_relation[edge[1]]
b_point = all_centroids[b_node]
b_point = QgsPoint(b_point[0], b_point[1])
dist = QgsGeometry().fromPoint(a_point).distance(
QgsGeometry().fromPoint(b_point))
feature = QgsFeature()
feature.setGeometry(
QgsGeometry.fromPolyline([a_point, b_point]))
desireline_link_id = dl_link_ids[a_node][b_node]
feature.setAttributes([
desireline_link_id, a_node, b_node, 0, dist,
float(link_loads[desireline_link_id, 0]),
float(link_loads[desireline_link_id, 1]),
float(link_loads[desireline_link_id, 0] +
link_loads[desireline_link_id, 1])
])
features.append(feature)
a = dlpr.addFeatures(features)
self.result_layer = desireline_layer
self.emit(SIGNAL("finished_threaded_procedure( PyQt_PyObject )"), True)
