def load_vector_layer_from_parameter(self, name, parameters, context,
feedback):
"""
Creates a dedicated command to load a vector into the workspace.
:param name: name of the parameter
:param parameters: Parameters of the algorithm.
:param context: Processing context
"""
if Qgis.QGIS_VERSION_INT >= 30900 and hasattr(
self, 'parameterAsCompatibleSourceLayerPathAndLayerName'):
# requires qgis 3.10 or later!
ogr_data_path, layer_name = self.parameterAsCompatibleSourceLayerPathAndLayerName(
parameters,
name,
context,
QgsVectorFileWriter.supportedFormatExtensions(),
feedback=feedback)
if layer_name:
return self.r_templates.set_variable_vector(
name, QDir.fromNativeSeparators(ogr_data_path), layer_name)
return self.r_templates.set_variable_vector(
name, QDir.fromNativeSeparators(ogr_data_path))
ogr_data_path = self.parameterAsCompatibleSourceLayerPath(
parameters,
name,
context,
QgsVectorFileWriter.supportedFormatExtensions(),
feedback=feedback)
ogr_layer = QgsVectorLayer(ogr_data_path, '', 'ogr')
return self.load_vector_layer_command(name, ogr_layer, feedback)
def showPluginHelp(packageName: str = None,
filename: str = "index",
section: str = ""):
try:
source = ""
if packageName is None:
import inspect
source = inspect.currentframe().f_back.f_code.co_filename
else:
import sys
source = sys.modules[packageName].__file__
except:
return
path = os.path.dirname(source)
locale = str(QLocale().name())
helpfile = os.path.join(path, filename + "-" + locale + ".html")
if not os.path.exists(helpfile):
helpfile = os.path.join(
path, filename + "-" + locale.split("_")[0] + ".html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + "-en.html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + "-en_US.html")
if not os.path.exists(helpfile):
helpfile = os.path.join(path, filename + ".html")
if os.path.exists(helpfile):
url = "file://" + QDir.fromNativeSeparators(helpfile)
if section != "":
url = url + "#" + section
QDesktopServices.openUrl(QUrl(url, QUrl.TolerantMode))
def _set_selected_directory(self, txt_box, title):
def_path = txt_box.text()
sel_doc_path = QFileDialog.getExistingDirectory(self, title, def_path)
if sel_doc_path:
normalized_path = QDir.fromNativeSeparators(sel_doc_path)
txt_box.clear()
txt_box.setText(normalized_path)
def load_vector_layer_command(self, name, layer, _):
"""
Creates a command to load a vector layer into the workspace
"""
source_parts = QgsProviderRegistry.instance().decodeUri(
'ogr', layer.source())
file_path = source_parts.get('path')
if self.pass_file_names:
return self.r_templates.set_variable_string(
name, QDir.fromNativeSeparators(file_path))
layer_name = source_parts.get('layerName')
if layer_name:
return self.r_templates.set_variable_vector(
name, QDir.fromNativeSeparators(file_path), layer=layer_name)
# no layer name -- readOGR expects the folder, with the filename as layer
return self.r_templates.set_variable_vector(
name, QDir.fromNativeSeparators(file_path))
def load_vector_layer_command(self, name, layer, _):
"""
Creates a command to load a vector layer into the workspace
"""
source_parts = QgsProviderRegistry.instance().decodeUri(
'ogr', layer.source())
file_path = source_parts.get('path')
if self.pass_file_names:
return '{}="{}"'.format(name, QDir.fromNativeSeparators(file_path))
layer_name = source_parts.get('layerName')
if layer_name:
# eg geopackage source
return '{}=readOGR("{}",layer="{}")'.format(
name, QDir.fromNativeSeparators(file_path), layer_name)
# no layer name -- readOGR expects the folder, with the filename as layer
folder, file_name = os.path.split(file_path)
base_name, _ = os.path.splitext(file_name)
return '{}=readOGR("{}",layer="{}")'.format(
name, QDir.fromNativeSeparators(folder), base_name)
def _load_source_document_directory_selector(self):
# Load file dialog for selecting source documents directory
title = self.tr('Select Source Document Directory')
def_path = self.txtRootFolder.text()
# Use the last set source document directory
if not def_path:
def_path = last_document_path()
sel_doc_path = QFileDialog.getExistingDirectory(self, title, def_path)
if sel_doc_path:
normalized_path = QDir.fromNativeSeparators(sel_doc_path)
self.txtRootFolder.clear()
self.txtRootFolder.setText(normalized_path)
def build_raster_layer_import_command(self, variable_name, layer):
"""
Returns an import command for the specified raster layer, storing it in a variable
"""
if layer is None:
return self.r_templates.set_variable_null(variable_name)
if layer.dataProvider().name() != 'gdal':
raise QgsProcessingException(
self.
tr("Layer {} is not a GDAL layer. Currently only GDAL based raster layers are supported."
).format(variable_name))
path = QgsProviderRegistry.instance().decodeUri(
layer.dataProvider().name(), layer.source())['path']
value = QDir.fromNativeSeparators(path)
if self.pass_file_names:
return self.r_templates.set_variable_string(variable_name, value)
return self.r_templates.set_variable_raster(variable_name, value)
def build_import_commands(
self, # pylint: disable=too-many-locals,too-many-branches,too-many-statements
parameters,
context,
feedback):
"""
Builds the set of input commands for the algorithm
"""
commands = list()
for param in self.parameterDefinitions():
if param.isDestination():
continue
if param.name(
) not in parameters or parameters[param.name()] is None:
commands.append(
self.r_templates.set_variable_null(param.name()))
continue
if isinstance(param, QgsProcessingParameterRasterLayer):
rl = self.parameterAsRasterLayer(parameters, param.name(),
context)
commands.append(
self.build_raster_layer_import_command(param.name(), rl))
elif isinstance(param, QgsProcessingParameterVectorLayer):
commands.append(
self.load_vector_layer_from_parameter(
param.name(), parameters, context, feedback))
elif isinstance(param, QgsProcessingParameterFeatureSource):
commands.append(
self.load_vector_layer_from_parameter(
param.name(), parameters, context, feedback))
elif isinstance(param, QgsProcessingParameterExtent):
extent = self.parameterAsExtent(parameters, param.name(),
context)
# Extent from raster package is "xmin, xmax, ymin, ymax" like in Processing
# http://www.inside-r.org/packages/cran/raster/docs/Extent
commands.append(
self.r_templates.set_variable_extent(
param.name(), extent.xMinimum(), extent.xMaximum(),
extent.yMinimum(), extent.yMaximum()))
elif isinstance(param, QgsProcessingParameterCrs):
crs = self.parameterAsCrs(parameters, param.name(), context)
if crs.isValid():
commands.append(
self.r_templates.set_variable_string(
param.name(), crs.authid()))
else:
commands.append(
self.r_templates.set_variable_null(param.name()))
elif isinstance(param, QgsProcessingParameterFile):
value = self.parameterAsString(parameters, param.name(),
context)
commands.append(
self.r_templates.set_variable_string(
param.name(), QDir.fromNativeSeparators(value)))
elif isinstance(param, QgsProcessingParameterString):
value = self.parameterAsString(parameters, param.name(),
context)
commands.append(
self.r_templates.set_variable_string(param.name(), value))
elif isinstance(param, QgsProcessingParameterField):
if param.allowMultiple():
value = self.parameterAsFields(parameters, param.name(),
context)
commands.append(
self.r_templates.set_variable_string_list(
param.name(), value))
else:
value = self.parameterAsString(parameters, param.name(),
context)
commands.append(
self.r_templates.set_variable_string(
param.name(), value))
elif isinstance(param, QgsProcessingParameterNumber):
value = self.parameterAsDouble(parameters, param.name(),
context)
commands.append(
self.r_templates.set_variable_directly(
param.name(), value))
elif isinstance(param, QgsProcessingParameterEnum):
value = self.parameterAsEnum(parameters, param.name(), context)
if self.r_templates.is_literal_enum(param.name()):
enum_values = self.parameterDefinition(
param.name()).options()
commands.append(
self.r_templates.set_variable_enum_value(
param.name(), value, enum_values))
else:
commands.append(
self.r_templates.set_variable_directly(
param.name(), value))
elif isinstance(param, QgsProcessingParameterBoolean):
value = self.parameterAsBool(parameters, param.name(), context)
value = 'TRUE' if value else 'FALSE'
commands.append(
self.r_templates.set_variable_directly(
param.name(), value))
elif isinstance(param, QgsProcessingParameterMultipleLayers):
layer_idx = 0
layers = self.parameterAsLayerList(parameters, param.name(),
context)
if param.layerType() == QgsProcessing.TypeRaster:
for layer in layers:
variable_name = 'tempvar{}'.format(layer_idx)
commands.append(
self.build_raster_layer_import_command(
variable_name, layer))
layer_idx += 1
else:
for layer in layers:
variable_name = 'tempvar{}'.format(layer_idx)
commands.append(
self.build_vector_layer_import_command(
variable_name, layer, context, feedback))
layer_idx += 1
s = ''
s += param.name()
s += ' = c('
layer_idx = 0
for _ in layers:
if layer_idx != 0:
s += ','
s += 'tempvar{}'.format(layer_idx)
layer_idx += 1
s += ')'
commands.append(s)
# folder, file/html output paths
for param in self.destinationParameterDefinitions():
if isinstance(param, QgsProcessingParameterFolderDestination):
folder = self.parameterAsString(parameters, param.name(),
context)
Path(folder).mkdir(parents=True, exist_ok=True)
commands.append(
self.r_templates.set_variable_string(
param.name(), QDir.fromNativeSeparators(folder)))
self.save_output_values = True
elif isinstance(param, QgsProcessingParameterFileDestination):
filename = self.parameterAsFileOutput(parameters, param.name(),
context)
Path(filename).parent.mkdir(parents=True, exist_ok=True)
commands.append(
self.r_templates.set_variable_string(
param.name(), QDir.fromNativeSeparators(filename)))
self.save_output_values = True
if self.show_plots:
html_filename = self.parameterAsFileOutput(parameters,
RAlgorithm.RPLOTS,
context)
path, _ = os.path.splitext(html_filename)
self.plots_filename = path + '.png'
self.plots_filename = self.plots_filename.replace('\\', '/')
commands.append(self.r_templates.create_png(self.plots_filename))
return commands
def __init__(
self,
xml_uri=None,
is_remote: bool = False,
attributes={},
geometry_mapping=None,
output_filename=None,
parent=None,
):
"""Constructor."""
super(CreationDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
# populate widgets if passed at the construction
self.replaceLayerChck.setEnabled(xml_uri is not None)
if xml_uri is not None:
if is_remote:
self.urlText.setText(xml_uri)
self.urlRadio.setChecked(True)
else:
self.filenameText.setText(QDir.fromNativeSeparators(xml_uri))
self.filenameRadio.setChecked(True)
self.replaceLayerChck.setCheckState(Qt.Checked)
for aname, v in attributes.items():
xpath, type = v
self.onAddMapping() # add a row
last = self.attributeTable.rowCount() - 1
self.attributeTable.item(last, 0).setText(aname)
self.attributeTable.cellWidget(last, 1).setCurrentIndex([
QVariant.String,
QVariant.Int,
QVariant.Double,
QVariant.DateTime,
].index(type))
self.attributeTable.item(last, 2).setText(xpath)
self.geometryColumnCheck.setChecked(True)
self.geometryColumnEdit.setText(geometry_mapping)
self.outFilenameText.setText(
QDir.fromNativeSeparators(output_filename))
else:
# new dialog
is_remote = (QSettings("complex_features").value(
"is_remote", "false") == "true")
source_url = QSettings("complex_features").value("source_url", "")
if is_remote:
self.urlRadio.setChecked(True)
self.urlText.setText(source_url)
else:
self.filenameRadio.setChecked(True)
self.filenameText.setText(
QDir.fromNativeSeparators(source_url))
# output file name
import tempfile
f = tempfile.NamedTemporaryFile()
self.outFilenameText.setText(QDir.fromNativeSeparators(f.name))
f.close()
import_type = int(
QSettings("complex_features").value("import_type", "0"))
self.mImportTypeCombo.setCurrentIndex(import_type)
self.mStackedWidgets.setCurrentIndex(import_type)
self.browseButton.clicked.connect(self.onBrowse)
self.addMappingBtn.clicked.connect(self.onAddMapping)
self.removeMappingBtn.clicked.connect(self.onRemoveMapping)
self.attributeTable.selectionModel().selectionChanged.connect(
self.onSelectMapping)
self.browseOutButton.clicked.connect(self.onBrowseOut)
