def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
cls.cleanup_paths = []
assert Grass7Utils.installedVersion()
def initGui(self):
Processing.initialize()
self.commander = None
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
Processing.addAlgListListener(self.toolbox)
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = self.toolbox.toggleViewAction()
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QIcon(os.path.join(cmd_folder, 'images', 'alg.png')))
self.toolboxAction.setText(self.tr('&Toolbox'))
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'model.png')),
self.tr('Graphical &Modeler...'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'history.gif')),
self.tr('&History and Log...'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.menu.addAction(self.historyAction)
self.configAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'config.png')),
self.tr('&Options...'), self.iface.mainWindow())
self.configAction.setObjectName('configAction')
self.configAction.triggered.connect(self.openConfig)
self.menu.addAction(self.configAction)
self.resultsAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'results.png')),
self.tr('&Results Viewer...'), self.iface.mainWindow())
self.resultsAction.setObjectName('resultsAction')
self.resultsAction.triggered.connect(self.openResults)
self.menu.addAction(self.resultsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(
self.iface.firstRightStandardMenu().menuAction(), self.menu)
self.commanderAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'commander.png')),
self.tr('&Commander'), self.iface.mainWindow())
self.commanderAction.setObjectName('commanderAction')
self.commanderAction.triggered.connect(self.openCommander)
self.menu.addAction(self.commanderAction)
self.iface.registerMainWindowAction(self.commanderAction,
self.tr('Ctrl+Alt+M'))
def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
cls.cleanup_paths = []
cls.in_place_layers = {}
cls.vector_layer_params = {}
def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
cls.cleanup_paths = []
cls.temp_dir = tempfile.mkdtemp()
cls.cleanup_paths.append(cls.temp_dir)
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
Processing.initialize()
def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
cls.cleanup_paths = []
cls.in_place_layers = {}
cls.vector_layer_params = {}
def setUpClass(cls):
"""Run before all tests"""
QCoreApplication.setOrganizationName("QGIS_Test")
QCoreApplication.setOrganizationDomain(
"QGIS_TestPyQgsProcessingInPlace.com")
QCoreApplication.setApplicationName("QGIS_TestPyQgsProcessingInPlace")
QgsSettings().clear()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
cls.registry = QgsApplication.instance().processingRegistry()
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 generate_drivetimes_contour(raster_layer, interval, parent_dialog):
"""Create drive times contour
:param raster_layer: Interpolated raster layer with drivetimes
:type raster_layer: QgsRasterLayer
:param interval: drivetimes interval
:type interval: int
:param parent_dialog: A dialog that called this function.
:type parent_dialog: QProgressDialog
:returns layer: Vector layer with contour drivetimes
:rtype layer: QgsVectorLayer
"""
drivetime_layer = None
try:
Processing.initialize()
Processing.updateAlgsList()
output_vector = processing.runalg(
'gdalogr:contour',
raster_layer,
interval,
'minutes',
None,
'[temporary_file]')
drivetime_layer = QgsVectorLayer(
output_vector['OUTPUT_VECTOR'],
'time(min)',
'ogr')
except Exception as exception: # pylint: disable=broad-except
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map,'
'please check if you have processing '
'plugin installed '))
else:
display_warning_message_box(
parent_dialog,
'Error',
'Error loading isochrone map,'
'please check if you have processing '
'plugin installed ')
return drivetime_layer
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
Processing.initialize()
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 mock_getAlgorithm(name):
"""
Modified version of the original getAlgorithm function.
:param name: Name of the algorithm to load.
:type name: str
:return: An algorithm concrete class.
:rtype: QgsAlgorithm ?
"""
Processing.initialize()
for provider in Processing.algs.values():
if name in provider:
return provider[name]
return None
def _initServer(project_path, parameters):
"""Initalize server"""
try:
WPS.methods
except:
Processing.initialize()
WPS.methods = Processing.algs
WPS.processes = []
for i in WPS.methods:
for m in WPS.methods[i]:
WPS.processes.append(QGISProcessFactory(m))
# TODO: handle POST, SOAP etc...
WPS.wps = pywps.Pywps('GET')
WPS.request = '&'.join(["%s=%s" % (k, parameters[k]) for k in parameters])
pywps.config.setConfigValue("server","outputPath", '/tmp')
def setUpClass(cls):
"""Run before all tests"""
QCoreApplication.setOrganizationName("QGIS_Test")
QCoreApplication.setOrganizationDomain(
"QGIS_TestPyQgsExportToPostgis.com")
QCoreApplication.setApplicationName("QGIS_TestPyQgsExportToPostgis")
QgsSettings().clear()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
cls.registry = QgsApplication.instance().processingRegistry()
# Create DB connection in the settings
settings = QgsSettings()
settings.beginGroup('/PostgreSQL/connections/qgis_test')
settings.setValue('service', 'qgis_test')
settings.setValue('database', 'qgis_test')
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
# Invalidate the locator filter for in-place when active layer changes
iface.currentLayerChanged.connect(lambda _: self.iface.invalidateLocatorResults())
self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter()
iface.registerLocatorFilter(self.edit_features_locator_filter)
Processing.initialize()
def setUpClass(cls):
"""Run before all tests"""
QCoreApplication.setOrganizationName("QGIS_Test")
QCoreApplication.setOrganizationDomain(
"QGIS_TestPyQgsProcessingInPlace.com")
QCoreApplication.setApplicationName("QGIS_TestPyQgsProcessingInPlace")
QgsSettings().clear()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
cls.registry = QgsApplication.instance().processingRegistry()
fields = QgsFields()
fields.append(QgsField('int_f', QVariant.Int))
cls.vl = QgsMemoryProviderUtils.createMemoryLayer(
'mylayer', fields, QgsWkbTypes.Point, QgsCoordinateReferenceSystem(4326))
f1 = QgsFeature(cls.vl.fields())
f1['int_f'] = 1
f1.setGeometry(QgsGeometry.fromWkt('Point(9 45)'))
f2 = QgsFeature(cls.vl.fields())
f2['int_f'] = 2
f2.setGeometry(QgsGeometry.fromWkt('Point(9.5 45.6)'))
cls.vl.dataProvider().addFeatures([f1, f2])
assert cls.vl.isValid()
assert cls.vl.featureCount() == 2
# Multipolygon layer
cls.multipoly_vl = QgsMemoryProviderUtils.createMemoryLayer(
'mymultiplayer', fields, QgsWkbTypes.MultiPolygon, QgsCoordinateReferenceSystem(4326))
f3 = QgsFeature(cls.multipoly_vl.fields())
f3.setGeometry(QgsGeometry.fromWkt('MultiPolygon (((2.81856297539240419 41.98170998812887689, 2.81874467773035464 41.98167537995160359, 2.81879535908157752 41.98154066615795443, 2.81866433873670452 41.98144056064155905, 2.81848263699778379 41.98147516865246587, 2.81843195500470811 41.98160988234612034, 2.81856297539240419 41.98170998812887689)),((2.81898589063455907 41.9815711567298635, 2.81892080450418803 41.9816030048432367, 2.81884192631866437 41.98143737613141724, 2.8190679469505846 41.98142270931093378, 2.81898589063455907 41.9815711567298635)))'))
f4 = QgsFeature(cls.multipoly_vl.fields())
f4.setGeometry(QgsGeometry.fromWkt('MultiPolygon (((2.81823679385631332 41.98133290154246566, 2.81830770255185703 41.98123540208609228, 2.81825871989355159 41.98112524362621656, 2.81813882853970243 41.98111258462271422, 2.81806791984415872 41.98121008407908761, 2.81811690250246416 41.98132024253896333, 2.81823679385631332 41.98133290154246566)),((2.81835835162010895 41.98123286963267731, 2.8183127674586852 41.98108725356146209, 2.8184520523963692 41.98115436357689134, 2.81835835162010895 41.98123286963267731)))'))
cls.multipoly_vl.dataProvider().addFeatures([f3, f4])
assert cls.multipoly_vl.isValid()
assert cls.multipoly_vl.featureCount() == 2
QgsProject.instance().addMapLayers([cls.vl, cls.multipoly_vl])
def mock_getAlgorithm(name):
"""
Modified version of the original getAlgorithm function.
:param name: Name of the algorithm to load.
:type name: str
:return: An algorithm concrete class.
:rtype: QgsAlgorithm ?
"""
Processing.initialize()
# FIXME: Had some weird bug in QGIS 2.18 MacOSX (KyngChaos)
try:
providers = Processing.algs.values()
except:
providers = Processing.algs().values()
for provider in providers:
if name in provider:
return provider[name]
return None
def __init__(self, iface):
self.iface = iface
QGisLayers.setInterface(iface)
Processing.initialize()
Processing.setInterface(iface)
Processing.setPlugin(self)
def convert(self):
gdal.AllRegister()
# ------------------------ FIRST METHOD -------------------------------------------------
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(False)
if self.inputLayerCombo.currentText() != "":
inputLayer = self.inputLayerCombo.currentText()
inputMask = self.inputMaskCombo.currentText()
# layer information
layer = QgsVectorLayer(
unicode(inputLayer).encode('utf8'), inputLayer, "ogr")
vectorlayer_vector = layer.dataProvider()
layer_mask = QgsVectorLayer(
unicode(inputMask).encode('utf8'), inputMask, "ogr")
vectorlayer_mask = layer_mask.dataProvider()
# mask extent
extent_rect = vectorlayer_mask.extent()
xmin = extent_rect.xMinimum()
xmax = extent_rect.xMaximum()
ymin = extent_rect.yMinimum()
ymax = extent_rect.yMaximum()
extent = str(xmin) + "," + str(xmax) + "," + str(ymin) + "," + str(
ymax)
# attribute
Elevation = self.lineAttrib.currentText()
# cellsize
cellSize = int(self.linePix.value())
outPath = self.inputLayerCombo3.text()
# size of atributte table == number of points
count = layer.featureCount()
# points interpolation idw
if self.comboBoxMethod.currentText(
) == "Inverse Distance Weighting":
Processing.initialize()
# grid directory (qgis2)
idw_interpolation = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/idw_interpolation"
Processing.runAlgorithm("grass:v.surf.idw", None, inputLayer,
count, 2.0, Elevation, False, extent,
cellSize, -1.0, 0.0001,
idw_interpolation)
idw_int = idw_interpolation + "." + "tif"
int_mask = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path() + "/int_mask"
# clip grid(interpolation) with polygon (mask)
Processing.runAlgorithm("saga:clipgridwithpolygon", None,
idw_int, inputMask, int_mask)
int_mask_zone = int_mask + "." + "tif"
# indexes for topography
numberRows = int(self.tableWidget.rowCount())
numberColumns = int(self.tableWidget.columnCount())
classes = ''
lista = []
for i in range(0, numberRows):
for j in range(0, numberColumns):
self.line = self.tableWidget.item(i, j)
lista = lista + [str(self.line.text())]
string = ","
intervalos = string.join(lista)
# reclassify idw interpolation
if self.comboBoxMethod.currentText(
) == "Inverse Distance Weighting":
idw_reclassify = QFileInfo(QgsApplication.qgisUserDbFilePath()
).path() + "/idw_reclassify"
Processing.runAlgorithm("saga:reclassifygridvalues", None,
int_mask_zone, 2, 0.0, 1.0, 0, 0.0,
1.0, 2.0, 0, intervalos, 0, True, 0.0,
True, 0.0, outPath)
# add result into canvas
file_info = QFileInfo(outPath)
if file_info.exists():
layer_name = file_info.baseName()
else:
return False
rlayer_new = QgsRasterLayer(outPath, layer_name)
if rlayer_new.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new)
layer = QgsMapCanvasLayer(rlayer_new)
layerList = [layer]
extent = self.iface.canvas.setExtent(rlayer_new.extent())
self.iface.canvas.setLayerSet(layerList)
self.iface.canvas.setVisible(True)
return True
else:
return False
# points interpolation kriging
if self.comboBoxMethod.currentText() == "Kriging":
Processing.initialize()
# grid directory (qgis2)
kriging_interpolation = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/kriging_interpolation"
Processing.runAlgorithm("saga:ordinarykrigingglobal", None,
inputLayer, Elevation, True, 0, 1,
False, 100, False, 0.0, 10, 1000, 1.0,
0.1, 1.0, 0.5, cellSize, True, extent,
kriging_interpolation, None)
kriging_int = kriging_interpolation + "." + "tif"
int_mask_kriging = QFileInfo(QgsApplication.qgisUserDbFilePath(
)).path() + "/int_mask_kriging"
# clip grid(interpolation) with polygon (mask)
Processing.runAlgorithm("saga:clipgridwithpolygon", None,
kriging_int, inputMask,
int_mask_kriging)
int_mask_zone_k = int_mask_kriging + "." + "tif"
kriging_reclassify = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/kriging_reclassify"
Processing.runAlgorithm("saga:reclassifygridvalues", None,
int_mask_zone_k, 2, 0.0, 1.0, 0, 0.0,
1.0, 2.0, 0, intervalos, 0, True, 0.0,
True, 0.0, outPath)
# add result into canvas
file_info_k = QFileInfo(outPath)
if file_info_k.exists():
layer_name_k = file_info_k.baseName()
else:
return False
rlayer_new_k = QgsRasterLayer(outPath, layer_name_k)
if rlayer_new_k.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new_k)
layer_k = QgsMapCanvasLayer(rlayer_new_k)
layerList_k = [layer_k]
extent_k = self.iface.canvas.setExtent(
rlayer_new_k.extent())
self.iface.canvas.setLayerSet(layerList_k)
self.iface.canvas.setVisible(True)
return True
else:
return False
# points interpolation cubic spline
if self.comboBoxMethod.currentText(
) == "Cubic spline approximation (SAGA)":
Processing.initialize()
# grid directory (qgis2)
cubicSpline_interpolation = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/cubicSpline_interpolation"
Processing.runAlgorithm("saga:cubicsplineapproximation", None,
inputLayer, Elevation, 0, 3, count, 5,
140.0, extent, cellSize,
cubicSpline_interpolation)
cubicSpline_int = cubicSpline_interpolation + "." + "tif"
int_mask_cubicSpline = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/int_mask_cubicSpline"
# clip grid(interpolation) with polygon (mask)
Processing.runAlgorithm("saga:clipgridwithpolygon", None,
cubicSpline_int, inputMask,
int_mask_cubicSpline)
int_mask_zone_cs = int_mask_cubicSpline + "." + "tif"
cubicSpline_reclassify = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/cubicSpline_reclassify"
Processing.runAlgorithm("saga:reclassifygridvalues", None,
int_mask_zone_cs, 2, 0.0, 1.0, 0, 0.0,
1.0, 2.0, 0, intervalos, 0, True, 0.0,
True, 0.0, outPath)
# add result into canvas
file_info_cs = QFileInfo(outPath)
if file_info_cs.exists():
layer_name_cs = file_info_cs.baseName()
else:
return False
rlayer_new_cs = QgsRasterLayer(outPath, layer_name_cs)
if rlayer_new_cs.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new_cs)
layer_cs = QgsMapCanvasLayer(rlayer_new_cs)
layerList_cs = [layer_cs]
extent_cs = self.iface.canvas.setExtent(
rlayer_new_cs.extent())
self.iface.canvas.setLayerSet(layerList_cs)
self.iface.canvas.setVisible(True)
return True
else:
return False
if self.comboBoxMethod.currentText(
) == "Spatial approximation using spline with tension (GRASS)":
Processing.initialize()
# grid directory (qgis2)
rst_interpolation = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/rst_interpolation"
Processing.runAlgorithm("grass:v.surf.rst", None, inputLayer,
"", None, Elevation, 40, 40, 300,
0.001, 2.5, 1, 0, 0, False, False,
extent, cellSize, -1, 0.0001,
rst_interpolation, None, None, None,
None, None)
rst_int = rst_interpolation + "." + "tif"
int_mask_rst = QFileInfo(QgsApplication.qgisUserDbFilePath()
).path() + "/int_mask_rst"
# clip grid(interpolation) with polygon (mask)
Processing.runAlgorithm("saga:clipgridwithpolygon", None,
rst_int, inputMask, int_mask_rst)
int_mask_zone_rst = int_mask_rst + "." + "tif"
rst_reclassify = QFileInfo(QgsApplication.qgisUserDbFilePath()
).path() + "/rst_reclassify"
Processing.runAlgorithm("saga:reclassifygridvalues", None,
int_mask_zone_rst, 2, 0.0, 1.0, 0, 0.0,
1.0, 2.0, 0, intervalos, 0, True, 0.0,
True, 0.0, outPath)
# add result into canvas
file_info_rst = QFileInfo(outPath)
if file_info_rst.exists():
layer_name_rst = file_info_rst.baseName()
else:
return False
rlayer_new_rst = QgsRasterLayer(outPath, layer_name_rst)
if rlayer_new_rst.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new_rst)
layer_rst = QgsMapCanvasLayer(rlayer_new_rst)
layerList_rst = [layer_rst]
extent_rst = self.iface.canvas.setExtent(
rlayer_new_rst.extent())
self.iface.canvas.setLayerSet(layerList_rst)
self.iface.canvas.setVisible(True)
return True
else:
return False
# ----------------------- SECOND RASTER ----------------------------------------------------------------------------------------
if self.inputLayerCombo_mdt != "":
outPath2 = self.inputLayerCombo3.text()
# read raster
inputRaster = self.inputLayerCombo_mdt.currentText()
layer_raster = QgsRasterLayer(
unicode(inputRaster).encode('utf8'), inputRaster, "gdal")
data_mdt = layer_raster.dataProvider()
extent_raster = data_mdt.extent()
xmin_raster = extent_raster.xMinimum()
xmax_raster = extent_raster.xMaximum()
ymin_raster = extent_raster.yMinimum()
ymax_raster = extent_raster.yMaximum()
extent_raster_str = str(xmin_raster) + "," + str(
xmax_raster) + "," + str(ymin_raster) + "," + str(ymax_raster)
cellSize = layer_raster.rasterUnitsPerPixelX()
# read maximum depth
max_depth = self.line_max.value()
# read distance
distance = self.line_distance.value()
# minimum size
size = self.line_size.value()
Processing.initialize()
# grid directory (qgis2)
# generate stream segments
stream = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path() + "/stream"
Processing.runAlgorithm("grass:r.watershed", None, inputRaster,
None, None, None, None, size, 0, 5, 300,
False, True, False, False,
extent_raster_str, cellSize, None, None,
None, stream, None, None, None, None)
stream_tif = stream + "." + "tif"
# condition stream > 1 to have the lines with value 1
stream_ones = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path() + "/stream_ones"
Processing.runAlgorithm("gdalogr:rastercalculator", None,
stream_tif, "1", None, "1", None, "1",
None, "1", None, "1", None, "1", "A>1",
"-9999", 5, "", stream_ones)
stream_ones_str = stream_ones + "." + "tif"
# raster distance
raster_distance = QFileInfo(QgsApplication.qgisUserDbFilePath()
).path() + "/raster_distance.sdat"
Processing.runAlgorithm("saga:proximitygrid", None,
stream_ones_str, raster_distance, None,
None)
# condition distance >= 200, always maximum depth meters
dist_major_200 = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path() + "/dist_major_200"
Processing.runAlgorithm("gdalogr:rastercalculator", None,
raster_distance, "1", None, "1", None, "1",
None, "1", None, "1", None, "1",
"A>=" + str(distance), "-9999", 5, "",
dist_major_200)
dist_major_200_str = dist_major_200 + "." + "tif"
dist_multiplication = QFileInfo(QgsApplication.qgisUserDbFilePath(
)).path() + "/dist_multiplication"
Processing.runAlgorithm("gdalogr:rastercalculator", None,
dist_major_200_str, "1", None, "1", None,
"1", None, "1", None, "1", None, "1",
"A*" + str(max_depth), "-9999", 5, "",
dist_multiplication)
dist_multiplication_str = dist_multiplication + "." + "tif"
# condition distance < 200, inteprolation between 0 and maximum depth
dist_minor_200 = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path() + "/dist_minor_200"
Processing.runAlgorithm("gdalogr:rastercalculator", None,
raster_distance, "1", None, "1", None, "1",
None, "1", None, "1", None, "1",
"A<" + str(distance), "-9999", 5, "",
dist_minor_200)
dist_minor_200_str = dist_minor_200 + "." + "tif"
# multiplication by the raster distance
dist_multiplication_dist = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path(
) + "/dist_multiplication_dist"
Processing.runAlgorithm("gdalogr:rastercalculator", None,
dist_minor_200_str, "1", raster_distance,
"1", None, "1", None, "1", None, "1", None,
"1", "A*B", "-9999", 5, "",
dist_multiplication_dist)
dist_multiplication_dist_str = dist_multiplication_dist + "." + "tif"
# interpolation between 0 and distance
interpolation_dist = QFileInfo(QgsApplication.qgisUserDbFilePath()
).path() + "/interpolation_dist"
Processing.runAlgorithm(
"gdalogr:rastercalculator", None, dist_multiplication_dist_str,
"1", None, "1", None, "1", None, "1", None, "1", None, "1",
"A*" + str(max_depth) + "/" + str(distance), "-9999", 5, "",
interpolation_dist)
interpolation_dist_str = interpolation_dist + "." + "tif"
# depth surface = sum of two conditions
depth_surface = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path() + "/depth_surface"
Processing.runAlgorithm("gdalogr:rastercalculator", None,
dist_multiplication_str, "1",
interpolation_dist_str, "1", None, "1",
None, "1", None, "1", None, "1", "A+B",
"-9999", 5, "", depth_surface)
depth_surface_tif = depth_surface + "." + "tif"
# indexes for topography
numberRows = int(self.tableWidget.rowCount())
numberColumns = int(self.tableWidget.columnCount())
classes = ''
lista = []
for i in range(0, numberRows):
for j in range(0, numberColumns):
self.line = self.tableWidget.item(i, j)
lista = lista + [str(self.line.text())]
string = ","
intervalos = string.join(lista)
depth_reclassify = QFileInfo(QgsApplication.qgisUserDbFilePath()
).path() + "/depth_reclassify.sdat"
Processing.runAlgorithm("saga:reclassifygridvalues", None,
depth_surface_tif, 2, 0.0, 1.0, 0, 0.0,
1.0, 2.0, 0, intervalos, 0, True, 0.0,
True, 0.0, outPath2)
# add result into canvas
file_info_norm = QFileInfo(outPath2)
if file_info_norm.exists():
layer_name_norm = file_info_norm.baseName()
else:
return False
rlayer_new_norm = QgsRasterLayer(outPath2, layer_name_norm)
if rlayer_new_norm.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new_norm)
layer_norm = QgsMapCanvasLayer(rlayer_new_norm)
layerList_norm = [layer_norm]
extent_norm = self.iface.canvas.setExtent(
rlayer_new_norm.extent())
self.iface.canvas.setLayerSet(layerList_norm)
self.iface.canvas.setVisible(True)
return True
else:
return False
QMessageBox.information(self, self.tr("Finished"),
self.tr("Depth completed."))
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
def __init__(self, iface):
interface.iface = iface
Processing.initialize()
def convert(self):
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(False)
# read D raster
inputLayer = self.inputLayerCombo.currentText()
# read R raster
inputLayer2 = self.inputLayerCombo2.currentText()
# read A raster
inputLayer3 = self.inputLayerCombo3.currentText()
# outpath
outPath = self.outputLayerCombo.text()
lista = []
lista.append(inputLayer2)
lista.append(inputLayer3)
gdal.AllRegister()
Processing.initialize()
Processing.runAlgorithm("saga:rastercalculator", None,inputLayer, ';'.join(lista),"a*b*c",False, 7, outPath)
if self.checkdrastic.isChecked():
# add result into canvas
file_info = QFileInfo(outPath)
if file_info.exists():
layer_name = file_info.baseName()
else:
return False
rlayer_new = QgsRasterLayer(outPath, layer_name)
if rlayer_new.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new)
layer = QgsMapCanvasLayer(rlayer_new)
layerList = [layer]
extent = self.iface.canvas.setExtent(rlayer_new.extent())
self.iface.canvas.setLayerSet(layerList)
self.iface.canvas.setVisible(True)
return True
else:
return False
QMessageBox.information(self, self.tr( "Finished" ), self.tr( "DRASTIC completed." ) )
colorfile = 'C:/OSGeo4W64/apps/qgis/python/plugins/DRASTIC/colorfile.clr'
outPath_color = self.outputLayerCombo_color.text()
from colorize import raster2png
if self.checkcolor.isChecked():
# add result into canvas
file_info = QFileInfo(outPath_color)
if file_info.exists():
layer_name = file_info.baseName()
else:
return False
rlayer_new = QgsRasterLayer(outPath_color, layer_name)
if rlayer_new.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new)
layer = QgsMapCanvasLayer(rlayer_new)
layerList = [layer]
extent = self.iface.canvas.setExtent(rlayer_new.extent())
self.iface.canvas.setLayerSet(layerList)
self.iface.canvas.setVisible(True)
return True
else:
return False
QMessageBox.information(self, self.tr( "Finished" ), self.tr( "DRASTIC completed." ) )
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
class ClipByExtent(QObject):
exportError = pyqtSignal(unicode)
exportMessage = pyqtSignal(unicode)
exportProcessed = pyqtSignal(int)
exportFinished = pyqtSignal()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(GdalAlgorithmProvider())
#print(processing.algorithmHelp("gdal:clipvectorbyextent"))
def __init__(self):
QObject.__init__(self)
def setOutputGpkgPath(self, filePath):
self.gpkgPath = filePath
def setOutputProjectPath(self, filePath):
self.qgisProjectpath = filePath
def setMinMaxClear(self, minmaxclear):
self.minmaxclear = minmaxclear
def setExtent(self, extent):
self.extent = extent
def clipAndExport(self):
project = QgsProject.instance()
self.exportMessage.emit("入力："+ project.fileName())
# クリッピング範囲
#clipextent = self.extent.toString().replace(","," ").replace(":"," ")
#clipextent = ("{},{},{},{}").format(
# self.extent.xMinimum(), # 順番に要注意
# self.extent.xMaximum(), # 順番に要注意
# self.extent.yMinimum(), # 順番に要注意
# self.extent.yMaximum()) # 順番に要注意
self.exportMessage.emit("extent:" + self.extent.toString())
# 1ループ目は上書き
appendSwitch = ""
# レイヤリスト保存 ソースがPostgreSQLの場合はここでｘ
# ソースレイヤのパスが./となっているとErrInvalidLayerになる
layers = project.mapLayers()
# DBのエクスポートと接続情報書き換えで2倍
cnt = project.count()
total = 100 / (cnt * 2)
# LayerID:LayerName
layerId = {}
self.exportMessage.emit("Clipping開始")
# Clip用形状を作成する
uri = "polygon?crs={}&field=id:integer".format("EPSG:4612");
cliplayer = QgsVectorLayer(uri, "clippolygon", "memory");
fields = cliplayer.fields()
feature = QgsFeature(fields)
feature.setGeometry(QgsGeometry.fromRect(self.extent))
cliplayer.startEditing()
feature['id'] = 1
ret = cliplayer.addFeature(feature)
cliplayer.commitChanges()
# GeoPackageに出力(デバッグ用)
#save_options = QgsVectorFileWriter.SaveVectorOptions()
#save_options.actionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile
#save_options.fileEncoding = "UTF-8"
#save_options.layerName = cliplayer.name()
#transform_context = QgsProject.instance().transformContext()
#error = QgsVectorFileWriter.writeAsVectorFormatV2(cliplayer,
# "c:\\DMP\\overlay.gpkg",
# transform_context,
# save_options)
index = 0
for layer in layers.values():
if layer.type() == QgsMapLayerType.VectorLayer:
self.exportMessage.emit("name:" + layer.name())
self.exportMessage.emit("source:" + layer.source())
self.exportMessage.emit("id:" + layer.id())
layername = GdalUtils.ogrLayerName(layer.dataProvider().dataSourceUri())
if not layername:
self.exportMessage.emit("未サポートのデータソース:" + layer.name())
break
#layerId[layer.id()] = layername
# PostGIS->GPKGの場合 gdal:clipvectorbyextent でogr2orすると
# [schema].[tablename]->[tablename]とschema名無のテーブル名になるため
layerId[layer.id()] = layer.name()
outputlayer = QgsProcessingOutputLayerDefinition(self.gpkgPath)
#'OPTIONS': -a_srsをつけるとエラーになる
option = ("{}".format(appendSwitch))
params = {
'INPUT' : layer,
#'EXTENT' : clipextent,
'EXTENT' : cliplayer,
'OPTIONS': option,
'OUTPUT' : outputlayer
}
res = processing.run('gdal:clipvectorbyextent', params)
if not res:
self.exportError.emit("processing failed:" + layer.name())
break
'''
dataSource = ""
sourceProvider = layer.storageType()
if sourceProvider == "GPKG":
dataSource = layer.source().replace("|layername=", " ")
elif sourceProvider.find("PostGIS"):
result = layer.source().split()
self.exportMessage.emit(result)
connection = {}
for token in result:
token2 = token.split("=")
if len(token2) == 2:
connection[token2[0]] = token2[1]
dbName = connection.get("dbname")
hostName = connection.get("host")
portNo = connection.get("port")
usrName = connection.get("user")
passWord = connection.get("password")
tableName = connection.get("table")
if passWord == None:
passWord = usrName
dataSource = ("PG:\"host={} port={} dbname={} user={} password={}\" {}".
format(hostName, portNo, dbName, usrName, passWord, tableName))
sourceCrs = layer.sourceCrs()
cmd = ("ogr2ogr {} -f \"GPKG\" {} -a_srs \"{}\" -clipsrc {} {}".
format(appendSwitch, self.gpkgPath, sourceCrs.authid(), clipextent, dataSource))
#runcmd = subprocess.check_call(cmd)
runcmd = subprocess.run(cmd,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True)
self.exportMessage.emit (runcmd)
'''
appendSwitch = "-append"
self.exportProcessed.emit(int(index * total))
index += 1
#プロジェクトファイルをrename
newproject = QgsProject.instance()
newproject.write(self.qgisProjectpath)
self.exportMessage.emit("出力：" + newproject.fileName())
# 指定範囲でエクスポートしたDBを再度読み込みsetDataSourceで参照先DBを変更
self.exportMessage.emit("プロジェクトファイルのデータソース書き換え開始")
for layerid in layerId.items():
fullname = self.gpkgPath + "|layername=" + layerid[1]
display_name = layerid[1]
tagetlayer = newproject.mapLayer(layerid[0])
provider_options = QgsDataProvider.ProviderOptions()
# Use project's transform context
provider_options.transformContext = newproject.transformContext()
self.exportMessage.emit("dataSource :" + fullname)
self.exportMessage.emit("baseName :" + display_name)
self.exportMessage.emit("RelacelayerID:" + tagetlayer.id())
tagetlayer.setDataSource(fullname, display_name, "ogr", provider_options)
# min max Zoom level設定をクリアする
if self.minmaxclear:
if tagetlayer.hasScaleBasedVisibility():
tagetlayer.setScaleBasedVisibility(False)
self.exportProcessed.emit(int(index * total))
index += 1
newproject.write()
self.exportMessage.emit("プロジェクトファイルのデータソース書き換え終了")
self.exportProcessed.emit(100)
self.exportFinished.emit()
def initGui(self):
Processing.initialize()
self.commander = None
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
Processing.addAlgListListener(self.toolbox)
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = self.toolbox.toggleViewAction()
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QIcon(os.path.join(cmd_folder, 'images', 'alg.png')))
self.toolboxAction.setText(self.tr('&Toolbox'))
self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T')
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'model.png')),
self.tr('Graphical &Modeler...'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M')
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'history.gif')),
self.tr('&History...'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H')
self.menu.addAction(self.historyAction)
self.configAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'config.png')),
self.tr('&Options...'), self.iface.mainWindow())
self.configAction.setObjectName('configAction')
self.configAction.triggered.connect(self.openConfig)
self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C')
self.menu.addAction(self.configAction)
self.resultsAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'results.png')),
self.tr('&Results Viewer...'), self.iface.mainWindow())
self.resultsAction.setObjectName('resultsAction')
self.resultsAction.triggered.connect(self.openResults)
self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R')
self.menu.addAction(self.resultsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.commanderAction = QAction(
QIcon(os.path.join(cmd_folder, 'images', 'commander.png')),
self.tr('&Commander'), self.iface.mainWindow())
self.commanderAction.setObjectName('commanderAction')
self.commanderAction.triggered.connect(self.openCommander)
self.menu.addAction(self.commanderAction)
self.iface.registerMainWindowAction(self.commanderAction,
self.tr('Ctrl+Alt+M'))
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import os.path
import sys
# Prepare processing framework
sys.path.append(":/plugins/processing")
from processing.core.Processing import Processing
Processing.initialize()
from processing.tools import *
from qgis.gui import QgsMessageBarItem
from qgis.core import QgsVectorLayer, QgsApplication, QgsCoordinateReferenceSystem
from qgis.utils import iface
from PyQt4.QtCore import QThread, QSettings
from PyQt4.uic import loadUi
from import_file import Import
from utils_job import popup, execFileDialog, pluginDirectory, no_vector_lyr_msg
class ImportLayer(object):
"""
/***************************************************************************
ImportLayer Class
def define_project_extent_using_input_polygon(
grassdb,
grass_location,
qgis_prefix_path,
path_dem_in,
path_extent_ply,
mask="MASK",
dem="dem",
):
"""Define processing extent
Function that used to define project processing spatial extent (PSE).
The processing spatial extent is a region where Toolbox will work in. Toolbox
will not process grids or features outside the processing spatial extent.
Several options is available here. The PSE can be defined using input polygon
Parameters
----------
grassdb : path (required)
It is a path to project grass database folder
grass_location : string (required)
It is a string of grass location name
qgis_prefix_path : string (required)
It is a string of qgis prefix path
path_dem_in : string (required)
It is the path to input dem
path_extent_ply : string (optional)
It is the path of a subregion polygon. It is only used when the Region
of interest is very large and the resolution of the dem is very high.
toolbox will first divide the whole region into several small subregions.
And then using devided subregion polygon as PSE.
mask : string (optional)
It is a output mask name, which will stored in grass_location in both
vector and raster format
dem : string (optional)
It is a output dem raster name, which will be stored in grass_location
Notes
-------
Outputs are following files
MASK : raster
it is a mask raster stored in grass database, which indicate
the PSE. The grass database is located at
os.path.join(grassdb, grass_location)
dem : raster
it is a dem raster stored in grass database, which is
has the same extent with MASK. The grass database is located at
os.path.join(grassdb, grass_location)
Returns:
-------
None
Examples
-------
"""
print("mask region: using input polygon ")
QgsApplication.setPrefixPath(qgis_prefix_path, True)
Qgs = QgsApplication([], False)
Qgs.initQgis()
from processing.core.Processing import Processing
from processing.tools import dataobjects
from qgis import processing
feedback = QgsProcessingFeedback()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
context = dataobjects.createContext()
context.setInvalidGeometryCheck(QgsFeatureRequest.GeometryNoCheck)
import grass.script as grass
import grass.script.setup as gsetup
from grass.pygrass.modules import Module
from grass.pygrass.modules.shortcuts import general as g
from grass.pygrass.modules.shortcuts import raster as r
from grass.script import array as garray
from grass.script import core as gcore
from grass_session import Session
os.environ.update(
dict(GRASS_COMPRESS_NULLS="1",
GRASS_COMPRESSOR="ZSTD",
GRASS_VERBOSE="1"))
# load subregion mask polygon to target grass location
PERMANENT = Session()
PERMANENT.open(
gisdb=grassdb,
location=grass_location + "t1",
create_opts="EPSG:4326",
)
grass_raster_v_in_org(
grass,
input_path=path_extent_ply,
output_vector_nm=mask,
location=grass_location,
)
PERMANENT.close()
# unpack dem and generate mask with loaded vector
PERMANENT = Session()
# grass unpack function report an error if gisdb is provided using relative
# path, so absolute path is provided here
PERMANENT.open(gisdb=os.path.abspath(grassdb),
location=grass_location,
create_opts="")
# unpack dem dataset
root, ext = os.path.splitext(path_dem_in)
if ext == ".pack":
grass_raster_r_unpack(grass,
input=os.path.abspath(path_dem_in),
output=dem + "_big")
else:
grass_raster_r_in_gdal(grass=grass,
raster_path=path_dem_in,
output_nm=dem + "_big")
###Use polygon to define a smaller region
# use big dem define region first and then change it by vector mask
grass_raster_g_region(grass, dem + "_big")
# define mask of current working enviroments
grass_raster_r_mask(grass, raster_nm="#", vector_nm=mask)
# define new region with this mask
grass_raster_g_region(grass, raster_nm="#", zoom="MASK")
# using vector define mask and clip big raster dem
grass_raster_r_mask(grass, raster_nm="#", vector_nm=mask)
exp = "%s = %s" % (dem, dem + "_big")
grass_raster_r_mapcalc(grass, expression=exp)
# using clipped dem to defing mask
grass_raster_r_mask(grass, raster_nm=dem)
# export dem and mask and generate mask polygon
grass_raster_r_out_gdal(
grass,
input_nm=mask,
output=os.path.join(grassdb, mask + ".tif"),
format="GTiff",
)
grass_raster_r_out_gdal(
grass,
input_nm=dem,
output=os.path.join(grassdb, dem + ".tif"),
format="GTiff",
)
# polygonize exported mask raster, and polygonize and dissove it.
qgis_raster_gdal_polygonize(
processing,
context,
INPUT=os.path.join(grassdb, mask + ".tif"),
OUTPUT=os.path.join(grassdb, mask + "1.shp"),
)
# qgis dissolve function for some reason not working here....
qgis_vector_dissolve(
processing,
context,
INPUT=os.path.join(grassdb, mask + "1.shp"),
FIELD="DN",
OUTPUT=os.path.join(grassdb, mask + ".shp"),
USING_GDAL_FUNCTION=True,
)
PERMANENT.close()
Qgs.exit()
def DXFImporter(uiParent, sOutForm, listDXFDatNam, zielPfadOrDatei, bZielSave, sCharSet, bCol, bLayer, bFormatText, bUseColor4Point, bUseColor4Line, bUseColor4Poly, dblFaktor, chkTransform, DreiPassPunkte ):
# 23.02.17
# Processing erst hier Laden, um den Start von QGIS zu beschleunigen
import processing
from processing.core.Processing import Processing
# -----------------------------------------------------------------------------------------------
# 1. Löschen der alten Projekte und evtl.if myqtVersion == 4 Ermittlung der zu überschreibenden Dateien
delZielDat=[]
for i in range(listDXFDatNam.count()):
AktDXFDatNam=listDXFDatNam.item(i).text()
AktList,AktOpt,ProjektName, Kern =ProjDaten4Dat(AktDXFDatNam, bCol, bLayer, bZielSave)
# evtl. Projektname (-gruppe) in Root löschen
rNode=QgsProject.instance().layerTreeRoot()
for node in rNode.children():
if str(type(node)) == "<class 'qgis._core.QgsLayerTreeGroup'>":
if node.name() == ProjektName:
rNode.removeChildNode(node)
# evtl. Shape Zieldateien ermitteln und löschen
if bZielSave:
if sOutForm == "SHP":
for p in AktList:
v = p.split(":")
shpdat=zielPfadOrDatei+Kern+v[0]+'.shp'
if os.path.exists(shpdat):
delZielDat.append (shpdat)
else:
gpkgdat=zielPfadOrDatei+Kern+'.gpkg'
if os.path.exists(shpdat):
delZielDat.append (gpkgdat)
if not DelZielDateien (delZielDat, sOutForm):
QMessageBox.information(None, tr("Cancel"), tr("Please set target"))
return None
# -----------------------------------------------------------------------------------------------
# 2. evtl. Dialog zur CRS-Eingabe aufrufen und Dummylayer schreiben, um eine qprj zu erhalten
# Vorteil der qprj: auch UserCRS werden erkannt
# a) CRS manuell oder automatisch je nach Einstellung
# es gibt 3 Arten: prompt,useProject,useGlobal
mLay=QgsVectorLayer('LineString','' , 'memory')
memDat=EZUTempDir() + str(uuid.uuid4()) + '.shp'
Antw=QgsVectorFileWriter.writeAsVectorFormat(mLay,memDat, None, mLay.crs(), "ESRI Shapefile")
qPrjDatName=memDat[0:-3] + 'qpj'
# es gibt 3 Arten: prompt,useProject,useGlobal
# originale Einstellung merken und für den weiter Verlauf zwingend auf automatisch einstellen
# Name der Eigenschaft in 3.0 geändert/korrigiert
if myqtVersion == 4:
crsRegParam4NewLayer='/Projections/defaultBehaviour'
else:
crsRegParam4NewLayer='/Projections/defaultBehavior'
crsArt = QSettings().value(crsRegParam4NewLayer)
crsDefWert = QSettings().value('/Projections/layerDefaultCrs')
QSettings().setValue('/Projections/layerDefaultCrs',mLay.crs().authid())
QSettings().setValue(crsRegParam4NewLayer,'useGlobal')
#try:
if True:
# -----------------------------------------------------------------------------------------------
# 3a. Initialisierung
# manchmal bleibt (bei mehrfachnutzung oder bei crash) irgend etwas hängen,
# die beiden nachfolgenden Zeilen haben bei einem Test das Problem gefixt - konnte aber noch nicht wiederholt werden
# recht zeitaufwändig
uiParent.FormRunning(True)
uiParent.SetDatAktionGesSchritte(8)
uiParent.SetAktionText("")
uiParent.SetDatAktionText(tr("process init - please wait"))
uiParent.SetDatAktionAktSchritt(1)
Processing.initialize()
#Processing.updateAlgsList() # existiert nicht mehr bei 2.99
# -----------------------------------------------------------------------------------------------
# 3. Abarbeitung der Dateien
uiParent.SetDatAktionGesSchritte(listDXFDatNam.count())
for i in range(listDXFDatNam.count()):
AktDXFDatNam=listDXFDatNam.item(i).text()
if myqtVersion == 5:
uiParent.SetDatAktionText(tr("Import: " + AktDXFDatNam ))
else:
uiParent.SetDatAktionText(tr("Import: " + AktDXFDatNam.encode("utf8") ))
uiParent.SetDatAktionAktSchritt(i+1)
AktList,AktOpt,ProjektName, Kern = ProjDaten4Dat(AktDXFDatNam,bCol,bLayer, bZielSave)
iface.mapCanvas().setRenderFlag( False )
# 1. Wurzel mit DXF- bzw. Projektname
# Projektname (-gruppe) in Root (neu) erstellen
root = QgsProject.instance().layerTreeRoot()
grpProjekt = root.addGroup( ProjektName)
#grpProjekt = iface.legendInterface().addGroup( ProjektName, False)
grpProjekt.setExpanded(True)
#iface.legendInterface().setGroupExpanded( grpProjekt, True )
#msgbox ("Bearbeite '" + AktDXFDatNam + "'")
okTransform=chkTransform
if chkTransform and DreiPassPunkte == None:
# Einpassdaten müssen aus wld kommen
wldDat=os.path.splitext(AktDXFDatNam)[0] + ".wld"
if os.path.exists(wldDat):
p=[[],[],[]]
p[0], p[1], Fehler = ReadWldDat(wldDat)
if Fehler == None:
# restliche Punkte per Helmert ermitteln
if p[1] == None:
# 2. Punkt ermitteln
p[0], p[1], p[2] = Helmert4Points(p[0], None)
# (immer) 3. Punkt ermitteln
p[0], p[1], p[2] = Helmert4Points(p[0],p[1])
DreiPassPunkte = p
else:
okTransform=False
addFehler (wldDat + ": " + Fehler)
else:
okTransform=False
addFehler(wldDat + ": " + tr("file not found"))
Antw = EineDXF (uiParent, mLay.crs(), bZielSave, sOutForm, grpProjekt, AktList, Kern, AktOpt, AktDXFDatNam, zielPfadOrDatei, qPrjDatName, sCharSet, bLayer, bFormatText, bUseColor4Point,bUseColor4Line,bUseColor4Poly, dblFaktor, okTransform, DreiPassPunkte)
# Ausgangswerte wieder herstellen
QSettings().setValue(crsRegParam4NewLayer,crsArt)
QSettings().setValue('/Projections/layerDefaultCrs',crsDefWert)
if len(getFehler()) > 0:
errbox("\n\n".join(getFehler()))
resetFehler()
if len(getHinweis()) > 0:
hinweislog("\n\n".join(getHinweis()))
resetHinweis()
uiParent.FormRunning(False)
def calculate(self, process_path):
qgs = QgsApplication([], False)
qgs.initQgis()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
gdal.AllRegister()
inputLayer = self.input_file
process_path = process_path
outPath = self.output_file
cellSize = self.cellSize
Elevation = self.elevation
lista_table = self.rattings
for file in glob.glob(os.path.dirname(inputLayer) + "/o.*"):
copyfile(file, process_path + os.path.basename(file))
inputLayer = process_path + os.path.basename(inputLayer)
layer = QgsVectorLayer(inputLayer, inputLayer, "ogr")
vectorlayer_vector = layer.dataProvider()
# extent
extent_rect = vectorlayer_vector.extent()
xmin = extent_rect.xMinimum()
xmax = extent_rect.xMaximum()
ymin = extent_rect.yMinimum()
ymax = extent_rect.yMaximum()
extent = str(xmin) + "," + str(xmax) + "," + str(ymin) + "," + str(
ymax)
# read fields and add a new column with the indexes
fields = layer.fields()
new_field = QgsField("Indexes", QVariant.Double)
layer_new = vectorlayer_vector.addAttributes([new_field])
layer.updateFields()
newFieldIndex = vectorlayer_vector.fieldNameIndex(new_field.name())
allAttrs = vectorlayer_vector.attributeIndexes()
# editing the new column
#numberRows = int(self.tableWidget.rowCount())
#numberColumns = int(self.tableWidget.columnCount())
#classes = ''
#lista = []
#for i in range(0,numberRows):
# for j in range(0,numberColumns):
# self.line = self.tableWidget.item(i,j)
# lista = lista + [str(self.line.text())]
# list of description on tool table
#lista_table = lista
field_names = [field.name() for field in fields]
n = len(field_names)
lista_attrib = []
for i in range(0, n):
f = field_names[i]
if f == str(Elevation):
number = i
for feat in layer.getFeatures():
attrb = feat.attributes()
attribute_read = attrb[number]
lista_attrib = lista_attrib + [str(attribute_read)]
# list of description on attribute table of shapefile
lista_attributes = lista_attrib
#QMessageBox.about(self, "teste", str(lista_attributes))
# obtain the indexes of the description of shapefile attribute table
description_common = set(lista_attributes).intersection(lista_table)
listDescription = list(description_common)
listElem = []
listElements = []
for j in range(0, len(listDescription)):
elem = lista_table.index(listDescription[j])
listElements = listElements + [elem]
elem_index = lista_table[int(elem + 1)]
listElem = listElem + [float(elem_index)]
for l in range(0, len(listElem)):
layer.startEditing()
exp = QgsExpression(str(listElem[l]))
#exp.prepare()
elemDescription = lista_table[listElements[l]]
for f in layer.getFeatures():
# get attributes of column defined by the user
attrb_elem = f[number]
if attrb_elem == elemDescription:
f[newFieldIndex] = exp.evaluate()
layer.updateFeature(f)
layer.commitChanges()
list_attrb_newField = []
for features in layer.getFeatures():
attrb_newField = features.attributes()
attrb_newField_read = attrb_newField[number + 1]
# update and read the new field
fieldsNew = layer.fields()
field_names_new = [newField.name() for newField in fieldsNew]
parameter_indexes = field_names_new[newFieldIndex]
Processing.initialize()
calculate = process_path + "/result.tif"
#soil = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path() + "/soil.sdat"
Processing.runAlgorithm(
"grass7:v.to.rast", {
'input': inputLayer,
'type': [0, 1, 3],
'where': '',
'use': 0,
'attribute_column': parameter_indexes,
'rgb_column': None,
'label_column': None,
'value': None,
'memory': 300,
'output': calculate,
'GRASS_REGION_PARAMETER': extent,
'GRASS_REGION_CELLSIZE_PARAMETER': cellSize,
'GRASS_RASTER_FORMAT_OPT': '',
'GRASS_RASTER_FORMAT_META': '',
'GRASS_SNAP_TOLERANCE_PARAMETER': -1,
'GRASS_MIN_AREA_PARAMETER': 0.0001
})
out_raster = gdal.Open(calculate)
gdal.Warp(outPath, out_raster, dstSRS="EPSG:3857")
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
Processing.initialize()
def idw_interpolation(layer, parent_dialog):
"""Run interpolation using inverse distance weight algorithm
:param layer: Vector layer with drivetimes
:type layer: QgsVectorLayer
:param parent_dialog: A dialog that called this function.
:type parent_dialog: QProgressDialog
:returns raster_layer: Interpolated raster layer with drivetimes
:rtype raster_layer: QgsRasterLayer
"""
raster_layer = None
try:
Processing.initialize()
Processing.updateAlgsList()
output_raster = processing.runalg(
'gdalogr:gridinvdist',
layer,
'minutes',
2, 0, 0, 0, 0, 0, 0, 0, 5,
"[temporary file]")
output_file = output_raster['OUTPUT']
file_info = QFileInfo(output_file)
base_name = file_info.baseName()
# retrieving the raster output , styling it and load it in Qgis
raster_layer = QgsRasterLayer(output_file, base_name)
except Exception as exception: # pylint: disable=broad-except
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map,'
'please check if you have processing '
'plugin installed '))
else:
display_warning_message_box(
parent_dialog,
'Error',
'Error loading isochrone map,'
'please check if you have processing '
'plugin installed ')
if raster_layer:
if raster_layer.isValid():
color_shader = QgsColorRampShader()
color_shader.setColorRampType(QgsColorRampShader.INTERPOLATED)
colors = {
'deep_green': '#1a9641',
'light_green': '#a6d96a',
'pale_yellow': '#ffffc0',
'light_red': '#fdae61',
'red': '#d7191c'
}
provider = raster_layer.dataProvider()
stats = provider.bandStatistics(
1,
QgsRasterBandStats.All,
raster_layer.extent(),
0)
values = {}
if stats:
min = stats.minimumValue
max = stats.maximumValue
stat_range = max - min
add = stat_range / 4
values[0] = min
value = min
for index in range(1, 4):
value += add
values[index] = value
values[4] = max
else:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map'
' Problem indexing the isochrones map'))
color_list = [
QgsColorRampShader.ColorRampItem(
values[0],
QColor(colors['deep_green'])),
QgsColorRampShader.ColorRampItem(
values[1],
QColor(colors['light_green'])),
QgsColorRampShader.ColorRampItem(
values[2],
QColor(colors['pale_yellow'])),
QgsColorRampShader.ColorRampItem(
values[3],
QColor(colors['light_red'])),
QgsColorRampShader.ColorRampItem(
values[4],
QColor(colors['red']))
]
color_shader.setColorRampItemList(color_list)
raster_shader = QgsRasterShader()
raster_shader.setRasterShaderFunction(color_shader)
renderer = QgsSingleBandPseudoColorRenderer(
raster_layer.dataProvider(),
1,
raster_shader)
raster_layer.setRenderer(renderer)
else:
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Problem'),
parent_dialog.tr('Problem styling the isochrone map'))
else:
display_warning_message_box(
parent_dialog,
'Problem',
'Problem styling the isochrone map')
QgsMapLayerRegistry.instance().addMapLayers([raster_layer])
else:
if parent_dialog:
display_warning_message_box(
parent_dialog,
parent_dialog.tr(
'Error'),
parent_dialog.tr('Error loading isochrone map '
'Could not load interpolated file!'))
else:
display_warning_message_box(
parent_dialog,
'Error',
'Error loading isochrone map '
'Could not load interpolated file!')
return raster_layer
import zipfile
import tempfile
os.chdir('/projectnb/landsat/projects/Colombia/vector/')
# Initialize QGIS Application
QgsApplication.setPrefixPath("/share/pkg/qgis/2.6.1/install/bin/qgis", True)
qgs = QgsApplication([], False)
qgs.initQgis()
# Add the path to Processing framework
sys.path.append('/share/pkg/qgis/2.6.1/install/share/qgis/python/plugins')
# Import and initialize Processing framework
from processing.core.Processing import Processing
Processing.initialize()
import processing
# Load vector
layerpath = "C:\OneDrive\Lab\Base layers\scene_overlap.shp"
layerpath = "/projectnb/landsat/projects/Colombia/vector/scene_overlap.shp"
# To extract basename from the path if needed (THIS IS NOR WORKING CORRECTLY)
path = os.path.splitext(layerpath)[0]
filename = os.path.basename(path)
layer = QgsVectorLayer(layerpath, 'scene_overlap', "ogr")
if not layer.isValid():
print "Layer failed to load!"
# Get layer data provider (starting edition session may be required after this)
def setUpClass(cls):
# start_app()
from processing.core.Processing import Processing
Processing.initialize()
def reproject_clip_vectors_by_polygon(grassdb, grass_location,
qgis_prefix_path, mask, path_polygon,
ply_name):
QgsApplication.setPrefixPath(qgis_prefix_path, True)
Qgs = QgsApplication([], False)
Qgs.initQgis()
from processing.core.Processing import Processing
from processing.tools import dataobjects
from qgis import processing
feedback = QgsProcessingFeedback()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
context = dataobjects.createContext()
context.setInvalidGeometryCheck(QgsFeatureRequest.GeometryNoCheck)
crs_id = qgis_vector_return_crs_id(processing,
context,
mask,
Input_Is_Feature_In_Mem=False)
qgis_vector_reproject_layers(
processing,
context,
INPUT=path_polygon,
TARGET_CRS=crs_id,
OUTPUT=os.path.join(grassdb, ply_name + "_project.shp"),
)
# lake polygon sometime has error in geometry
try:
qgis_vector_ectract_by_location(
processing,
context,
INPUT=os.path.join(grassdb, ply_name + "_project.shp"),
INTERSECT=mask,
OUTPUT=os.path.join(grassdb, ply_name + ".shp"),
)
if ply_name == 'kc_zone':
processing.run(
"native:clip", {
'INPUT': os.path.join(grassdb, ply_name + "_project.shp"),
'OVERLAY': mask,
'OUTPUT': os.path.join(grassdb, ply_name + "_clip.shp")
})
except:
print("Need fix lake boundary geometry to speed up")
qgis_vector_fix_geometries(
processing,
context,
INPUT=os.path.join(grassdb, ply_name + "_project.shp"),
OUTPUT=os.path.join(grassdb, ply_name + "_fixgeo.shp"),
)
qgis_vector_fix_geometries(
processing,
context,
INPUT=mask,
OUTPUT=os.path.join(grassdb, "mask_fixgeo.shp"),
)
qgis_vector_ectract_by_location(
processing,
context,
INPUT=os.path.join(grassdb, ply_name + "_fixgeo.shp"),
INTERSECT=os.path.join(grassdb, "mask_fixgeo.shp"),
OUTPUT=os.path.join(grassdb, ply_name + ".shp"),
)
if ply_name == 'kc_zone':
processing.run(
"native:clip", {
'INPUT': os.path.join(grassdb, ply_name + "_fixgeo.shp"),
'OVERLAY': os.path.join(grassdb, "mask_fixgeo.shp"),
'OUTPUT': os.path.join(grassdb, ply_name + "_clip.shp")
})
Qgs.exit()
def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
cls.cleanup_paths = []
def convert(self):
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(False)
# read D raster
inputLayer = self.inputLayerCombo.currentText()
bn_inputLayer = str(os.path.splitext(os.path.basename(inputLayer))[0])
teste = str(bn_inputLayer) + '@1\''
QMessageBox.about(self, "Seepage", str(teste))
# read R raster
inputLayer2 = self.inputLayerCombo2.currentText()
bn_inputLayer2 = str(
os.path.splitext(os.path.basename(inputLayer2))[0])
# read A raster
inputLayer3 = self.inputLayerCombo3.currentText()
bn_inputLayer3 = str(
os.path.splitext(os.path.basename(inputLayer3))[0])
# read S raster
inputLayer4 = self.inputLayerCombo4.currentText()
bn_inputLayer4 = str(
os.path.splitext(os.path.basename(inputLayer4))[0])
# read T raster
inputLayer5 = self.inputLayerCombo5.currentText()
bn_inputLayer5 = str(
os.path.splitext(os.path.basename(inputLayer5))[0])
# read I raster
inputLayer6 = self.inputLayerCombo6.currentText()
bn_inputLayer6 = str(
os.path.splitext(os.path.basename(inputLayer6))[0])
# read C raster
inputLayer7 = self.inputLayerCombo7.currentText()
bn_inputLayer7 = str(
os.path.splitext(os.path.basename(inputLayer7))[0])
# outpath
outPath = self.outputLayerCombo.text()
gdal.AllRegister()
# sum of the raster = Seepage
# D
gdalRaster = gdal.Open(str(inputLayer))
# # multiply by weight
# depth_weight = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/depth_weight"
x = gdalRaster.RasterXSize
y = gdalRaster.RasterYSize
geo = gdalRaster.GetGeoTransform()
# band = gdalRaster.GetRasterBand(1)
# data = band.ReadAsArray(0,0,x,y)
# mul = numpy.multiply(data, int(self.lineWeightD.value()))
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver = gdal.GetDriverByName( "GTiff" )
# outData = driver.Create(str(depth_weight), x,y,1, gdal.GDT_Float32)
# outData.GetRasterBand(1).WriteArray(mul)
# outData.SetGeoTransform(geo)
# outData = None
#
# geo = gdalRaster.GetGeoTransform()
# # pixel size
pixelSize = geo[1]
# extent
minx = geo[0]
maxy = geo[3]
maxx = minx + geo[1] * x
miny = maxy + geo[5] * y
extent = str(minx) + "," + str(maxx) + "," + str(miny) + "," + str(
maxy)
band = gdalRaster.GetRasterBand(1)
# data_d = band.ReadAsArray(0,0,x,y)
Processing.initialize()
resamp_d = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path(
) + "/resamp_d_Seepage.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize, resamp_r)
Processing.runAlgorithm(
"saga:resampling", {
'INPUT':
inputLayer,
'KEEP_TYPE':
True,
'SCALE_UP':
0,
'SCALE_DOWN':
0,
'TARGET_USER_XMIN TARGET_USER_XMAX TARGET_USER_YMIN TARGET_USER_YMAX':
extent + '[EPSG:3763]',
'TARGET_USER_SIZE':
pixelSize,
'TARGET_USER_FITS':
0,
'TARGET_TEMPLATE':
None,
'OUTPUT':
resamp_d
})
resamp_r = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path(
) + "/resamp_r_Seepage.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize, resamp_r)
Processing.runAlgorithm(
"saga:resampling", {
'INPUT':
inputLayer2,
'KEEP_TYPE':
True,
'SCALE_UP':
0,
'SCALE_DOWN':
0,
'TARGET_USER_XMIN TARGET_USER_XMAX TARGET_USER_YMIN TARGET_USER_YMAX':
extent + '[EPSG:3763]',
'TARGET_USER_SIZE':
pixelSize,
'TARGET_USER_FITS':
0,
'TARGET_TEMPLATE':
None,
'OUTPUT':
resamp_r
})
resamp_a = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path(
) + "/resamp_a_Seepage.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize, resamp_r)
Processing.runAlgorithm(
"saga:resampling", {
'INPUT':
inputLayer3,
'KEEP_TYPE':
True,
'SCALE_UP':
0,
'SCALE_DOWN':
0,
'TARGET_USER_XMIN TARGET_USER_XMAX TARGET_USER_YMIN TARGET_USER_YMAX':
extent + '[EPSG:3763]',
'TARGET_USER_SIZE':
pixelSize,
'TARGET_USER_FITS':
0,
'TARGET_TEMPLATE':
None,
'OUTPUT':
resamp_a
})
resamp_s = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path(
) + "/resamp_s_Seepage.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize, resamp_r)
Processing.runAlgorithm(
"saga:resampling", {
'INPUT':
inputLayer4,
'KEEP_TYPE':
True,
'SCALE_UP':
0,
'SCALE_DOWN':
0,
'TARGET_USER_XMIN TARGET_USER_XMAX TARGET_USER_YMIN TARGET_USER_YMAX':
extent + '[EPSG:3763]',
'TARGET_USER_SIZE':
pixelSize,
'TARGET_USER_FITS':
0,
'TARGET_TEMPLATE':
None,
'OUTPUT':
resamp_s
})
resamp_t = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path(
) + "/resamp_t_Seepage.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize, resamp_r)
Processing.runAlgorithm(
"saga:resampling", {
'INPUT':
inputLayer5,
'KEEP_TYPE':
True,
'SCALE_UP':
0,
'SCALE_DOWN':
0,
'TARGET_USER_XMIN TARGET_USER_XMAX TARGET_USER_YMIN TARGET_USER_YMAX':
extent + '[EPSG:3763]',
'TARGET_USER_SIZE':
pixelSize,
'TARGET_USER_FITS':
0,
'TARGET_TEMPLATE':
None,
'OUTPUT':
resamp_t
})
resamp_i = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path(
) + "/resamp_t_Seepage.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize, resamp_r)
Processing.runAlgorithm(
"saga:resampling", {
'INPUT':
inputLayer6,
'KEEP_TYPE':
True,
'SCALE_UP':
0,
'SCALE_DOWN':
0,
'TARGET_USER_XMIN TARGET_USER_XMAX TARGET_USER_YMIN TARGET_USER_YMAX':
extent + '[EPSG:3763]',
'TARGET_USER_SIZE':
pixelSize,
'TARGET_USER_FITS':
0,
'TARGET_TEMPLATE':
None,
'OUTPUT':
resamp_i
})
resamp_c = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path(
) + "/resamp_t_Seepage.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize, resamp_r)
Processing.runAlgorithm(
"saga:resampling", {
'INPUT':
inputLayer7,
'KEEP_TYPE':
True,
'SCALE_UP':
0,
'SCALE_DOWN':
0,
'TARGET_USER_XMIN TARGET_USER_XMAX TARGET_USER_YMIN TARGET_USER_YMAX':
extent + '[EPSG:3763]',
'TARGET_USER_SIZE':
pixelSize,
'TARGET_USER_FITS':
0,
'TARGET_TEMPLATE':
None,
'OUTPUT':
resamp_c
})
#
#
# gdalRaster_d = gdal.Open(str(depth_weight))
# x_d = gdalRaster_d.RasterXSize
# y_d = gdalRaster_d.RasterYSize
# geo_d = gdalRaster_d.GetGeoTransform()
# band_d = gdalRaster_d.GetRasterBand(1)
# data_d = band_d.ReadAsArray(0,0,x_d,y_d)
#
#
# # R
# # resampling R raster
# gdalRaster2 = gdal.Open(str(inputLayer2))
# # multiply by weight
# recharge_weight = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/recharge_weight"
# x2 = gdalRaster2.RasterXSize
# y2 = gdalRaster2.RasterYSize
# geo2 = gdalRaster2.GetGeoTransform()
# band2 = gdalRaster2.GetRasterBand(1)
# data2 = band2.ReadAsArray(0,0,x2,y2)
# mul2 = numpy.multiply(data2, int(self.lineWeightR.value()))
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver2 = gdal.GetDriverByName( "GTiff" )
# outData2 = driver2.Create(str(recharge_weight), x2,y2,1, gdal.GDT_Float32)
# outData2.GetRasterBand(1).WriteArray(mul2)
# outData2.SetGeoTransform(geo2)
# outData2 = None
#
# Processing.initialize()
# resamp_r = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/resamp_r.sdat"
# Processing.runAlgorithm("saga:resampling", None, recharge_weight, True, 0, 0, extent, pixelSize,0, None,3, resamp_r)
# #resamp_r_dir = resamp_r + "." + "tif"
# # R
# gdalRaster_r = gdal.Open(str(resamp_r))
# x_r = gdalRaster_r.RasterXSize
# y_r = gdalRaster_r.RasterYSize
# geo_r = gdalRaster_r.GetGeoTransform()
# band_r = gdalRaster_r.GetRasterBand(1)
# data_r = band_r.ReadAsArray(0,0,x_r,y_r)
#
# # A
# # resampling A raster
# gdalRaster3 = gdal.Open(str(inputLayer3))
# # multiply by weight
# aquifer_weight = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/aquifer_weight"
# x3 = gdalRaster3.RasterXSize
# y3 = gdalRaster3.RasterYSize
# geo3 = gdalRaster3.GetGeoTransform()
# band3 = gdalRaster3.GetRasterBand(1)
# data3 = band3.ReadAsArray(0,0,x3,y3)
# mul3 = numpy.multiply(data3, int(self.lineWeightA.value()))
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver3 = gdal.GetDriverByName( "GTiff" )
# outData3 = driver3.Create(str(aquifer_weight), x3,y3,1, gdal.GDT_Float32)
# outData3.GetRasterBand(1).WriteArray(mul3)
# outData3.SetGeoTransform(geo3)
# outData3 = None
# resamp_a = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/resamp_a.sdat"
# Processing.runAlgorithm("saga:resampling", None, aquifer_weight, True, 0, 0, extent, pixelSize,0, None,3, resamp_a)
#
# # A
# gdalRaster_a = gdal.Open(str(resamp_a))
# x_a = gdalRaster_a.RasterXSize
# y_a = gdalRaster_a.RasterYSize
# geo_a = gdalRaster_a.GetGeoTransform()
# band_a = gdalRaster_a.GetRasterBand(1)
# data_a = band_a.ReadAsArray(0,0,x_a,y_a)
#
#
# # S
# # resampling S raster
# gdalRaster4 = gdal.Open(str(inputLayer4))
# # multiply by weight
# soil_weight = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/soil_weight"
# x4 = gdalRaster4.RasterXSize
# y4 = gdalRaster4.RasterYSize
# geo4 = gdalRaster4.GetGeoTransform()
# band4 = gdalRaster4.GetRasterBand(1)
# data4 = band4.ReadAsArray(0,0,x4,y4)
# mul4 = numpy.multiply(data4, int(self.lineWeightS.value()))
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver4 = gdal.GetDriverByName( "GTiff" )
# outData4 = driver4.Create(str(soil_weight), x4,y4,1, gdal.GDT_Float32)
# outData4.GetRasterBand(1).WriteArray(mul4)
# outData4.SetGeoTransform(geo4)
# outData4 = None
#
# # find nodata values
# if self.lineWeightS.value()==2:
# error = -299997
#
# # soil_weight_correct = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/soil_weight_correct.sdat"
# # # reclassify no data values
# # Processing.initialize()
# # Processing.runAlgorithm("saga:reclassifygridvalues", None, soil_weight, 0, error, 0, 0, 0.0, 1.0, 2.0, 0, "0,0,0,0,0,0,0,0,0", 0, True, 0.0, False, 0.0, soil_weight_correct)
# #
#
#
# resamp_s = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/resamp_s.sdat"
# Processing.runAlgorithm("saga:resampling", None, soil_weight, True, 0, 0, extent, pixelSize,0, None,3, resamp_s)
#
# # S
# gdalRaster_s = gdal.Open(str(resamp_s))
# x_s = gdalRaster_s.RasterXSize
# y_s = gdalRaster_s.RasterYSize
# geo_s = gdalRaster_s.GetGeoTransform()
# band_s = gdalRaster_s.GetRasterBand(1)
# data_s = band_s.ReadAsArray(0,0,x_s,y_s)
#
# # T
# # resampling T raster
# gdalRaster5 = gdal.Open(str(inputLayer5))
# # multiply by weight
# topography_weight = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/topography_weight"
# x5 = gdalRaster5.RasterXSize
# y5 = gdalRaster5.RasterYSize
# geo5 = gdalRaster5.GetGeoTransform()
# band5 = gdalRaster5.GetRasterBand(1)
# data5 = band5.ReadAsArray(0,0,x5,y5)
# mul5 = numpy.multiply(data5, int(self.lineWeightT.value()))
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver5 = gdal.GetDriverByName( "GTiff" )
# outData5 = driver5.Create(str(topography_weight), x5,y5,1, gdal.GDT_Float32)
# outData5.GetRasterBand(1).WriteArray(mul5)
# outData5.SetGeoTransform(geo5)
# outData5 = None
# resamp_t = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/resamp_t.sdat"
# Processing.runAlgorithm("saga:resampling", None, topography_weight, True, 0, 0, extent, pixelSize,0, None,3, resamp_t)
#
# # T
# gdalRaster_t = gdal.Open(str(resamp_t))
# x_t = gdalRaster_t.RasterXSize
# y_t = gdalRaster_t.RasterYSize
# geo_t = gdalRaster_t.GetGeoTransform()
# band_t = gdalRaster_t.GetRasterBand(1)
# data_t = band_t.ReadAsArray(0,0,x_t,y_t)
# #QMessageBox.about(self, "Seepage", str(data_t))
#
# # I
# # resampling I raster
# gdalRaster6 = gdal.Open(str(inputLayer6))
# # multiply by weight
# impact_weight = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/impact_weight"
# x6 = gdalRaster6.RasterXSize
# y6 = gdalRaster6.RasterYSize
# geo6 = gdalRaster6.GetGeoTransform()
# band6 = gdalRaster6.GetRasterBand(1)
# data6 = band6.ReadAsArray(0,0,x6,y6)
# mul6 = numpy.multiply(data6, int(self.lineWeightI.value()))
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver6 = gdal.GetDriverByName( "GTiff" )
# outData6 = driver6.Create(str(impact_weight), x6,y6,1, gdal.GDT_Float32)
# outData6.GetRasterBand(1).WriteArray(mul6)
# outData6.SetGeoTransform(geo6)
# outData6 = None
# resamp_i = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/resamp_i.sdat"
# Processing.runAlgorithm("saga:resampling", None, impact_weight, True, 0, 0, extent, pixelSize, 0, None,3,resamp_i)
#
# # I
# gdalRaster_i = gdal.Open(str(resamp_i))
# x_i = gdalRaster_i.RasterXSize
# y_i = gdalRaster_i.RasterYSize
# geo_i = gdalRaster_i.GetGeoTransform()
# band_i = gdalRaster_i.GetRasterBand(1)
# data_i = band_i.ReadAsArray(0,0,x_i,y_i)
#
# # C
# # resampling C raster
# gdalRaster7 = gdal.Open(str(inputLayer7))
# # multiply by weight
# hydraulic_weight = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/hydraulic_weight"
# x7 = gdalRaster7.RasterXSize
# y7 = gdalRaster7.RasterYSize
# geo7 = gdalRaster7.GetGeoTransform()
# band7 = gdalRaster7.GetRasterBand(1)
# data7 = band7.ReadAsArray(0,0,x7,y7)
# mul7 = numpy.multiply(data7, int(self.lineWeightC.value()))
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver7 = gdal.GetDriverByName( "GTiff" )
# outData7 = driver7.Create(str(hydraulic_weight), x7,y7,1, gdal.GDT_Float32)
# outData7.GetRasterBand(1).WriteArray(mul7)
# outData7.SetGeoTransform(geo7)
# outData7 = None
# resamp_c = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/resamp_c.sdat"
# Processing.runAlgorithm("saga:resampling", None, hydraulic_weight, True, 0, 0, extent, pixelSize, 0, None,3, resamp_c)
#
# # C
# gdalRaster_c = gdal.Open(str(resamp_c))
# x_c = gdalRaster_c.RasterXSize
# y_c = gdalRaster_c.RasterYSize
# geo_c = gdalRaster_c.GetGeoTransform()
# band_c = gdalRaster_c.GetRasterBand(1)
# data_c = band_c.ReadAsArray(0,0,x_c,y_c)
# list_raster = []
# list_raster = list_raster + [inputLayer2]+[inputLayer3]+[inputLayer4]+[inputLayer5]+[inputLayer6]+[inputLayer7]
# listt = ';'.join(list_raster)
#
# sum
# first5 = QFileInfo(QgsApplication.qgisUserDatabaseFilePath()).path() + "/first5"
# Processing.runAlgorithm("gdal:rastercalculator",
# {'INPUT_A': inputLayer, 'BAND_A': 1, 'INPUT_B': inputLayer2, 'BAND_B': 1,
# 'INPUT_C': inputLayer3, 'BAND_C': 1, 'INPUT_D': inputLayer4,
# 'BAND_D': 1, 'INPUT_E': inputLayer5, 'BAND_E': 1, 'INPUT_F': inputLayer6, 'BAND_F': 1,
# 'FORMULA': "A+B+C+D+E+F", 'NO_DATA': None, 'RTYPE': 5,
# 'EXTRA': '', 'OPTIONS': '',
# 'OUTPUT': first5})
# Processing.runAlgorithm("gdal:rastercalculator",
# {'INPUT_A': first5, 'BAND_A': 1, 'INPUT_B': inputLayer7, 'BAND_B': 1,
# 'INPUT_C': None, 'BAND_C': -1, 'INPUT_D': None,
# 'BAND_D': -1, 'INPUT_E': None, 'BAND_E': -1, 'INPUT_F': None, 'BAND_F': -1,
# 'FORMULA': "A+B", 'NO_DATA': None, 'RTYPE': 5,
# 'EXTRA': '', 'OPTIONS': '',
# 'OUTPUT': outPath})
# QMessageBox.about(self, "Seepage", str('\\"' + str(bn_inputLayer3) + '@1\'' + '\\"' + str(bn_inputLayer7) + '@1\' + '\\"' + str(bn_inputLayer) + '@1\'' + '\"' + str(bn_inputLayer6) + '@1\'' + '\"' + str(bn_inputLayer2) + '@1\'' + '\"' + str(bn_inputLayer4) + '@1\'' + '\"' + str(bn_inputLayer5) + '@1\''))
drasti = QFileInfo(
QgsApplication.qgisUserDatabaseFilePath()).path() + "/drasti.sdat"
Processing.runAlgorithm(
"gdal:rastercalculator", {
'INPUT_A': resamp_d,
'BAND_A': 1,
'INPUT_B': resamp_r,
'BAND_B': 1,
'INPUT_C': resamp_a,
'BAND_C': 1,
'INPUT_D': resamp_s,
'BAND_D': 1,
'INPUT_E': resamp_t,
'BAND_E': 1,
'INPUT_F': resamp_i,
'BAND_F': 1,
'FORMULA': 'A+B+C+D+E+F',
'NO_DATA': None,
'RTYPE': 5,
'EXTRA': '',
'OPTIONS': '',
'OUTPUT': drasti
})
Processing.runAlgorithm(
"gdal:rastercalculator", {
'INPUT_A': drasti,
'BAND_A': 1,
'INPUT_B': resamp_c,
'BAND_B': 1,
'INPUT_C': None,
'BAND_C': -1,
'INPUT_D': None,
'BAND_D': -1,
'INPUT_E': None,
'BAND_E': -1,
'INPUT_F': None,
'BAND_F': -1,
'FORMULA': 'A+B',
'NO_DATA': None,
'RTYPE': 5,
'EXTRA': '',
'OPTIONS': '',
'OUTPUT': outPath
})
# summ = data_d + data_r + data_a + data_s + data_t + data_i + data_c
#
# sum_nodata = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/sum_nodata"
# sum_nodata_rec = sum_nodata + "." + "tif"
#
# # Create an output imagedriver with the reclassified values multiplied by the weight
# driver_sum = gdal.GetDriverByName( "GTiff" )
# outData_sum = driver_sum.Create(str(sum_nodata), x,y,1, gdal.GDT_Float32)
# outData_sum.GetRasterBand(1).WriteArray(summ)
# outData_sum.SetGeoTransform(geo)
# outData_sum = None
# reclassify no data values
# Processing.runAlgorithm("saga:reclassifygridvalues", None, sum_nodata, 0, -10000100352, 0, 0, 0.0, 1.0, 2.0, 0, "0,0,0,0,0,0,0,0,0", 0, True, 0.0, False, 0.0, outPath)
if self.checkSeepage.isChecked():
# add result into canvas
file_info_norm = QFileInfo(str(outPath))
# QMessageBox.about(self, "teste", str(file_info_norm))
rlayer_new_norm = QgsRasterLayer(outPath,
file_info_norm.fileName(), 'gdal')
# QMessageBox.about(self, "teste", str(rlayer_new_norm))
QgsProject.instance().addMapLayer(rlayer_new_norm)
self.iface.canvas.setExtent(rlayer_new_norm.extent())
# set the map canvas layer set
self.iface.canvas.setLayers([rlayer_new_norm])
# # add result into canvas
# file_info = QFileInfo(outPath)
# if file_info.exists():
# layer_name = file_info.baseName()
# else:
# return False
# rlayer_new = QgsRasterLayer(outPath, layer_name)
# if rlayer_new.isValid():
# QgsMapLayerRegistry.instance().addMapLayer(rlayer_new)
# layer = QgsMapCanvasLayer(rlayer_new)
# layerList = [layer]
# extent = self.iface.canvas.setExtent(rlayer_new.extent())
# self.iface.canvas.setLayerSet(layerList)
# self.iface.canvas.setVisible(True)
# return True
# else:
# return False
QMessageBox.information(self, self.tr("Finished"),
self.tr("Seepage completed."))
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
def __init__(self, iface):
self.iface = iface
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
Processing.initialize()
def initProcessing(self):
if not self.initialized:
self.initialized = True
Processing.initialize()
def init_processing() -> None:
from processing.core.Processing import Processing
from qgis.analysis import QgsNativeAlgorithms
from qgis.core import QgsApplication
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
Processing.initialize()
def setUpClass(cls):
"""Run before all tests"""
QCoreApplication.setOrganizationName("QGIS_Test")
QCoreApplication.setOrganizationDomain(
"QGIS_TestPyQgsPackageLayers.com")
QCoreApplication.setApplicationName("QGIS_TestPyQgsPackageLayers")
QgsSettings().clear()
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
cls.registry = QgsApplication.instance().processingRegistry()
cls.tmp_dir = QTemporaryDir()
cls.temp_path = os.path.join(cls.tmp_dir.path(), 'package_layers.gpkg')
cls.temp_export_path = os.path.join(cls.tmp_dir.path(), 'package_layers_export.gpkg')
# Create test DB
"""
Test data:
Region 1
Province 1
City 1
City 2
Province 2
City 3
Region 2
Province 3
Province 4
City 4
"""
ds = ogr.GetDriverByName('GPKG').CreateDataSource(cls.temp_path)
lyr = ds.CreateLayer('region', geom_type=ogr.wkbNone)
lyr.CreateField(ogr.FieldDefn('name', ogr.OFTString))
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'region one'
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'region two'
lyr.CreateFeature(f)
lyr = ds.CreateLayer('province', geom_type=ogr.wkbNone)
lyr.CreateField(ogr.FieldDefn('name', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('region', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'province one'
f['region'] = 1
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'province two'
f['region'] = 1
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'province three'
f['region'] = 2
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'province four'
f['region'] = 2
lyr.CreateFeature(f)
lyr = ds.CreateLayer('city', geom_type=ogr.wkbNone)
lyr.CreateField(ogr.FieldDefn('name', ogr.OFTString))
lyr.CreateField(ogr.FieldDefn('province', ogr.OFTInteger))
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'city one'
f['province'] = 1
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'city two'
f['province'] = 1
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'city three'
f['province'] = 2
lyr.CreateFeature(f)
f = ogr.Feature(lyr.GetLayerDefn())
f['name'] = 'city four'
f['province'] = 4
lyr.CreateFeature(f)
f = None
ds = None
region = QgsVectorLayer(cls.temp_path + '|layername=region', 'region')
province = QgsVectorLayer(cls.temp_path + '|layername=province', 'province')
city = QgsVectorLayer(cls.temp_path + '|layername=city', 'city')
QgsProject.instance().addMapLayers([region, province, city])
relMgr = QgsProject.instance().relationManager()
rel = QgsRelation()
rel.setId('rel1')
rel.setName('province -> region')
rel.setReferencingLayer(province.id())
rel.setReferencedLayer(region.id())
rel.addFieldPair('region', 'fid')
assert rel.isValid()
relMgr.addRelation(rel)
rel = QgsRelation()
rel.setId('rel2')
rel.setName('city -> province')
rel.setReferencingLayer(city.id())
rel.setReferencedLayer(province.id())
rel.addFieldPair('province', 'fid')
assert rel.isValid()
relMgr.addRelation(rel)
def setUpClass(cls):
start_app()
from processing.core.Processing import Processing
Processing.initialize()
cls.cleanup_paths = []
def setUpClass(cls):
# start_app()
from processing.core.Processing import Processing
Processing.initialize()
def convert(self):
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(False)
inputLayer = self.inputLayerCombo.currentText()
# layer information
layer = QgsVectorLayer(inputLayer, inputLayer, "ogr")
vectorlayer_vector = layer.dataProvider()
# extent
extent_rect = vectorlayer_vector.extent()
xmin = extent_rect.xMinimum()
xmax = extent_rect.xMaximum()
ymin = extent_rect.yMinimum()
ymax = extent_rect.yMaximum()
extent = str(xmin) + "," + str(xmax) + "," + str(ymin) + "," + str(ymax)
# attribute
Elevation = self.lineAttrib.currentText()
# cellsize
cellSize = int(self.linePix.value())
outPath = self.inputLayerCombo3.text()
# read fields and add a new column with the indexes
fields = layer.fields()
new_field = QgsField("Indexes", QVariant.Double)
layer_new = vectorlayer_vector.addAttributes([new_field])
layer.updateFields()
newFieldIndex = vectorlayer_vector.fieldNameIndex(new_field.name())
allAttrs = vectorlayer_vector.attributeIndexes()
# editing the new column
numberRows = int(self.tableWidget.rowCount())
numberColumns = int(self.tableWidget.columnCount())
classes = ''
lista = []
for i in range(0, numberRows):
for j in range(0, numberColumns):
self.line = self.tableWidget.item(i, j)
lista = lista + [str(self.line.text())]
# list of description on tool table
lista_table = lista
field_names = [field.name() for field in fields]
n = len(field_names)
lista_attrib = []
for i in range(0, n):
f = field_names[i]
if f == str(Elevation):
number = i
for feat in layer.getFeatures():
attrb = feat.attributes()
attribute_read = attrb[number]
lista_attrib = lista_attrib + [str(attribute_read)]
# list of description on attribute table of shapefile
lista_attributes = lista_attrib
# obtain the indexes of the description of shapefile attribute table
description_common = set(lista_attributes).intersection(lista_table)
listDescription = list(description_common)
listElem = []
listElements = []
for j in range(0, len(listDescription)):
elem = lista_table.index(listDescription[j])
listElements = listElements + [elem]
elem_index = lista_table[int(elem + 1)]
listElem = listElem + [float(elem_index)]
for l in range(0, len(listElem)):
layer.startEditing()
exp = QgsExpression(str(listElem[l]))
# exp.prepare(fields)
elemDescription = lista_table[listElements[l]]
for f in layer.getFeatures():
# get attributes of column defined by the user
attrb_elem = f[number]
if attrb_elem == elemDescription:
f[newFieldIndex] = exp.evaluate()
layer.updateFeature(f)
layer.commitChanges()
list_attrb_newField = []
for features in layer.getFeatures():
attrb_newField = features.attributes()
attrb_newField_read = attrb_newField[number + 1]
# update and read the new field
fieldsNew = layer.fields()
field_names_new = [newField.name() for newField in fieldsNew]
parameter_indexes = field_names_new[newFieldIndex]
Processing.initialize()
# aquifer = QFileInfo(QgsApplication.qgisUserDbFilePath()).path() + "/aquifer"
Processing.runAlgorithm("grass7:v.to.rast", {'input': inputLayer, 'type': [0, 1, 3], 'where': '', 'use': 0,
'attribute_column': parameter_indexes, 'rgb_column': None,
'label_column': None, 'value': None, 'memory': 300,
'output': outPath, 'GRASS_REGION_PARAMETER': extent,
'GRASS_REGION_CELLSIZE_PARAMETER': cellSize,
'GRASS_RASTER_FORMAT_OPT': '', 'GRASS_RASTER_FORMAT_META': '',
'GRASS_SNAP_TOLERANCE_PARAMETER': -1,
'GRASS_MIN_AREA_PARAMETER': 0.0001})
# aquifer_complete = aquifer + "." + "tif"
# Processing.runAlgorithm("grass:r.surf.idw", None,aquifer_complete , 12, False, extent, cellSize, outPath)
# add result into canvas
file_info_norm = QFileInfo(str(outPath))
# QMessageBox.about(self, "teste", str(file_info_norm))
rlayer_new_norm = QgsRasterLayer(outPath, file_info_norm.fileName(), 'gdal')
# QMessageBox.about(self, "teste", str(rlayer_new_norm))
QgsProject.instance().addMapLayer(rlayer_new_norm)
self.iface.canvas.setExtent(rlayer_new_norm.extent())
# set the map canvas layer set
self.iface.canvas.setLayers([rlayer_new_norm])
# add result into canvas
# file_info = QFileInfo(outPath)
# if file_info.exists():
# layer_name = file_info.baseName()
# else:
# return False
# rlayer_new = QgsRasterLayer(outPath, layer_name)
# if rlayer_new.isValid():
# QgsMapLayerRegistry.instance().addMapLayer(rlayer_new)
# layer = QgsMapCanvasLayer(rlayer_new)
# layerList = [layer]
# extent = self.iface.canvas.setExtent(rlayer_new.extent())
# self.iface.canvas.setLayerSet(layerList)
# self.iface.canvas.setVisible(True)
# return True
# else:
# return False
# QMessageBox.information(self, self.tr( "Finished" ), self.tr( "Aquifer media completed." ) )
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
def __init__(self, iface):
interface.iface = iface
Processing.initialize()
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 on_buttonBox_accepted(self):
self.copyFiles(self.scriptsList, self.scripts, os.path.join(currentPath, '..', '..', '..', '..', 'processing', 'scripts'))
Processing.initialize()
self.copyFiles(self.modelsList, self.models, os.path.join(currentPath, '..', '..', '..', '..', 'processing', 'models'))
Processing.initialize()
def __init__(self, iface):
self.iface = iface
Processing.initialize()
def initProcessing(self):
if not self.initialized:
self.initialized = True
Processing.initialize()
def __init__(self, interface, workerThread):
QDialog.__init__(self, interface.mainWindow())
# QGIS interface
self.iface = interface
# QGIS map canvas
self.canvas = self.iface.mapCanvas()
# Threading
self.workerThread = workerThread
# Setup GUI of SEILAPLAN (import from ui_seilaplanDialog.py)
self.setupUi(self)
# Interaction with canvas, is used to draw onto map canvas
self.drawTool = ProfiletoolMapTool(self.canvas, self.draw, self.buttonShowProf)
# Connect emited signals
self.drawTool.sig_clearMap.connect(self.clearMap)
self.drawTool.sig_createProfile.connect(self.createProfile)
self.drawTool.sig_changeCoord.connect(self.changeLineCoordinates)
# Define some important paths and locations
self.userHomePath = os.path.join(os.path.expanduser('~'))
self.homePath = os.path.dirname(__file__)
# Config file 'params.txt' stores parameters of cable types
self.paramPath = os.path.join(self.homePath, 'config', 'params.txt')
# Config file 'commonPaths.txt' stores previous output folders
self.commonPathsFile = os.path.join(self.homePath, 'config',
'commonPaths.txt')
self.commonPaths, outputOpt = self.createCommonPathList()
# Get the preferences for output options
self.outputOpt = {'outputPath': self.commonPaths[-1], # last used output path
'report': outputOpt[0],
'plot': outputOpt[1],
'geodata': outputOpt[2],
'coords': outputOpt[3]}
self.projName = None
# Initialize cable parameters
self.param = None # All parameters of a certain cable type
self.paramOrder = None # Order of parameters
self.paramSet = None # Name of cable type
self.settingFields = {} # Dictionary of all GUI setting fields
# GUI fields and variables handling coordinate information
self.coordFields = {}
self.linePoints = {
'A': QgsPointXY(-100, -100),
'E': QgsPointXY(-100, -100)
}
self.azimut = 0
self.coordStateA = 'yellow'
self.coordStateE = 'yellow'
# Organize parameter GUI fields in dictionary
self.groupFields()
# Dictionary containing information about selected elevation model
self.dhm = {}
# User defined fixed intermediate support
self.fixStue = {}
# Dialog with explanatory images
self.imgBox = DialogWithImage(self.iface)
# Additional GIS-Layers
self.osmLyrButton.setEnabled(False)
self.contourLyrButton.setEnabled(False)
# Connect GUI elements from dialog window with functions
self.connectGuiElements()
# Set initial sate of some buttons
# Button to show profile
self.buttonShowProf.setEnabled(False)
# Button that activates drawing on map
self.draw.setEnabled(False)
# Button stays down when pressed
self.draw.setCheckable(True)
# Dialog window with height profile
self.profileWin = None
# Dialog windows with output options
self.optionWin = DialogOutputOptions(self.iface, self, self.outputOpt)
self.optionWin.fillInDropDown(self.commonPaths)
Processing.initialize()
QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
def __init__(self, iface):
self.iface = iface
Processing.initialize()
def convert(self):
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(False)
inputLayer = self.inputLayerCombo.currentText()
# layer information
layer = QgsVectorLayer(
unicode(inputLayer).encode('utf8'), inputLayer, "ogr")
vectorlayer_vector = layer.dataProvider()
# extent
extent_rect = vectorlayer_vector.extent()
xmin = extent_rect.xMinimum()
xmax = extent_rect.xMaximum()
ymin = extent_rect.yMinimum()
ymax = extent_rect.yMaximum()
extent = str(xmin) + "," + str(xmax) + "," + str(ymin) + "," + str(
ymax)
# attribute
Elevation = self.lineAttrib.currentText()
# cellsize
cellSize = int(self.linePix.value())
outPath = self.inputLayerCombo3.text()
# read fields and add a new column with the indexes
fields = layer.pendingFields()
new_field = QgsField("Indexes", QVariant.Double)
layer_new = vectorlayer_vector.addAttributes([new_field])
layer.updateFields()
newFieldIndex = vectorlayer_vector.fieldNameIndex(new_field.name())
allAttrs = vectorlayer_vector.attributeIndexes()
# editing the new column
numberRows = int(self.tableWidget.rowCount())
numberColumns = int(self.tableWidget.columnCount())
classes = ''
lista = []
for i in range(0, numberRows):
for j in range(0, numberColumns):
self.line = self.tableWidget.item(i, j)
lista = lista + [str(self.line.text())]
# list of description on tool table
lista_table = lista
field_names = [field.name() for field in fields]
n = len(field_names)
lista_attrib = []
for i in range(0, n):
f = field_names[i]
if f == str(Elevation):
number = i
for feat in layer.getFeatures():
attrb = feat.attributes()
attribute_read = attrb[number]
lista_attrib = lista_attrib + [str(attribute_read)]
# list of description on attribute table of shapefile
lista_attributes = lista_attrib
# obtain the indexes of the description of shapefile attribute table
description_common = set(lista_attributes).intersection(lista_table)
listDescription = list(description_common)
listElem = []
listElements = []
for j in range(0, len(listDescription)):
elem = lista_table.index(listDescription[j])
listElements = listElements + [elem]
elem_index = lista_table[int(elem + 1)]
listElem = listElem + [float(elem_index)]
for l in range(0, len(listElem)):
layer.startEditing()
exp = QgsExpression(str(listElem[l]))
exp.prepare(fields)
elemDescription = lista_table[listElements[l]]
for f in layer.getFeatures():
# get attributes of column defined by the user
attrb_elem = f[number]
if attrb_elem == elemDescription:
f[newFieldIndex] = exp.evaluate(f)
layer.updateFeature(f)
layer.commitChanges()
list_attrb_newField = []
for features in layer.getFeatures():
attrb_newField = features.attributes()
attrb_newField_read = attrb_newField[number + 1]
# update and read the new field
fieldsNew = layer.pendingFields()
field_names_new = [newField.name() for newField in fieldsNew]
parameter_indexes = field_names_new[newFieldIndex]
Processing.initialize()
soil = QFileInfo(
QgsApplication.qgisUserDbFilePath()).path() + "/soil.sdat"
Processing.runAlgorithm("grass7:v.to.rast.attribute", None, inputLayer,
0, parameter_indexes, extent, cellSize, -1,
0.0001, outPath)
# add result into canvas
file_info = QFileInfo(outPath)
if file_info.exists():
layer_name = file_info.baseName()
else:
return False
rlayer_new = QgsRasterLayer(outPath, layer_name)
if rlayer_new.isValid():
QgsMapLayerRegistry.instance().addMapLayer(rlayer_new)
layer = QgsMapCanvasLayer(rlayer_new)
layerList = [layer]
extent = self.iface.canvas.setExtent(rlayer_new.extent())
self.iface.canvas.setLayerSet(layerList)
self.iface.canvas.setVisible(True)
return True
else:
return False
QMessageBox.information(self, self.tr("Finished"),
self.tr("Aquifer media completed."))
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
