def onConnectivityClicked(self):
if self.NETWORK_DS is None:
return
network = gnm.CastToGenericNetwork(self.NETWORK_DS)
if network is None:
return
if self.GFID_STARTFLAG == -1:
self.showMsg(
self.
tr(u'The start point has not been set! Set it before any calculations'
))
return
for bl_gfid in self.GFIDS_BLOCKFLAGS:
network.ChangeBlockState(bl_gfid, True)
res_layer = network.GetPath(self.GFID_STARTFLAG, -1,
gnm.GATConnectedComponents)
if res_layer is None:
self.showMsg(
self.tr(
u'Unable to calculate shortest path! Some error occured'))
elif res_layer.GetFeatureCount() == 0:
self.showMsg(
self.
tr(u'The start feature has no connections to other features!'))
network.ReleaseResultSet(res_layer)
else:
self.updateResultLayer(res_layer, self.LAYER_RESULT_CONNECTIVITY)
network.ReleaseResultSet(res_layer)
for bl_gfid in self.GFIDS_BLOCKFLAGS:
network.ChangeBlockState(bl_gfid, False)
def test_gnm_autoconnect():
if not ogrtest.have_gnm:
pytest.skip()
ds = gdal.OpenEx('tmp/test_gnm')
dgn = gnm.CastToGenericNetwork(ds)
assert dgn is not None, 'cast to GNMGenericNetwork failed'
ret = dgn.ConnectPointsByLines(['pipes', 'wells'], 0.000001, 1, 1, gnm.GNM_EDGE_DIR_BOTH)
assert ret == 0, 'failed to connect'
dgn = None
def gnm_autoconnect():
if not ogrtest.have_gnm:
return 'skip'
ds = gdal.OpenEx('tmp/test_gnm')
dgn = gnm.CastToGenericNetwork(ds)
if dgn is None:
gdaltest.post_reason('cast to GNMGenericNetwork failed')
return 'fail'
ret = dgn.ConnectPointsByLines(['pipes', 'wells'], 0.000001, 1, 1, gnm.GNM_EDGE_DIR_BOTH)
if ret != 0:
gdaltest.post_reason('failed to connect')
return 'fail'
dgn = None
return 'success'
def onPathsClicked(self):
if self.NETWORK_DS is None:
return
network = gnm.CastToGenericNetwork(self.NETWORK_DS)
if network is None:
return
if self.GFID_STARTFLAG == -1:
self.showMsg(
self.
tr(u'The start point has not been set! Set it before any calculations'
))
return
if self.GFID_ENDFLAG == -1:
self.showMsg(
self.
tr(u'The end point has not been set! Set it before calculating shortest paths'
))
return
for bl_gfid in self.GFIDS_BLOCKFLAGS:
network.ChangeBlockState(bl_gfid, True)
options = []
options.append('num_paths=' + str(self.GNM_SETTING_K))
res_layer = network.GetPath(self.GFID_STARTFLAG, self.GFID_ENDFLAG,
gnm.GATKShortestPath, options)
if res_layer is None:
self.showMsg(
self.tr(
u'Unable to calculate shortest path! Some error occured'))
elif res_layer.GetFeatureCount() == 0:
self.showMsg(
self.tr(u'There is no path between start and end points!'))
network.ReleaseResultSet(res_layer)
else:
self.updateResultLayers(res_layer, self.LAYERS_RESULT_PATHS)
network.ReleaseResultSet(res_layer)
for bl_gfid in self.GFIDS_BLOCKFLAGS:
network.ChangeBlockState(bl_gfid, False)
def onPathClicked(self):
if self.NETWORK_DS is None:
return
network = gnm.CastToGenericNetwork(self.NETWORK_DS)
if network is None:
return
if self.GFID_STARTFLAG == -1:
self.showMsg(
self.
tr(u'The start point has not been set! Set it before any calculations'
))
return
if self.GFID_ENDFLAG == -1:
self.showMsg(
self.
tr(u'The end point has not been set! Set it before calculating shortest path'
))
return
for bl_gfid in self.GFIDS_BLOCKFLAGS: # block required features
network.ChangeBlockState(bl_gfid, True)
res_layer = network.GetPath(self.GFID_STARTFLAG, self.GFID_ENDFLAG,
gnm.GATDijkstraShortestPath)
if res_layer is None:
self.showMsg(
self.tr(
u'Unable to calculate shortest path! Some error occured'))
elif res_layer.GetFeatureCount() == 0:
self.showMsg(
self.tr(u'There is no path between start and end points!'))
network.ReleaseResultSet(res_layer)
else:
self.updateResultLayer(
res_layer,
self.LAYER_RESULT_PATH) # copy features to qgis layer
network.ReleaseResultSet(res_layer)
for bl_gfid in self.GFIDS_BLOCKFLAGS: # unblock previously blocked features (anyway!)
network.ChangeBlockState(bl_gfid, False)
def createGnmLayersGroup(self):
"""Create special set of layers for the QGIS GNM"""
dataset = self.NETWORK_DS
network = gnm.CastToGenericNetwork(self.NETWORK_DS)
if network is None:
self.showMsgBox(self.tr(u'Error working with network'))
return False
network_fullpath = self.NETWORK_FULLPATH
self.NETWORK_NAME = network.GetName()
network_srs = network.GetProjectionRef()
# 0. Create root group.
root_layer_tree = QgsProject.instance().layerTreeRoot()
common_group = root_layer_tree.addGroup(self.NETWORK_NAME)
# 1. Create flag layers.
flags_group = common_group.addGroup('Flags')
self.LAYER_STARTFLAG = self.createFlagsLayer(
flags_group, '_flag_start',
self.plugin_dir + '/styles/start_flag.svg', network_srs)
if self.LAYER_STARTFLAG is None:
self.showWarn(self.tr(u'Unable to create start flag\'s layer'))
self.LAYER_ENDFLAG = self.createFlagsLayer(
flags_group, '_flag_end', self.plugin_dir + '/styles/end_flag.svg',
network_srs)
if self.LAYER_ENDFLAG is None:
self.showWarn(self.tr(u'Unable to create end flag\'s layer'))
self.LAYER_BLOCKFLAGS = self.createFlagsLayer(
flags_group, '_flags_block',
self.plugin_dir + '/styles/block_flag.svg', network_srs)
if self.LAYER_BLOCKFLAGS is None:
self.showWarn(self.tr(u'Unable to create block flags\' layer'))
# 2. Load data layers.
layers_passed_count = 0
data_group = common_group.addGroup('Data')
data_layer_count = dataset.GetLayerCount()
for i in range(0, data_layer_count):
gdal_layer = dataset.GetLayer(i)
data_layer = self.loadDataLayer(data_group, gdal_layer,
network_fullpath)
if data_layer is None:
layers_passed_count = layers_passed_count + 1
continue
self.LAYERS_DATA.append(data_layer)
if layers_passed_count != 0:
self.showWarn(
self.tr(u'Network layers skipped (unable to read): ') +
str(layers_passed_count))
# 3. Create result layers.
results_group = common_group.addGroup('Results')
self.LAYER_RESULT_PATH = self.createResultLayer(
results_group, '_path_dijkstra', QColor(255, 0, 0), network_srs)
if self.LAYER_RESULT_PATH is None:
self.showWarn(
self.
tr(u'Unable to create result layer for shortest path calculations'
))
paths_group = results_group.addGroup('_paths_k')
for i in range(self.GNM_SETTING_K):
transp_coef = 255 / self.GNM_SETTING_K - 5
layer_i = self.createResultLayer(
paths_group, '_path_' + str(i),
QColor(0, 133, 63, 255 - i * transp_coef), network_srs)
if layer_i is None:
self.showWarn(
self.
tr(u'Unable to create result layer for one of the K-paths calculation'
))
continue
self.LAYERS_RESULT_PATHS.append(layer_i)
self.LAYER_RESULT_CONNECTIVITY = self.createResultLayer(
results_group, '_tree_connectivity', QColor(0, 157, 255),
network_srs)
if self.LAYER_RESULT_CONNECTIVITY is None:
self.showWarn(
self.
tr(u'Unable to create result layer for connectivity tree calculations'
))
return True
def onCreateClicked(self):
#gdal.SetConfigOption('CPL_DEBUG','ON');
#gdal.SetConfigOption('CPL_LOG','D:/nextgis/gnmmanager/gdal_log.txt');
#gdal.SetConfigOption('CPL_LOG_ERRORS','ON');
# Start creating network.
self.butCreate.setEnabled(False)
self.msg(self.tr(u'Starting network creation...'))
self.progress(0)
# Obtain network parameters from the dialog.
# TODO: replace it with real saving params via according group of widgets:
path = self.editFileParams.text()
# TODO: replace it with real format selection via combobox:
format = self.comboFormat.currentText()
gnm_format = self.GNM_CONST_FILEFORMAT
srs = self.comboSrs.currentText()
name = self.editName.text()
descr = self.editDescr.text()
if self.isStrVoid(path):
self.msgErr(self.tr(u'The network\'s saving path is set incorrectly!'))
self.progress(0)
return
if self.isStrVoid(name):
self.msgErr(self.tr(u'The network\'s name is set incorrectly!'))
self.progress(0)
return
options = []
self.addOption(options,self.GNM_CONST_OPT_NAME,name)
self.addOption(options,self.GNM_CONST_OPT_DESCR,descr)
self.addOption(options,self.GNM_CONST_OPT_SRS,self.getSrsKeyname(srs))
layer_other_paths = []
layer_names = []
cnt = self.listLayers.count()
if cnt == 0:
self.msgWarn(self.tr(u'No layers were defined for import. The network will be void!'))
for i in range(0,cnt):
#layer_other_name = str(self.listLayers.item(i).text())
#layer_other_data = str(self.listLayers.item(i).data(Qt.UserRole))
layer_other_paths.append(self.listLayers.item(i).text())
try:
tolerance = float(str(self.editTolerance.text()))
except ValueError:
tolerance = 0
if tolerance < 0:
self.msgWarn(self.tr(u'Tolerance for layers connection was set incorrectly [ = ')
+self.editTolerance.text()+u']. '
+self.tr(u'The default value [ = 0] will be used!'))
tolerance = 0
self.progress(5)
# Initialize network via creation.
self.msg(u'')
self.msg(self.tr(u'Creating network dataset...'))
self.msg(self.tr(u'Format: ')+format)
self.msg(self.tr(u'Path: ')+path)
self.msg(self.tr(u'SRS: ')+srs)
driver = gdal.GetDriverByName(str(gnm_format))
if driver is None:
self.msgErr(self.tr(u'Unable to initialize network driver via GDAL'))
self.progress(0)
return
dataset = driver.Create(str(path), 0, 0, 0, gdal.GDT_Unknown, options)
network = gnm.CastToNetwork(dataset)
if network is None:
self.msgErr(self.tr(u'Unable to initialize network dataset via GDAL'))
self.progress(0)
return
gen_network = gnm.CastToGenericNetwork(dataset)
if gen_network is None:
self.msgErr(self.tr(u'Unable to initialize (generic) network dataset via GDAL'))
self.progress(0)
return
self.msg(self.tr(u'...done'))
self.progress(20)
# Fill network with layers.
self.msg(u'')
has_point_layer = False
has_line_layer = False
for layer_other_path in layer_other_paths:
self.msg(self.tr(u'Importing layer: ')+layer_other_path)
dataset_other = gdal.OpenEx(str(layer_other_path), gdal.OF_VECTOR)
if dataset_other is None:
self.msgErr(self.tr(u'Failed to open side dataset'))
self.progress(0)
return
layer_other = dataset_other.GetLayerByIndex(0)
if layer_other is None:
self.msgErr(self.tr(u'Failed to fetch layer in a side dataset'))
self.progress(0)
return
layer_name_other = layer_other.GetName()
layer = network.CopyLayer(layer_other, layer_name_other)
if layer is None:
self.msgErr(self.tr(u'Failed to import layer to the network'))
return
layer_geom = layer.GetGeomType()
if layer_geom == ogr.wkbPoint:
has_point_layer = True
elif layer_geom == ogr.wkbLineString:
has_line_layer = True
layer_names.append(layer.GetName())
dataset_other = None
# TODO: we do not need such checks if there is some other algorithm of automatic topology creation:
if not has_point_layer:
self.msgWarn(self.tr(u'No layer with point geometry was imported. '
'At least one required to properly build network\'s topology'))
if not has_line_layer:
self.msgWarn(self.tr(u'No layer with line geometry was imported. '
'At least one required to properly build network\'s topology'))
self.msg(self.tr(u'...done'))
self.progress(55)
# Establish network connectivity.
self.msg(u'')
self.msg(self.tr(u'Creating network\'s topology...'))
# TODO: get weights for the graph edges from the layer's fields via ChangeEdge method:
err = gen_network.ConnectPointsByLines(layer_names, tolerance, 1, 1, gnm.GNM_EDGE_DIR_BOTH)
if err != 0:
self.msgWarn(self.tr(u'Failed to create topology. Features in the network will be unconnected'))
self.msg(self.tr(u'...done'))
self.progress(85)
# Close network for successfull saving all data.
gen_network = None
network = None
dataset = None
# Open network for further returning it outside the dialog.
net_fullpath = path + '/' + name
dataset = gdal.OpenEx(net_fullpath)
network = gnm.CastToNetwork(dataset)
if network is None:
self.msgErr(self.tr(u'Network created successfully but it is not able to open it'))
return
self.NETWORK_DS = dataset
self.NETWORK_FULLPATH = net_fullpath
self.butBack.setEnabled(False) # no way to return back
self.butOk.show()
self.msg(u'')
self.msg(self.tr(u'Network was successfully created!'))
self.progress(99)
