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 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 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)