def testUniqueValues(self):
ProcessingConfig.initialize()
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
v = vector.uniqueValues(test_layer, 2)
self.assertEqual(len(v), len(set(v)))
self.assertEqual(set(v), set([2, 1, 0]))
# field by name
v = vector.uniqueValues(test_layer, 'id2')
self.assertEqual(len(v), len(set(v)))
self.assertEqual(set(v), set([2, 1, 0]))
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
v = vector.uniqueValues(test_layer, 'id')
self.assertEqual(len(v), len(set(v)))
self.assertEqual(set(v), set([5, 7, 3]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
def sagaPath():
folder = ProcessingConfig.getSetting(SAGA_FOLDER)
if folder is None or folder == '':
folder = findSagaFolder()
if folder is not None:
ProcessingConfig.setSettingValue(SAGA_FOLDER, folder)
return folder or ''
def runAlgorithm(self):
'''
Execute geo-operation GeoAlgorithm Processing based
'''
self.dlg.openChartDialogButton.setEnabled(False)
algorithm = self.GeoprocessingAlgorithms[self.dlg.getGeoprocessingTypeData()](self.dlg.getOutputType())
self.dlg.algorithm = algorithm
algorithm.provider = QGISAlgorithmProvider()
algorithm.setParameterValue('ORIGIN',self.dlg.getComboboxData('originLayerSelect'))
algorithm.setParameterValue('TARGET',self.dlg.getComboboxData('targetLayerSelect'))
algorithm.setParameterValue('FIELDSORIGIN',self.dlg.getSelectedFields('tableViewOriginLayerFields'))
algorithm.setParameterValue('FIELDSTARGET',self.dlg.getSelectedFields('tableViewTargetLayerFields'))
algorithm.setParameterValue('EXPRESSIONSORIGIN',self.dlg.getSelectedFieldsNameWithExpression('tableViewOriginLayerFields'))
algorithm.setParameterValue('EXPRESSIONSTARGET',self.dlg.getSelectedFieldsNameWithExpression('tableViewTargetLayerFields'))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_FILENAME_AS_LAYER_NAME,True)
if self.dlg.getOutputType() == 'Shape File':
outputFile = self.dlg.outputShapeFile.text()
elif self.dlg.getOutputType() == 'Spatialite':
outputFile = self.dlg.outputSpatialite.text()
else:
outputFile = self.dlg.getPostgisOutputValues()
algorithm.setOutputValue('OUTPUT',outputFile)
algorithm.execute(self.dlg)
self.dlg.reslayer = handleAlgorithmResults(algorithm,self.dlg)
#QObject.connect(self.dlg.reslayer[0], SIGNAL('layerDeleted()'),self.dlg.clearReslayer)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_FILENAME_AS_LAYER_NAME,False)
self.dlg.openChartDialogButton.setEnabled(True)
def grassPath():
if not isWindows() and not isMac():
return ''
folder = ProcessingConfig.getSetting(GrassUtils.GRASS_FOLDER) or ''
if not os.path.exists(folder):
folder = None
if folder is None:
if isWindows():
if "OSGEO4W_ROOT" in os.environ:
testfolder = os.path.join(str(os.environ['OSGEO4W_ROOT']), "apps")
else:
testfolder = str(QgsApplication.prefixPath())
testfolder = os.path.join(testfolder, 'grass')
if os.path.isdir(testfolder):
for subfolder in os.listdir(testfolder):
if subfolder.startswith('grass-6'):
folder = os.path.join(testfolder, subfolder)
break
else:
folder = os.path.join(QgsApplication.prefixPath(), 'grass')
if not os.path.isdir(folder):
folder = '/Applications/GRASS-6.4.app/Contents/MacOS'
if folder:
ProcessingConfig.setSettingValue(GrassUtils.GRASS_FOLDER, folder)
return folder or ''
def testGrass(self):
'''Test GRASS is installed QGIS-89 (2)'''
folder = ProcessingConfig.getSetting(GrassUtils.GRASS_FOLDER)
ProcessingConfig.removeSetting(GrassUtils.GRASS_FOLDER)
msg = GrassUtils.checkGrassIsInstalled()
self.assertIsNone(msg)
ProcessingConfig.setSettingValue(GrassUtils.GRASS_FOLDER, folder)
def addToLog(msgtype, msg):
try:
# It seems that this fails sometimes depending on the msg
# added. To avoid it stopping the normal functioning of the
# algorithm, we catch all errors, assuming that is better
# to miss some log info that breaking the algorithm.
if isinstance(msg, list):
a = '|'.join(m.strip('\n') for m in msg)
text = a
else:
text = msg.replace('\n', '|')
line = msgtype + '|' + datetime.datetime.now().strftime(
ProcessingLog.DATE_FORMAT).decode('utf-8') + '|' \
+ text + '\n'
logfile = codecs.open(ProcessingLog.logFilename(), 'a',
encoding='utf-8')
logfile.write(line)
logfile.close()
if msgtype == ProcessingLog.LOG_ALGORITHM:
algname = text[len('Processing.runalg("'):]
algname = algname[:algname.index('"')]
if algname not in ProcessingLog.recentAlgs:
ProcessingLog.recentAlgs.append(algname)
recentAlgsString = ';'.join(ProcessingLog.recentAlgs[-6:])
ProcessingConfig.setSettingValue(
ProcessingConfig.RECENT_ALGORITHMS,
recentAlgsString)
except:
pass
def addToLog(msgtype, msg):
try:
# It seems that this fails sometimes depending on the msg
# added. To avoid it stopping the normal functioning of the
# algorithm, we catch all errors, assuming that is better
# to miss some log info than breaking the algorithm.
if msgtype == ProcessingLog.LOG_ALGORITHM:
line = msgtype + '|' + datetime.datetime.now().strftime(
ProcessingLog.DATE_FORMAT) + '|' \
+ msg + '\n'
with codecs.open(ProcessingLog.logFilename(), 'a',
encoding='utf-8') as logfile:
logfile.write(line)
algname = msg[len('Processing.runalg("'):]
algname = algname[:algname.index('"')]
if algname not in ProcessingLog.recentAlgs:
ProcessingLog.recentAlgs.append(algname)
recentAlgsString = ';'.join(ProcessingLog.recentAlgs[-6:])
ProcessingConfig.setSettingValue(
ProcessingConfig.RECENT_ALGORITHMS,
recentAlgsString)
else:
if isinstance(msg, list):
msg = '\n'.join([m for m in msg])
msgtypes = {ProcessingLog.LOG_ERROR: QgsMessageLog.CRITICAL,
ProcessingLog.LOG_INFO: QgsMessageLog.INFO,
ProcessingLog.LOG_WARNING: QgsMessageLog.WARNING, }
QgsMessageLog.logMessage(msg, ProcessingLog.tr("Processing"), msgtypes[msgtype])
except:
pass
def setUp(self):
ProcessingConfig.setSettingValue(ProcessingConfig.USE_THREADS, self.threaded)
print
print bcolors.INFO, self.msg, bcolors.ENDC,
print "Parameters: ", self.alg.parameters,
print "Outputs: ", [out for out in self.alg.outputs if not out.hidden],
self.args = list(self.gen_test_parameters(self.alg, True))
print ' => ', self.args, bcolors.WARNING,
def activateProvider(self, id):
name = 'ACTIVATE_' + id.upper().replace(' ', '_')
ProcessingConfig.setSettingValue(name, True)
self.fillTree()
self.textChanged()
self.showDisabled()
provider = QgsApplication.processingRegistry().providerById(id)
if not provider.canBeActivated():
QMessageBox.warning(self, "Activate provider",
"The provider has been activated, but it might need additional configuration.")
def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
ProcessingConfig.setSettingValue(ModelerUtils.MODELS_FOLDER, os.path.join(os.path.dirname(__file__), 'models'))
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
cls.cleanup_paths = []
cls.in_place_layers = {}
cls.vector_layer_params = {}
cls._original_models_folder = ProcessingConfig.getSetting(ModelerUtils.MODELS_FOLDER)
def activateProvider(self, providerName):
name = 'ACTIVATE_' + providerName.upper().replace(' ', '_')
ProcessingConfig.setSettingValue(name, True)
self.fillTree()
self.textChanged()
self.showDisabled()
provider = Processing.getProviderFromName(providerName)
if not provider.canBeActivated():
QMessageBox.warning(self, "Activate provider",
"The provider has been activated, but it might need additional configuration.")
def testSaga(self):
'''Test SAGA is installed. QGIS-89 (1)'''
folder = ProcessingConfig.getSetting(SAGA_FOLDER)
hasSetting = True
try:
ProcessingConfig.removeSetting(SAGA_FOLDER)
except:
hasSetting = False
self.assertTrue(getSagaInstalledVersion(True) in ["2.1.2", "2.1.3", "2.1.4", "2.2.0"])
if hasSetting:
ProcessingConfig.setSettingValue(SAGA_FOLDER, folder)
def _test_difference_on_invalid_geometries(self, geom_option):
polygon_layer = self._make_layer('Polygon')
self.assertTrue(polygon_layer.startEditing())
f = QgsFeature(polygon_layer.fields())
f.setAttributes([1])
# Flake!
f.setGeometry(QgsGeometry.fromWkt('Polygon ((0 0, 2 2, 0 2, 2 0, 0 0))'))
self.assertTrue(f.isValid())
self.assertTrue(polygon_layer.addFeatures([f]))
polygon_layer.commitChanges()
polygon_layer.rollBack()
self.assertEqual(polygon_layer.featureCount(), 1)
overlay_layer = self._make_layer('Polygon')
self.assertTrue(overlay_layer.startEditing())
f = QgsFeature(overlay_layer.fields())
f.setAttributes([1])
f.setGeometry(QgsGeometry.fromWkt('Polygon ((0 0, 2 0, 2 2, 0 2, 0 0))'))
self.assertTrue(f.isValid())
self.assertTrue(overlay_layer.addFeatures([f]))
overlay_layer.commitChanges()
overlay_layer.rollBack()
self.assertEqual(overlay_layer.featureCount(), 1)
QgsProject.instance().addMapLayers([polygon_layer, overlay_layer])
old_features = [f for f in polygon_layer.getFeatures()]
# 'Ignore features with invalid geometries' = 1
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, geom_option)
feedback = ConsoleFeedBack()
context = dataobjects.createContext(feedback)
context.setProject(QgsProject.instance())
alg = self.registry.createAlgorithmById('native:difference')
self.assertIsNotNone(alg)
parameters = {
'OVERLAY': overlay_layer,
'INPUT': polygon_layer,
'OUTPUT': ':memory',
}
old_features = [f for f in polygon_layer.getFeatures()]
self.assertTrue(polygon_layer.startEditing())
polygon_layer.selectAll()
ok, _ = execute_in_place_run(
alg, parameters, context=context, feedback=feedback, raise_exceptions=True)
new_features = [f for f in polygon_layer.getFeatures()]
return old_features, new_features
def testUniqueValues(self):
ProcessingConfig.initialize()
# disable check for geometry validity
prevInvalidGeoms = ProcessingConfig.getSetting(ProcessingConfig.FILTER_INVALID_GEOMETRIES)
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, 0)
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
v = vector.uniqueValues(test_layer, 2)
self.assertEqual(len(v), len(set(v)))
self.assertEqual(set(v), set([2, 1, 0]))
# field by name
v = vector.uniqueValues(test_layer, 'id2')
self.assertEqual(len(v), len(set(v)))
self.assertEqual(set(v), set([2, 1, 0]))
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
v = vector.uniqueValues(test_layer, 'id')
self.assertEqual(len(v), len(set(v)))
self.assertEqual(set(v), set([5, 7, 3]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, prevInvalidGeoms)
def addToLog(msg):
try:
# It seems that this fails sometimes depending on the msg
# added. To avoid it stopping the normal functioning of the
# algorithm, we catch all errors, assuming that is better
# to miss some log info than breaking the algorithm.
line = 'ALGORITHM' + LOG_SEPARATOR + datetime.datetime.now().strftime(
ProcessingLog.DATE_FORMAT) + LOG_SEPARATOR \
+ msg + '\n'
with codecs.open(ProcessingLog.logFilename(), 'a',
encoding='utf-8') as logfile:
logfile.write(line)
algname = msg[len('processing.run("'):]
algname = algname[:algname.index('"')]
if algname not in ProcessingLog.recentAlgs:
ProcessingLog.recentAlgs.append(algname)
recentAlgsString = ';'.join(ProcessingLog.recentAlgs[-6:])
ProcessingConfig.setSettingValue(
ProcessingConfig.RECENT_ALGORITHMS,
recentAlgsString)
except:
pass
def testValues(self):
ProcessingConfig.initialize()
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# field by index
res = vector.values(test_layer, 1)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# field by name
res = vector.values(test_layer, 'id')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
# two fields
res = vector.values(test_layer, 1, 2)
self.assertEqual(res[1], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name
res = vector.values(test_layer, 'id', 'id2')
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res['id2'], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# two fields by name and index
res = vector.values(test_layer, 'id', 2)
self.assertEqual(res['id'], [1, 2, 3, 4, 5, 6, 7, 8, 9])
self.assertEqual(res[2], [2, 1, 0, 2, 1, 0, 0, 0, 0])
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
res = vector.values(test_layer, 1)
self.assertEqual(set(res[1]), set([5, 7, 3]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
def addToLog(msgtype, msg):
try: #it seems that this fails sometimes depending on the msg added:
#To avoid it stopping the normal functioning of the algorithm,
#we catch all errors, assuming that is better to miss some log info
#that breaking the algorithm.
if isinstance(msg, list):
a = "|".join(m.strip("\n") for m in msg)
text = a
else:
text = msg.replace("\n", "|")
line = msgtype + "|" + datetime.datetime.now().strftime(ProcessingLog.DATE_FORMAT).decode("utf-8") + "|" + text + "\n"
logfile = codecs.open(ProcessingLog.logFilename(), "a", encoding="utf-8")
#logfile = codecs.open(ProcessingLog.logFilename(), "a", encoding='utf-8')
logfile.write(line)
logfile.close()
if msgtype==ProcessingLog.LOG_ALGORITHM:
algname = text[len("Processing.runalg(\""):]
algname = algname[:algname.index("\"")]
if algname not in ProcessingLog.recentAlgs:
ProcessingLog.recentAlgs.append(algname)
recentAlgsString = ';'.join(ProcessingLog.recentAlgs[-6:])
ProcessingConfig.setSettingValue(ProcessingConfig.RECENT_ALGORITHMS, recentAlgsString)
except:
pass
def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
ProcessingConfig.setSettingValue("OTB_ACTIVATE", True)
ProcessingConfig.setSettingValue(OtbSettings.FOLDER, OTB_INSTALL_DIR)
ProcessingConfig.setSettingValue(OtbSettings.APP_FOLDER, os.path.join(OTB_INSTALL_DIR, 'lib', 'otb', 'applications'))
ProcessingConfig.readSettings()
# Refresh OTB Algorithms after settings are changed.
for p in QgsApplication.processingRegistry().providers():
if p.id() == "otb":
p.refreshAlgorithms()
cls.descrFolder = os.path.join(OTB_INSTALL_DIR, 'share', 'otb', 'description')
cls.cleanup_paths = []
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
SELECTED_ONLY = self.getParameterValue(self.SELECTED_ONLY)
kneighbors = int(self.getParameterValue(self.KNEIGHBORS))
use_field = self.getParameterValue(self.METHOD) == 1
field_name = self.getParameterValue(self.FIELD)
# temporarily alter the processing environment
old_setting = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, SELECTED_ONLY)
# get properties of the field the grouping is based on
if use_field:
field = QgsField(field_name)
field.setType(QVariant.String)
field.setLength(255)
index = layer.fieldNameIndex(field_name)
field_type = layer.pendingFields()[index].type()
if field_type == QVariant.Int:
field.setType(QVariant.Int)
field.setLength(20)
elif field_type == QVariant.Double:
field.setType(QVariant.Double)
field.setLength(20)
field.setPrecision(6)
else:
field.setType(QVariant.String)
field.setLength(255)
fields = [QgsField('clusterId', QVariant.Int, '', 20), field]
else:
# setup the fields of the output layer
fields = [QgsField('clusterId', QVariant.Int, '', 20)]
#fields.extend(layer.pendingFields().toList())
# initialize writer
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QGis.WKBPoint, layer.crs())
current = 0
fid = 1
if use_field:
# get unique values of field denoted by index as filter conditions
unique_values = layer.uniqueValues(index)
total = 100.0 / float(layer.featureCount() * len(unique_values))
for unique in unique_values:
points = []
first = True
features = vector.features(layer)
for in_feature in features:
value = in_feature[field_name]
if value == unique:
if first:
val = unique
first = False
points.extend(vector.extractPoints(QgsGeometry(in_feature.geometry())))
current += 1
progress.setPercentage(int(current * total))
# A minimum of 3 points is necessary to proceed
if len(points) >= 3:
out_feature = QgsFeature()
try:
clusters = SSNClusters(points, kneighbors).get_clusters()
for cluster in clusters.keys():
#mpoint = QgsGeometry.fromMultiPoint([QgsPoint(point[0], point[1]) for point in clusters[cluster]])
for member in clusters[cluster]:
point = QgsGeometry.fromPoint(QgsPoint(member[0], member[1]))
out_feature.setGeometry(point)
out_feature.setAttributes([fid, val])
writer.addFeature(out_feature)
fid += 1
except:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, 'Exception while computing clusters.')
raise GeoAlgorithmExecutionException('Exception while computing clusters.')
finally:
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, old_setting)
else:
points = []
features = vector.features(layer)
total = 100.0 / float(len(features))
for in_feature in features:
##points.append(in_feature.geometry().asPoint())
points.extend(vector.extractPoints(QgsGeometry(in_feature.geometry())))
current += 1
progress.setPercentage(int(current * total))
out_feature = QgsFeature()
try:
clusters = SSNClusters(points, kneighbors).get_clusters()
for cluster in clusters.keys():
#mpoint = QgsGeometry.fromMultiPoint([QgsPoint(point[0], point[1]) for point in clusters[cluster]])
for member in clusters[cluster]:
point = QgsGeometry.fromPoint(QgsPoint(member[0], member[1]))
out_feature.setGeometry(point)
out_feature.setAttributes([cluster])
writer.addFeature(out_feature)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, 'Exception while computing clusters.')
raise GeoAlgorithmExecutionException('Exception while computing clusters')
finally:
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, old_setting)
del writer
def setActive(self, active):
ProcessingConfig.setSettingValue(QTO3_ACTIVE, active)
def tearDownClass(cls):
from processing.core.Processing import Processing
Processing.deinitialize()
for path in cls.cleanup_paths:
shutil.rmtree(path)
ProcessingConfig.setSettingValue(ModelerUtils.MODELS_FOLDER, cls._original_models_folder)
def testSaga(self):
folder = ProcessingConfig.getSetting(SAGA_FOLDER)
ProcessingConfig.removeSetting(SAGA_FOLDER)
self.assertTrue(
getSagaInstalledVersion(True) in ["2.1.2", "2.1.3", "2.1.4"])
ProcessingConfig.setSettingValue(SAGA_FOLDER, folder)
def testFeatures(self):
ProcessingConfig.initialize()
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# disable check for geometry validity
prevInvalidGeoms = ProcessingConfig.getSetting(ProcessingConfig.FILTER_INVALID_GEOMETRIES)
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, 0)
# test with all features
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 3)
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
# selection, but not using selected features
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# using selected features, but no selection
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.removeSelection()
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test that feature request is honored
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
features = vector.features(test_layer, QgsFeatureRequest().setFilterFids([1, 3, 5]))
self.assertEqual(set([f.id() for f in features]), set([1, 3, 5]))
# test that feature request is honored when using selections
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertTrue(all([not f.hasGeometry() for f in features]))
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
# test exception is raised when filtering invalid geoms
#ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, 2)
#test_layer_invalid_geoms = QgsVectorLayer(invalid_geometries(), 'test', 'ogr')
#with self.assertRaises(GeoAlgorithmExecutionException):
# features = vector.features(test_layer_invalid_geoms)
# feats = [f for f in features]
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, prevInvalidGeoms)
def testGrass(self):
folder = ProcessingConfig.getSetting(GrassUtils.GRASS_FOLDER)
ProcessingConfig.removeSetting(GrassUtils.GRASS_FOLDER)
msg = GrassUtils.checkGrassIsInstalled()
self.assertIsNone(msg)
ProcessingConfig.setSettingValue(GrassUtils.GRASS_FOLDER, folder)
def testFeatures(self):
ProcessingConfig.initialize()
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# test with all features
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 3)
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
# selection, but not using selected features
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# using selected features, but no selection
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.removeSelection()
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test that feature request is honored
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
features = vector.features(test_layer, QgsFeatureRequest().setFilterFids([1, 3, 5]))
self.assertEqual(set([f.id() for f in features]), set([1, 3, 5]))
# test that feature request is honored when using selections
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertTrue(all([not f.hasGeometry() for f in features]))
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
def testFeatures(self):
ProcessingConfig.initialize()
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# test with all features
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 3)
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
# selection, but not using selected features
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# using selected features, but no selection
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.removeSelection()
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test that feature request is honored
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
features = vector.features(test_layer, QgsFeatureRequest().setFilterFids([1, 3, 5]))
self.assertEqual(set([f.id() for f in features]), set([1, 3, 5]))
# test that feature request is honored when using selections
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertTrue(all([not f.hasGeometry() for f in features]))
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT))
SELECTED_ONLY = self.getParameterValue(self.SELECTED_ONLY)
kneighbors = int(self.getParameterValue(self.KNEIGHBORS))
use_field = self.getParameterValue(self.METHOD) == 1
field_name = self.getParameterValue(self.FIELD)
# temporarily alter the processing environment
old_setting = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, SELECTED_ONLY)
# get properties of the field the grouping is based on
if use_field:
field = QgsField(field_name)
field.setType(QVariant.String)
field.setLength(255)
index = layer.fieldNameIndex(field_name)
field_type = layer.pendingFields()[index].type()
if field_type == QVariant.Int:
field.setType(QVariant.Int)
field.setLength(20)
elif field_type == QVariant.Double:
field.setType(QVariant.Double)
field.setLength(20)
field.setPrecision(6)
else:
field.setType(QVariant.String)
field.setLength(255)
fields = [QgsField('clusterId', QVariant.Int, '', 20), field]
else:
# setup the fields of the output layer
fields = [QgsField('clusterId', QVariant.Int, '', 20)]
#fields.extend(layer.pendingFields().toList())
# initialize writer
writer = self.getOutputFromName(self.OUTPUT).getVectorWriter(fields, QGis.WKBPoint, layer.crs())
current = 0
fid = 1
if use_field:
# get unique values of field denoted by index as filter conditions
unique_values = layer.uniqueValues(index)
total = 100.0 / float(layer.featureCount() * len(unique_values))
for unique in unique_values:
points = []
first = True
features = vector.features(layer)
for in_feature in features:
value = in_feature[field_name]
if value == unique:
if first:
val = unique
first = False
points.extend(vector.extractPoints(QgsGeometry(in_feature.geometry())))
current += 1
progress.setPercentage(int(current * total))
# A minimum of 3 points is necessary to proceed
if len(points) >= 3:
out_feature = QgsFeature()
try:
clusters = SSNClusters(points, kneighbors).get_clusters()
for cluster in clusters.keys():
#mpoint = QgsGeometry.fromMultiPoint([QgsPoint(point[0], point[1]) for point in clusters[cluster]])
for member in clusters[cluster]:
point = QgsGeometry.fromPoint(QgsPoint(member[0], member[1]))
out_feature.setGeometry(point)
out_feature.setAttributes([fid, val])
writer.addFeature(out_feature)
fid += 1
except:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, 'Exception while computing clusters.')
raise GeoAlgorithmExecutionException('Exception while computing clusters.')
finally:
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, old_setting)
else:
points = []
features = vector.features(layer)
total = 100.0 / float(len(features))
for in_feature in features:
##points.append(in_feature.geometry().asPoint())
points.extend(vector.extractPoints(QgsGeometry(in_feature.geometry())))
current += 1
progress.setPercentage(int(current * total))
out_feature = QgsFeature()
try:
clusters = SSNClusters(points, kneighbors).get_clusters()
for cluster in clusters.keys():
#mpoint = QgsGeometry.fromMultiPoint([QgsPoint(point[0], point[1]) for point in clusters[cluster]])
for member in clusters[cluster]:
point = QgsGeometry.fromPoint(QgsPoint(member[0], member[1]))
out_feature.setGeometry(point)
out_feature.setAttributes([cluster])
writer.addFeature(out_feature)
except:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, 'Exception while computing clusters.')
raise GeoAlgorithmExecutionException('Exception while computing clusters')
finally:
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, old_setting)
del writer
def setActive(self, active):
ProcessingConfig.setSettingValue('ACTIVATE_GRASS7', active)
def setActive(self, active):
ProcessingConfig.setSettingValue('ACTIVATE_EXAMPLE', active)
def testSaga(self):
folder = ProcessingConfig.getSetting(SAGA_FOLDER)
ProcessingConfig.removeSetting(SAGA_FOLDER)
self.assertTrue(getSagaInstalledVersion(True) in ["2.1.2", "2.1.3", "2.1.4"])
ProcessingConfig.setSettingValue(SAGA_FOLDER, folder)
def setActive(self, active):
ProcessingConfig.setSettingValue('VISIBILITY_ANALYSIS_ACTIVATED', active)
def testFeatures(self):
ProcessingConfig.initialize()
test_data = points()
test_layer = QgsVectorLayer(test_data, 'test', 'ogr')
# disable check for geometry validity
prevInvalidGeoms = ProcessingConfig.getSetting(ProcessingConfig.FILTER_INVALID_GEOMETRIES)
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, 0)
# test with all features
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test with selected features
previous_value = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 3)
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
# selection, but not using selected features
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# using selected features, but no selection
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.removeSelection()
features = vector.features(test_layer)
self.assertEqual(len(features), 9)
self.assertEqual(set([f.id() for f in features]), set([0, 1, 2, 3, 4, 5, 6, 7, 8]))
# test that feature request is honored
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, False)
features = vector.features(test_layer, QgsFeatureRequest().setFilterFids([1, 3, 5]))
self.assertEqual(set([f.id() for f in features]), set([1, 3, 5]))
# test that feature request is honored when using selections
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, True)
test_layer.selectByIds([2, 4, 6])
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertTrue(all([not f.hasGeometry() for f in features]))
features = vector.features(test_layer, QgsFeatureRequest().setFlags(QgsFeatureRequest.NoGeometry))
self.assertEqual(set([f.id() for f in features]), set([2, 4, 6]))
ProcessingConfig.setSettingValue(ProcessingConfig.USE_SELECTED, previous_value)
# test exception is raised when filtering invalid geoms
#ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, 2)
#test_layer_invalid_geoms = QgsVectorLayer(invalid_geometries(), 'test', 'ogr')
#with self.assertRaises(GeoAlgorithmExecutionException):
# features = vector.features(test_layer_invalid_geoms)
# feats = [f for f in features]
ProcessingConfig.setSettingValue(ProcessingConfig.FILTER_INVALID_GEOMETRIES, prevInvalidGeoms)
def activateProvider(providerOrName, activate=True):
providerName = providerOrName.getName() if isinstance(
providerOrName, AlgorithmProvider) else providerOrName
name = 'ACTIVATE_' + providerName.upper().replace(' ', '_')
ProcessingConfig.setSettingValue(name, activate)
algList.providerUpdated.emit(providerName)
def setActive(self, active):
ProcessingConfig.setSettingValue(OtbUtils.ACTIVATE, active)
def activateProvider(providerOrName, activate=True):
providerName = providerOrName.getName() if isinstance(providerOrName, AlgorithmProvider) else providerOrName
name = "ACTIVATE_" + providerName.upper().replace(" ", "_")
ProcessingConfig.setSettingValue(name, activate)
algList.providerUpdated.emit(providerName)
def setActive(self, active):
ProcessingConfig.setSettingValue(OtbSettings.ACTIVATE, active)
def setActive(self, active):
ProcessingConfig.setSettingValue(circuitscapeUtils.CIRCUITSCAPE_ACTIVE, active)
def testSaga(self):
folder = ProcessingConfig.getSetting(SAGA_FOLDER)
ProcessingConfig.removeSetting(SAGA_FOLDER)
self.assertEqual("2.1.4", getSagaInstalledVersion(True))
ProcessingConfig.setSettingValue(SAGA_FOLDER, folder)
def responseComplete(self):
QgsMessageLog.logMessage("wpsFilter.responseComplete")
request = self.serverInterface().requestHandler()
params = request.parameterMap()
service = params.get('SERVICE', '')
if service and service.upper() == 'WPS':
# prepare query
inputQuery = '&'.join(["%s=%s" % (k, params[k]) for k in params if k.lower() != 'map' and k.lower() != 'config' and k.lower != 'request_body'])
request_body = params.get('REQUEST_BODY', '')
# get config
configPath = os.getenv("PYWPS_CFG")
if not configPath and 'config' in params :
configPath = params['config']
elif not configPath and 'CONFIG' in params :
configPath = params['CONFIG']
QgsMessageLog.logMessage("configPath "+str(configPath))
if configPath :
os.environ["PYWPS_CFG"] = configPath
pywpsConfig.loadConfiguration()
try:
providerList = ''
algList = ''
algsFilter = ''
if pywpsConfig.config.has_section( 'qgis' ) :
# get the providers to publish
if pywpsConfig.config.has_option( 'qgis', 'providers' ) :
providerList = pywpsConfig.getConfigValue( 'qgis', 'providers' )
if providerList :
providerList = providerList.split(',')
# get the algorithm list to publish
if pywpsConfig.config.has_option( 'qgis', 'algs' ) :
algList = pywpsConfig.getConfigValue( 'qgis', 'algs' )
if algList :
algList = algList.split(',')
# get the algorithm filter
if pywpsConfig.config.has_option( 'qgis', 'algs_filter' ) :
algsFilter = pywpsConfig.getConfigValue( 'qgis', 'algs_filter' )
# init Processing
Processing.initialize()
# modify processes path and reload algorithms
if pywpsConfig.config.has_section( 'qgis' ) and pywpsConfig.config.has_option( 'qgis', 'processing_folder' ) :
processingPath = pywpsConfig.getConfigValue( 'qgis', 'processing_folder' )
if os.path.exists( processingPath ) and os.path.isdir( processingPath ) :
ProcessingConfig.setSettingValue( 'MODELS_FOLDER', os.path.join( processingPath, 'models' ) )
ProcessingConfig.setSettingValue( 'SCRIPTS_FOLDER', os.path.join( processingPath, 'scripts' ) )
ProcessingConfig.setSettingValue( 'R_FOLDER', os.path.join( processingPath, 'rscripts' ) )
# Reload algorithms
Processing.loadAlgorithms()
# get QGIS project path
projectPath = os.getenv("QGIS_PROJECT_FILE")
if not projectPath and 'map' in params :
projectPath = params['map']
elif not projectPath and 'MAP' in params :
projectPath = params['MAP']
#projectFolder
projectFolder = ''
if projectPath and os.path.exists( projectPath ) :
projectFolder = os.path.dirname( projectPath )
QgsMessageLog.logMessage("projectPath "+str(projectPath))
rasterLayers = []
vectorLayers = []
crsList = []
if projectPath and os.path.exists( projectPath ) :
p_dom = minidom.parse( projectPath )
for ml in p_dom.getElementsByTagName('maplayer') :
l= {'type':ml.attributes["type"].value,
'name':ml.getElementsByTagName('layername')[0].childNodes[0].data,
'datasource':ml.getElementsByTagName('datasource')[0].childNodes[0].data,
'provider':ml.getElementsByTagName('provider')[0].childNodes[0].data,
'crs':ml.getElementsByTagName('srs')[0].getElementsByTagName('authid')[0].childNodes[0].data,
'proj4':ml.getElementsByTagName('srs')[0].getElementsByTagName('proj4')[0].childNodes[0].data
}
# Update relative path
if l['provider'] in ['ogr','gdal'] and str(l['datasource']).startswith('.'):
l['datasource'] = os.path.abspath( os.path.join( projectFolder, l['datasource'] ) )
if not os.path.exists( l['datasource'] ) :
continue
elif l['provider'] in ['gdal'] and str(l['datasource']).startswith('NETCDF:'):
theURIParts = l['datasource'].split( ":" );
src = theURIParts[1]
src = src.replace( '"', '' );
if src.startswith('.') :
src = os.path.abspath( os.path.join( projectFolder, src ) )
theURIParts[1] = '"' + src + '"'
l['datasource'] = ':'.join( theURIParts )
if l['type'] == "raster" :
rasterLayers.append( l )
elif l['type'] == "vector" :
l['geometry'] = ml.attributes["geometry"].value
vectorLayers.append( l )
deafultCrs = ''
for mapcanvas in p_dom.getElementsByTagName('mapcanvas'):
for destinationsrs in mapcanvas.getElementsByTagName('destinationsrs'):
for authid in destinationsrs.getElementsByTagName('authid'):
defaultCrs = authid.childNodes[0].data
crsList.append( defaultCrs )
for wmsCrsList in p_dom.getElementsByTagName('WMSCrsList') :
for wmsCrs in wmsCrsList.getElementsByTagName('value') :
wmsCrsValue = wmsCrs.childNodes[0].data
if wmsCrsValue and wmsCrsValue != defaultCrs:
crsList.append( wmsCrsValue )
processes = [None] # if no processes found no processes return (deactivate default pywps process)
identifier = params.get('IDENTIFIER', '').lower()
for i in Processing.algs :
if providerList and i not in providerList :
continue
QgsMessageLog.logMessage("provider "+i+" "+str(len(Processing.algs[i])))
for m in Processing.algs[i]:
if identifier and identifier != m :
continue
if algList and m not in algList :
continue
if algsFilter :
alg = Processing.getAlgorithm( m )
if algsFilter.lower() not in alg.name.lower() and algsFilter.lower() not in m.lower():
continue
#QgsMessageLog.logMessage("provider "+i+" "+m)
processes.append(QGISProcessFactory(m, projectPath, vectorLayers, rasterLayers, crsList))
#pywpsConfig.setConfigValue("server","outputPath", '/tmp/wpsoutputs')
#pywpsConfig.setConfigValue("server","logFile", '/tmp/pywps.log')
qgisaddress = self.serverInterface().getEnv('SERVER_NAME')+self.serverInterface().getEnv('SCRIPT_NAME')
if self.serverInterface().getEnv('HTTPS') :
qgisaddress = 'https://'+qgisaddress
else :
qgisaddress = 'http://'+qgisaddress
qgisaddress = qgisaddress+'?'
if 'map' in params :
qgisaddress = qgisaddress +'map='+ params['map'] +'&'
elif 'MAP' in params :
qgisaddress = qgisaddress +'MAP='+ params['MAP'] +'&'
if 'config' in params :
qgisaddress = qgisaddress +'config='+ params['config'] +'&'
elif 'CONFIG' in params :
qgisaddress = qgisaddress +'CONFIG='+ params['CONFIG'] +'&'
#pywpsConfig.setConfigValue("wps","serveraddress", qgisaddress)
#QgsMessageLog.logMessage("qgisaddress "+qgisaddress)
#pywpsConfig.setConfigValue("qgis","qgisserveraddress", qgisaddress)
# init wps
method = 'GET'
if request_body :
method = 'POST'
wps = pywps.Pywps(method)
# create the request file for POST request
if request_body :
tmpPath=pywpsConfig.getConfigValue("server","tempPath")
requestFile = open(os.path.join(tmpPath, "request-"+str(wps.UUID)),"w")
requestFile.write(str(request_body))
requestFile.close()
requestFile = open(os.path.join(tmpPath, "request-"+str(wps.UUID)),"r")
inputQuery = requestFile
if wps.parseRequest(inputQuery):
response = wps.performRequest(processes=processes)
if response:
request.clearHeaders()
request.clearBody()
#request.setHeader('Content-type', 'text/xml')
request.setInfoFormat(wps.request.contentType)
resp = wps.response
if wps.request.contentType == 'application/xml':
import re
import xml.sax.saxutils as saxutils
resp = re.sub(r'Get xlink:href=".*"', 'Get xlink:href="'+saxutils.escape(qgisaddress)+'"', resp)
resp = re.sub(r'Post xlink:href=".*"', 'Post xlink:href="'+saxutils.escape(qgisaddress)+'"', resp)
# test response type
if isinstance( resp, str ):
request.appendBody(resp)
elif isinstance( resp, file ) :
request.appendBody(resp.read())
except WPSException,e:
request.clearHeaders()
#request.setHeader('Content-type', 'text/xml')
request.clearBody()
request.setInfoFormat('text/xml')
request.appendBody(e.__str__())
def setActive(self, active):
ProcessingConfig.setSettingValue('ACTIVATE_GDAL', active)
def tearDownClass(cls):
from processing.core.Processing import Processing
Processing.deinitialize()
for path in cls.cleanup_paths:
shutil.rmtree(path)
ProcessingConfig.setSettingValue(ModelerUtils.MODELS_FOLDER, cls._original_models_folder)
