def test_identify_features_river_test(self):
"""Test for identify_features on the River_Test dataset."""
sungai_layer = get_temp_shapefile_layer(
RIVER_TEST_SHP, 'River_Test')
_, output_layer = identify_features(
sungai_layer, 1, console_progress_callback)
num_sinks = 0
num_wells = 0
num_unseparated = 0
wells = []
for feature in output_layer.getFeatures():
point = feature.geometry().asPoint().toString(17)
result = [feature.geometry().asPoint(), feature.attributes()[3]]
message = '%s is not found %s' % (point, feature.id())
# self.assertIn(result, expected_result, message)
if result[1] == 'Sink':
num_sinks += 1
if result[1] == 'Well':
num_wells += 1
wells.append(point)
if result[1] == 'Unseparated':
num_unseparated += 1
message = ('There should be %s sinks, but I got %s' % (10, num_sinks))
self.assertEqual(10, num_sinks, message)
message = ('There should be %s wells, but I got %s' % (15, num_wells))
self.assertEqual(16, num_wells, message)
message = ('There should be %s unseparated, but I got %s' % (
5, num_unseparated))
self.assertEqual(4, num_unseparated, message)
message = ('There should be %s features, but I got %s' %
(119, output_layer.featureCount()))
self.assertEqual(119, output_layer.featureCount(), message)
remove_temp_layer(sungai_layer.source())
def test_identify_features_sungai_baru(self):
"""Test for identify_features on the sungai baru dataset."""
sungai_layer = get_temp_shapefile_layer(
SUNGAI_BARU_SHP, 'sungai_baru')
_, output_layer = identify_features(
sungai_layer, 1, console_progress_callback)
features_count = output_layer.featureCount()
expected_result = [
[QgsPoint(4505079.78066084068268538, 5820617.32926965225487947),
'Watershed'],
[QgsPoint(4505796.71872960310429335, 5819594.76427788194268942),
'Unseparated'],
[QgsPoint(4505201.38892469275742769, 5818932.09107278566807508),
'Unclear Bifurcation'],
[QgsPoint(4505994.16670085769146681, 5818944.59937320277094841),
'Confluence'],
[QgsPoint(4505423.69021992385387421, 5819349.8841874785721302),
'Pseudo node'],
[QgsPoint(4504424.25703522842377424, 5819771.00726572517305613),
'Branch'],
[QgsPoint(4504424.25681891199201345, 5821004.36726346984505653),
'Well'],
[QgsPoint(4506321.54563129413872957, 5820690.89381018560379744),
'Sink'],
[QgsPoint(4505706.96817480307072401, 5820597.46010562963783741),
'Self Intersection'],
[QgsPoint(4504954.79498676210641861, 5819664.31516459211707115),
'Intersection'],
[QgsPoint(4504516.27684732060879469, 5820388.85559526737779379),
'Segment Center'],
[QgsPoint(4505459.87090463936328888, 5820124.74861902091652155),
'Segment Center'],
[QgsPoint(4505597.77781277894973755, 5818938.34522299282252789),
'Segment Center'],
[QgsPoint(4505298.45680753327906132, 5818640.22502889111638069),
'Segment Center'],
[QgsPoint(4505874.24493211694061756, 5818746.94614691846072674),
'Segment Center'],
[QgsPoint(4505905.3135033342987299, 5820416.27267749048769474),
'Segment Center'],
[QgsPoint(4504960.94927519094198942, 5819710.47232702653855085),
'Segment Center'],
[QgsPoint(4506065.1831744248047471, 5819712.94692023564130068),
'Segment Center'],
[QgsPoint(4504974.16828893031924963, 5819660.41915996465831995),
'Segment Center'],
[QgsPoint(4504515.96725786849856377, 5819123.59523478243499994),
'Segment Center'],
[QgsPoint(4505754.27464655786752701, 5818549.32406418491154909),
'Sink']
]
for feature in output_layer.getFeatures():
point = feature.geometry().asPoint().toString(17)
result = [feature.geometry().asPoint(), feature.attributes()[3]]
message = '%s is not found %s' % (point, feature.id())
self.assertIn(result, expected_result, message)
message = ('There should be %s features, but I got %s' %
(len(expected_result), features_count))
self.assertEqual(features_count, len(expected_result), message)
remove_temp_layer(sungai_layer.source())
def test_identify_features_dgn(self):
"""Test for identify_features on the dgn test dataset."""
layer = get_temp_shapefile_layer(DGN_SHP, 'dgn_lines')
_, output_layer = identify_features(
layer, THRESHOLD, callback=console_progress_callback)
num_wells = 0
num_sinks = 0
num_branches = 0
num_confluences = 0
num_pseudo_nodes = 0
num_watersheds = 0
num_self_intersections = 0
num_segment_center = 0
num_intersections = 0
num_unseparated = 0
for f in output_layer.getFeatures():
node_type = f.attributes()[3]
if node_type == 'Well':
num_wells += 1
if node_type == 'Sink':
num_sinks += 1
if node_type == 'Branch':
num_branches += 1
if node_type == 'Confluence':
num_confluences += 1
if node_type == 'Pseudo node':
num_pseudo_nodes += 1
if node_type == 'Watershed':
num_watersheds += 1
if node_type == 'Self Intersection':
num_self_intersections += 1
if node_type == 'Segment Center':
num_segment_center += 1
if node_type == 'Intersection':
num_intersections += 1
if node_type == 'Unseparated':
num_unseparated += 1
print 'wells', num_wells
print 'sinks', num_sinks
print 'branches', num_branches
print 'confluences', num_confluences
print 'pseudo nodes', num_pseudo_nodes
print 'watersheds', num_watersheds
print 'self intersections', num_self_intersections
print 'segment center', num_segment_center
print 'unseparated', num_unseparated
feature_count = output_layer.featureCount()
message = (
'There should be 24005 features, but I got %s' % feature_count)
self.assertEqual(feature_count, 24005, message)
message = (
'There should be 12 intersections / kreuzung, but I got %s' % i)
self.assertEqual(num_intersections, 12, message)
message = 'There should be 1893 pseudo node, but I got %s' % i
self.assertEqual(num_pseudo_nodes, 1893, message)
message = 'There should be 847 wells / quelle, but I got %s' % i
self.assertEqual(num_wells, 847, message)
message = 'There should be 125 sinks / senke, but I got %s' % i
self.assertEqual(num_sinks, 125, message)
message = (
'There should be 186 branches / verzweigung, but I got %s' % i)
self.assertEqual(num_branches, 186, message)
message = (
'There should be 867 confluences / Zusammenfluss, but I '
'got %s' % i)
self.assertEqual(num_confluences, 867, message)
remove_temp_layer(layer.source())
def run(self):
"""Run method that performs all the real work."""
message_bar = self.iface.messageBar().createMessage(
self.tr('Extracting stream features'),
self.tr('Please stand by while calculation is in progress.'),
self.iface.mainWindow())
progress_bar = QProgressBar()
progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
# Need to implement a separate worker thread if we want cancel
#cancel_button = QPushButton()
#cancel_button.setText(self.tr('Cancel'))
#cancel_button.clicked.connect(worker.kill)
message_bar.layout().addWidget(progress_bar)
#message_bar.layout().addWidget(cancel_button)
self.iface.messageBar().pushWidget(
message_bar, self.iface.messageBar().INFO)
self.message_bar = message_bar
def progress_callback(current, maximum, message=None):
"""GUI based callback implementation for showing progress.
:param current: Current progress.
:type current: int
:param maximum: Maximum range (point at which task is complete.
:type maximum: int
:param message: Optional message to display in the progress bar
:type message: str, QString
"""
if message is not None:
message_bar.setText(message)
if progress_bar is not None:
progress_bar.setMaximum(maximum)
progress_bar.setValue(current)
settings = QSettings()
distance = settings.value(
'stream-feature-extractor/search-distance', 0, type=float)
load_intermediate_layer = settings.value(
'stream-feature-extractor/load-intermediate-layer',
False,
type=bool)
# noinspection PyBroadException
try:
intermediate_layer, nodes = identify_features(
self.iface.activeLayer(),
threshold=distance,
callback=progress_callback)
except Exception:
LOGGER.exception('A failure occurred calling identify_features.')
self.iface.messageBar().popWidget(message_bar)
self.iface.messageBar().pushMessage(
self.tr('Feature extraction error.'),
self.tr('Please check logs for details.'),
level=QgsMessageBar.CRITICAL,
duration=5)
return
# Get rid of the message bar again.
self.iface.messageBar().popWidget(message_bar)
self._load_nodes_with_style(nodes)
if load_intermediate_layer:
QgsMapLayerRegistry.instance().addMapLayer(intermediate_layer)
#QgsMapLayerRegistry.instance().addMapLayers([layer])
self.iface.messageBar().pushMessage(
self.tr('Extraction completed.'),
self.tr('Use "Layer->Save as" to save the results permanently.'),
level=QgsMessageBar.INFO,
duration=10)
