def getConsoleCommands(self):
noData = unicode(self.getParameterValue(self.NO_DATA))
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))
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if len(srccrs) > 0:
arguments.append('-s_srs')
arguments.append(srccrs)
if len(dstcrs) > 0:
arguments.append('-t_srs')
arguments.append(dstcrs)
if 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 = unicode(self.getParameterValue(self.EXTRA))
if 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(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
projwin = str(self.getParameterValue(self.PROJWIN))
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('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
regionCoords = projwin.split(',')
arguments.append('-projwin')
arguments.append(regionCoords[0])
arguments.append(regionCoords[3])
arguments.append(regionCoords[1])
arguments.append(regionCoords[2])
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(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, progress):
doTransf = self.transfList()
if self.getParameterValue(self.TRANSF) == 0:
# Direct transformation
arguments = ['-s_srs']
arguments.append(str(doTransf[self.getParameterValue(self.CRS)][self.getParameterValue(self.GRID)])[2:-2])
arguments.append('-t_srs')
arguments.append('EPSG:4258')
else:
# Inverse transformation
arguments = ['-s_srs']
arguments.append('EPSG:4258')
arguments.append('-t_srs')
arguments.append(str(doTransf[self.getParameterValue(self.CRS)][self.getParameterValue(self.GRID)])[2:-2])
arguments.append('-multi')
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
if os.path.isfile(os.path.dirname(__file__) + '/grids/AT_GIS_GRID.gsb') is False:
import urllib
urllib.urlretrieve ("https://github.com/NaturalGIS/ntv2_transformations_grids_and_sample_data/raw/master/at/AT_GIS_GRID.gsb", os.path.dirname(__file__) + "/grids/AT_GIS_GRID.gsb")
GdalUtils.runGdal(['gdalwarp', GdalUtils.escapeAndJoin(arguments)],
progress)
def getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
noData = self.getParameterValue(self.NO_DATA)
opts = self.getParameterValue(self.OPTIONS)
projwin = self.getParameterValue(self.PROJWIN)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
regionCoords = projwin.split(',')
arguments.append('-projwin')
arguments.append(regionCoords[0])
arguments.append(regionCoords[3])
arguments.append(regionCoords[1])
arguments.append(regionCoords[2])
if opts:
arguments.append('-co')
arguments.append(opts)
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
noData = unicode(self.getParameterValue(self.NO_DATA))
projwin = unicode(self.getParameterValue(self.PROJWIN))
extra = unicode(self.getParameterValue(self.EXTRA))
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
regionCoords = projwin.split(',')
arguments.append('-projwin')
arguments.append(regionCoords[0])
arguments.append(regionCoords[3])
arguments.append(regionCoords[1])
arguments.append(regionCoords[2])
if len(extra) > 0:
arguments.append(extra)
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters):
arguments = ['slope']
arguments.append(str(self.getParameterValue(self.INPUT)))
output = str(self.getOutputValue(self.OUTPUT))
arguments.append(output)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append('-b')
arguments.append(str(self.getParameterValue(self.BAND)))
arguments.append('-s')
arguments.append(str(self.getParameterValue(self.SCALE)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append('-compute_edges')
if self.getParameterValue(self.ZEVENBERGEN):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
if self.getParameterValue(self.AS_PERCENT):
arguments.append('-p')
return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
output = self.getOutputValue(self.OUTPUT)
arguments = []
arguments.append("-md")
arguments.append(str(self.getParameterValue(self.DISTANCE)))
if self.getParameterValue(self.ITERATIONS) != 0:
arguments.append("-si")
arguments.append(str(self.getParameterValue(self.ITERATIONS)))
arguments.append("-b")
arguments.append(str(self.getParameterValue(self.BAND)))
mask = self.getParameterValue(self.MASK)
if mask is not None:
arguments.append("-mask")
arguments.append(mask)
if self.getParameterValue(self.NO_DEFAULT_MASK):
arguments.append("-nomask")
arguments.append("-of")
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(output)
commands = []
if isWindows():
commands = ["cmd.exe", "/C ", "gdal_fillnodata.bat", GdalUtils.escapeAndJoin(arguments)]
else:
commands = ["gdal_fillnodata.py", GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self):
arguments = ["aspect"]
arguments.append(unicode(self.getParameterValue(self.INPUT)))
output = unicode(self.getOutputValue(self.OUTPUT))
arguments.append(output)
arguments.append("-of")
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append("-b")
arguments.append(str(self.getParameterValue(self.BAND)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append("-compute_edges")
if self.getParameterValue(self.ZEVENBERGEN):
arguments.append("-alg")
arguments.append("ZevenbergenThorne")
if self.getParameterValue(self.TRIG_ANGLE):
arguments.append("-trigonometric")
if self.getParameterValue(self.ZERO_FLAT):
arguments.append("-zero_for_flat")
return ["gdaldem", GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
arguments = []
arguments.append("-ot")
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if self.getParameterValue(self.SEPARATE):
arguments.append("-separate")
if self.getParameterValue(self.PCT):
arguments.append("-pct")
opts = self.getParameterValue(self.OPTIONS)
if opts:
arguments.append("-co")
arguments.append(opts)
arguments.append("-o")
out = self.getOutputValue(self.OUTPUT)
arguments.append(out)
arguments.append("-of")
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.extend(self.getParameterValue(self.INPUT).split(";"))
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):
output = self.getOutputValue(self.OUTPUT)
arguments = []
arguments.append('-st')
arguments.append(unicode(self.getParameterValue(self.THRESHOLD)))
arguments.append('-' +
self.PIXEL_CONNECTIONS[self.getParameterValue(
self.CONNECTIONS)])
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(output)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_sieve.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_sieve.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def processAlgorithm(self, progress):
out = self.getOutputValue(self.OUTPUT)
noData = str(self.getParameterValue(self.NO_DATA))
projwin = str(self.getParameterValue(self.PROJWIN))
extra = str(self.getParameterValue(self.EXTRA))
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
if len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
regionCoords = projwin.split(',')
arguments.append('-projwin')
arguments.append(regionCoords[0])
arguments.append(regionCoords[3])
arguments.append(regionCoords[1])
arguments.append(regionCoords[2])
if len(extra) > 0:
arguments.append(extra)
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
GdalUtils.runGdal(['gdal_translate',
GdalUtils.escapeAndJoin(arguments)], progress)
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(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, 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.TRIG_ANGLE, context):
arguments.append('-trigonometric')
if self.parameterAsBool(parameters, self.ZERO_FLAT, context):
arguments.append('-zero_for_flat')
return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, progress):
arguments = ['aspect']
arguments.append(unicode(self.getParameterValue(self.INPUT)))
output = unicode(self.getOutputValue(self.OUTPUT))
arguments.append(output)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append('-b')
arguments.append(str(self.getParameterValue(self.BAND)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append('-compute_edges')
if self.getParameterValue(self.ZEVENBERGEN):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
if self.getParameterValue(self.TRIG_ANGLE):
arguments.append('-trigonometric')
if self.getParameterValue(self.ZERO_FLAT):
arguments.append('-zero_for_flat')
GdalUtils.runGdal(['gdaldem',
GdalUtils.escapeAndJoin(arguments)], progress)
def getConsoleCommands(self):
arguments = ['aspect']
arguments.append(str(self.getParameterValue(self.INPUT)))
output = str(self.getOutputValue(self.OUTPUT))
arguments.append(output)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append('-b')
arguments.append(str(self.getParameterValue(self.BAND)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append('-compute_edges')
if self.getParameterValue(self.ZEVENBERGEN):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
if self.getParameterValue(self.TRIG_ANGLE):
arguments.append('-trigonometric')
if self.getParameterValue(self.ZERO_FLAT):
arguments.append('-zero_for_flat')
return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
arguments = ['color-relief']
arguments.append(unicode(self.getParameterValue(self.INPUT)))
arguments.append(unicode(self.getParameterValue(self.COLOR_TABLE)))
#filePath = unicode(self.getParameterValue(self.COLOR_TABLE))
#if filePath is None or filePath == '':
# filePath = os.path.join(os.path.dirname(__file__), 'terrain.txt')
#arguments.append(filePath)
arguments.append(unicode(self.getOutputValue(self.OUTPUT)))
out = unicode(self.getOutputValue(self.OUTPUT))
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-b')
arguments.append(unicode(self.getParameterValue(self.BAND)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append('-compute_edges')
mode = self.getParameterValue(self.MATCH_MODE)
if mode == 1:
arguments.append('-exact_color_entry')
elif mode == 2:
arguments.append('-nearest_color_entry')
return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, progress):
arguments = ["-s_srs"]
if self.getParameterValue(self.GRID) == 0:
# Jose Alberto Goncalves
arguments.append(
"+proj=tmerc +lat_0=39.66666666666666 +lon_0=-8.131906111111112 +k=1 +x_0=180.598 +y_0=-86.99 +ellps=intl +nadgrids="
+ os.path.dirname(__file__)
+ "/grids/pt73_e89.gsb +wktext +units=m +no_defs"
)
else:
# Direccao Geral do Territorio
arguments.append(
"+proj=tmerc +lat_0=39.66666666666666 +lon_0=-8.131906111111112 +k=1 +x_0=180.598 +y_0=-86.99 +ellps=intl +nadgrids="
+ os.path.dirname(__file__)
+ "/grids/D73_ETRS89_geo.gsb +wktext +units=m +no_defs"
)
arguments.append("-t_srs")
arguments.append("EPSG:3763")
arguments.append("-r")
arguments.append("bilinear")
arguments.append("-dstnodata")
arguments.append("nan")
arguments.append("-of")
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
GdalUtils.runGdal(["gdalwarp", GdalUtils.escapeAndJoin(arguments)], progress)
def getConsoleCommands(self):
arguments = ['hillshade']
arguments.append(unicode(self.getParameterValue(self.INPUT)))
arguments.append(unicode(self.getOutputValue(self.OUTPUT)))
out = unicode(self.getOutputValue(self.OUTPUT))
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-b')
arguments.append(unicode(self.getParameterValue(self.BAND)))
arguments.append('-z')
arguments.append(unicode(self.getParameterValue(self.Z_FACTOR)))
arguments.append('-s')
arguments.append(unicode(self.getParameterValue(self.SCALE)))
arguments.append('-az')
arguments.append(unicode(self.getParameterValue(self.AZIMUTH)))
arguments.append('-alt')
arguments.append(unicode(self.getParameterValue(self.ALTITUDE)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append('-compute_edges')
if self.getParameterValue(self.ZEVENBERGEN):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
return ['gdaldem', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
out = self.getOutputValue(translate.OUTPUT)
outsize = str(self.getParameterValue(self.OUTSIZE))
outsizePerc = str(self.getParameterValue(self.OUTSIZE_PERC))
noData = self.getParameterValue(self.NO_DATA)
expand = str(self.getParameterFromName(
self.EXPAND).options[self.getParameterValue(self.EXPAND)])
projwin = str(self.getParameterValue(self.PROJWIN))
crsId = self.getParameterValue(self.SRS)
sds = self.getParameterValue(self.SDS)
opts = self.getParameterValue(self.OPTIONS)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if outsizePerc == 'True':
arguments.append('-outsize')
arguments.append(outsize + '%')
arguments.append(outsize + '%')
else:
arguments.append('-outsize')
arguments.append(outsize)
arguments.append(outsize)
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
if expand != 'none':
arguments.append('-expand')
arguments.append(expand)
regionCoords = projwin.split(',')
try:
projwin = []
projwin.append('-projwin')
projwin.append(regionCoords[0])
projwin.append(regionCoords[3])
projwin.append(regionCoords[1])
projwin.append(regionCoords[2])
except IndexError:
projwin = []
if projwin:
arguments.extend(projwin)
if crsId:
arguments.append('-a_srs')
arguments.append(str(crsId))
if sds:
arguments.append('-sds')
if opts:
arguments.append('-co')
arguments.append(opts)
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters):
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if self.getParameterValue(self.SEPARATE):
arguments.append('-separate')
if self.getParameterValue(self.PCT):
arguments.append('-pct')
opts = self.getParameterValue(self.OPTIONS)
if opts:
arguments.append('-co')
arguments.append(opts)
arguments.append('-o')
out = self.getOutputValue(self.OUTPUT)
arguments.append(out)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.extend(self.getParameterValue(self.INPUT).split(';'))
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):
arguments = ["slope"]
arguments.append(str(self.getParameterValue(self.INPUT)))
output = str(self.getOutputValue(self.OUTPUT))
arguments.append(output)
arguments.append("-of")
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append("-b")
arguments.append(str(self.getParameterValue(self.BAND)))
arguments.append("-s")
arguments.append(str(self.getParameterValue(self.SCALE)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append("-compute_edges")
if self.getParameterValue(self.ZEVENBERGEN):
arguments.append("-alg")
arguments.append("ZevenbergenThorne")
if self.getParameterValue(self.AS_PERCENT):
arguments.append("-p")
return ["gdaldem", GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, progress):
arguments = []
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
arguments.append('-s_srs')
arguments.append(str(self.getParameterValue(self.SOURCE_SRS)))
arguments.append('-t_srs')
crsId = self.getParameterValue(self.DEST_SRS)
self.crs = QgsCoordinateReferenceSystem(crsId)
arguments.append(str(crsId))
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 = str(self.getParameterValue(self.EXTRA))
if len(extra) > 0:
arguments.append(extra)
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
GdalUtils.runGdal(['gdalwarp', GdalUtils.escapeAndJoin(arguments)],
progress)
def getConsoleCommands(self):
arguments = ['-l']
arguments.append(
os.path.basename(os.path.splitext(
unicode(self.getParameterValue(self.INPUT)))[0]))
fieldName = self.getParameterValue(self.Z_FIELD)
if fieldName is not None and fieldName != '':
arguments.append('-zfield')
arguments.append(fieldName)
params = 'average'
params += ':radius1=%s' % self.getParameterValue(self.RADIUS_1)
params += ':radius2=%s' % self.getParameterValue(self.RADIUS_2)
params += ':angle=%s' % self.getParameterValue(self.ANGLE)
params += ':min_points=%s' % self.getParameterValue(self.MIN_POINTS)
params += ':nodata=%s' % self.getParameterValue(self.NODATA)
arguments.append('-a')
arguments.append(params)
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
out = self.getOutputValue(self.OUTPUT)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append(unicode(self.getParameterValue(self.INPUT)))
arguments.append(unicode(self.getOutputValue(self.OUTPUT)))
return ['gdal_grid', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, progress):
output = self.getOutputValue(self.OUTPUT)
arguments = []
arguments.append('-st')
arguments.append(str(self.getParameterValue(self.THRESHOLD)))
arguments.append('-' +
self.PIXEL_CONNECTIONS[self.getParameterValue(
self.CONNECTIONS)])
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(output)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_sieve.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_sieve.py', GdalUtils.escapeAndJoin(arguments)]
GdalUtils.runGdal(commands, progress)
def processAlgorithm(self, progress):
arguments = ['slope']
arguments.append(unicode(self.getParameterValue(self.INPUT)))
output = unicode(self.getOutputValue(self.OUTPUT))
arguments.append(output)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append('-b')
arguments.append(str(self.getParameterValue(self.BAND)))
arguments.append('-s')
arguments.append(str(self.getParameterValue(self.SCALE)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append('-compute_edges')
if self.getParameterValue(self.ZEVENBERGEN):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
if self.getParameterValue(self.AS_PERCENT):
arguments.append('-p')
GdalUtils.runGdal(['gdaldem',
GdalUtils.escapeAndJoin(arguments)], progress)
def getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
noData = unicode(self.getParameterValue(self.NO_DATA))
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))
out = self.getOutputValue(self.OUTPUT)
extra = unicode(self.getParameterValue(self.EXTRA))
arguments = []
arguments.append('-a')
arguments.append(unicode(self.getParameterValue(self.FIELD)))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
dimType = self.getParameterValue(self.DIMENSIONS)
if dimType == 0:
# size in pixels
arguments.append('-ts')
arguments.append(unicode(self.getParameterValue(self.WIDTH)))
arguments.append(unicode(self.getParameterValue(self.HEIGHT)))
else:
# resolution in map units per pixel
arguments.append('-tr')
arguments.append(unicode(self.getParameterValue(self.WIDTH)))
arguments.append(unicode(self.getParameterValue(self.HEIGHT)))
if len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
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)
if len(extra) > 0:
arguments.append(extra)
arguments.append('-l')
arguments.append(ogrLayerName(inLayer))
arguments.append(ogrLayer)
arguments.append(unicode(self.getOutputValue(self.OUTPUT)))
return ['gdal_rasterize', 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 getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = unicode(extra)
formula = self.getParameterValue(self.FORMULA)
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = unicode(noData)
arguments = []
arguments.append('--calc "{}"'.format(formula))
arguments.append('--format')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('--type')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if noData and len(noData) > 0:
arguments.append('--NoDataValue')
arguments.append(noData)
if extra and len(extra) > 0:
arguments.append(extra)
arguments.append('-A')
arguments.append(self.getParameterValue(self.INPUT_A))
if self.getParameterValue(self.BAND_A):
arguments.append('--A_band ' + self.getParameterValue(self.BAND_A))
if self.getParameterValue(self.INPUT_B):
arguments.append('-B')
arguments.append(self.getParameterValue(self.INPUT_B))
if self.getParameterValue(self.BAND_B):
arguments.append('--B_band ' + self.getParameterValue(self.BAND_B))
if self.getParameterValue(self.INPUT_C):
arguments.append('-C')
arguments.append(self.getParameterValue(self.INPUT_C))
if self.getParameterValue(self.BAND_C):
arguments.append('--C_band ' + self.getParameterValue(self.BAND_C))
if self.getParameterValue(self.INPUT_D):
arguments.append('-D')
arguments.append(self.getParameterValue(self.INPUT_D))
if self.getParameterValue(self.BAND_D):
arguments.append('--D_band ' + self.getParameterValue(self.BAND_D))
if self.getParameterValue(self.INPUT_E):
arguments.append('-E')
arguments.append(self.getParameterValue(self.INPUT_E))
if self.getParameterValue(self.BAND_E):
arguments.append('--E_band ' + self.getParameterValue(self.BAND_E))
if self.getParameterValue(self.INPUT_F):
arguments.append('-F')
arguments.append(self.getParameterValue(self.INPUT_F))
if self.getParameterValue(self.BAND_F):
arguments.append('--F_band ' + self.getParameterValue(self.BAND_F))
arguments.append('--outfile')
arguments.append(out)
if isWindows():
return ['gdal_calc', GdalUtils.escapeAndJoin(arguments)]
else:
return ['gdal_calc.py', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, progress):
out = self.getOutputValue(self.OUTPUT)
extra = str(self.getParameterValue(self.EXTRA))
#debug = self.getParameterValue(self.DEBUG)
formula = self.getParameterValue(self.FORMULA)
noData = str(self.getParameterValue(self.NO_DATA))
arguments = []
arguments.append('--calc')
arguments.append('"' + formula + '"')
arguments.append('--format')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('--type')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if len(noData) > 0:
arguments.append('--NoDataValue')
arguments.append(noData)
if len(extra) > 0:
arguments.append(extra)
#if debug:
# arguments.append('--debug')
arguments.append('-A')
arguments.append(self.getParameterValue(self.INPUT_A))
if self.getParameterValue(self.BAND_A):
arguments.append('--A_band ' + self.getParameterValue(self.BAND_A))
if self.getParameterValue(self.INPUT_B):
arguments.append('-B')
arguments.append(self.getParameterValue(self.INPUT_B))
if self.getParameterValue(self.BAND_B):
arguments.append('--B_band ' + self.getParameterValue(self.BAND_B))
if self.getParameterValue(self.INPUT_C):
arguments.append('-C')
arguments.append(self.getParameterValue(self.INPUT_C))
if self.getParameterValue(self.BAND_C):
arguments.append('--C_band ' + self.getParameterValue(self.BAND_C))
if self.getParameterValue(self.INPUT_D):
arguments.append('-D')
arguments.append(self.getParameterValue(self.INPUT_D))
if self.getParameterValue(self.BAND_D):
arguments.append('--D_band ' + self.getParameterValue(self.BAND_D))
if self.getParameterValue(self.INPUT_E):
arguments.append('-E')
arguments.append(self.getParameterValue(self.INPUT_E))
if self.getParameterValue(self.BAND_E):
arguments.append('--E_band ' + self.getParameterValue(self.BAND_E))
if self.getParameterValue(self.INPUT_F):
arguments.append('-F')
arguments.append(self.getParameterValue(self.INPUT_F))
if self.getParameterValue(self.BAND_F):
arguments.append('--F_band ' + self.getParameterValue(self.BAND_F))
arguments.append('--outfile')
arguments.append(out)
if isWindows():
GdalUtils.runGdal(['gdal_calc', GdalUtils.escapeAndJoin(arguments)], progress)
else:
GdalUtils.runGdal(['gdal_calc.py', GdalUtils.escapeAndJoin(arguments)], progress)
def processAlgorithm(self, parameters, context, feedback):
expression = self.getParameterValue(self.EXPRESSION)
layersValue = self.getParameterValue(self.LAYERS)
layersDict = {}
if layersValue:
layers = [QgsProcessingUtils.mapLayerFromString(f, context) for f in layersValue.split(";")]
layersDict = {os.path.basename(lyr.source().split(".")[0]): lyr for lyr in layers}
for lyr in QgsProcessingUtils.compatibleRasterLayers(context.project()):
name = lyr.name()
if (name + "@") in expression:
layersDict[name] = lyr
entries = []
for name, lyr in layersDict.items():
for n in range(lyr.bandCount()):
entry = QgsRasterCalculatorEntry()
entry.ref = '{:s}@{:d}'.format(name, n + 1)
entry.raster = lyr
entry.bandNumber = n + 1
entries.append(entry)
output = self.getOutputValue(self.OUTPUT)
extentValue = self.getParameterValue(self.EXTENT)
if not extentValue:
extentValue = QgsProcessingUtils.combineLayerExtents(layersValue)
if extentValue:
extent = extentValue.split(',')
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
else:
if layersDict:
bbox = list(layersDict.values())[0].extent()
for lyr in layersDict.values():
bbox.combineExtentWith(lyr.extent())
else:
raise GeoAlgorithmExecutionException(self.tr("No layers selected"))
def _cellsize(layer):
return (layer.extent().xMaximum() - layer.extent().xMinimum()) / layer.width()
cellsize = self.getParameterValue(self.CELLSIZE) or min([_cellsize(lyr) for lyr in layersDict.values()])
width = math.floor((bbox.xMaximum() - bbox.xMinimum()) / cellsize)
height = math.floor((bbox.yMaximum() - bbox.yMinimum()) / cellsize)
driverName = GdalUtils.getFormatShortNameFromFilename(output)
calc = QgsRasterCalculator(expression,
output,
driverName,
bbox,
width,
height,
entries)
res = calc.processCalculation()
if res == QgsRasterCalculator.ParserError:
raise GeoAlgorithmExecutionException(self.tr("Error parsing formula"))
def getConsoleCommands(self):
arguments = ['roughness']
arguments.append(unicode(self.getParameterValue(self.INPUT)))
output = unicode(self.getOutputValue(self.OUTPUT))
arguments.append(output)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(output))
arguments.append('-b')
arguments.append(unicode(self.getParameterValue(self.BAND)))
if self.getParameterValue(self.COMPUTE_EDGES):
arguments.append('-compute_edges')
return ['gdaldem', 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 getConsoleCommands(self):
out = self.getOutputValue(translate.OUTPUT)
outsize = unicode(self.getParameterValue(self.OUTSIZE))
outsizePerc = unicode(self.getParameterValue(self.OUTSIZE_PERC))
noData = unicode(self.getParameterValue(self.NO_DATA))
expand = unicode(
self.getParameterFromName(
self.EXPAND).options[self.getParameterValue(self.EXPAND)])
projwin = unicode(self.getParameterValue(self.PROJWIN))
crsId = self.getParameterValue(self.SRS)
sds = self.getParameterValue(self.SDS)
extra = unicode(self.getParameterValue(self.EXTRA))
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))
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if outsizePerc == 'True':
arguments.append('-outsize')
arguments.append(outsize + '%')
arguments.append(outsize + '%')
else:
arguments.append('-outsize')
arguments.append(outsize)
arguments.append(outsize)
if len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
if expand != 'none':
arguments.append('-expand')
arguments.append(expand)
regionCoords = projwin.split(',')
arguments.append('-projwin')
arguments.append(regionCoords[0])
arguments.append(regionCoords[3])
arguments.append(regionCoords[1])
arguments.append(regionCoords[2])
if crsId:
arguments.append('-a_srs')
arguments.append(unicode(crsId))
if sds:
arguments.append('-sds')
if 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(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
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))
out = self.getOutputValue(self.OUTPUT)
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = str(extra)
rastext = str(self.getParameterValue(self.RAST_EXT))
arguments = []
arguments.append('-a')
arguments.append(str(self.getParameterValue(self.FIELD)))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
dimType = self.getParameterValue(self.DIMENSIONS)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
regionCoords = rastext.split(',')
try:
rastext = []
rastext.append('-te')
rastext.append(regionCoords[0])
rastext.append(regionCoords[2])
rastext.append(regionCoords[1])
rastext.append(regionCoords[3])
except IndexError:
rastext = []
if rastext:
arguments.extend(rastext)
if dimType == 0:
# size in pixels
arguments.append('-ts')
arguments.append(str(self.getParameterValue(self.WIDTH)))
arguments.append(str(self.getParameterValue(self.HEIGHT)))
else:
# resolution in map units per pixel
arguments.append('-tr')
arguments.append(str(self.getParameterValue(self.WIDTH)))
arguments.append(str(self.getParameterValue(self.HEIGHT)))
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
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)
if extra and len(extra) > 0:
arguments.append(extra)
arguments.append('-l')
arguments.append(ogrLayerName(inLayer))
arguments.append(ogrLayer)
arguments.append(str(self.getOutputValue(self.OUTPUT)))
return ['gdal_rasterize', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
expression = self.parameterAsString(parameters, self.EXPRESSION,
context)
layers = self.parameterAsLayerList(parameters, self.LAYERS, context)
layersDict = {}
if layers:
layersDict = {
os.path.basename(lyr.source().split(".")[0]): lyr
for lyr in layers
}
crs = self.parameterAsCrs(parameters, self.CRS, context)
if not layers and not crs.isValid():
raise QgsProcessingException(
self.tr("No reference layer selected nor CRS provided"))
if not crs.isValid() and layers:
crs = list(layersDict.values())[0].crs()
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
if not layers and bbox.isNull():
raise QgsProcessingException(
self.tr("No reference layer selected nor extent box provided"))
if not bbox.isNull():
bboxCrs = self.parameterAsExtentCrs(parameters, self.EXTENT,
context)
if bboxCrs != crs:
transform = QgsCoordinateTransform(bboxCrs, crs,
context.project())
bbox = transform.transformBoundingBox(bbox)
if bbox.isNull() and layers:
bbox = QgsProcessingUtils.combineLayerExtents(layers, crs)
cellsize = self.parameterAsDouble(parameters, self.CELLSIZE, context)
if not layers and cellsize == 0:
raise QgsProcessingException(
self.tr(
"No reference layer selected nor cellsize value provided"))
def _cellsize(layer):
ext = layer.extent()
if layer.crs() != crs:
transform = QgsCoordinateTransform(layer.crs(), crs,
context.project())
ext = transform.transformBoundingBox(ext)
return (ext.xMaximum() - ext.xMinimum()) / layer.width()
if cellsize == 0:
cellsize = min([_cellsize(lyr) for lyr in layersDict.values()])
for lyr in QgsProcessingUtils.compatibleRasterLayers(
context.project()):
name = lyr.name()
if (name + "@") in expression:
layersDict[name] = lyr
entries = []
for name, lyr in layersDict.items():
for n in range(lyr.bandCount()):
ref = '{:s}@{:d}'.format(name, n + 1)
if ref in expression:
entry = QgsRasterCalculatorEntry()
entry.ref = ref
entry.raster = lyr
entry.bandNumber = n + 1
entries.append(entry)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
width = math.floor((bbox.xMaximum() - bbox.xMinimum()) / cellsize)
height = math.floor((bbox.yMaximum() - bbox.yMinimum()) / cellsize)
driverName = GdalUtils.getFormatShortNameFromFilename(output)
calc = QgsRasterCalculator(expression, output, driverName, bbox, crs,
width, height, entries)
res = calc.processCalculation(feedback)
if res == QgsRasterCalculator.ParserError:
raise QgsProcessingException(self.tr("Error parsing formula"))
return {self.OUTPUT: output}
def getConsoleCommands(self, parameters, context, feedback):
inLayer = self.getParameterValue(self.INPUT)
out = self.getOutputValue(translate.OUTPUT)
outsize = str(self.getParameterValue(self.OUTSIZE))
outsizePerc = str(self.getParameterValue(self.OUTSIZE_PERC))
noData = self.getParameterValue(self.NO_DATA)
expand = parameters[self.EXPAND].options[self.getParameterValue(
self.EXPAND)][1]
projwin = str(self.getParameterValue(self.PROJWIN))
if not projwin:
projwin = QgsProcessingUtils.combineLayerExtents([inLayer])
crsId = self.getParameterValue(self.SRS)
sds = self.getParameterValue(self.SDS)
opts = self.getParameterValue(self.OPTIONS)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if outsizePerc == 'True':
arguments.append('-outsize')
arguments.append(outsize + '%')
arguments.append(outsize + '%')
else:
arguments.append('-outsize')
arguments.append(outsize)
arguments.append(outsize)
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
if expand != 'none':
arguments.append('-expand')
arguments.append(expand)
regionCoords = projwin.split(',')
try:
projwin = []
projwin.append('-projwin')
projwin.append(regionCoords[0])
projwin.append(regionCoords[3])
projwin.append(regionCoords[1])
projwin.append(regionCoords[2])
except IndexError:
projwin = []
if projwin:
arguments.extend(projwin)
if crsId:
arguments.append('-a_srs')
arguments.append(str(crsId))
if sds:
arguments.append('-sds')
if opts:
arguments.append('-co')
arguments.append(opts)
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT)
noData = self.getParameterValue(self.NO_DATA)
rastext = str(self.getParameterValue(self.RAST_EXT))
opts = self.getParameterValue(self.OPTIONS)
out = self.getOutputValue(self.OUTPUT)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-a')
arguments.append(str(self.getParameterValue(self.FIELD)))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
dimType = self.getParameterValue(self.DIMENSIONS)
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
regionCoords = rastext.split(',')
try:
rastext = []
rastext.append('-te')
rastext.append(regionCoords[0])
rastext.append(regionCoords[2])
rastext.append(regionCoords[1])
rastext.append(regionCoords[3])
except IndexError:
rastext = []
if rastext:
arguments.extend(rastext)
if dimType == 0:
# size in pixels
arguments.append('-ts')
arguments.append(str(self.getParameterValue(self.WIDTH)))
arguments.append(str(self.getParameterValue(self.HEIGHT)))
else:
# resolution in map units per pixel
arguments.append('-tr')
arguments.append(str(self.getParameterValue(self.WIDTH)))
arguments.append(str(self.getParameterValue(self.HEIGHT)))
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
if opts:
arguments.append('-co')
arguments.append(opts)
arguments.append('-l')
print(ogrLayerName(inLayer))
arguments.append(ogrLayerName(inLayer))
arguments.append(ogrLayer)
arguments.append(out)
return ['gdal_rasterize', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, parameters, context, feedback):
expression = self.parameterAsString(parameters, self.EXPRESSION,
context)
layers = self.parameterAsLayerList(parameters, self.LAYERS, context)
layersDict = {}
if layers:
layersDict = {lyr.source(): lyr for lyr in layers}
crs = self.parameterAsCrs(parameters, self.CRS, context)
if crs is None or not crs.isValid():
if not layers:
raise QgsProcessingException(
self.tr("No reference layer selected nor CRS provided"))
else:
crs = list(layersDict.values())[0].crs()
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
if bbox.isNull() and not layers:
raise QgsProcessingException(
self.tr("No reference layer selected nor extent box provided"))
if not bbox.isNull():
bboxCrs = self.parameterAsExtentCrs(parameters, self.EXTENT,
context)
if bboxCrs != crs:
transform = QgsCoordinateTransform(bboxCrs, crs,
context.project())
bbox = transform.transformBoundingBox(bbox)
if bbox.isNull() and layers:
bbox = QgsProcessingUtils.combineLayerExtents(layers, crs)
cellsize = self.parameterAsDouble(parameters, self.CELLSIZE, context)
if cellsize == 0 and not layers:
raise QgsProcessingException(
self.tr(
"No reference layer selected nor cellsize value provided"))
def _cellsize(layer):
ext = layer.extent()
if layer.crs() != crs:
transform = QgsCoordinateTransform(layer.crs(), crs,
context.project())
ext = transform.transformBoundingBox(ext)
return (ext.xMaximum() - ext.xMinimum()) / layer.width()
if cellsize == 0:
cellsize = min([_cellsize(lyr) for lyr in layersDict.values()])
# check for layers available in the model
layersDictCopy = layersDict.copy(
) # need a shallow copy because next calls invalidate iterator
for lyr in layersDictCopy.values():
expression = self.mappedNameToLayer(lyr, expression, layersDict,
context)
# check for layers available in the project
for lyr in QgsProcessingUtils.compatibleRasterLayers(
context.project()):
expression = self.mappedNameToLayer(lyr, expression, layersDict,
context)
# create the list of layers to be passed as inputs to RasterCalculaltor
# at this phase expression has been modified to match available layers
# in the current scope
entries = []
for name, lyr in layersDict.items():
for n in range(lyr.bandCount()):
ref = '{:s}@{:d}'.format(name, n + 1)
if ref in expression:
entry = QgsRasterCalculatorEntry()
entry.ref = ref
entry.raster = lyr
entry.bandNumber = n + 1
entries.append(entry)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
width = math.floor((bbox.xMaximum() - bbox.xMinimum()) / cellsize)
height = math.floor((bbox.yMaximum() - bbox.yMinimum()) / cellsize)
driverName = GdalUtils.getFormatShortNameFromFilename(output)
calc = QgsRasterCalculator(expression, output, driverName, bbox, crs,
width, height, entries)
res = calc.processCalculation(feedback)
if res == QgsRasterCalculator.ParserError:
raise QgsProcessingException(self.tr("Error parsing formula"))
return {self.OUTPUT: output}
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
formula = self.parameterAsString(parameters, self.FORMULA, context)
if self.NO_DATA in parameters and parameters[self.NO_DATA] is not None:
noData = self.parameterAsDouble(parameters, self.NO_DATA, context)
else:
noData = None
arguments = []
arguments.append('--calc "{}"'.format(formula))
arguments.append('--format')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('--type')
arguments.append(self.TYPE[self.parameterAsEnum(
parameters, self.RTYPE, context)])
if noData is not None:
arguments.append('--NoDataValue')
arguments.append(noData)
layer = self.parameterAsRasterLayer(parameters, self.INPUT_A, context)
if layer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT_A))
arguments.append('-A')
arguments.append(layer.source())
if self.parameterAsString(parameters, self.BAND_A, context):
arguments.append(
'--A_band ' +
self.parameterAsString(parameters, self.BAND_A, context))
if self.INPUT_B in parameters and parameters[self.INPUT_B] is not None:
layer = self.parameterAsRasterLayer(parameters, self.INPUT_B,
context)
if layer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT_B))
arguments.append('-B')
arguments.append(layer.source())
if self.parameterAsString(parameters, self.BAND_B, context):
arguments.append(
'--B_band ' +
self.parameterAsString(parameters, self.BAND_B, context))
if self.INPUT_C in parameters and parameters[self.INPUT_C] is not None:
layer = self.parameterAsRasterLayer(parameters, self.INPUT_C,
context)
if layer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT_C))
arguments.append('-C')
arguments.append(layer.source())
if self.parameterAsString(parameters, self.BAND_C, context):
arguments.append(
'--C_band ' +
self.parameterAsString(parameters, self.BAND_C, context))
if self.INPUT_D in parameters and parameters[self.INPUT_D] is not None:
layer = self.parameterAsRasterLayer(parameters, self.INPUT_D,
context)
if layer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT_D))
arguments.append('-D')
arguments.append(layer.source())
if self.parameterAsString(parameters, self.BAND_D, context):
arguments.append(
'--D_band ' +
self.parameterAsString(parameters, self.BAND_D, context))
if self.INPUT_E in parameters and parameters[self.INPUT_E] is not None:
layer = self.parameterAsRasterLayer(parameters, self.INPUT_E,
context)
if layer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT_E))
arguments.append('-E')
arguments.append(layer.source())
if self.parameterAsString(parameters, self.BAND_E, context):
arguments.append(
'--E_band ' +
self.parameterAsString(parameters, self.BAND_E, context))
if self.INPUT_F in parameters and parameters[self.INPUT_F] is not None:
layer = self.parameterAsRasterLayer(parameters, self.INPUT_F,
context)
if layer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT_F))
arguments.append('-F')
arguments.append(layer.source())
if self.parameterAsString(parameters, self.BAND_F, context):
arguments.append(
'--F_band ' +
self.parameterAsString(parameters, self.BAND_F, context))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append('--outfile')
arguments.append(out)
return [self.commandName(), 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 processAlgorithm(self, progress):
if self.getParameterValue(self.TRANSF) == 0:
# Direct transformation
arguments = ['-s_srs']
if self.getParameterValue(self.CRS) == 0:
# HDKS5
if self.getParameterValue(self.GRID) == 0:
# HR_NTv2
arguments.append(
'+proj=tmerc +pm=greenwich +lat_0=0 +lon_0=15 +k=0.9999 +x_0=5500000 +y_0=0 +ellps=bessel +nadgrids='
+ os.path.dirname(__file__) +
'/grids/HRNTv2.gsb +wktext +units=m')
else:
# HDKS6
if self.getParameterValue(self.GRID) == 0:
# HR_NTv2
arguments.append(
'+proj=tmerc +pm=greenwich +lat_0=0 +lon_0=18 +k=0.9999 +x_0=6500000 +y_0=0 +ellps=bessel +nadgrids='
+ os.path.dirname(__file__) +
'/grids/HRNTv2.gsb +wktext +units=m')
arguments.append('-t_srs')
arguments.append('EPSG:3765')
else:
# Inverse transformation
arguments = ['-s_srs']
arguments.append('EPSG:3765')
arguments.append('-t_srs')
if self.getParameterValue(self.CRS) == 0:
# HDKS5
if self.getParameterValue(self.GRID) == 0:
# HR_NTv2
arguments.append(
'+proj=tmerc +pm=greenwich +lat_0=0 +lon_0=15 +k=0.9999 +x_0=5500000 +y_0=0 +ellps=bessel +nadgrids='
+ os.path.dirname(__file__) +
'/grids/HRNTv2.gsb +wktext +units=m')
else:
# HDKS6
if self.getParameterValue(self.GRID) == 0:
# HR_NTv2
arguments.append(
'+proj=tmerc +pm=greenwich +lat_0=0 +lon_0=18 +k=0.9999 +x_0=6500000 +y_0=0 +ellps=bessel +nadgrids='
+ os.path.dirname(__file__) +
'/grids/HRNTv2.gsb +wktext +units=m')
arguments.append('-multi')
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
if os.path.isfile(os.path.dirname(__file__) +
'/grids/HRNTv2.gsb') is False:
try:
from urllib import urlretrieve
except ImportError:
from urllib.request import urlretrieve
urlretrieve(
"https://github.com/NaturalGIS/ntv2_transformations_grids_and_sample_data/raw/master/hr/HRNTv2.gsb",
os.path.dirname(__file__) + "/grids/HRNTv2.gsb")
GdalUtils.runGdal(
['gdalwarp', GdalUtils.escapeAndJoin(arguments)], progress)
def processAlgorithm(self, parameters, context, feedback):
expression = self.getParameterValue(self.EXPRESSION)
layersValue = self.getParameterValue(self.LAYERS)
layersDict = {}
if layersValue:
layers = [
QgsProcessingUtils.mapLayerFromString(f, context)
for f in layersValue.split(";")
]
layersDict = {
os.path.basename(lyr.source().split(".")[0]): lyr
for lyr in layers
}
for lyr in QgsProcessingUtils.compatibleRasterLayers(
QgsProject.instance()):
name = lyr.name()
if (name + "@") in expression:
layersDict[name] = lyr
entries = []
for name, lyr in layersDict.items():
for n in range(lyr.bandCount()):
entry = QgsRasterCalculatorEntry()
entry.ref = '{:s}@{:d}'.format(name, n + 1)
entry.raster = lyr
entry.bandNumber = n + 1
entries.append(entry)
output = self.getOutputValue(self.OUTPUT)
extentValue = self.getParameterValue(self.EXTENT)
if not extentValue:
extentValue = QgsProcessingUtils.combineLayerExtents(layersValue)
if extentValue:
extent = extentValue.split(',')
bbox = QgsRectangle(float(extent[0]), float(extent[2]),
float(extent[1]), float(extent[3]))
else:
if layersDict:
bbox = list(layersDict.values())[0].extent()
for lyr in layersDict.values():
bbox.combineExtentWith(lyr.extent())
else:
raise GeoAlgorithmExecutionException(
self.tr("No layers selected"))
def _cellsize(layer):
return (layer.extent().xMaximum() -
layer.extent().xMinimum()) / layer.width()
cellsize = self.getParameterValue(self.CELLSIZE) or min(
[_cellsize(lyr) for lyr in layersDict.values()])
width = math.floor((bbox.xMaximum() - bbox.xMinimum()) / cellsize)
height = math.floor((bbox.yMaximum() - bbox.yMinimum()) / cellsize)
driverName = GdalUtils.getFormatShortNameFromFilename(output)
calc = QgsRasterCalculator(expression, output, driverName, bbox, width,
height, entries)
res = calc.processCalculation()
if res == QgsRasterCalculator.ParserError:
raise GeoAlgorithmExecutionException(
self.tr("Error parsing formula"))
def getConsoleCommands(self):
out = self.getOutputValue(translate_slms.OUTPUT)
outsize = unicode(100)
outsizePerc = False
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = unicode(noData)
expand = unicode("none")
#projwin = unicode(self.getParameterValue(self.PROJWIN))
crsId = self.getParameterValue(self.SRS)
sds = self.getParameterValue(self.SDS)
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = unicode(extra)
jpegcompression = unicode(
75) #unicode(self.getParameterValue(self.JPEGCOMPRESSION))
predictor = unicode(
1) #unicode(self.getParameterValue(self.PREDICTOR))
zlevel = unicode(6) #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))
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
#if outsizePerc == 'True':
arguments.append('-outsize')
arguments.append(outsize + '%')
arguments.append(outsize + '%')
#else:
# arguments.append('-outsize')
# arguments.append(outsize)
# arguments.append(outsize)
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
if expand != 'none':
arguments.append('-expand')
arguments.append(expand)
#regionCoords = projwin.split(',')
#try:
# projwin = []
# projwin.append('-projwin')
# projwin.append(regionCoords[0])
# projwin.append(regionCoords[3])
# projwin.append(regionCoords[1])
# projwin.append(regionCoords[2])
#except IndexError:
# projwin = []
#if projwin:
# arguments.extend(projwin)
if crsId:
arguments.append('-a_srs')
arguments.append(unicode(crsId))
if sds:
arguments.append('-sds')
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")
arguments.append("-co TILED=YES")
#------------------------------------------
#if tfw == "True":
# arguments.append("-co TFW=YES")
#if len(bigtiff) > 0:
# arguments.append("-co BIGTIFF=" + bigtiff)
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdal_translate', 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 GdalUtils.version() >= 2000000:
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, context, feedback, executing=True):
out = self.getOutputValue(self.OUTPUT)
extra = self.getParameterValue(self.EXTRA)
if extra is not None:
extra = str(extra)
#debug = self.getParameterValue(self.DEBUG)
formula = self.getParameterValue(self.FORMULA)
noData = self.getParameterValue(self.NO_DATA)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('--calc')
arguments.append('"' + formula + '"')
arguments.append('--format')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('--type')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if noData and len(noData) > 0:
arguments.append('--NoDataValue')
arguments.append(noData)
if extra and len(extra) > 0:
arguments.append(extra)
#if debug:
# arguments.append('--debug')
arguments.append('-A')
arguments.append(self.getParameterValue(self.INPUT_A))
if self.getParameterValue(self.BAND_A):
arguments.append('--A_band ' + self.getParameterValue(self.BAND_A))
if self.getParameterValue(self.INPUT_B):
arguments.append('-B')
arguments.append(self.getParameterValue(self.INPUT_B))
if self.getParameterValue(self.BAND_B):
arguments.append('--B_band ' + self.getParameterValue(self.BAND_B))
if self.getParameterValue(self.INPUT_C):
arguments.append('-C')
arguments.append(self.getParameterValue(self.INPUT_C))
if self.getParameterValue(self.BAND_C):
arguments.append('--C_band ' + self.getParameterValue(self.BAND_C))
if self.getParameterValue(self.INPUT_D):
arguments.append('-D')
arguments.append(self.getParameterValue(self.INPUT_D))
if self.getParameterValue(self.BAND_D):
arguments.append('--D_band ' + self.getParameterValue(self.BAND_D))
if self.getParameterValue(self.INPUT_E):
arguments.append('-E')
arguments.append(self.getParameterValue(self.INPUT_E))
if self.getParameterValue(self.BAND_E):
arguments.append('--E_band ' + self.getParameterValue(self.BAND_E))
if self.getParameterValue(self.INPUT_F):
arguments.append('-F')
arguments.append(self.getParameterValue(self.INPUT_F))
if self.getParameterValue(self.BAND_F):
arguments.append('--F_band ' + self.getParameterValue(self.BAND_F))
arguments.append('--outfile')
arguments.append(out)
if isWindows():
return ['gdal_calc', GdalUtils.escapeAndJoin(arguments)]
else:
return ['gdal_calc.py', 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, parameters, context, feedback):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
outsize = str(self.parameterAsInt(parameters, self.OUTSIZE, context))
outsizePerc = self.parameterAsBool(parameters, self.OUTSIZE_PERC,
context)
noData = self.parameterAsString(parameters, self.NO_DATA, context)
expand = self.parameterDefinition(
self.EXPAND).options()[self.parameterAsEnum(
parameters, self.EXPAND, context)]
proj_extent = self.parameterAsExtent(parameters, self.PROJWIN, context)
if proj_extent.isNull():
proj_extent = QgsProcessingUtils.combineLayerExtents([inLayer])
crsId = self.parameterAsCrs(parameters, self.SRS, context).authid()
sds = self.parameterAsBool(parameters, self.SDS, context)
opts = self.parameterAsString(parameters, self.OPTIONS, context)
if noData is not None:
noData = str(noData)
arguments = []
arguments.append('-of')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('-ot')
arguments.append(self.TYPE[self.parameterAsEnum(
parameters, self.RTYPE, context)])
if outsizePerc:
arguments.append('-outsize')
arguments.append(outsize + '%')
arguments.append(outsize + '%')
else:
arguments.append('-outsize')
arguments.append(outsize)
arguments.append(outsize)
if noData and len(noData) > 0:
arguments.append('-a_nodata')
arguments.append(noData)
if expand != 'none':
arguments.append('-expand')
arguments.append(expand)
try:
projwin = []
projwin.append('-projwin')
projwin.append(proj_extent.xMinimum())
projwin.append(proj_extent.yMaximum())
projwin.append(proj_extent.xMaximum())
projwin.append(proj_extent.yMinimum())
except IndexError:
projwin = []
if projwin:
arguments.extend(projwin)
if crsId:
arguments.append('-a_srs')
arguments.append(str(crsId))
if sds:
arguments.append('-sds')
if opts:
arguments.append('-co')
arguments.append(opts)
arguments.append(inLayer.source())
arguments.append(out)
return ['gdal_translate', GdalUtils.escapeAndJoin(arguments)]
def processAlgorithm(self, progress):
if self.getParameterValue(self.TRANSF) == 0:
# Direct transformation
arguments = ['-s_srs']
if self.getParameterValue(self.CRS) == 0:
# Monte Mario - GBO
if self.getParameterValue(self.GRID) == 0:
# Grigliati NTv2 RER 2013 la trasformazione di coordinate in Emilia-Romagna
arguments.append(
'+proj=tmerc +lat_0=0 +lon_0=9 +k=0.9996 +x_0=1500000 +y_0=0 +ellps=intl +nadgrids='
+ os.path.dirname(__file__) +
'/grids/RER_AD400_MM_ETRS89_V1A.gsb +wktext +units=m +no_defs'
)
else:
# UTM - ED50
if self.getParameterValue(self.GRID) == 0:
# Grigliati NTv2 RER 2013 la trasformazione di coordinate in Emilia-Romagna
arguments.append(
'+proj=utm +zone=32 +ellps=intl +nadgrids=' +
os.path.dirname(__file__) +
'/grids/RER_ED50_ETRS89_GPS7_K2.gsb +wktext +units=m +no_defs'
)
arguments.append('-t_srs')
arguments.append('EPSG:4258')
else:
# Inverse transformation
arguments = ['-s_srs']
arguments.append('EPSG:4258')
arguments.append('-t_srs')
if self.getParameterValue(self.CRS) == 0:
# Monte Mario - GBO
if self.getParameterValue(self.GRID) == 0:
# Grigliati NTv2 RER 2013 la trasformazione di coordinate in Emilia-Romagna
arguments.append(
'+proj=tmerc +lat_0=0 +lon_0=9 +k=0.9996 +x_0=1500000 +y_0=0 +ellps=intl +nadgrids='
+ os.path.dirname(__file__) +
'/grids/RER_AD400_MM_ETRS89_V1A.gsb +wktext +units=m +no_defs'
)
else:
# UTM - ED50
if self.getParameterValue(self.GRID) == 0:
# Grigliati NTv2 RER 2013 la trasformazione di coordinate in Emilia-Romagna
arguments.append(
'+proj=utm +zone=32 +ellps=intl +nadgrids=' +
os.path.dirname(__file__) +
'/grids/RER_ED50_ETRS89_GPS7_K2.gsb +wktext +units=m +no_defs'
)
arguments.append('-multi')
arguments.append('-of')
out = self.getOutputValue(self.OUTPUT)
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
if os.path.isfile(
os.path.dirname(__file__) +
'/grids/RER_AD400_MM_ETRS89_V1A.gsb') is False:
try:
from urllib import urlretrieve
except ImportError:
from urllib.request import urlretrieve
urlretrieve(
"https://github.com/NaturalGIS/ntv2_transformations_grids_and_sample_data/raw/master/it_rer/RER_AD400_MM_ETRS89_V1A.gsb",
os.path.dirname(__file__) +
"/grids/RER_AD400_MM_ETRS89_V1A.gsb")
urlretrieve(
"https://github.com/NaturalGIS/ntv2_transformations_grids_and_sample_data/raw/master/it_rer/RER_ED50_ETRS89_GPS7_K2.GSB",
os.path.dirname(__file__) +
"/grids/RER_ED50_ETRS89_GPS7_K2.GSB")
GdalUtils.runGdal(
['gdalwarp', GdalUtils.escapeAndJoin(arguments)], progress)
self.tr('Additional creation parameters'), '', optional=True))
self.addOutput(OutputRaster(self.OUTPUT, self.tr('Calculated')))
def getConsoleCommands(self):
out = self.getOutputValue(self.OUTPUT)
extra = unicode(self.getParameterValue(self.EXTRA))
#debug = self.getParameterValue(self.DEBUG)
formula = self.getParameterValue(self.FORMULA)
noData = unicode(self.getParameterValue(self.NO_DATA))
>>>>>>> upstream/master
arguments = []
arguments.append('--calc')
arguments.append('"' + formula + '"')
arguments.append('--format')
arguments.append(GdalUtils.getFormatShortNameFromFilename(out))
arguments.append('--type')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
if len(noData) > 0:
arguments.append('--NoDataValue')
arguments.append(noData)
if len(extra) > 0:
arguments.append(extra)
#if debug:
# arguments.append('--debug')
arguments.append('-A')
arguments.append(self.getParameterValue(self.INPUT_A))
if self.getParameterValue(self.BAND_A):
arguments.append('--A_band ' + self.getParameterValue(self.BAND_A))
if self.getParameterValue(self.INPUT_B):
arguments.append('-B')
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)]
