def testDriverForExtension(self):
self.assertEqual(QgsRasterFileWriter.driverForExtension('tif'), 'GTiff')
self.assertEqual(QgsRasterFileWriter.driverForExtension('TIF'), 'GTiff')
self.assertEqual(QgsRasterFileWriter.driverForExtension('tIf'), 'GTiff')
self.assertEqual(QgsRasterFileWriter.driverForExtension('.tif'), 'GTiff')
self.assertEqual(QgsRasterFileWriter.driverForExtension('img'), 'HFA')
self.assertEqual(QgsRasterFileWriter.driverForExtension('.vrt'), 'VRT')
self.assertEqual(QgsRasterFileWriter.driverForExtension('.jpg'), 'JPEG')
self.assertEqual(QgsRasterFileWriter.driverForExtension('asc'), 'AAIGrid')
self.assertEqual(QgsRasterFileWriter.driverForExtension('not a format'), '')
self.assertEqual(QgsRasterFileWriter.driverForExtension(''), '')
def processAlgorithm(self, parameters, context, feedback):
inputFile = self.parameterAsRasterLayer(parameters, self.INPUT, context).source()
zFactor = self.parameterAsDouble(parameters, self.Z_FACTOR, context)
automaticColors = self.parameterAsBoolean(parameters, self.AUTO_COLORS, context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
frequencyDistribution = self.parameterAsFileOutput(parameters, self.FREQUENCY_DISTRIBUTION, context)
outputFormat = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1])
relief = QgsRelief(inputFile, outputFile, outputFormat)
if automaticColors:
reliefColors = relief.calculateOptimizedReliefClasses()
else:
colors = ParameterReliefColors.valueToColors(parameters[self.COLORS])
if colors is None or len(colors) == 0:
raise QgsProcessingException(
self.tr('Specify relief colors or activate "Generate relief classes automatically" option.'))
reliefColors = []
for c in colors:
v = c.split(',')
color = QgsRelief.ReliefColor(QColor(int(v[2]), int(v[3]), int(v[4])),
float(v[0]),
float(v[1]))
reliefColors.append(color)
relief.setReliefColors(reliefColors)
relief.setZFactor(zFactor)
if frequencyDistribution:
relief.exportFrequencyDistributionToCsv(frequencyDistribution)
relief.processRaster(feedback)
return {self.OUTPUT: outputFile, self.FREQUENCY_DISTRIBUTION: frequencyDistribution}
def getConsoleCommands(self, parameters, context, feedback):
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback)
arguments = ['-l']
arguments.append(layerName)
fieldName = self.parameterAsString(parameters, self.Z_FIELD, context)
if fieldName:
arguments.append('-zfield')
arguments.append(fieldName)
params = 'linear'
params += ':radius={}'.format(self.parameterAsDouble(parameters, self.RADIUS, context))
params += ':nodata={}'.format(self.parameterAsDouble(parameters, self.NODATA, context))
arguments.append('-a')
arguments.append(params)
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(ogrLayer)
arguments.append(out)
return ['gdal_grid', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
arguments.append('-st')
arguments.append(str(self.parameterAsInt(parameters, self.THRESHOLD, context)))
if self.parameterAsBool(parameters, self.EIGHT_CONNECTEDNESS, context):
arguments.append('-8')
else:
arguments.append('-4')
if self.parameterAsBool(parameters, self.NO_MASK, context):
arguments.append('-nomask')
mask = self.parameterAsRasterLayer(parameters, self.MASK_LAYER, context)
if mask:
arguments.append('-mask {}'.format(mask.source()))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
raster = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if raster is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(raster.source())
arguments.append(out)
commands = [self.commandName() + '.py', GdalUtils.escapeAndJoin(arguments)]
if isWindows():
commands.insert(0, 'python3')
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing)
arguments = ['-l']
arguments.append(layerName)
fieldName = self.parameterAsString(parameters, self.Z_FIELD, context)
if fieldName:
arguments.append('-zfield')
arguments.append(fieldName)
params = 'nearest'
params += ':radius1={}'.format(self.parameterAsDouble(parameters, self.RADIUS_1, context))
params += ':radius2={}'.format(self.parameterAsDouble(parameters, self.RADIUS_2, context))
params += ':angle={}'.format(self.parameterAsDouble(parameters, self.ANGLE, context))
params += ':nodata={}'.format(self.parameterAsDouble(parameters, self.NODATA, context))
arguments.append('-a')
arguments.append(params)
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(ogrLayer)
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = ['color-relief']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
arguments.append(self.parameterAsFile(parameters, self.COLOR_TABLE, context))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBoolean(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
arguments.append(self.modes[self.parameterAsEnum(parameters, self.MATCH_MODE, context)][1])
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context, inLayer.crs())
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
arguments.append('-projwin')
arguments.append(str(bbox.xMinimum()))
arguments.append(str(bbox.yMaximum()))
arguments.append(str(bbox.xMaximum()))
arguments.append(str(bbox.yMinimum()))
if nodata:
arguments.append('-a_nodata {}'.format(nodata))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(inLayer.source())
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
bands = self.parameterAsInts(parameters, self.BANDS, context)
for band in bands:
arguments.append('-b {}'.format(band))
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
if data_type:
arguments.append('-ot ' + self.TYPES[data_type])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = ['aspect']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(out)
self.setOutputValue(self.OUTPUT, out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBoolean(parameters, self.TRIG_ANGLE, context):
arguments.append('-trigonometric')
if self.parameterAsBoolean(parameters, self.ZERO_FLAT, context):
arguments.append('-zero_for_flat')
if self.parameterAsBoolean(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
if self.parameterAsBoolean(parameters, self.ZEVENBERGEN, context):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBool(parameters, self.RGBA, context):
arguments.append('-rgba')
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'pct2rgb.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['pct2rgb.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
arguments = []
crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
if crs.isValid():
arguments.append('-a_srs')
arguments.append(crs.authid())
if nodata:
arguments.append('-a_nodata')
arguments.append(nodata)
if self.parameterAsBool(parameters, self.COPY_SUBDATASETS, context):
arguments.append('-sds')
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(inLayer.source())
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBoolean(parameters, self.RGBA, context):
arguments.append('-rgba')
if isWindows():
commands = ["python3", "-m", self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
spectral = self.parameterAsRasterLayer(parameters, self.SPECTRAL, context)
if spectral is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.SPECTRAL))
panchromatic = self.parameterAsRasterLayer(parameters, self.PANCHROMATIC, context)
if panchromatic is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.PANCHROMATIC))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
arguments.append(panchromatic.source())
arguments.append(spectral.source())
arguments.append(out)
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
if isWindows():
commands = ['python3', '-m', self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = ['slope']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-s')
arguments.append(str(self.parameterAsDouble(parameters, self.SCALE, context)))
if self.parameterAsBool(parameters, self.AS_PERCENT, context):
arguments.append('-p')
if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
if self.parameterAsBool(parameters, self.ZEVENBERGEN, context):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
arguments.append('-st')
arguments.append(str(self.parameterAsInt(parameters, self.THRESHOLD, context)))
if self.parameterAsBool(parameters, self.EIGHT_CONNECTEDNESS, context):
arguments.append('-8')
else:
arguments.append('-4')
if self.parameterAsBool(parameters, self.NO_MASK, context):
arguments.append('-nomask')
mask = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if mask:
arguments.append('-mask {}'.format(mask.source()))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append(self.parameterAsRasterLayer(parameters, self.INPUT, context).source())
arguments.append(out)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_sieve.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_sieve.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION, context)
arguments = []
if sourceCrs.isValid():
arguments.append('-s_srs')
arguments.append(sourceCrs.authid())
if targetCrs.isValid():
arguments.append('-t_srs')
arguments.append(targetCrs.authid())
if nodata:
arguments.append('-dstnodata')
arguments.append(str(nodata))
if resolution:
arguments.append('-tr')
arguments.append(str(resolution))
arguments.append(str(resolution))
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1])
extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT, context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS, context)
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs.authid())
if self.parameterAsBool(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments = []
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-o')
arguments.append(out)
arguments.append('-near')
arguments.append(str(self.parameterAsInt(parameters, self.NEAR, context)))
if self.parameterAsBool(parameters, self.WHITE, context):
arguments.append('-white')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback):
arguments = ['aspect']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBool(parameters, self.TRIG_ANGLE, context):
arguments.append('-trigonometric')
if self.parameterAsBool(parameters, self.ZERO_FLAT, context):
arguments.append('-zero_for_flat')
if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
if self.parameterAsBool(parameters, self.ZEVENBERGEN, context):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = ['roughness']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
crs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
extent = self.parameterAsExtent(parameters, self.EXTENT, context, crs)
value = self.parameterAsDouble(parameters, self.NUMBER, context)
pixelSize = self.parameterAsDouble(parameters, self.PIXEL_SIZE, context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
outputFormat = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1])
rows = max([math.ceil(extent.height() / pixelSize) + 1, 1.0])
cols = max([math.ceil(extent.width() / pixelSize) + 1, 1.0])
writer = QgsRasterFileWriter(outputFile)
writer.setOutputProviderKey('gdal')
writer.setOutputFormat(outputFormat)
provider = writer.createOneBandRaster(Qgis.Float32, cols, rows, extent, crs)
provider.setNoDataValue(1, -9999)
data = [value] * cols
block = QgsRasterBlock(Qgis.Float32, cols, 1)
block.setData(struct.pack('{}f'.format(len(data)), *data))
total = 100.0 / rows if rows else 0
for i in range(rows):
if feedback.isCanceled():
break
provider.writeBlock(block, 1, 0, i)
feedback.setProgress(int(i * rows))
provider.setEditable(False)
return {self.OUTPUT: outputFile}
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context)
replaceValue = self.parameterAsDouble(parameters, self.REPLACE, context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
arguments.append('-srcband')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-distunits')
arguments.append(self.distanceUnits[self.parameterAsEnum(parameters, self.UNITS, context)][1])
values = self.parameterAsString(parameters, self.VALUES, context)
if values:
arguments.append('-values')
arguments.append(values)
if distance:
arguments.append('-maxdist')
arguments.append(str(distance))
if nodata is not None:
arguments.append('-nodata')
arguments.append(str(nodata))
if replaceValue:
arguments.append('-fixed-buf-val')
arguments.append(str(replaceValue))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
if isWindows():
commands = ["python3", "-m", self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
return commands
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
radius = self.parameterAsDouble(parameters, self.RADIUS, context)
kernel_shape = self.parameterAsEnum(parameters, self.KERNEL, context)
pixel_size = self.parameterAsDouble(parameters, self.PIXEL_SIZE, context)
decay = self.parameterAsDouble(parameters, self.DECAY, context)
output_values = self.parameterAsEnum(parameters, self.OUTPUT_VALUE, context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
output_format = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1])
weight_field = self.parameterAsString(parameters, self.WEIGHT_FIELD, context)
radius_field = self.parameterAsString(parameters, self.RADIUS_FIELD, context)
attrs = []
kde_params = QgsKernelDensityEstimation.Parameters()
kde_params.source = source
kde_params.radius = radius
kde_params.pixelSize = pixel_size
# radius field
if radius_field:
kde_params.radiusField = radius_field
attrs.append(source.fields().lookupField(radius_field))
# weight field
if weight_field:
kde_params.weightField = weight_field
attrs.append(source.fields().lookupField(weight_field))
kde_params.shape = kernel_shape
kde_params.decayRatio = decay
kde_params.outputValues = output_values
kde = QgsKernelDensityEstimation(kde_params, outputFile, output_format)
if kde.prepare() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not create destination layer'))
request = QgsFeatureRequest()
request.setSubsetOfAttributes(attrs)
features = source.getFeatures(request)
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if feedback.isCanceled():
break
if kde.addFeature(f) != QgsKernelDensityEstimation.Success:
feedback.reportError(self.tr('Error adding feature with ID {} to heatmap').format(f.id()))
feedback.setProgress(int(current * total))
if kde.finalise() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not save destination layer'))
return {self.OUTPUT: outputFile}
def getConsoleCommands(self, parameters, context, feedback):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context)
replaceValue = self.parameterAsDouble(parameters, self.REPLACE, context)
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
arguments.append('-srcband')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-distunits')
arguments.append(self.distanceUnits[self.parameterAsEnum(parameters, self.UNITS, context)][1])
values = self.parameterAsString(parameters, self.VALUES, context)
if values:
arguments.append('-values')
arguments.append(values)
if distance:
arguments.append('-maxdist')
arguments.append(str(distance))
if nodata:
arguments.append('-nodata')
arguments.append(str(nodata))
if replaceValue:
arguments.append('-fixed-buf-val')
arguments.append(str(replaceValue))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(inLayer.source())
arguments.append(out)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_proximity.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_proximity.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
def processAlgorithm(self, parameters, context, feedback):
inputFile = self.parameterAsRasterLayer(parameters, self.INPUT, context).source()
zFactor = self.parameterAsDouble(parameters, self.Z_FACTOR, context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
outputFormat = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1])
slope = QgsSlopeFilter(inputFile, outputFile, outputFormat)
slope.setZFactor(zFactor)
slope.processRaster(feedback)
return {self.OUTPUT: outputFile}
def processAlgorithm(self, parameters, context, feedback):
inputFile = exportRasterLayer(self.parameterAsRasterLayer(parameters, self.INPUT, context))
zFactor = self.parameterAsDouble(parameters, self.Z_FACTOR, context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
outputFormat = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1])
ruggedness = QgsRuggednessFilter(inputFile, outputFile, outputFormat)
ruggedness.setZFactor(zFactor)
ruggedness.processRaster(feedback)
return {self.OUTPUT: outputFile}
def getDriverForFile(self, filename):
"""
Get the GDAL driver for a filename, based on its extension. (.gpkg,
.mbtiles...)
"""
_, extension = os.path.splitext(filename)
# If no extension is set, use .tif as default
if extension == '':
extension = '.tif'
driver_name = QgsRasterFileWriter.driverForExtension(extension[1:])
return osgeo.gdal.GetDriverByName(driver_name)
def processAlgorithm(self, parameters, context, feedback):
inputFile = self.parameterAsRasterLayer(parameters, self.INPUT, context).source()
zFactor = self.parameterAsDouble(parameters, self.Z_FACTOR, context)
azimuth = self.parameterAsDouble(parameters, self.AZIMUTH, context)
vAngle = self.parameterAsDouble(parameters, self.V_ANGLE, context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
outputFormat = QgsRasterFileWriter.driverForExtension(os.path.splitext(outputFile)[1])
hillshade = QgsHillshadeFilter(inputFile, outputFile, outputFormat, azimuth, vAngle)
hillshade.setZFactor(zFactor)
hillshade.processRaster(feedback)
return {self.OUTPUT: outputFile}
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = ['hillshade']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-z')
arguments.append(str(self.parameterAsDouble(parameters, self.Z_FACTOR, context)))
arguments.append('-s')
arguments.append(str(self.parameterAsDouble(parameters, self.SCALE, context)))
multidirectional = self.parameterAsBool(parameters, self.MULTIDIRECTIONAL, context)
# azimuth and multidirectional are mutually exclusive
if not multidirectional:
arguments.append('-az')
arguments.append(str(self.parameterAsDouble(parameters, self.AZIMUTH, context)))
arguments.append('-alt')
arguments.append(str(self.parameterAsDouble(parameters, self.ALTITUDE, context)))
if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
if self.parameterAsBool(parameters, self.ZEVENBERGEN, context):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
if self.parameterAsBool(parameters, self.COMBINED, context):
arguments.append('-combined')
if multidirectional:
arguments.append('-multidirectional')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
maskLayer, maskLayerName = self.getOgrCompatibleSource(self.MASK, parameters, context, feedback, executing)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
if data_type:
arguments.append('-ot ' + self.TYPES[data_type])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if self.parameterAsBool(parameters, self.KEEP_RESOLUTION, context):
arguments.append('-tr')
arguments.append(str(inLayer.rasterUnitsPerPixelX()))
arguments.append(str(-inLayer.rasterUnitsPerPixelY()))
arguments.append('-tap')
arguments.append('-cutline')
arguments.append(maskLayer)
if self.parameterAsBool(parameters, self.CROP_TO_CUTLINE, context):
arguments.append('-crop_to_cutline')
if self.parameterAsBool(parameters, self.ALPHA_BAND, context):
arguments.append('-dstalpha')
if nodata is not None:
arguments.append('-dstnodata {}'.format(nodata))
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
if self.parameterAsBoolean(parameters, self.PCT, context):
arguments.append('-pct')
if self.parameterAsBoolean(parameters, self.SEPARATE, context):
arguments.append('-separate')
if self.NODATA_INPUT in parameters and parameters[self.NODATA_INPUT] is not None:
nodata_input = self.parameterAsInt(parameters, self.NODATA_INPUT, context)
arguments.append('-n')
arguments.append(str(nodata_input))
if self.NODATA_OUTPUT in parameters and parameters[self.NODATA_OUTPUT] is not None:
nodata_output = self.parameterAsInt(parameters, self.NODATA_OUTPUT, context)
arguments.append('-a_nodata')
arguments.append(str(nodata_output))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append('-o')
arguments.append(out)
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
list_file = GdalUtils.writeLayerParameterToTextFile(filename='mergeInputFiles.txt', alg=self, parameters=parameters, parameter_name=self.INPUT, context=context, quote=True, executing=executing)
arguments.append('--optfile')
arguments.append(list_file)
if isWindows():
commands = ["python3", "-m", self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
return commands
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
if self.parameterAsRasterLayer(parameters, self.INITIAL_ROAD_NETWORK,
context):
initial_road_network_raster = self.parameterAsRasterLayer(
parameters, self.INITIAL_ROAD_NETWORK, context)
else:
initial_road_network_raster = None
basic_distance_cost = self.parameterAsDouble(parameters,
self.BASIC_DISTANCE_COST,
context)
if self.parameterAsRasterLayer(parameters,
self.COARSE_ELEVATION_RASTER, context):
coarse_elevation_raster = self.parameterAsRasterLayer(
parameters, self.COARSE_ELEVATION_RASTER, context)
else:
coarse_elevation_raster = None
if self.parameterAsMatrix(parameters, self.COARSE_ELEVATION_COSTS,
context):
coarse_elevation_costs = self.parameterAsMatrix(
parameters, self.COARSE_ELEVATION_COSTS, context)
coarse_elevation_costs = CostRasterCreatorHelper.CollapsedTableToMatrix(
coarse_elevation_costs, 3)
else:
coarse_elevation_costs = None
if self.parameterAsRasterLayer(parameters, self.FINE_ELEVATION_RASTER,
context):
fine_elevation_raster = self.parameterAsRasterLayer(
parameters, self.FINE_ELEVATION_RASTER, context)
else:
fine_elevation_raster = None
if self.parameterAsMatrix(parameters, self.FINE_ELEVATION_COSTS,
context):
fine_elevation_costs = self.parameterAsMatrix(
parameters, self.FINE_ELEVATION_COSTS, context)
fine_elevation_costs = CostRasterCreatorHelper.CollapsedTableToMatrix(
fine_elevation_costs, 3)
else:
fine_elevation_costs = None
if self.parameterAsRasterLayer(parameters, self.COARSE_WATER_RASTER,
context):
coarse_water_raster = self.parameterAsRasterLayer(
parameters, self.COARSE_WATER_RASTER, context)
else:
coarse_water_raster = None
if self.parameterAsDouble(parameters, self.COARSE_WATER_COST, context):
coarse_water_cost = self.parameterAsDouble(parameters,
self.COARSE_WATER_COST,
context)
else:
coarse_water_cost = None
if self.parameterAsRasterLayer(parameters, self.FINE_WATER_RASTER,
context):
fine_water_raster = self.parameterAsRasterLayer(
parameters, self.FINE_WATER_RASTER, context)
else:
fine_water_raster = None
if self.parameterAsDouble(parameters, self.FINE_WATER_COST, context):
fine_water_cost = self.parameterAsDouble(parameters,
self.FINE_WATER_COST,
context)
else:
fine_water_cost = None
if self.parameterAsRasterLayer(parameters, self.SOIL_RASTER, context):
soil_raster = self.parameterAsRasterLayer(parameters,
self.SOIL_RASTER,
context)
else:
soil_raster = None
if self.parameterAsRasterLayer(parameters, self.ADDITIONAL_COST_RASTER,
context):
special_raster = self.parameterAsRasterLayer(
parameters, self.ADDITIONAL_COST_RASTER, context)
else:
special_raster = None
feedback.pushInfo(self.tr("Checking inputs..."))
# If source was not found, throw an exception to indicate that the algorithm
# encountered a fatal error. The exception text can be any string, but in this
# case we use the pre-built invalidSourceError method to return a standard
# helper text for when a source cannot be evaluated
if basic_distance_cost is None or basic_distance_cost == 0:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.BASIC_DISTANCE_COST))
# Now, we check to see if the CRS, extent and resolution of every raster is equal, so that their align properly.
listOfRastersToCheck = list()
if initial_road_network_raster is not None:
listOfRastersToCheck.append(initial_road_network_raster)
if coarse_elevation_raster is not None:
listOfRastersToCheck.append(coarse_elevation_raster)
if fine_elevation_raster is not None:
listOfRastersToCheck.append(fine_elevation_raster)
if coarse_water_raster is not None:
listOfRastersToCheck.append(coarse_water_raster)
if fine_water_raster is not None:
listOfRastersToCheck.append(fine_water_raster)
if soil_raster is not None:
listOfRastersToCheck.append(soil_raster)
if special_raster is not None:
listOfRastersToCheck.append(special_raster)
if len(listOfRastersToCheck) == 0:
raise QgsProcessingException(
self.
tr("At least one input raster is needed ! Please, input one raster."
))
# We check that every raster has the same CRS, extent and resolution.
CostRasterCreatorHelper.CheckRastersCompatibility(listOfRastersToCheck)
# We also check that the matrix of parameters entered for the coarse elevation costs and fine elevation costs
# are correct : meaning that there are no holes between the thresholds, and that every lower threshold is lower
# than the upper threshold.
if coarse_elevation_costs is not None:
CostRasterCreatorHelper.CheckThresholds(coarse_elevation_costs,
"Coarse elevation costs")
if fine_elevation_costs is not None:
CostRasterCreatorHelper.CheckThresholds(fine_elevation_costs,
"Fine elevation costs")
# Then, we create the raster blocks
if initial_road_network_raster is not None:
initial_road_network_raster_block = CostRasterCreatorHelper.get_all_block(
initial_road_network_raster)
else:
initial_road_network_raster_block = None
if coarse_elevation_raster is not None:
coarse_elevation_raster_block = CostRasterCreatorHelper.get_all_block(
coarse_elevation_raster)
else:
coarse_elevation_raster_block = None
if fine_elevation_raster is not None:
fine_elevation_raster_block = CostRasterCreatorHelper.get_all_block(
fine_elevation_raster)
else:
fine_elevation_raster_block = None
if coarse_water_raster is not None:
coarse_water_raster_block = CostRasterCreatorHelper.get_all_block(
coarse_water_raster)
else:
coarse_water_raster_block = None
if fine_water_raster is not None:
fine_water_raster_block = CostRasterCreatorHelper.get_all_block(
fine_water_raster)
else:
fine_water_raster_block = None
if soil_raster is not None:
soil_raster_block = CostRasterCreatorHelper.get_all_block(
soil_raster)
else:
soil_raster_block = None
if special_raster is not None:
special_raster_block = CostRasterCreatorHelper.get_all_block(
special_raster)
else:
special_raster_block = None
feedback.pushInfo(self.tr("Preparing output..."))
# We set the output to be ready : It is a QgsDataProvider
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
outputFormat = QgsRasterFileWriter.driverForExtension(
os.path.splitext(outputFile)[1])
crs = listOfRastersToCheck[0].crs()
extent = listOfRastersToCheck[0].extent()
rows = max([
math.ceil(extent.height() /
listOfRastersToCheck[0].rasterUnitsPerPixelY()), 1.0
])
cols = max([
math.ceil(extent.width() /
listOfRastersToCheck[0].rasterUnitsPerPixelX()), 1.0
])
# We will need this value for the fine water computation later
pixelSide = (listOfRastersToCheck[0].rasterUnitsPerPixelY() +
listOfRastersToCheck[0].rasterUnitsPerPixelX()) / 2
writer = QgsRasterFileWriter(outputFile)
writer.setOutputProviderKey('gdal')
writer.setOutputFormat(outputFormat)
provider = writer.createOneBandRaster(Qgis.Float32, cols, rows, extent,
crs)
if provider is None:
raise QgsProcessingException(
self.tr("Could not create raster output: {}").format(
outputFile))
if not provider.isValid():
raise QgsProcessingException(
self.tr("Could not create raster output {}").format(
outputFile))
provider.setNoDataValue(1, -9999)
# We create the data block for the output raster, and we fill it with the values we need
dataBlock = QgsRasterBlock(Qgis.Float32, cols, rows)
# i = float(1.0)
feedback.pushInfo(self.tr("Calculating cost raster..."))
progress = 0
feedback.setProgress(0)
errorMessages = list()
for y in range(dataBlock.height()):
for x in range(dataBlock.width()):
if feedback.isCanceled():
raise QgsProcessingException(
self.tr("ERROR: Operation was cancelled."))
# If there is a road already on this pixel, then the cost is 0.
if initial_road_network_raster_block is not None and \
(initial_road_network_raster_block.value(y,
x) != 0 and not initial_road_network_raster_block.isNoData(
y, x)):
finalValue = 0
# If there is a water body on this pixel, we stop everything :
# The cost will be the construction of a bridge
elif coarse_water_raster_block is not None and coarse_water_raster_block.value(
y, x) != 0:
if coarse_water_cost is not None:
finalValue = coarse_water_cost
else:
raise QgsProcessingException(
self.
tr("A coarse water raster has been given, but no coarse "
+
"water cost. Please input a coarse water cost.")
)
# feedback.pushInfo("Seems like there was a road on this pixel. Final value is " + str(finalValue))
# Else, if we are not on a road or on a body of water...
else:
# We start with the base cost of crossing the pixel
finalValue = basic_distance_cost
# feedback.pushInfo("No road on this pixel, we put basic distance cost. Final value is " + str(finalValue))
# Then, if we have it, we add the soil cost
if soil_raster_block is not None:
finalValue += soil_raster_block.value(y, x)
# feedback.pushInfo("After soils, final value is " + str(finalValue))
if special_raster_block is not None:
finalValue += special_raster_block.value(y, x)
# Then the coarse elevation value
if coarse_elevation_raster_block is not None:
additionalValue, errorMessage = CostRasterCreatorHelper.CalculateCoarseElevationCost(
y, x, coarse_elevation_raster_block,
coarse_elevation_costs, pixelSide)
finalValue += additionalValue
if errorMessage is not None:
errorMessages.append(errorMessage)
# feedback.pushInfo("After coarse elevation, final value is " + str(finalValue))
# Then the fine water value
if fine_water_raster_block is not None:
finalValue += CostRasterCreatorHelper.CalculateFineWaterCost(
y, x, fine_water_raster_block, fine_water_cost,
pixelSide)
# feedback.pushInfo("After fine water, final value is " + str(finalValue))
# Then, we multiply everything with the fine elevation cost.
if fine_elevation_raster_block is not None:
finalValue, errorMessage = CostRasterCreatorHelper.CalculateFineElevationCost(
y, x, fine_elevation_raster_block,
fine_elevation_costs, finalValue)
if errorMessage is not None:
errorMessages.append(errorMessage)
# feedback.pushInfo("After fine elevation, final value is " + str(finalValue))
dataBlock.setValue(y, x, float(finalValue))
progress += 1
feedback.setProgress(
100 * (progress /
(dataBlock.height() * dataBlock.width())))
# We write the values in the provider of our files
provider.writeBlock(dataBlock, 1)
# We stop the edition of the output raster
provider.setEditable(False)
# We display the warning messages about the thresholds
if len(errorMessages) > 0:
above = 0
below = 0
for errorMessage in errorMessages:
if errorMessage == "Above":
above += 1
elif errorMessage == "Below":
below += 1
feedback.pushInfo(
self.
tr("WARNING : There were " + str(below) +
" situations where the value of a pixel was under"
" the lowest threshold given as a parameter; and " +
str(above) + " when it was above the"
" highest. In those cases, the lowest or highest value of the parameter range was used."
" To avoid that, please make sure to use thresholds that cover all of the range of values in"
" your rasters."))
# We make the output
return {self.OUTPUT: outputFile}
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, outFile)
direction = self.parameterAsEnum(parameters, self.TRANSF, context)
src_crs = self.src_datums[self.parameterAsEnum(parameters,
self.SRC_CRS,
context)][1]
dst_crs = self.dst_datums[self.parameterAsEnum(parameters,
self.DST_CRS,
context)][1]
v = self.parameterAsEnum(parameters, self.ZONE, context)
zone = '' if v == 0 else self.zones[v]
found, text = au_transformation_agd(src_crs, zone)
if not found:
raise QgsProcessingException(text)
arguments = []
if direction == 0:
# Direct transformation
arguments.append('-s_srs')
arguments.append(text)
arguments.append('-t_srs')
arguments.append('EPSG:{}{}'.format(dst_crs, zone))
else:
# Inverse transformation
arguments = ['-s_srs']
arguments.append('EPSG:{}{}'.format(dst_crs, zone))
arguments.append('-t_srs')
arguments.append(text)
arguments.append('-multi')
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(
os.path.splitext(outFile)[1]))
arguments.append(inLayer.source())
arguments.append(outFile)
# Set the EPSG string when we aren't using one to define the target
if direction == 1:
arguments.append('&&')
arguments.append('gdal_edit.py')
arguments.append('-a_srs')
arguments.append('EPSG:{}{}'.format(src_crs, zone))
arguments.append(outFile)
if not os.path.isfile(
os.path.join(pluginPath, 'grids',
'A66_National_13_09_01.gsb')):
urlretrieve(
'http://www.naturalgis.pt/downloads/ntv2grids/au/A66_National_13_09_01.gsb',
os.path.join(pluginPath, 'grids', 'A66_National_13_09_01.gsb'))
urlretrieve(
'http://www.naturalgis.pt/downloads/ntv2grids/au/National_84_02_07_01.gsb',
os.path.join(pluginPath, 'grids', 'National_84_02_07_01.gsb'))
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
# Retrieve the values of the parameters
pan_layer = self.parameterAsRasterLayer(parameters, self.INPUT_PAN,
context)
pan_band = self.parameterAsInt(parameters, self.BAND_PAN, context)
xs_layer = self.parameterAsRasterLayer(parameters, self.INPUT_XS,
context)
red_band = self.parameterAsInt(parameters, self.BAND_R, context)
green_band = self.parameterAsInt(parameters, self.BAND_G, context)
blue_band = self.parameterAsInt(parameters, self.BAND_B, context)
nir_band = self.parameterAsInt(parameters, self.BAND_NIR, context)
weight_r = self.parameterAsDouble(parameters, self.WEIGHT_R, context)
weight_g = self.parameterAsDouble(parameters, self.WEIGHT_G, context)
weight_b = self.parameterAsDouble(parameters, self.WEIGHT_B, context)
weight_nir = self.parameterAsDouble(parameters, self.WEIGHT_NIR,
context)
out_crs = self.parameterAsCrs(parameters, self.OUT_CRS, context)
if not out_crs.isValid():
out_crs = pan_layer.crs()
out_extent = self.parameterAsExtent(parameters,
self.OUT_EXTENT,
context,
crs=out_crs)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
output_format = QgsRasterFileWriter.driverForExtension(
os.path.splitext(output_file)[1])
if not output_format:
output_format = 'GTiff'
# check if it is canceled
if feedback.isCanceled():
return {}
# Throw an exception to indicate and invalid input
if pan_layer is None or not pan_layer.isValid():
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT_PAN))
if xs_layer is None or not xs_layer.isValid():
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT_XS))
if out_extent is None or out_extent.isEmpty():
raise QgsProcessingException(
self.invalidSourceError(parameters, self.OUT_EXTENT))
# Throw an exception if they have different crs
if pan_layer.crs().authid() != xs_layer.crs().authid():
raise QgsProcessingException(
"The panchromatic and multispectral layers must have the same CRS!"
)
# update progress
feedback.setProgressText('Reading layers.')
# get layers filenames and open GDAL ds
pan_fn = pan_layer.dataProvider().dataSourceUri()
xs_fn = xs_layer.dataProvider().dataSourceUri()
pan_ds = gdal.Open(pan_fn, gdal.GA_ReadOnly)
xs_ds = gdal.Open(xs_fn, gdal.GA_ReadOnly)
# check if it is canceled
if feedback.isCanceled():
return {}
bandnames = ['red', 'green', 'blue']
xs_bands = [
xs_ds.GetRasterBand(red_band),
xs_ds.GetRasterBand(green_band),
xs_ds.GetRasterBand(blue_band)
]
# make template XML and update xs_bands list
if nir_band == 0:
total_weight = weight_r + weight_g + weight_b
if total_weight <= 1 and isclose(total_weight, 1, abs_tol=0.011):
weights = '{0:.2f},{1:.2f},{2:.2f}'.format(
weight_r, weight_g, weight_b)
feedback.pushInfo(
f'Using weights [{weights}] in the pansharpening algorithm.'
)
pszXML = f"""<VRTDataset subClass="VRTPansharpenedDataset">
<PansharpeningOptions>
<AlgorithmOptions>
<Weights>{weights}</Weights>
</AlgorithmOptions>
<SpectralBand dstBand="1">
</SpectralBand>
<SpectralBand dstBand="2">
</SpectralBand>
<SpectralBand dstBand="3">
</SpectralBand>
</PansharpeningOptions>
</VRTDataset>"""
else:
# ignores supplied weights
feedback.pushInfo('Invalid weights! They will be ignored.')
pszXML = f"""<VRTDataset subClass="VRTPansharpenedDataset">
<PansharpeningOptions>
<SpectralBand dstBand="1">
</SpectralBand>
<SpectralBand dstBand="2">
</SpectralBand>
<SpectralBand dstBand="3">
</SpectralBand>
</PansharpeningOptions>
</VRTDataset>"""
# update progress
# create pansharpened ds for r/g/b bands
feedback.setProgressText('Pansharpening r/g/b bands.')
else:
total_weight = weight_r + weight_g + weight_b + weight_nir
if total_weight <= 1 and isclose(total_weight, 1, abs_tol=0.011):
weights = '{0:.2f},{1:.2f},{2:.2f},{3:.2f}'.format(
weight_r, weight_g, weight_b, weight_nir)
feedback.pushInfo(
f'Using weights [{weights}] in the pansharpening algorithm.'
)
pszXML = f"""<VRTDataset subClass="VRTPansharpenedDataset">
<PansharpeningOptions>
<AlgorithmOptions>
<Weights>{weights}</Weights>
</AlgorithmOptions>
<SpectralBand dstBand="1">
</SpectralBand>
<SpectralBand dstBand="2">
</SpectralBand>
<SpectralBand dstBand="3">
</SpectralBand>
<SpectralBand dstBand="4">
</SpectralBand>
</PansharpeningOptions>
</VRTDataset>"""
else:
# ignores supplied weights
feedback.pushInfo('Invalid weights! They will be ignored.')
pszXML = f"""<VRTDataset subClass="VRTPansharpenedDataset">
<PansharpeningOptions>
<SpectralBand dstBand="1">
</SpectralBand>
<SpectralBand dstBand="2">
</SpectralBand>
<SpectralBand dstBand="3">
</SpectralBand>
<SpectralBand dstBand="4">
</SpectralBand>
</PansharpeningOptions>
</VRTDataset>"""
# update progress
# create pansharpened ds for r/g/b/nir bands
feedback.setProgressText('Pansharpening r/g/b/nir bands.')
xs_bands.append(xs_ds.GetRasterBand(nir_band))
bandnames.append('nir')
# create pansharpened GDAL ds
pansharpened_ds = gdal.CreatePansharpenedVRT(
pszXML, pan_ds.GetRasterBand(pan_band), xs_bands)
# check if it is canceled
if feedback.isCanceled():
return {}
# extent (minX, minY, maxX, maxY) and crs (epsg id)
output_ext = '{0:.18g} {1:.18g} {2:.18g} {3:.18g}'.format(
out_extent.xMinimum(), out_extent.yMinimum(),
out_extent.xMaximum(), out_extent.yMaximum())
output_SRS = out_crs.authid()
# gdal.Warp
opts = f'-of {output_format} -t_srs {output_SRS} -te {output_ext}'
feedback.pushInfo('GDAL Warp options: ' + opts)
# update progress
feedback.setProgressText(
'Creating output file ({}).'.format(output_format))
ds = gdal.Warp(output_file, pansharpened_ds, options=opts)
feedback.setProgressText('Naming bands.')
for i, bn in enumerate(bandnames):
b = ds.GetRasterBand(i + 1)
b.SetDescription(bn)
ds.FlushCache()
ds = None
return {self.OUTPUT: output_file}
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
arguments = ['hillshade']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(
str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-z')
arguments.append(
str(self.parameterAsDouble(parameters, self.Z_FACTOR, context)))
arguments.append('-s')
arguments.append(
str(self.parameterAsDouble(parameters, self.SCALE, context)))
multidirectional = self.parameterAsBool(parameters,
self.MULTIDIRECTIONAL, context)
# azimuth and multidirectional are mutually exclusive
if not multidirectional:
arguments.append('-az')
arguments.append(
str(self.parameterAsDouble(parameters, self.AZIMUTH, context)))
arguments.append('-alt')
arguments.append(
str(self.parameterAsDouble(parameters, self.ALTITUDE, context)))
if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
if self.parameterAsBool(parameters, self.ZEVENBERGEN, context):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
if self.parameterAsBool(parameters, self.COMBINED, context):
arguments.append('-combined')
if multidirectional:
arguments.append('-multidirectional')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing)
arguments = ['-l']
arguments.append(layerName)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
if fieldName:
arguments.append('-a')
arguments.append(fieldName)
else:
arguments.append('-burn')
arguments.append(self.parameterAsDouble(parameters, self.BURN, context))
units = self.parameterAsEnum(parameters, self.UNITS, context)
if units == 0:
arguments.append('-ts')
else:
arguments.append('-tr')
arguments.append(self.parameterAsDouble(parameters, self.WIDTH, context))
arguments.append(self.parameterAsDouble(parameters, self.HEIGHT, context))
initValue = self.parameterAsDouble(parameters, self.INIT, context)
if initValue:
arguments.append('-init')
arguments.append(initValue)
if self.parameterAsBool(parameters, self.INVERT, context):
arguments.append('-i')
if self.parameterAsBool(parameters, self.ALL_TOUCH, context):
arguments.append('-at')
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
if nodata:
arguments.append('-a_nodata')
arguments.append(nodata)
extent = self.parameterAsExtent(parameters, self.EXTENT, context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(ogrLayer)
arguments.append(out)
return ['gdal_rasterize', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE,
context)
replaceValue = self.parameterAsDouble(parameters, self.REPLACE,
context)
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
arguments.append('-srcband')
arguments.append(
str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-distunits')
arguments.append(self.distanceUnits[self.parameterAsEnum(
parameters, self.UNITS, context)][1])
values = self.parameterAsString(parameters, self.VALUES, context)
if values:
arguments.append('-values')
arguments.append(values)
if distance:
arguments.append('-maxdist')
arguments.append(str(distance))
if nodata:
arguments.append('-nodata')
arguments.append(str(nodata))
if replaceValue:
arguments.append('-fixed-buf-val')
arguments.append(str(replaceValue))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(inLayer.source())
arguments.append(out)
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'gdal_proximity.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = [
'gdal_proximity.py',
GdalUtils.escapeAndJoin(arguments)
]
return commands
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION,
context)
arguments = []
if sourceCrs.isValid():
arguments.append('-s_srs')
arguments.append(sourceCrs.authid())
if targetCrs.isValid():
arguments.append('-t_srs')
arguments.append(targetCrs.authid())
if nodata:
arguments.append('-dstnodata')
arguments.append(str(nodata))
if resolution:
arguments.append('-tr')
arguments.append(str(resolution))
arguments.append(str(resolution))
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(
parameters, self.RESAMPLING, context)][1])
extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT,
context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS,
context)
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs.authid())
if self.parameterAsBool(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(inLayer.source())
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsSource(parameters, self.INPUT, context)
radius = self.parameterAsDouble(parameters, self.RADIUS, context)
kernel_shape = self.parameterAsEnum(parameters, self.KERNEL, context)
pixel_size = self.parameterAsDouble(parameters, self.PIXEL_SIZE,
context)
decay = self.parameterAsDouble(parameters, self.DECAY, context)
output_values = self.parameterAsEnum(parameters, self.OUTPUT_VALUE,
context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
output_format = QgsRasterFileWriter.driverForExtension(
os.path.splitext(outputFile)[1])
weight_field = self.parameterAsString(parameters, self.WEIGHT_FIELD,
context)
radius_field = self.parameterAsString(parameters, self.RADIUS_FIELD,
context)
attrs = []
kde_params = QgsKernelDensityEstimation.Parameters()
kde_params.source = source
kde_params.radius = radius
kde_params.pixelSize = pixel_size
# radius field
if radius_field:
kde_params.radiusField = radius_field
attrs.append(source.fields().lookupField(radius_field))
# weight field
if weight_field:
kde_params.weightField = weight_field
attrs.append(source.fields().lookupField(weight_field))
kde_params.shape = kernel_shape
kde_params.decayRatio = decay
kde_params.outputValues = output_values
kde = QgsKernelDensityEstimation(kde_params, outputFile, output_format)
if kde.prepare() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not create destination layer'))
request = QgsFeatureRequest()
request.setSubsetOfAttributes(attrs)
features = source.getFeatures(request)
total = 100.0 / source.featureCount() if source.featureCount() else 0
for current, f in enumerate(features):
if feedback.isCanceled():
break
if kde.addFeature(f) != QgsKernelDensityEstimation.Success:
feedback.reportError(
self.tr(
'Error adding feature with ID {} to heatmap').format(
f.id()))
feedback.setProgress(int(current * total))
if kde.finalise() != QgsKernelDensityEstimation.Success:
raise QgsProcessingException(
self.tr('Could not save destination layer'))
return {self.OUTPUT: outputFile}
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION, context)
arguments = []
if sourceCrs.isValid():
arguments.append('-s_srs')
arguments.append(GdalUtils.gdal_crs_string(sourceCrs))
if targetCrs.isValid():
arguments.append('-t_srs')
arguments.append(GdalUtils.gdal_crs_string(targetCrs))
if nodata is not None:
arguments.append('-dstnodata')
arguments.append(str(nodata))
if resolution:
arguments.append('-tr')
arguments.append(str(resolution))
arguments.append(str(resolution))
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1])
extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT, context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS, context)
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs.authid())
if self.parameterAsBool(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
if data_type:
arguments.append('-ot ' + self.TYPES[data_type])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
"""
Here is where the processing itself takes place.
"""
log = feedback.setProgressText
input_lulc_source_index = self.parameterAsEnum(parameters,
self.INPUT_LULC_SOURCE,
context)
input_lulc_source = self.LULC_SOURCES[input_lulc_source_index]
input_raster = self.parameterAsRasterLayer(parameters,
self.INPUT_RASTER, context)
input_esv_field_index = self.parameterAsEnum(parameters,
self.INPUT_ESV_FIELD,
context)
input_esv_field = self.INPUT_ESV_FIELD_OPTIONS[input_esv_field_index]
input_esv_stat_index = self.parameterAsEnum(parameters,
self.INPUT_ESV_STAT,
context)
input_esv_stat_full_name = self.STATS[input_esv_stat_index]
input_esv_stat = self.STATS_MAP[input_esv_stat_full_name]
output_raster_destination = self.parameterAsOutputLayer(
parameters, self.OUTPUT_RASTER, context)
result = {self.OUTPUT_RASTER: output_raster_destination}
# // STEP 1. Check output file format to make sure it is a geotiff //
output_format = QgsRasterFileWriter.driverForExtension(
splitext(output_raster_destination)[1])
if not output_format or output_format.lower() != "gtiff":
error_message = "CRITICAL: Currently only GeoTIFF output format allowed, exiting!"
feedback.reportError(error_message)
return ({'error': error_message})
else:
message = "Output file is GeoTIFF. Check"
log(message)
# // STEP 2. Make instance of LULC dataset from clipped layer here //
LULC_raster = LULC_dataset(input_lulc_source, input_raster)
# Check to make sure all land use codes are valid
valid = LULC_raster.is_valid()
if isinstance(valid, str):
#If is instance returns a string it is not valid. The string contains the error message
error_message = valid
feedback.reportError(error_message)
return {'error': error_message}
# // STEP 3. Reclassification //
# Get reclassify table for selected parameters
ESV_data = ESV_dataset()
reclass_table = ESV_data.make_reclassify_table(LULC_raster.cell_size(),
input_lulc_source,
input_esv_stat,
input_esv_field)
# Perform reclassification
reclassify_params = {
'INPUT_RASTER': input_raster,
'RASTER_BAND': 1,
'TABLE': reclass_table,
'NO_DATA': -9999,
'RANGE_BOUNDARIES': 0,
'NODATA_FOR_MISSING': True,
'DATA_TYPE': 6,
'OUTPUT': output_raster_destination
}
processing.run("native:reclassifybytable", reclassify_params)
#must add raster to iface so that is becomes active layer, then symbolize it in next step
output_raster = QgsRasterLayer(output_raster_destination)
iface.addRasterLayer(output_raster_destination)
#grabs active layer and data from that layer
layer = iface.activeLayer()
provider = layer.dataProvider()
extent = layer.extent()
raster_stats = provider.bandStatistics(1, QgsRasterBandStats.All)
# // STEP 4. Symbolize output layer //
log("Symbolizing Output Layer")
#creates raster shader and creates discrete color ramp
raster_shader = QgsColorRampShader()
raster_shader.setColorRampType(QgsColorRampShader.Discrete)
#creates layer symbology from raster_stats data
raster_stats = provider.bandStatistics(1, QgsRasterBandStats.All)
symbology = Symbology(raster_stats, input_esv_field)
colors_list = symbology.symbolize_input_raster()
raster_shader.setColorRampItemList(
colors_list) #applies symbology to raster_shader
shader = QgsRasterShader()
shader.setRasterShaderFunction(raster_shader)
renderer = QgsSingleBandPseudoColorRenderer(
layer.dataProvider(), 1, shader) #renders selected raster layer
layer.setRenderer(renderer)
layer.triggerRepaint()
log(self.tr(f"Adding final raster to map."))
#need to add result from gdal:rastercalculator to map (doesn't happen automatically)
log(self.tr("Done!\n"))
# Return the results of the algorithm. In this case our only result is
# the feature sink which contains the processed features, but some
# algorithms may return multiple feature sinks, calculated numeric
# statistics, etc. These should all be included in the returned
# dictionary, with keys matching the feature corresponding parameter
# or output names.
return result
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
ogrLayer, layerName = self.getOgrCompatibleSource(
self.INPUT, parameters, context, feedback, executing)
arguments = ['-l', layerName]
fieldName = self.parameterAsString(parameters, self.FIELD, context)
use_z = self.parameterAsBoolean(parameters, self.USE_Z, context)
if use_z:
arguments.append('-3d')
elif fieldName:
arguments.append('-a')
arguments.append(fieldName)
else:
arguments.append('-burn')
arguments.append(
self.parameterAsDouble(parameters, self.BURN, context))
units = self.parameterAsEnum(parameters, self.UNITS, context)
if units == 0:
arguments.append('-ts')
else:
arguments.append('-tr')
arguments.append(
self.parameterAsDouble(parameters, self.WIDTH, context))
arguments.append(
self.parameterAsDouble(parameters, self.HEIGHT, context))
if self.INIT in parameters and parameters[self.INIT] is not None:
initValue = self.parameterAsDouble(parameters, self.INIT, context)
arguments.append('-init')
arguments.append(initValue)
if self.parameterAsBoolean(parameters, self.INVERT, context):
arguments.append('-i')
if self.parameterAsBoolean(parameters, self.ALL_TOUCH, context):
arguments.append('-at')
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
arguments.append('-a_nodata')
arguments.append(nodata)
extent = self.parameterAsExtent(parameters, self.EXTENT, context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
if self.EXTRA in parameters and parameters[self.EXTRA] not in (None,
''):
extra = self.parameterAsString(parameters, self.EXTRA, context)
arguments.append(extra)
arguments.append(ogrLayer)
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE,
context)
replaceValue = self.parameterAsDouble(parameters, self.REPLACE,
context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
arguments.append('-srcband')
arguments.append(
str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-distunits')
arguments.append(self.distanceUnits[self.parameterAsEnum(
parameters, self.UNITS, context)][1])
values = self.parameterAsString(parameters, self.VALUES, context)
if values:
arguments.append('-values')
arguments.append(values)
if distance:
arguments.append('-maxdist')
arguments.append(str(distance))
if nodata is not None:
arguments.append('-nodata')
arguments.append(str(nodata))
if replaceValue:
arguments.append('-fixed-buf-val')
arguments.append(str(replaceValue))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
if isWindows():
commands = ["python3", "-m", self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
return commands
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
if self.parameterAsBool(parameters, self.PCT, context):
arguments.append('-pct')
if self.parameterAsBool(parameters, self.SEPARATE, context):
arguments.append('-separate')
if self.NODATA_INPUT in parameters and parameters[
self.NODATA_INPUT] is not None:
nodata_input = self.parameterAsInt(parameters, self.NODATA_INPUT,
context)
arguments.append('-n')
arguments.append(str(nodata_input))
if self.NODATA_OUTPUT in parameters and parameters[
self.NODATA_OUTPUT] is not None:
nodata_output = self.parameterAsInt(parameters, self.NODATA_OUTPUT,
context)
arguments.append('-a_nodata')
arguments.append(str(nodata_output))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append('-o')
arguments.append(out)
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
list_file = GdalUtils.writeLayerParameterToTextFile(
filename='mergeInputFiles.txt',
alg=self,
parameters=parameters,
parameter_name=self.INPUT,
context=context,
quote=True,
executing=executing)
arguments.append('--optfile')
arguments.append(list_file)
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'gdal_merge.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['gdal_merge.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
maskLayer, maskLayerName = self.getOgrCompatibleSource(
self.MASK, parameters, context, feedback, executing)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
if data_type:
arguments.append('-ot ' + self.TYPES[data_type])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if self.parameterAsBool(parameters, self.KEEP_RESOLUTION, context):
arguments.append('-tr')
arguments.append(str(inLayer.rasterUnitsPerPixelX()))
arguments.append(str(-inLayer.rasterUnitsPerPixelY()))
arguments.append('-tap')
arguments.append('-cutline')
arguments.append(maskLayer)
if self.parameterAsBool(parameters, self.CROP_TO_CUTLINE, context):
arguments.append('-crop_to_cutline')
if self.parameterAsBool(parameters, self.ALPHA_BAND, context):
arguments.append('-dstalpha')
if nodata is not None:
arguments.append('-dstnodata {}'.format(nodata))
extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT,
context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS,
context)
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs.authid())
if self.parameterAsBool(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
inputFile = self.parameterAsRasterLayer(parameters, self.INPUT,
context).source()
zFactor = self.parameterAsDouble(parameters, self.Z_FACTOR, context)
automaticColors = self.parameterAsBoolean(parameters, self.AUTO_COLORS,
context)
outputFile = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
frequencyDistribution = self.parameterAsFileOutput(
parameters, self.FREQUENCY_DISTRIBUTION, context)
outputFormat = QgsRasterFileWriter.driverForExtension(
os.path.splitext(outputFile)[1])
relief = QgsRelief(inputFile, outputFile, outputFormat)
if automaticColors:
reliefColors = relief.calculateOptimizedReliefClasses()
else:
colors = ParameterReliefColors.valueToColors(
parameters[self.COLORS])
if colors is None or len(colors) == 0:
raise QgsProcessingException(
self.
tr('Specify relief colors or activate "Generate relief classes automatically" option.'
))
reliefColors = []
for c in colors:
v = c.split(',')
color = QgsRelief.ReliefColor(
QColor(int(v[2]), int(v[3]), int(v[4])), float(v[0]),
float(v[1]))
reliefColors.append(color)
relief.setReliefColors(reliefColors)
relief.setZFactor(zFactor)
if frequencyDistribution:
relief.exportFrequencyDistributionToCsv(frequencyDistribution)
res = relief.processRaster(feedback)
if res == 1:
raise QgsProcessingException(self.tr('Can not open input file.'))
elif res == 2:
raise QgsProcessingException(
self.tr('Can not get GDAL driver for output file.'))
elif res == 3:
raise QgsProcessingException(
self.tr('Can not create output file.'))
elif res == 4:
raise QgsProcessingException(self.tr('Can not get input band.'))
elif res == 5:
raise QgsProcessingException(
self.tr('Can not create output bands.'))
elif res == 6:
raise QgsProcessingException(
self.tr(
'Output raster size is too small (at least 3 rows needed).'
))
elif res == 7:
feedback.pushInfo(self.tr('Canceled.'))
return {
self.OUTPUT: outputFile,
self.FREQUENCY_DISTRIBUTION: frequencyDistribution
}
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
maskLayer, maskLayerName = self.getOgrCompatibleSource(
self.MASK, parameters, context, feedback, executing)
sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
if sourceCrs.isValid():
arguments.append('-s_srs')
arguments.append(GdalUtils.gdal_crs_string(sourceCrs))
if targetCrs.isValid():
arguments.append('-t_srs')
arguments.append(GdalUtils.gdal_crs_string(targetCrs))
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
if data_type:
arguments.append('-ot ' + self.TYPES[data_type])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if self.parameterAsBoolean(parameters, self.KEEP_RESOLUTION, context):
arguments.append('-tr')
arguments.append(str(inLayer.rasterUnitsPerPixelX()))
arguments.append(str(-inLayer.rasterUnitsPerPixelY()))
arguments.append('-tap')
if self.parameterAsBoolean(parameters, self.SET_RESOLUTION, context):
arguments.append('-tr')
if self.X_RESOLUTION in parameters and parameters[
self.X_RESOLUTION] is not None:
xres = self.parameterAsDouble(parameters, self.X_RESOLUTION,
context)
arguments.append('{}'.format(xres))
else:
arguments.append(str(inLayer.rasterUnitsPerPixelX()))
if self.Y_RESOLUTION in parameters and parameters[
self.Y_RESOLUTION] is not None:
yres = self.parameterAsDouble(parameters, self.Y_RESOLUTION,
context)
arguments.append('{}'.format(yres))
else:
arguments.append(str(-inLayer.rasterUnitsPerPixelY()))
arguments.append('-tap')
arguments.append('-cutline')
arguments.append(maskLayer)
arguments.append('-cl')
arguments.append(maskLayerName)
if self.parameterAsBoolean(parameters, self.CROP_TO_CUTLINE, context):
arguments.append('-crop_to_cutline')
if self.parameterAsBoolean(parameters, self.ALPHA_BAND, context):
arguments.append('-dstalpha')
if nodata is not None:
arguments.append('-dstnodata {}'.format(nodata))
if self.parameterAsBoolean(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
if self.EXTRA in parameters and parameters[self.EXTRA] not in (None,
''):
extra = self.parameterAsString(parameters, self.EXTRA, context)
arguments.append(extra)
arguments.append(inLayer.source())
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
