def getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
mask = self.getParameterValue(self.MASK)
maskLayer = dataobjects.getObjectFromUri(
self.getParameterValue(self.MASK))
ogrMask = ogrConnectionString(mask)[1:-1]
noData = self.getParameterValue(self.NO_DATA)
opts = self.getParameterValue(self.OPTIONS)
if noData is not None:
noData = str(noData)
addAlphaBand = self.getParameterValue(self.ALPHA_BAND)
cropToCutline = self.getParameterValue(self.CROP_TO_CUTLINE)
keepResolution = self.getParameterValue(self.KEEP_RESOLUTION)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
arguments.append('-q')
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if noData and len(noData) > 0:
arguments.append('-dstnodata')
arguments.append(noData)
if keepResolution:
r = gdal.Open(self.getParameterValue(self.INPUT))
geoTransform = r.GetGeoTransform()
r = None
arguments.append('-tr')
arguments.append(str(geoTransform[1]))
arguments.append(str(geoTransform[5]))
arguments.append('-tap')
arguments.append('-cutline')
arguments.append(ogrMask)
if maskLayer and maskLayer.subsetString() != '':
arguments.append('-cwhere')
arguments.append(maskLayer.subsetString())
if cropToCutline:
arguments.append('-crop_to_cutline')
if addAlphaBand:
arguments.append('-dstalpha')
if opts:
arguments.append('-co')
arguments.append(opts)
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters):
out = self.getOutputValue(self.OUTPUT)
mask = self.getParameterValue(self.MASK)
context = dataobjects.createContext()
maskLayer = QgsProcessingUtils.mapLayerFromString(self.getParameterValue(self.MASK), context)
ogrMask = ogrConnectionString(mask)[1:-1]
noData = self.getParameterValue(self.NO_DATA)
opts = self.getParameterValue(self.OPTIONS)
if noData is not None:
noData = str(noData)
addAlphaBand = self.getParameterValue(self.ALPHA_BAND)
cropToCutline = self.getParameterValue(self.CROP_TO_CUTLINE)
keepResolution = self.getParameterValue(self.KEEP_RESOLUTION)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
arguments.append('-q')
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if noData and len(noData) > 0:
arguments.append('-dstnodata')
arguments.append(noData)
if keepResolution:
r = gdal.Open(self.getParameterValue(self.INPUT))
geoTransform = r.GetGeoTransform()
r = None
arguments.append('-tr')
arguments.append(str(geoTransform[1]))
arguments.append(str(geoTransform[5]))
arguments.append('-tap')
arguments.append('-cutline')
arguments.append(ogrMask)
if maskLayer and maskLayer.subsetString() != '':
arguments.append('-cwhere')
arguments.append(maskLayer.subsetString())
if cropToCutline:
arguments.append('-crop_to_cutline')
if addAlphaBand:
arguments.append('-dstalpha')
if opts:
arguments.append('-co')
arguments.append(opts)
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Warp (reproject)')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Projections')
self.tags = self.tr('transform,reproject,crs,srs')
self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(ParameterCrs(self.SOURCE_SRS,
self.tr('Source SRS'), '', optional=True))
self.addParameter(ParameterCrs(self.DEST_SRS,
self.tr('Destination SRS'), 'EPSG:4326'))
self.addParameter(ParameterString(self.NO_DATA,
self.tr("Nodata value, leave blank to take the nodata value from input"),
'', optional=True))
self.addParameter(ParameterNumber(self.TR,
self.tr('Output file resolution in target georeferenced units (leave 0 for no change)'),
0.0, None, 0.0))
self.addParameter(ParameterSelection(self.METHOD,
self.tr('Resampling method'), self.METHOD_OPTIONS))
self.addParameter(ParameterExtent(self.RAST_EXT, self.tr('Raster extent'), optional=True))
if GdalUtils.version() >= 2000000:
self.addParameter(ParameterCrs(self.EXT_CRS,
self.tr('CRS of the raster extent, leave blank for using Destination SRS'),
optional=True))
params = []
params.append(ParameterSelection(self.RTYPE,
self.tr('Output raster type'), self.TYPE, 5))
params.append(ParameterSelection(self.COMPRESS,
self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 4))
params.append(ParameterNumber(self.JPEGCOMPRESSION,
self.tr('Set the JPEG compression level'),
1, 100, 75))
params.append(ParameterNumber(self.ZLEVEL,
self.tr('Set the DEFLATE compression level'),
1, 9, 6))
params.append(ParameterNumber(self.PREDICTOR,
self.tr('Set the predictor for LZW or DEFLATE compression'),
1, 3, 1))
params.append(ParameterBoolean(self.TILED,
self.tr('Create tiled output (only used for the GTiff format)'), False))
params.append(ParameterSelection(self.BIGTIFF,
self.tr('Control whether the created file is a BigTIFF or a classic TIFF'), self.BIGTIFFTYPE, 0))
params.append(ParameterBoolean(self.TFW,
self.tr('Force the generation of an associated ESRI world file (.tfw))'), False))
params.append(ParameterString(self.EXTRA,
self.tr('Additional creation parameters'), '', optional=True))
for param in params:
param.isAdvanced = True
self.addParameter(param)
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Reprojected')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Warp (reproject)')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Projections')
self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(ParameterCrs(self.SOURCE_SRS,
self.tr('Source SRS'), '', optional=True))
self.addParameter(ParameterCrs(self.DEST_SRS,
self.tr('Destination SRS'), ''))
self.addParameter(ParameterString(self.NO_DATA,
self.tr("Nodata value, leave blank to take the nodata value from input"),
'', optional=True))
self.addParameter(ParameterNumber(self.TR,
self.tr('Output file resolution in target georeferenced units (leave 0 for no change)'),
0.0, None, 0.0))
self.addParameter(ParameterSelection(self.METHOD,
self.tr('Resampling method'), self.METHOD_OPTIONS))
self.addParameter(ParameterExtent(self.RAST_EXT, self.tr('Raster extent'), optional=True))
if GdalUtils.version() >= 2000000:
self.addParameter(ParameterCrs(self.EXT_CRS,
self.tr('CRS of the raster extent, leave blank for using Destination SRS'),
optional=True))
params = []
params.append(ParameterSelection(self.RTYPE,
self.tr('Output raster type'), self.TYPE, 5))
params.append(ParameterSelection(self.COMPRESS,
self.tr('GeoTIFF options. Compression type:'), self.COMPRESSTYPE, 4))
params.append(ParameterNumber(self.JPEGCOMPRESSION,
self.tr('Set the JPEG compression level'),
1, 100, 75))
params.append(ParameterNumber(self.ZLEVEL,
self.tr('Set the DEFLATE compression level'),
1, 9, 6))
params.append(ParameterNumber(self.PREDICTOR,
self.tr('Set the predictor for LZW or DEFLATE compression'),
1, 3, 1))
params.append(ParameterBoolean(self.TILED,
self.tr('Create tiled output (only used for the GTiff format)'), False))
params.append(ParameterSelection(self.BIGTIFF,
self.tr('Control whether the created file is a BigTIFF or a classic TIFF'), self.BIGTIFFTYPE, 0))
params.append(ParameterBoolean(self.TFW,
self.tr('Force the generation of an associated ESRI world file (.tfw))'), False))
params.append(ParameterString(self.EXTRA,
self.tr('Additional creation parameters'), '', optional=True))
for param in params:
param.isAdvanced = True
self.addParameter(param)
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Reprojected')))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Warp (reproject)')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Projections')
self.tags = self.tr('transform,reproject,crs,srs')
self.addParameter(ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(ParameterCrs(self.SOURCE_SRS,
self.tr('Source SRS'),
'',
optional=True))
self.addParameter(ParameterCrs(self.DEST_SRS,
self.tr('Destination SRS'),
'EPSG:4326'))
self.addParameter(ParameterString(self.NO_DATA,
self.tr("Nodata value, leave blank to take the nodata value from input"),
'', optional=True))
self.addParameter(ParameterNumber(self.TR,
self.tr('Output file resolution in target georeferenced units (leave 0 for no change)'),
0.0, None, 0.0))
self.addParameter(ParameterSelection(self.METHOD,
self.tr('Resampling method'),
self.METHOD_OPTIONS))
self.addParameter(ParameterExtent(self.RAST_EXT,
self.tr('Raster extent'),
optional=True))
if GdalUtils.version() >= 2000000:
self.addParameter(ParameterCrs(self.EXT_CRS,
self.tr('CRS of the raster extent, leave blank for using Destination SRS'),
optional=True))
self.addParameter(ParameterString(self.OPTIONS,
self.tr('Additional creation options'),
optional=True,
metadata={'widget_wrapper': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}))
self.addParameter(ParameterSelection(self.RTYPE,
self.tr('Output raster type'),
self.TYPE, 5))
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Reprojected')))
def getConsoleCommands(self):
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
srccrs = self.getParameterValue(self.SOURCE_SRS)
dstcrs = self.getParameterValue(self.DEST_SRS)
jpegcompression = str(self.getParameterValue(self.JPEGCOMPRESSION))
predictor = str(self.getParameterValue(self.PREDICTOR))
zlevel = str(self.getParameterValue(self.ZLEVEL))
tiled = str(self.getParameterValue(self.TILED))
compress = self.COMPRESSTYPE[self.getParameterValue(self.COMPRESS)]
bigtiff = self.BIGTIFFTYPE[self.getParameterValue(self.BIGTIFF)]
tfw = str(self.getParameterValue(self.TFW))
rastext = self.getParameterValue(self.RAST_EXT)
rastext_crs = self.getParameterValue(self.EXT_CRS)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(
self.METHOD_OPTIONS[self.getParameterValue(self.METHOD)])
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.getParameterValue(self.TR) != 0:
arguments.append('-tr')
arguments.append(str(self.getParameterValue(self.TR)))
arguments.append(str(self.getParameterValue(self.TR)))
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = str(extra)
if rastext:
regionCoords = rastext.split(',')
if len(regionCoords) >= 4:
arguments.append('-te')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
if GdalUtils.version() >= 2000000:
if rastext_crs:
arguments.append('-te_srs')
arguments.append(rastext_crs)
if extra and len(extra) > 0:
arguments.append(extra)
if GdalUtils.getFormatShortNameFromFilename(out) == "GTiff":
arguments.append("-co COMPRESS=" + compress)
if compress == 'JPEG':
arguments.append("-co JPEG_QUALITY=" + jpegcompression)
elif (compress == 'LZW') or (compress == 'DEFLATE'):
arguments.append("-co PREDICTOR=" + predictor)
if compress == 'DEFLATE':
arguments.append("-co ZLEVEL=" + zlevel)
if tiled == "True":
arguments.append("-co TILED=YES")
if tfw == "True":
arguments.append("-co TFW=YES")
if len(bigtiff) > 0:
arguments.append("-co BIGTIFF=" + bigtiff)
arguments.append("-wo OPTIMIZE_SIZE=TRUE")
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = unicode(noData)
srccrs = self.getParameterValue(self.SOURCE_SRS)
dstcrs = self.getParameterValue(self.DEST_SRS)
jpegcompression = unicode(self.getParameterValue(self.JPEGCOMPRESSION))
predictor = unicode(self.getParameterValue(self.PREDICTOR))
zlevel = unicode(self.getParameterValue(self.ZLEVEL))
tiled = unicode(self.getParameterValue(self.TILED))
compress = self.COMPRESSTYPE[self.getParameterValue(self.COMPRESS)]
bigtiff = self.BIGTIFFTYPE[self.getParameterValue(self.BIGTIFF)]
tfw = unicode(self.getParameterValue(self.TFW))
useRasterExtent = self.getParameterValue(self.USE_RASTER_EXTENT)
rasterExtent = unicode(self.getParameterValue(self.RASTER_EXTENT))
extentCrs = self.getParameterValue(self.EXTENT_CRS)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData and len(noData) > 0:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(self.METHOD_OPTIONS[self.getParameterValue(
self.METHOD)])
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.getParameterValue(self.TR) != 0:
arguments.append('-tr')
arguments.append(unicode(self.getParameterValue(self.TR)))
arguments.append(unicode(self.getParameterValue(self.TR)))
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = unicode(extra)
if useRasterExtent:
regionCoords = rasterExtent.split(',')
if len(regionCoords) >= 4:
rastext = []
rastext.append('-te')
rastext.append(regionCoords[0])
rastext.append(regionCoords[2])
rastext.append(regionCoords[1])
rastext.append(regionCoords[3])
arguments.extend(rastext)
if GdalUtils.version() >= 2000000:
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs)
if extra and len(extra) > 0:
arguments.append(extra)
if GdalUtils.getFormatShortNameFromFilename(out) == "GTiff":
arguments.append("-co COMPRESS=" + compress)
if compress == 'JPEG':
arguments.append("-co JPEG_QUALITY=" + jpegcompression)
elif (compress == 'LZW') or (compress == 'DEFLATE'):
arguments.append("-co PREDICTOR=" + predictor)
if compress == 'DEFLATE':
arguments.append("-co ZLEVEL=" + zlevel)
if tiled == "True":
arguments.append("-co TILED=YES")
if tfw == "True":
arguments.append("-co TFW=YES")
if len(bigtiff) > 0:
arguments.append("-co BIGTIFF=" + bigtiff)
arguments.append("-wo OPTIMIZE_SIZE=TRUE")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
srccrs = self.parameterAsCrs(parameters, self.SOURCE_SRS, context).authid()
dstcrs = self.parameterAsCrs(parameters, self.DEST_SRS, context).authid()
useRasterExtent = self.parameterAsBool(parameters, self.USE_RASTER_EXTENT, context)
rasterExtent = self.parameterAsExtent(parameters, self.RASTER_EXTENT, context)
if rasterExtent.isNull():
rasterExtent = QgsProcessingUtils.combineLayerExtents([inLayer])
extentCrs = self.parameterAsCrs(parameters, self.EXTENT_CRS, context).authid()
opts = self.parameterAsEnum(parameters, self.OPTIONS, context)
noData = self.parameterAsString(parameters, self.NO_DATA, context)
multithreading = self.parameterAsBool(parameters, self.MULTITHREADING, context)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.parameterAsEnum(parameters, self.RTYPE, context)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(
self.METHOD_OPTIONS[self.parameterAsEnum(parameters, self.METHOD, context)])
arguments.append('-of')
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.parameterAsDouble(parameters, self.TR, context) != 0:
arguments.append('-tr')
arguments.append(str(self.parameterAsDouble(parameters, self.TR, context)))
arguments.append(str(self.parameterAsDouble(parameters, self.TR, context)))
if useRasterExtent:
arguments.append('-te')
arguments.append(rasterExtent.xMinimum())
arguments.append(rasterExtent.yMinimum())
arguments.append(rasterExtent.xMaximum())
arguments.append(rasterExtent.yMaximum())
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs)
if opts:
arguments.append('-co')
arguments.append(opts)
if multithreading:
arguments.append('-multi')
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(inLayer.source())
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
class warp(GdalAlgorithm):
INPUT = 'INPUT'
OUTPUT = 'OUTPUT'
SOURCE_SRS = 'SOURCE_SRS'
DEST_SRS = 'DEST_SRS'
METHOD = 'METHOD'
METHOD_OPTIONS = ['near', 'bilinear', 'cubic', 'cubicspline', 'lanczos']
if GdalUtils.version() >= 1100000:
METHOD_OPTIONS.extend(['average', 'mode'])
if GdalUtils.version() >= 2000000:
METHOD_OPTIONS.extend(['max', 'min', 'med', 'q1', 'q3'])
TR = 'TR'
NO_DATA = 'NO_DATA'
EXTRA = 'EXTRA'
RTYPE = 'RTYPE'
TYPE = ['Byte', 'Int16', 'UInt16', 'UInt32', 'Int32', 'Float32', 'Float64']
TILED = 'TILED'
COMPRESS = 'COMPRESS'
JPEGCOMPRESSION = 'JPEGCOMPRESSION'
PREDICTOR = 'PREDICTOR'
ZLEVEL = 'ZLEVEL'
BIGTIFF = 'BIGTIFF'
BIGTIFFTYPE = ['', 'YES', 'NO', 'IF_NEEDED', 'IF_SAFER']
COMPRESSTYPE = ['NONE', 'JPEG', 'LZW', 'PACKBITS', 'DEFLATE']
TFW = 'TFW'
USE_RASTER_EXTENT = 'USE_RASTER_EXTENT'
RASTER_EXTENT = 'RASTER_EXTENT'
EXTENT_CRS = 'EXTENT_CRS'
def getIcon(self):
return QIcon(
os.path.join(pluginPath, 'images', 'gdaltools', 'warp.png'))
def defineCharacteristics(self):
self.name, self.i18n_name = self.trAlgorithm('Warp (reproject)')
self.group, self.i18n_group = self.trAlgorithm('[GDAL] Projections')
self.addParameter(
ParameterRaster(self.INPUT, self.tr('Input layer'), False))
self.addParameter(
ParameterCrs(self.SOURCE_SRS,
self.tr('Source SRS'),
'',
optional=True))
self.addParameter(
ParameterCrs(self.DEST_SRS, self.tr('Destination SRS'), ''))
self.addParameter(
ParameterString(
self.NO_DATA,
self.
tr("Nodata value, leave blank to take the nodata value from input"
),
'',
optional=True))
self.addParameter(
ParameterNumber(
self.TR,
self.
tr('Output file resolution in target georeferenced units (leave 0 for no change)'
), 0.0, None, 0.0))
self.addParameter(
ParameterSelection(self.METHOD, self.tr('Resampling method'),
self.METHOD_OPTIONS))
self.addParameter(
ParameterBoolean(
self.USE_RASTER_EXTENT,
self.tr('Set georeferenced extents of output file'), False))
self.addParameter(
ParameterExtent(self.RASTER_EXTENT,
self.tr('Raster extent'),
optional=True))
self.addParameter(
ParameterCrs(self.EXTENT_CRS,
self.tr('CRS of the raster extent'),
'',
optional=True))
params = []
params.append(
ParameterSelection(self.RTYPE, self.tr('Output raster type'),
self.TYPE, 5))
params.append(
ParameterSelection(self.COMPRESS,
self.tr('GeoTIFF options. Compression type:'),
self.COMPRESSTYPE, 4))
params.append(
ParameterNumber(self.JPEGCOMPRESSION,
self.tr('Set the JPEG compression level'), 1, 100,
75))
params.append(
ParameterNumber(self.ZLEVEL,
self.tr('Set the DEFLATE compression level'), 1, 9,
6))
params.append(
ParameterNumber(
self.PREDICTOR,
self.tr('Set the predictor for LZW or DEFLATE compression'), 1,
3, 1))
params.append(
ParameterBoolean(
self.TILED,
self.tr(
'Create tiled output (only used for the GTiff format)'),
False))
params.append(
ParameterSelection(
self.BIGTIFF,
self.
tr('Control whether the created file is a BigTIFF or a classic TIFF'
), self.BIGTIFFTYPE, 0))
params.append(
ParameterBoolean(
self.TFW,
self.
tr('Force the generation of an associated ESRI world file (.tfw))'
), False))
params.append(
ParameterString(self.EXTRA,
self.tr('Additional creation parameters'),
'',
optional=True))
for param in params:
param.isAdvanced = True
self.addParameter(param)
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Reprojected')))
def getConsoleCommands(self):
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = unicode(noData)
srccrs = self.getParameterValue(self.SOURCE_SRS)
dstcrs = self.getParameterValue(self.DEST_SRS)
jpegcompression = unicode(self.getParameterValue(self.JPEGCOMPRESSION))
predictor = unicode(self.getParameterValue(self.PREDICTOR))
zlevel = unicode(self.getParameterValue(self.ZLEVEL))
tiled = unicode(self.getParameterValue(self.TILED))
compress = self.COMPRESSTYPE[self.getParameterValue(self.COMPRESS)]
bigtiff = self.BIGTIFFTYPE[self.getParameterValue(self.BIGTIFF)]
tfw = unicode(self.getParameterValue(self.TFW))
useRasterExtent = self.getParameterValue(self.USE_RASTER_EXTENT)
rasterExtent = unicode(self.getParameterValue(self.RASTER_EXTENT))
extentCrs = self.getParameterValue(self.EXTENT_CRS)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData and len(noData) > 0:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(self.METHOD_OPTIONS[self.getParameterValue(
self.METHOD)])
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.getParameterValue(self.TR) != 0:
arguments.append('-tr')
arguments.append(unicode(self.getParameterValue(self.TR)))
arguments.append(unicode(self.getParameterValue(self.TR)))
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = unicode(extra)
if useRasterExtent:
regionCoords = rasterExtent.split(',')
if len(regionCoords) >= 4:
rastext = []
rastext.append('-te')
rastext.append(regionCoords[0])
rastext.append(regionCoords[2])
rastext.append(regionCoords[1])
rastext.append(regionCoords[3])
arguments.extend(rastext)
if GdalUtils.version() >= 2000000:
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs)
if extra and len(extra) > 0:
arguments.append(extra)
if GdalUtils.getFormatShortNameFromFilename(out) == "GTiff":
arguments.append("-co COMPRESS=" + compress)
if compress == 'JPEG':
arguments.append("-co JPEG_QUALITY=" + jpegcompression)
elif (compress == 'LZW') or (compress == 'DEFLATE'):
arguments.append("-co PREDICTOR=" + predictor)
if compress == 'DEFLATE':
arguments.append("-co ZLEVEL=" + zlevel)
if tiled == "True":
arguments.append("-co TILED=YES")
if tfw == "True":
arguments.append("-co TFW=YES")
if len(bigtiff) > 0:
arguments.append("-co BIGTIFF=" + bigtiff)
arguments.append("-wo OPTIMIZE_SIZE=TRUE")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def initAlgorithm(self, config=None):
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_A,
self.tr('Input layer A'),
optional=False))
self.addParameter(
QgsProcessingParameterBand(
self.BAND_A,
self.tr('Number of raster band for A'),
parentLayerParameterName=self.INPUT_A))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_B,
self.tr('Input layer B'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(
self.BAND_B,
self.tr('Number of raster band for B'),
parentLayerParameterName=self.INPUT_B,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_C,
self.tr('Input layer C'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(
self.BAND_C,
self.tr('Number of raster band for C'),
parentLayerParameterName=self.INPUT_C,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_D,
self.tr('Input layer D'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(
self.BAND_D,
self.tr('Number of raster band for D'),
parentLayerParameterName=self.INPUT_D,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_E,
self.tr('Input layer E'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(
self.BAND_E,
self.tr('Number of raster band for E'),
parentLayerParameterName=self.INPUT_E,
optional=True))
self.addParameter(
QgsProcessingParameterRasterLayer(
self.INPUT_F,
self.tr('Input layer F'),
optional=True))
self.addParameter(
QgsProcessingParameterBand(
self.BAND_F,
self.tr('Number of raster band for F'),
parentLayerParameterName=self.INPUT_F,
optional=True))
self.addParameter(
QgsProcessingParameterString(
self.FORMULA,
self.tr('Calculation in gdalnumeric syntax using +-/* or any numpy array functions (i.e. logical_and())'),
'A*2',
optional=False))
self.addParameter(
QgsProcessingParameterNumber(
self.NO_DATA,
self.tr('Set output nodata value'),
type=QgsProcessingParameterNumber.Double,
defaultValue=None,
optional=True))
if GdalUtils.version() >= 3030000:
extent_param = QgsProcessingParameterExtent(self.EXTENT,
self.tr('Output extent'),
optional=True)
extent_param.setHelp(self.tr('Custom extent of the output raster'))
self.addParameter(extent_param)
self.addParameter(
QgsProcessingParameterEnum(
self.RTYPE,
self.tr('Output raster type'),
options=self.TYPE,
defaultValue=5))
options_param = QgsProcessingParameterString(self.OPTIONS,
self.tr('Additional creation options'),
defaultValue='',
optional=True)
options_param.setFlags(options_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
options_param.setMetadata({
'widget_wrapper': {
'class': 'processing.algs.gdal.ui.RasterOptionsWidget.RasterOptionsWidgetWrapper'}})
self.addParameter(options_param)
extra_param = QgsProcessingParameterString(self.EXTRA,
self.tr('Additional command-line parameters'),
defaultValue=None,
optional=True)
extra_param.setFlags(extra_param.flags() | QgsProcessingParameterDefinition.FlagAdvanced)
self.addParameter(extra_param)
self.addParameter(
QgsProcessingParameterRasterDestination(
self.OUTPUT,
self.tr('Calculated')))
def getConsoleCommands(self, parameters):
inLayer = self.getParameterValue(self.INPUT)
srccrs = self.getParameterValue(self.SOURCE_SRS)
dstcrs = self.getParameterValue(self.DEST_SRS)
useRasterExtent = self.getParameterValue(self.USE_RASTER_EXTENT)
rasterExtent = self.getParameterValue(self.RASTER_EXTENT)
if not rasterExtent:
rasterExtent = QgsProcessingUtils.combineLayerExtents([inLayer])
extentCrs = self.getParameterValue(self.EXTENT_CRS)
opts = self.getParameterValue(self.OPTIONS)
noData = self.getParameterValue(self.NO_DATA)
multithreading = self.getParameterValue(self.MULTITHREADING)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(
self.METHOD_OPTIONS[self.getParameterValue(self.METHOD)])
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.getParameterValue(self.TR) != 0:
arguments.append('-tr')
arguments.append(str(self.getParameterValue(self.TR)))
arguments.append(str(self.getParameterValue(self.TR)))
if useRasterExtent:
regionCoords = rasterExtent.split(',')
if len(regionCoords) >= 4:
arguments.append('-te')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs)
if opts:
arguments.append('-co')
arguments.append(opts)
if multithreading:
arguments.append('-multi')
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
mask = self.getParameterValue(self.MASK)
maskLayer = dataobjects.getObjectFromUri(self.getParameterValue(self.MASK))
ogrMask = ogrConnectionString(mask)[1:-1]
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
addAlphaBand = self.getParameterValue(self.ALPHA_BAND)
cropToCutline = self.getParameterValue(self.CROP_TO_CUTLINE)
keepResolution = self.getParameterValue(self.KEEP_RESOLUTION)
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = str(extra)
jpegcompression = str(self.getParameterValue(self.JPEGCOMPRESSION))
predictor = str(self.getParameterValue(self.PREDICTOR))
zlevel = str(self.getParameterValue(self.ZLEVEL))
tiled = str(self.getParameterValue(self.TILED))
compress = self.COMPRESSTYPE[self.getParameterValue(self.COMPRESS)]
bigtiff = self.BIGTIFFTYPE[self.getParameterValue(self.BIGTIFF)]
tfw = str(self.getParameterValue(self.TFW))
arguments = []
arguments.append("-ot")
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
arguments.append("-q")
arguments.append("-of")
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if noData and len(noData) > 0:
arguments.append("-dstnodata")
arguments.append(noData)
if keepResolution:
r = gdal.Open(self.getParameterValue(self.INPUT))
geoTransform = r.GetGeoTransform()
r = None
arguments.append("-tr")
arguments.append(str(geoTransform[1]))
arguments.append(str(geoTransform[5]))
arguments.append("-tap")
arguments.append("-cutline")
arguments.append(ogrMask)
if maskLayer and maskLayer.subsetString() != "":
arguments.append("-cwhere")
arguments.append(maskLayer.subsetString())
if cropToCutline:
arguments.append("-crop_to_cutline")
if addAlphaBand:
arguments.append("-dstalpha")
if extra and len(extra) > 0:
arguments.append(extra)
if GdalUtils.getFormatShortNameFromFilename(out) == "GTiff":
arguments.append("-co COMPRESS=" + compress)
if compress == "JPEG":
arguments.append("-co JPEG_QUALITY=" + jpegcompression)
elif (compress == "LZW") or (compress == "DEFLATE"):
arguments.append("-co PREDICTOR=" + predictor)
if compress == "DEFLATE":
arguments.append("-co ZLEVEL=" + zlevel)
if tiled == "True":
arguments.append("-co TILED=YES")
if tfw == "True":
arguments.append("-co TFW=YES")
if len(bigtiff) > 0:
arguments.append("-co BIGTIFF=" + bigtiff)
arguments.append("-wo OPTIMIZE_SIZE=TRUE")
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ["gdalwarp", GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
srccrs = self.parameterAsCrs(parameters, self.SOURCE_SRS, context).authid()
dstcrs = self.parameterAsCrs(parameters, self.DEST_SRS, context).authid()
useRasterExtent = self.parameterAsBool(parameters, self.USE_RASTER_EXTENT, context)
rasterExtent = self.parameterAsExtent(parameters, self.RASTER_EXTENT, context)
if rasterExtent.isNull():
rasterExtent = QgsProcessingUtils.combineLayerExtents([inLayer])
extentCrs = self.parameterAsCrs(parameters, self.EXTENT_CRS, context).authid()
opts = self.parameterAsEnum(parameters, self.OPTIONS, context)
noData = self.parameterAsString(parameters, self.NO_DATA, context)
multithreading = self.parameterAsBool(parameters, self.MULTITHREADING, context)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.parameterAsEnum(parameters, self.RTYPE, context)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(
self.METHOD_OPTIONS[self.parameterAsEnum(parameters, self.METHOD, context)])
arguments.append('-of')
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.parameterAsDouble(parameters, self.TR, context) != 0:
arguments.append('-tr')
arguments.append(str(self.parameterAsDouble(parameters, self.TR, context)))
arguments.append(str(self.parameterAsDouble(parameters, self.TR, context)))
if useRasterExtent:
arguments.append('-te')
arguments.append(rasterExtent.xMinimum())
arguments.append(rasterExtent.yMinimum())
arguments.append(rasterExtent.xMaximum())
arguments.append(rasterExtent.yMaximum())
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs)
if opts:
arguments.append('-co')
arguments.append(opts)
if multithreading:
arguments.append('-multi')
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(inLayer.source())
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
srccrs = self.getParameterValue(self.SOURCE_SRS)
dstcrs = self.getParameterValue(self.DEST_SRS)
rastext = self.getParameterValue(self.RAST_EXT)
rastext_crs = self.getParameterValue(self.EXT_CRS)
opts = self.getParameterValue(self.OPTIONS)
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(
self.METHOD_OPTIONS[self.getParameterValue(self.METHOD)])
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.getParameterValue(self.TR) != 0:
arguments.append('-tr')
arguments.append(str(self.getParameterValue(self.TR)))
arguments.append(str(self.getParameterValue(self.TR)))
if rastext:
regionCoords = rastext.split(',')
if len(regionCoords) >= 4:
arguments.append('-te')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
if rastext_crs:
arguments.append('-te_srs')
arguments.append(rastext_crs)
if opts:
arguments.append('-co')
arguments.append(opts)
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters):
inLayer = self.getParameterValue(self.INPUT)
srccrs = self.getParameterValue(self.SOURCE_SRS)
dstcrs = self.getParameterValue(self.DEST_SRS)
useRasterExtent = self.getParameterValue(self.USE_RASTER_EXTENT)
rasterExtent = self.getParameterValue(self.RASTER_EXTENT)
if not rasterExtent:
rasterExtent = QgsProcessingUtils.combineLayerExtents([inLayer])
extentCrs = self.getParameterValue(self.EXTENT_CRS)
opts = self.getParameterValue(self.OPTIONS)
noData = self.getParameterValue(self.NO_DATA)
multithreading = self.getParameterValue(self.MULTITHREADING)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(self.METHOD_OPTIONS[self.getParameterValue(
self.METHOD)])
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.getParameterValue(self.TR) != 0:
arguments.append('-tr')
arguments.append(str(self.getParameterValue(self.TR)))
arguments.append(str(self.getParameterValue(self.TR)))
if useRasterExtent:
regionCoords = rasterExtent.split(',')
if len(regionCoords) >= 4:
arguments.append('-te')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs)
if opts:
arguments.append('-co')
arguments.append(opts)
if multithreading:
arguments.append('-multi')
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
if GdalUtils.version() < 3030000 and self.EXTENT in parameters.keys():
raise QgsProcessingException(self.tr('The output extent option is only available on GDAL 3.3 or later'))
return GdalAlgorithm.processAlgorithm(self, parameters, context, feedback)
def getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
mask = self.getParameterValue(self.MASK)
maskLayer = dataobjects.getObjectFromUri(
self.getParameterValue(self.MASK))
ogrMask = ogrConnectionString(mask)[1:-1]
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
addAlphaBand = self.getParameterValue(self.ALPHA_BAND)
cropToCutline = self.getParameterValue(self.CROP_TO_CUTLINE)
keepResolution = self.getParameterValue(self.KEEP_RESOLUTION)
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = str(extra)
jpegcompression = str(self.getParameterValue(self.JPEGCOMPRESSION))
predictor = str(self.getParameterValue(self.PREDICTOR))
zlevel = str(self.getParameterValue(self.ZLEVEL))
tiled = str(self.getParameterValue(self.TILED))
compress = self.COMPRESSTYPE[self.getParameterValue(self.COMPRESS)]
bigtiff = self.BIGTIFFTYPE[self.getParameterValue(self.BIGTIFF)]
tfw = str(self.getParameterValue(self.TFW))
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
arguments.append('-q')
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if noData and len(noData) > 0:
arguments.append('-dstnodata')
arguments.append(noData)
if keepResolution:
r = gdal.Open(self.getParameterValue(self.INPUT))
geoTransform = r.GetGeoTransform()
r = None
arguments.append('-tr')
arguments.append(str(geoTransform[1]))
arguments.append(str(geoTransform[5]))
arguments.append('-tap')
arguments.append('-cutline')
arguments.append(ogrMask)
if maskLayer and maskLayer.subsetString() != '':
arguments.append('-cwhere')
arguments.append(maskLayer.subsetString())
if cropToCutline:
arguments.append('-crop_to_cutline')
if addAlphaBand:
arguments.append('-dstalpha')
if extra and len(extra) > 0:
arguments.append(extra)
if GdalUtils.getFormatShortNameFromFilename(out) == "GTiff":
arguments.append("-co COMPRESS=" + compress)
if compress == 'JPEG':
arguments.append("-co JPEG_QUALITY=" + jpegcompression)
elif (compress == 'LZW') or (compress == 'DEFLATE'):
arguments.append("-co PREDICTOR=" + predictor)
if compress == 'DEFLATE':
arguments.append("-co ZLEVEL=" + zlevel)
if tiled == "True":
arguments.append("-co TILED=YES")
if tfw == "True":
arguments.append("-co TFW=YES")
if len(bigtiff) > 0:
arguments.append("-co BIGTIFF=" + bigtiff)
arguments.append("-wo OPTIMIZE_SIZE=TRUE")
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def produce_warped_tif(self, write_result):
self.out("produce_warped_tif()")
"""
ASCII to warped TIF
"""
# very important!
if path.exists(self._full_tif_filename):
#self.out("removing old version of warped TIF before creating a new one...")
os.remove(self._full_tif_filename)
proj_radolan = self._model.projection_radolan
"""
METHOD Options:
0 - near
1 - bilinear
2 - cubic
3 - cubicspline
4 - lanczos
Eigentlich Default: 0 - aber man muss es angeben (QGIS 2.14 "Essen")
RTYPE: default: 5 = Float32
COMPRESS(GeoTIFF options. Compression type:)
0 - NONE
1 - JPEG
2 - LZW
3 - PACKBITS
4 - DEFLATE
wohl kein Default, also angeben
"""
# Standard (certain) params:
params = {
"INPUT": self._full_asc_filename,
"SOURCE_SRS": proj_radolan,
#"DEST_SRS": 'EPSG:3035', # QGIS 2?
"TARGET_CRS": 'EPSG:3035',
"METHOD": 0,
"COMPRESS": 4
}
"""
useful tip:
If you don't need to use the output for further elaborations, you may save it as memory layer.
For doing this you only need to set the 'output' parameter as None:
first = processing.runalg("gdalogr:warpreproject", { "INPUT": ... , "OUTPUT": None } )
Instead, if you want to use the output, you may easily do this by giving it a name and
then by calling it with getObject():
second = processing.getObject( first['OUTPUT'] )
-> https://gis.stackexchange.com/questions/224389/pyqgis-processing-runalg-release-input-in-windows
"""
#params['OUTPUT'] = self._full_tif_filename if write_result else None
params['OUTPUT'] = self._full_tif_filename if write_result else 'none' # in QGIS 3. Verrückt
# New GdalUtils version with some additional parameters! (RAST_EXT, ...)
#if version >= 2000000:
# Other possibility:
#>>> QgsExpressionContextUtils.globalScope().variableNames(): show all avail vars
#>>> QgsExpressionContextUtils.globalScope().variable('qgis_version') # with name
# out: u'2.99.0-Master'
#>>> QgsExpressionContextUtils.globalScope().variable('qgis_version_no') # better
""" .............................................................
HERE WE CAN SEND A GDAL CALL ADAPTED TO THE CORRESPONDING VERION!
............................................................. """
add_additional_keys = False
try:
version = GdalUtils.version()
if platform.system() == 'Windows':
system_name = "{} {}".format(platform.system(), platform.release())
raise OSError("Running on '{}'".format(system_name))
#except AttributeError as ex: # ex: class GdalUtils has no attribute 'version'
except AttributeError:
self.out("WARN: GdalUtils.version could not determined (older version?)", False)
self.out("continue without dict keys 'RAST_EXT', 'EXT_CRS'", False)
except OSError as e:
self.out(e, False)
self.out("continue without dict keys 'RAST_EXT', 'EXT_CRS'", False)
# Nur wenn Try OK: section for determining the extent of input raster by creating layer datatype
else:
self.out("GdalUtils.version is {}".format(version))
# Result for
# Dev-Version/Linux: 2010200
# 2.18.15 Las Palmas: 2020300
# Für diese Versionsnummer ging es nämlich NICHT! (openSUSE Leap 42.3, obige QGIS-Version)
if version != 2020300:
add_additional_keys = True
# Ende try-except-else-Block
if add_additional_keys:
# Make layer type from ASCII file to determine the mandatory 'extent':
asc_layer = self._create_QGSRasterLayer_with_projection(proj_radolan) # avoid projection dialog
extent = asc_layer.extent()
extent_params_as_string = "%f,%f,%f,%f" \
% (extent.xMinimum(), extent.xMaximum(), extent.yMinimum(), extent.yMaximum() )
# insert these params later for newer GDAL versions:
params['RAST_EXT'] = extent_params_as_string ### NEW! for new gdal versions.
params['EXT_CRS' ] = proj_radolan ### NEW! for new gdal versions. MUST be Radolan-Proj.!!!
self.out(" -> inserting new keys 'RAST_EXT', 'EXT_CRS'")
# Diagnose:
print("### Dict params are:\n ", params)
# For overview of the parameters use in QGIS python console:
# processing.alghelp("gdalogr:warpreproject")
#target = processing.runalg("gdalogr:warpreproject", params ) # return: dict QGIS 2
target = processing.run("gdal:warpreproject", params) # QGIS 3
fallback = False
# TIF shouldt be written but doesn't exists:
if write_result and not path.exists(self._full_tif_filename):
fallback = True
# Normal mode: return Memory Layer:
if not fallback:
#self._result = processing.getObject(target["OUTPUT"]) # key of dict, QGIS 2
context = QgsProcessingContext()
self._result = QgsProcessingUtils.mapLayerFromString(target["OUTPUT"], context)
#print("result =", self._result)
return #return self._result
"""
When warped TIF wasn't created:
FALLBACK MODE without dict
normally not, when dict is working
The normal way is positive tested on a QGIS-dev on Linux 2.12.99.
But the following fallback way need to implemented for the following
configuration: also on Linux, Python-Version 2.7.12 (default, Jul 01 2016, 15:36:53) [GCC]
QGIS-Version: 2.8.2 "Wien", exported
"""
#return
self._produce_warped_tif_fallback(write_result)
def getConsoleCommands(self):
srccrs = self.getParameterValue(self.SOURCE_SRS)
dstcrs = self.getParameterValue(self.DEST_SRS)
rastext = self.getParameterValue(self.RAST_EXT)
rastext_crs = self.getParameterValue(self.EXT_CRS)
opts = self.getParameterValue(self.OPTIONS)
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if srccrs:
arguments.append('-s_srs')
arguments.append(srccrs)
if dstcrs:
arguments.append('-t_srs')
arguments.append(dstcrs)
if noData:
arguments.append('-dstnodata')
arguments.append(noData)
arguments.append('-r')
arguments.append(self.METHOD_OPTIONS[self.getParameterValue(
self.METHOD)])
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if self.getParameterValue(self.TR) != 0:
arguments.append('-tr')
arguments.append(str(self.getParameterValue(self.TR)))
arguments.append(str(self.getParameterValue(self.TR)))
if rastext:
regionCoords = rastext.split(',')
if len(regionCoords) >= 4:
arguments.append('-te')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
if rastext_crs:
arguments.append('-te_srs')
arguments.append(rastext_crs)
if opts:
arguments.append('-co')
arguments.append(opts)
if GdalUtils.version() in [2010000, 2010100]:
arguments.append("--config GDALWARP_IGNORE_BAD_CUTLINE YES")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
