def exportVectorLayer(layer, supported=None):
"""Takes a QgsVectorLayer and returns the filename to refer to it,
which allows external apps which support only file-based layers to
use it. It performs the necessary export in case the input layer
is not in a standard format suitable for most applications, it is
a remote one or db-based (non-file based) one, or if there is a
selection and it should be used, exporting just the selected
features.
Currently, the output is restricted to shapefiles, so anything
that is not in a shapefile will get exported. It also export to
a new file if the original one contains non-ascii characters.
"""
supported = supported or ["shp"]
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
filename = os.path.basename(unicode(layer.source()))
idx = filename.rfind('.')
if idx != -1:
filename = filename[:idx]
filename = unicode(layer.name())
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
filename = ''.join(c for c in filename if c in validChars)
if len(filename) == 0:
filename = 'layer'
output = getTempFilenameInTempFolder(filename + '.shp')
provider = layer.dataProvider()
useSelection = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
if useSelection and layer.selectedFeatureCount() != 0:
writer = QgsVectorFileWriter(output, systemEncoding,
layer.pendingFields(),
provider.geometryType(), layer.crs())
selection = layer.selectedFeatures()
for feat in selection:
writer.addFeature(feat)
del writer
return output
else:
isASCII = True
try:
unicode(layer.source()).decode('ascii')
except UnicodeEncodeError:
isASCII = False
if not os.path.splitext()[1].lower() in supported or not isASCII:
writer = QgsVectorFileWriter(
output, systemEncoding,
layer.pendingFields(), provider.geometryType(),
layer.crs()
)
for feat in layer.getFeatures():
writer.addFeature(feat)
del writer
return output
else:
return unicode(layer.source())
def exportVectorLayer(layer):
"""Takes a QgsVectorLayer and returns the filename to refer to it,
which allows external apps which support only file-based layers to
use it. It performs the necessary export in case the input layer
is not in a standard format suitable for most applications, it is
a remote one or db-based (non-file based) one, or if there is a
selection and it should be used, exporting just the selected
features.
Currently, the output is restricted to shapefiles, so anything
that is not in a shapefile will get exported. It also export to
a new file if the original one contains non-ascii characters.
"""
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
filename = os.path.basename(unicode(layer.source()))
idx = filename.rfind('.')
if idx != -1:
filename = filename[:idx]
filename = unicode(layer.name())
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
filename = ''.join(c for c in filename if c in validChars)
if len(filename) == 0:
filename = 'layer'
output = getTempFilenameInTempFolder(filename + '.shp')
provider = layer.dataProvider()
useSelection = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
if useSelection and layer.selectedFeatureCount() != 0:
writer = QgsVectorFileWriter(output, systemEncoding,
layer.pendingFields(),
provider.geometryType(), layer.crs())
selection = layer.selectedFeatures()
for feat in selection:
writer.addFeature(feat)
del writer
return output
else:
isASCII = True
try:
unicode(layer.source()).decode('ascii')
except UnicodeEncodeError:
isASCII = False
if not unicode(layer.source()).endswith('shp') or not isASCII:
writer = QgsVectorFileWriter(
output, systemEncoding,
layer.pendingFields(), provider.geometryType(),
layer.crs()
)
for feat in layer.getFeatures():
writer.addFeature(feat)
del writer
return output
else:
return unicode(layer.source())
def exportVectorLayer(layer, supported=None):
"""Takes a QgsVectorLayer and returns the filename to refer to it,
which allows external apps which support only file-based layers to
use it. It performs the necessary export in case the input layer
is not in a standard format suitable for most applications, it is
a remote one or db-based (non-file based) one, or if there is a
selection and it should be used, exporting just the selected
features.
Currently, the output is restricted to shapefiles, so anything
that is not in a shapefile will get exported. It also export to
a new file if the original one contains non-ascii characters.
"""
supported = supported or ["shp"]
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
output = getTempFilename('shp')
basename = removeInvalidChars(os.path.basename(layer.source()))
if basename:
if not basename.endswith("shp"):
basename = basename + ".shp"
output = getTempFilenameInTempFolder(basename)
else:
output = getTempFilename("shp")
provider = layer.dataProvider()
useSelection = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
if useSelection and layer.selectedFeatureCount() != 0:
writer = QgsVectorFileWriter(output, systemEncoding,
layer.fields(),
layer.wkbType(), layer.crs())
selection = layer.selectedFeatures()
for feat in selection:
writer.addFeature(feat)
del writer
return output
else:
isASCII = True
try:
str(layer.source()).decode('ascii')
except UnicodeEncodeError:
isASCII = False
if not os.path.splitext(layer.source())[1].lower() in supported or not isASCII:
writer = QgsVectorFileWriter(
output, systemEncoding,
layer.fields(), layer.wkbType(),
layer.crs()
)
for feat in layer.getFeatures():
writer.addFeature(feat)
del writer
return output
else:
return str(layer.source())
def exportVectorLayer(layer, supported=None):
"""Takes a QgsVectorLayer and returns the filename to refer to it,
which allows external apps which support only file-based layers to
use it. It performs the necessary export in case the input layer
is not in a standard format suitable for most applications, it is
a remote one or db-based (non-file based) one, or if there is a
selection and it should be used, exporting just the selected
features.
Currently, the output is restricted to shapefiles, so anything
that is not in a shapefile will get exported. It also export to
a new file if the original one contains non-ascii characters.
"""
supported = supported or ["shp"]
settings = QSettings()
systemEncoding = settings.value('/UI/encoding', 'System')
output = getTempFilename('shp')
basename = removeInvalidChars(os.path.basename(layer.source()))
if basename:
if not basename.endswith("shp"):
basename = basename + ".shp"
output = getTempFilenameInTempFolder(basename)
else:
output = getTempFilename("shp")
provider = layer.dataProvider()
useSelection = ProcessingConfig.getSetting(ProcessingConfig.USE_SELECTED)
if useSelection and layer.selectedFeatureCount() != 0:
writer = QgsVectorFileWriter(output, systemEncoding,
layer.fields(),
layer.wkbType(), layer.crs())
selection = layer.selectedFeatures()
for feat in selection:
writer.addFeature(feat)
del writer
return output
else:
isASCII = True
try:
str(layer.source())
except UnicodeEncodeError:
isASCII = False
if not os.path.splitext(layer.source())[1].lower() in supported or not isASCII:
writer = QgsVectorFileWriter(
output, systemEncoding,
layer.fields(), layer.wkbType(),
layer.crs()
)
for feat in layer.getFeatures():
writer.addFeature(feat)
del writer
return output
else:
return str(layer.source())
def getCompatibleFileName(self, alg):
"""Returns a filename that is compatible with the algorithm
that is going to generate this output.
If the algorithm supports the file format of the current
output value, it returns that value. If not, it returns a
temporary file with a supported file format, to be used to
generate the output result.
"""
ext = self.value[self.value.rfind('.') + 1:]
if ext in self.getSupportedOutputVectorLayerExtensions():
return self.value
else:
if self.compatible is None:
self.compatible = getTempFilenameInTempFolder(
self.name + '.' + self.getDefaultFileExtension(alg))
return self.compatible
def getCompatibleFileName(self, alg):
"""Returns a filename that is compatible with the algorithm
that is going to generate this output.
If the algorithm supports the file format of the current
output value, it returns that value. If not, it returns a
temporary file with a supported file format, to be used to
generate the output result.
"""
ext = self.value[self.value.rfind('.') + 1:]
if ext in alg.provider.getSupportedOutputVectorLayerExtensions():
return self.value
else:
if self.compatible is None:
self.compatible = getTempFilenameInTempFolder(
self.name + '.' + self.getDefaultFileExtension(alg))
return self.compatible
def exportRasterLayer(self, source):
global sessionExportedLayers
if source in sessionExportedLayers:
self.exportedLayers[source] = sessionExportedLayers[source]
return None
fileName = os.path.basename(source)
validChars = \
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
fileName = ''.join(c for c in fileName if c in validChars)
if len(fileName) == 0:
fileName = 'layer'
destFilename = system.getTempFilenameInTempFolder(fileName + '.asc')
self.exportedLayers[source] = destFilename
sessionExportedLayers[source] = destFilename
return 'gdal_translate -of AAIGrid %s %s' % (source, destFilename)
def executeRAlgorithm(alg, progress):
# generate new R script file name in a temp folder
RUtils.rscriptfilename = getTempFilenameInTempFolder('processing_script.r')
# run commands
RUtils.verboseCommands = alg.getVerboseCommands()
RUtils.createRScriptFromRCommands(alg.getFullSetOfRCommands())
if isWindows():
if ProcessingConfig.getSetting(RUtils.R_USE64):
execDir = 'x64'
else:
execDir = 'i386'
command = [
RUtils.RFolder() + os.sep + 'bin' + os.sep + execDir + os.sep
+ 'R.exe',
'CMD',
'BATCH',
'--vanilla',
RUtils.getRScriptFilename(),
RUtils.getConsoleOutputFilename()
]
else:
os.chmod(RUtils.getRScriptFilename(), stat.S_IEXEC | stat.S_IREAD
| stat.S_IWRITE)
command = 'R CMD BATCH --vanilla ' + RUtils.getRScriptFilename() \
+ ' ' + RUtils.getConsoleOutputFilename()
proc = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=open(os.devnull),
stderr=subprocess.STDOUT,
universal_newlines=True,
)
proc.wait()
RUtils.createConsoleOutput()
loglines = []
loglines.append(RUtils.tr('R execution console output'))
loglines += RUtils.allConsoleResults
for line in loglines:
progress.setConsoleInfo(line)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
def executeRAlgorithm(alg, feedback):
# generate new R script file name in a temp folder
RUtils.rscriptfilename = getTempFilenameInTempFolder('processing_script.r')
# run commands
RUtils.verboseCommands = alg.getVerboseCommands()
RUtils.createRScriptFromRCommands(alg.getFullSetOfRCommands())
if isWindows():
if ProcessingConfig.getSetting(RUtils.R_USE64):
execDir = 'x64'
else:
execDir = 'i386'
command = [
os.path.join(RUtils.RFolder(), 'bin', execDir, 'R.exe'),
'CMD',
'BATCH',
'--vanilla',
RUtils.getRScriptFilename(),
RUtils.getConsoleOutputFilename()
]
else:
os.chmod(RUtils.getRScriptFilename(), stat.S_IEXEC | stat.S_IREAD
| stat.S_IWRITE)
command = 'R CMD BATCH --vanilla ' + RUtils.getRScriptFilename() \
+ ' ' + RUtils.getConsoleOutputFilename()
proc = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
)
proc.wait()
RUtils.createConsoleOutput()
loglines = []
loglines.append(RUtils.tr('R execution console output'))
loglines += RUtils.allConsoleResults
for line in loglines:
feedback.pushConsoleInfo(line)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
def getCompatibleFileName(self, alg):
"""
Returns a filename that is compatible with the algorithm
that is going to generate this output. If the algorithm
supports the file format of the current output value, it
returns that value. If not, it returns a temporary file with
a supported file format, to be used to generate the output
result.
"""
ext = self.value[self.value.rfind('.') + 1:]
if ext in alg.provider.getSupportedOutputRasterLayerExtensions():
return self.value
else:
if self.compatible is None:
supported = alg.provider.getSupportedOutputRasterLayerExtensions()
default = ProcessingConfig.getSetting(ProcessingConfig.DEFAULT_OUTPUT_RASTER_LAYER_EXT)
ext = default if default in supported else supported[0]
self.compatible = getTempFilenameInTempFolder(self.name + '.' + ext)
return self.compatible
def getCompatibleFileName(self, alg):
"""
Returns a filename that is compatible with the algorithm
that is going to generate this output. If the algorithm
supports the file format of the current output value, it
returns that value. If not, it returns a temporary file with
a supported file format, to be used to generate the output
result.
"""
ext = self.value[self.value.rfind('.') + 1:]
if ext in alg.provider.getSupportedOutputRasterLayerExtensions():
return self.value
else:
if self.compatible is None:
supported = alg.provider.getSupportedOutputRasterLayerExtensions()
default = ProcessingConfig.getSetting(ProcessingConfig.DEFAULT_OUTPUT_RASTER_LAYER_EXT)
ext = default if default in supported else supported[0]
self.compatible = getTempFilenameInTempFolder(self.name + '.' + ext)
return self.compatible
def executeRAlgorithm(alg, feedback):
# generate new R script file name in a temp folder
RUtils.rscriptfilename = getTempFilenameInTempFolder("processing_script.r")
# run commands
RUtils.verboseCommands = alg.getVerboseCommands()
RUtils.createRScriptFromRCommands(alg.getFullSetOfRCommands())
if isWindows():
if ProcessingConfig.getSetting(RUtils.R_USE64):
execDir = "x64"
else:
execDir = "i386"
command = [
os.path.join(RUtils.RFolder(), "bin", execDir, "R.exe"),
"CMD",
"BATCH",
"--vanilla",
RUtils.getRScriptFilename(),
RUtils.getConsoleOutputFilename(),
]
else:
os.chmod(RUtils.getRScriptFilename(), stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE)
command = "R CMD BATCH --vanilla " + RUtils.getRScriptFilename() + " " + RUtils.getConsoleOutputFilename()
proc = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
)
proc.wait()
RUtils.createConsoleOutput()
loglines = []
loglines.append(RUtils.tr("R execution console output"))
loglines += RUtils.allConsoleResults
for line in loglines:
feedback.pushConsoleInfo(line)
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
def exportRasterLayer(self, source):
global sessionExportedLayers
if source in sessionExportedLayers:
exportedLayer = sessionExportedLayers[source]
if os.path.exists(exportedLayer):
self.exportedLayers[source] = exportedLayer
return None
else:
del sessionExportedLayers[source]
layer = dataobjects.getObjectFromUri(source, False)
if layer:
filename = str(layer.name())
else:
filename = os.path.basename(source)
validChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
filename = ''.join(c for c in filename if c in validChars)
if len(filename) == 0:
filename = 'layer'
destFilename = getTempFilenameInTempFolder(filename + '.sgrd')
self.exportedLayers[source] = destFilename
sessionExportedLayers[source] = destFilename
return 'io_gdal 0 -TRANSFORM -INTERPOL 0 -GRIDS "' + destFilename + '" -FILES "' + source + '"'
def exportRasterLayer(self, source):
global sessionExportedLayers
if source in sessionExportedLayers:
exportedLayer = sessionExportedLayers[source]
if os.path.exists(exportedLayer):
self.exportedLayers[source] = exportedLayer
return None
else:
del sessionExportedLayers[source]
layer = dataobjects.getObjectFromUri(source, False)
if layer:
filename = layer.name()
else:
filename = os.path.basename(source)
validChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
filename = ''.join(c for c in filename if c in validChars)
if len(filename) == 0:
filename = 'layer'
destFilename = getTempFilenameInTempFolder(filename + '.sgrd')
self.exportedLayers[source] = destFilename
sessionExportedLayers[source] = destFilename
return 'io_gdal 0 -TRANSFORM 1 -INTERPOL 0 -GRIDS "' + destFilename + '" -FILES "' + source + '"'
def exportRasterLayer(self, source):
global sessionExportedLayers
context = dataobjects.createContext()
if source in sessionExportedLayers:
exportedLayer = sessionExportedLayers[source]
if os.path.exists(exportedLayer):
self.exportedLayers[source] = exportedLayer
return None
else:
del sessionExportedLayers[source]
layer = QgsProcessingUtils.mapLayerFromString(source, context, False)
if layer:
filename = str(layer.name())
else:
filename = os.path.basename(source)
validChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
filename = ''.join(c for c in filename if c in validChars)
if len(filename) == 0:
filename = 'layer'
destFilename = getTempFilenameInTempFolder(filename + '.sgrd')
self.exportedLayers[source] = destFilename
sessionExportedLayers[source] = destFilename
return 'io_gdal 0 -TRANSFORM 1 -RESAMPLING 0 -GRIDS "' + destFilename + '" -FILES "' + source + '"'
def exportRasterLayer(self, source):
global sessionExportedLayers
context = dataobjects.createContext()
if source in sessionExportedLayers:
exportedLayer = sessionExportedLayers[source]
if os.path.exists(exportedLayer):
self.exportedLayers[source] = exportedLayer
return None
else:
del sessionExportedLayers[source]
layer = QgsProcessingUtils.mapLayerFromString(source, context, False)
if layer:
filename = str(layer.name())
else:
filename = os.path.basename(source)
validChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
filename = ''.join(c for c in filename if c in validChars)
if len(filename) == 0:
filename = 'layer'
destFilename = getTempFilenameInTempFolder(filename + '.sgrd')
self.exportedLayers[source] = destFilename
sessionExportedLayers[source] = destFilename
return 'io_gdal 0 -TRANSFORM 1 -RESAMPLING 0 -GRIDS "' + destFilename + '" -FILES "' + source + '"'
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
if output.value == '':
ext = output.getDefaultFileExtension(self)
output.value = system.getTempFilenameInTempFolder(
output.name + '.' + ext)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(),
layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
# add layer to registry to fix https://issues.qgis.org/issues/17300
# it is necessary only for aggregate expressions that verify that layer
# is registered
removeRegistryAfterEvaluation = False
if not QgsMapLayerRegistry.instance().mapLayer(layer.id()):
removeRegistryAfterEvaluation = True
QgsMapLayerRegistry.instance().addMapLayer(layer, addToLegend=False)
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features) if len(features) > 0 else 1
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
progress.setPercentage(int(current * total))
del writer
# remove from registry if added for expression requirement
# see above comment about fix #17300
if removeRegistryAfterEvaluation:
QgsMapLayerRegistry.instance().removeMapLayer(layer)
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
def _resolveTemporary(self, alg):
ext = self.getDefaultFileExtension()
return getTempFilenameInTempFolder(self.name + '.' + ext)
def _resolveTemporary(self, alg):
if alg.provider.supportsNonFileBasedOutput():
return "memory:"
else:
ext = self.getDefaultFileExtension()
return getTempFilenameInTempFolder(self.name + '.' + ext)
def run_blur(self):
self.progressBar_blur.setValue(0)
self.label_progress.setText('')
# Get all the fields.
layer_to_blur = self.comboBox_layerToBlur.currentLayer()
radius = self.spinBox_radius.value()
display = self.checkBox_addToMap.isChecked()
selected_features_only = self.checkBox_selectedOnlyFeatures.isChecked()
file_name = self.lineEdit_outputFile.text()
export_radius = self.checkBox_exportRadius.isChecked()
export_centroid = self.checkBox_exportCentroid.isChecked()
if self.checkBox_envelope.isChecked():
layer_envelope = self.comboBox_envelope.currentLayer()
else:
layer_envelope = None
# Test values
try:
if not layer_to_blur:
raise NoLayerProvidedException
if not file_name and not display:
raise NoFileNoDisplayException
if layer_to_blur.crs().mapUnits() != 0:
msg = tr('The projection of the map or of the layer is not '
'in meters. These parameters should be in meters.')
display_message_bar(msg,
level=QgsMessageBar.WARNING,
duration=5)
if not file_name:
file_name = getTempFilenameInTempFolder('blurring.shp')
if layer_envelope:
if layer_to_blur.crs() != layer_envelope.crs():
raise DifferentCrsException(
epsg1=layer_to_blur.crs().authid(),
epsg2=layer_envelope.crs().authid())
self.label_progress.setText('Creating index ...')
layer_envelope = LayerIndex(layer_envelope)
self.progressBar_blur.setValue(0)
self.label_progress.setText('Blurring ...')
if selected_features_only:
features = layer_to_blur.selectedFeatures()
nb_features = layer_to_blur.selectedFeatureCount()
else:
features = layer_to_blur.getFeatures()
nb_features = layer_to_blur.featureCount()
# Fields
fields = layer_to_blur.pendingFields()
if export_radius:
fields.append(QgsField(u"Radius", QVariant.Int))
if export_centroid:
fields.append(QgsField(u"X centroid", QVariant.Int))
fields.append(QgsField(u"Y centroid", QVariant.Int))
# Creating the output shapefile
file_writer = QgsVectorFileWriter(file_name, 'utf-8', fields,
QGis.WKBPolygon,
layer_to_blur.crs(),
'ESRI Shapefile')
if file_writer.hasError() != QgsVectorFileWriter.NoError:
raise CreatingShapeFileException(suffix=file_writer.hasError())
# Creating the algorithm with radius
algo = Blur(radius, layer_envelope, export_radius, export_centroid)
for j, feature in enumerate(features):
feature = algo.blur(feature)
file_writer.addFeature(feature)
# Update progress bar
percent = int((j + 1) * 100 / nb_features)
self.progressBar_blur.setValue(percent)
# Write all features in the file
del file_writer
if display:
old_default_projection = self.settings.value(
'/Projections/defaultBehaviour')
self.settings.setValue('/Projections/defaultBehaviour',
'useProject')
layer_name = basename(file_name)
new_layer = QgsVectorLayer(file_name, layer_name, 'ogr')
new_layer.commitChanges()
new_layer.clearCacheImage()
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayers([new_layer])
self.settings.setValue('/Projections/defaultBehaviour',
old_default_projection)
msg = tr('Successful export in %s' % file_name)
iface.messageBar().pushMessage(msg,
level=QgsMessageBar.INFO,
duration=5)
self.signalAskCloseWindow.emit()
except GeoHealthException, e:
self.label_progress.setText('')
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
def _resolveTemporary(self, alg):
ext = self.getDefaultFileExtension()
return getTempFilenameInTempFolder(self.name + '.' + ext)
def _resolveTemporary(self, alg):
if alg.provider.supportsNonFileBasedOutput():
return "memory:"
else:
ext = self.getDefaultFileExtension()
return getTempFilenameInTempFolder(self.name + '.' + ext)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
if output.value == '':
ext = output.getDefaultFileExtension(self)
output.value = system.getTempFilenameInTempFolder(output.name +
'.' + ext)
provider = layer.dataProvider()
fields = layer.pendingFields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, provider.geometryType(),
layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
canvas = iface.mapCanvas()
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
if not exp.prepare(layer.pendingFields()):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
current = 0
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp.setCurrentRowNumber(rownum)
value = exp.evaluate(f)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
progress.setPercentage(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occured while evaluating the calculation '
'string:\n%s' % error))
def run_blur(self):
self.progressBar_blur.setValue(0)
self.label_progress.setText('')
# Get all the fields.
layer_to_blur = self.comboBox_layerToBlur.currentLayer()
radius = self.spinBox_radius.value()
display = self.checkBox_addToMap.isChecked()
selected_features_only = self.checkBox_selectedOnlyFeatures.isChecked()
file_name = self.lineEdit_outputFile.text()
export_radius = self.checkBox_exportRadius.isChecked()
export_centroid = self.checkBox_exportCentroid.isChecked()
if self.checkBox_envelope.isChecked():
layer_envelope = self.comboBox_envelope.currentLayer()
else:
layer_envelope = None
# Test values
try:
if not layer_to_blur:
raise NoLayerProvidedException
if not file_name and not display:
raise NoFileNoDisplayException
if layer_to_blur.crs().mapUnits() != 0:
msg = tr('The projection of the map or of the layer is not '
'in meters. These parameters should be in meters.')
display_message_bar(
msg, level=QgsMessageBar.WARNING, duration=5)
if not file_name:
file_name = getTempFilenameInTempFolder('blurring.shp')
pass
if layer_envelope:
if layer_to_blur.crs() != layer_envelope.crs():
raise DifferentCrsException(
epsg1=layer_to_blur.crs().authid(),
epsg2=layer_envelope.crs().authid())
self.label_progress.setText('Creating index ...')
layer_envelope = LayerIndex(layer_envelope)
self.progressBar_blur.setValue(0)
self.label_progress.setText('Blurring ...')
if selected_features_only:
features = layer_to_blur.selectedFeatures()
nb_features = layer_to_blur.selectedFeatureCount()
else:
features = layer_to_blur.getFeatures()
nb_features = layer_to_blur.featureCount()
# Fields
fields = layer_to_blur.pendingFields()
if export_radius:
fields.append(QgsField(u"Radius", QVariant.Int))
if export_centroid:
fields.append(QgsField(u"X centroid", QVariant.Int))
fields.append(QgsField(u"Y centroid", QVariant.Int))
# Creating the output shapefile
file_writer = QgsVectorFileWriter(
file_name,
'utf-8',
fields,
QGis.WKBPolygon,
layer_to_blur.crs(),
'ESRI Shapefile')
if file_writer.hasError() != QgsVectorFileWriter.NoError:
raise CreatingShapeFileException(suffix=file_writer.hasError())
# Creating the algorithm with radius
algo = Blur(radius, layer_envelope, export_radius, export_centroid)
for j, feature in enumerate(features):
feature = algo.blur(feature)
file_writer.addFeature(feature)
# Update progress bar
percent = int((j + 1) * 100 / nb_features)
self.progressBar_blur.setValue(percent)
# Write all features in the file
del file_writer
if display:
old_default_projection = self.settings.value(
'/Projections/defaultBehaviour')
self.settings.setValue(
'/Projections/defaultBehaviour', 'useProject')
layer_name = basename(file_name)
new_layer = QgsVectorLayer(file_name, layer_name, 'ogr')
new_layer.commitChanges()
new_layer.clearCacheImage()
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().addMapLayers([new_layer])
self.settings.setValue(
'/Projections/defaultBehaviour', old_default_projection)
msg = tr('Successful export in %s' % file_name)
iface.messageBar().pushMessage(
msg, level=QgsMessageBar.INFO, duration=5)
self.signalAskCloseWindow.emit()
except GeoPublicHealthException, e:
self.label_progress.setText('')
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
if output.value == '':
ext = output.getDefaultFileExtension(self)
output.value = system.getTempFilenameInTempFolder(
output.name + '.' + ext)
provider = layer.dataProvider()
fields = layer.pendingFields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, provider.geometryType(),
layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
if not exp.prepare(layer.pendingFields()):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features)
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp.setCurrentRowNumber(rownum)
value = exp.evaluate(f)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
progress.setPercentage(int(current * total))
del writer
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.FIELD_NAME)
fieldType = self.TYPES[self.getParameterValue(self.FIELD_TYPE)]
width = self.getParameterValue(self.FIELD_LENGTH)
precision = self.getParameterValue(self.FIELD_PRECISION)
newField = self.getParameterValue(self.NEW_FIELD)
formula = self.getParameterValue(self.FORMULA)
output = self.getOutputFromName(self.OUTPUT_LAYER)
if output.value == '':
ext = output.getDefaultFileExtension(self)
output.value = system.getTempFilenameInTempFolder(output.name +
'.' + ext)
fields = layer.fields()
if newField:
fields.append(QgsField(fieldName, fieldType, '', width, precision))
writer = output.getVectorWriter(fields, layer.wkbType(), layer.crs())
exp = QgsExpression(formula)
da = QgsDistanceArea()
da.setSourceCrs(layer.crs().srsid())
da.setEllipsoidalMode(
iface.mapCanvas().mapSettings().hasCrsTransformEnabled())
da.setEllipsoid(QgsProject.instance().readEntry(
'Measure', '/Ellipsoid', GEO_NONE)[0])
exp.setGeomCalculator(da)
exp.setDistanceUnits(QgsProject.instance().distanceUnits())
exp.setAreaUnits(QgsProject.instance().areaUnits())
exp_context = QgsExpressionContext()
exp_context.appendScope(QgsExpressionContextUtils.globalScope())
exp_context.appendScope(QgsExpressionContextUtils.projectScope())
exp_context.appendScope(QgsExpressionContextUtils.layerScope(layer))
if not exp.prepare(exp_context):
raise GeoAlgorithmExecutionException(
self.tr('Evaluation error: %s' % exp.evalErrorString()))
# add layer to registry to fix https://issues.qgis.org/issues/17300
# it is necessary only for aggregate expressions that verify that layer
# is registered
removeRegistryAfterEvaluation = False
if not QgsMapLayerRegistry.instance().mapLayer(layer.id()):
removeRegistryAfterEvaluation = True
QgsMapLayerRegistry.instance().addMapLayer(layer,
addToLegend=False)
outFeature = QgsFeature()
outFeature.initAttributes(len(fields))
outFeature.setFields(fields)
error = ''
calculationSuccess = True
features = vector.features(layer)
total = 100.0 / len(features) if len(features) > 0 else 1
rownum = 1
for current, f in enumerate(features):
rownum = current + 1
exp_context.setFeature(f)
exp_context.lastScope().setVariable("row_number", rownum)
value = exp.evaluate(exp_context)
if exp.hasEvalError():
calculationSuccess = False
error = exp.evalErrorString()
break
else:
outFeature.setGeometry(f.geometry())
for fld in f.fields():
outFeature[fld.name()] = f[fld.name()]
outFeature[fieldName] = value
writer.addFeature(outFeature)
progress.setPercentage(int(current * total))
del writer
# remove from registry if added for expression requirement
# see above comment about fix #17300
if removeRegistryAfterEvaluation:
QgsMapLayerRegistry.instance().removeMapLayer(layer)
if not calculationSuccess:
raise GeoAlgorithmExecutionException(
self.tr('An error occurred while evaluating the calculation '
'string:\n%s' % error))
