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 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 getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
clipExtent = self.getParameterValue(self.CLIP_EXTENT)
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = ogrConnectionString(outFile)
options = str(self.getParameterValue(self.OPTIONS))
arguments = []
regionCoords = clipExtent.split(',')
arguments.append('-spat')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
arguments.append('-clipsrc spat_extent')
if len(options) > 0:
arguments.append(options)
arguments.append(output)
arguments.append(ogrLayer)
arguments.append(ogrLayerName(inLayer))
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
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 processAlgorithm(self, progress):
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = self.ogrConnectionString(inLayer)[1:-1]
clipLayer = self.getParameterValue(self.CLIP_LAYER)
ogrClipLayer = self.ogrConnectionString(clipLayer)[1:-1]
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = self.ogrConnectionString(outFile)
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-clipsrc')
arguments.append(ogrClipLayer)
arguments.append("-clipsrclayer")
arguments.append(self.ogrLayerName(clipLayer))
if len(options) > 0:
arguments.append(options)
arguments.append(output)
arguments.append(ogrLayer)
arguments.append(self.ogrLayerName(inLayer))
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
GdalUtils.runGdal(commands, progress)
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 = []
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, parameters, context, feedback):
arguments = []
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
arguments.append(inLayer.source())
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
output, outFormat = GdalUtils.ogrConnectionStringAndFormat(outFile, context)
arguments.append(output)
if self.parameterAsBool(parameters, self.EIGHT_CONNECTEDNESS, context):
arguments.append('-8')
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if outFormat:
arguments.append('-f {}'.format(outFormat))
arguments.append(GdalUtils.ogrLayerName(output))
arguments.append(self.parameterAsString(parameters, self.FIELD, context))
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_polygonize.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_polygonize.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters):
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
clipLayer = self.getParameterValue(self.CLIP_LAYER)
ogrClipLayer = ogrConnectionString(clipLayer)[1:-1]
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = ogrConnectionString(outFile)
options = str(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-clipsrc')
arguments.append(ogrClipLayer)
arguments.append("-clipsrclayer")
arguments.append(ogrLayerName(clipLayer))
if options is not None and len(options.strip()) > 0:
arguments.append(options)
arguments.append(output)
arguments.append(ogrLayer)
arguments.append(ogrLayerName(inLayer))
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def processAlgorithm(self, progress):
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = self.ogrConnectionString(inLayer)
clipExtent = self.getParameterValue(self.CLIP_EXTENT)
ogrclipExtent = self.ogrConnectionString(clipExtent)
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = self.ogrConnectionString(outFile)
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
regionCoords = ogrclipExtent.split(',')
arguments.append('-spat')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
arguments.append('-clipsrc spat_extent')
if len(options) > 0:
arguments.append(options)
arguments.append(output)
arguments.append(ogrLayer)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
GdalUtils.runGdal(commands, progress)
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
arguments.append('-st')
arguments.append(str(self.parameterAsInt(parameters, self.THRESHOLD, context)))
if self.parameterAsBool(parameters, self.EIGHT_CONNECTEDNESS, context):
arguments.append('-8')
else:
arguments.append('-4')
if self.parameterAsBool(parameters, self.NO_MASK, context):
arguments.append('-nomask')
mask = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if mask:
arguments.append('-mask {}'.format(mask.source()))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append(self.parameterAsRasterLayer(parameters, self.INPUT, context).source())
arguments.append(out)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_sieve.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_sieve.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self):
arguments = []
if self.getParameterValue(self.PROFILE):
arguments.append("-p")
arguments.append(self.PROFILES[self.getParameterValue(self.PROFILE)])
if self.getParameterValue(self.RESAMPLING):
arguments.append("-r")
arguments.append(self.RESAMPLINGS[self.getParameterValue(self.RESAMPLING)])
ssrs = str(self.getParameterValue(self.S_SRS))
if len(ssrs) > 0:
arguments.append("-s")
arguments.append(ssrs)
if self.getParameterValue(self.ZOOM):
arguments.append("-z")
arguments.append(str(self.getParameterValue(self.ZOOM)))
if self.getParameterValue(self.RESUME):
arguments.append("-e")
if self.getParameterValue(self.NODATA):
arguments.append("-a")
arguments.append(str(self.getParameterValue(self.NODATA)))
# KML arguments
if self.getParameterValue(self.FORCEKML):
arguments.append("-k")
if self.getParameterValue(self.NOKML):
arguments.append("-n")
if self.getParameterValue(self.URL):
arguments.append("-u")
arguments.append(str(self.getParameterValue(self.URL)))
# Web viewer arguments
if self.getParameterValue(self.WEBVIEWER):
arguments.append("-w")
arguments.append(self.WEBVIEWERS[self.getParameterValue(self.WEBVIEWER)])
parameters = {self.TITLE: "-t", self.COPYRIGHT: "-c", self.GOOGLEKEY: "-g", self.BINGKEY: "-b"}
for arg, parameter in list(parameters.items()):
if self.getParameterValue(arg):
arguments.append(parameter)
arguments.append(self.getParameterValue(arg))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(self.getOutputValue(self.OUTPUTDIR))
commands = []
if isWindows():
commands = ["cmd.exe", "/C ", "gdal2tiles.bat", GdalUtils.escapeAndJoin(arguments)]
else:
commands = ["gdal2tiles.py", GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
output, outFormat = GdalUtils.ogrConnectionStringAndFormat(outFile, context)
arguments.append(output)
if self.parameterAsBool(parameters, self.EIGHT_CONNECTEDNESS, context):
arguments.append('-8')
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if outFormat:
arguments.append('-f {}'.format(outFormat))
arguments.append(GdalUtils.ogrLayerName(output))
arguments.append(self.parameterAsString(parameters, self.FIELD, context))
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', self.commandName() + '.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = [self.commandName() + '.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(out)
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBool(parameters, self.RGBA, context):
arguments.append('-rgba')
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'pct2rgb.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['pct2rgb.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context)
replaceValue = self.parameterAsDouble(parameters, self.REPLACE, context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
arguments.append('-srcband')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-distunits')
arguments.append(self.distanceUnits[self.parameterAsEnum(parameters, self.UNITS, context)][1])
values = self.parameterAsString(parameters, self.VALUES, context)
if values:
arguments.append('-values')
arguments.append(values)
if distance:
arguments.append('-maxdist')
arguments.append(str(distance))
if nodata is not None:
arguments.append('-nodata')
arguments.append(str(nodata))
if replaceValue:
arguments.append('-fixed-buf-val')
arguments.append(str(replaceValue))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', self.commandName() + '.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = [self.commandName() + '.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback):
arguments = []
arguments.append('-ps')
arguments.append(str(self.parameterAsInt(parameters, self.TILE_SIZE_X, context)))
arguments.append(str(self.parameterAsInt(parameters, self.TILE_SIZE_Y, context)))
arguments.append('-overlap')
arguments.append(str(self.parameterAsInt(parameters, self.OVERLAP, context)))
arguments.append('-levels')
arguments.append(str(self.parameterAsInt(parameters, self.LEVELS, context)))
crs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
if crs.isValid():
arguments.append('-s_srs')
arguments.append(crs.authid())
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1])
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
if self.parameterAsBool(parameters, self.DIR_FOR_ROW, context):
arguments.append('-pyramidOnly')
if self.parameterAsBool(parameters, self.ONLY_PYRAMIDS, context):
arguments.append('-useDirForEachRow')
csvFile = self.parameterAsFileOutput(parameters, self.OUTPUT_CSV, context)
if csvFile:
arguments.append('-csv')
arguments.append(csvFile)
delimiter = self.parameterAsString(parameters, self.DELIMITER, context)
if delimiter:
arguments.append('-csvDelim')
arguments.append('"{}"'.format(delimiter))
arguments.append('-targetDir')
arguments.append(self.parameterAsString(parameters, self.OUTPUT, context))
layers = [l.source() for l in self.parameterAsLayerList(parameters, self.INPUT, context)]
arguments.extend(layers)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_retile.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_retile.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
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 getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
layername = "'" + ogrLayerName(inLayer) + "'"
geometry = unicode(self.getParameterValue(self.GEOMETRY))
field = unicode(self.getParameterValue(self.FIELD))
statsatt = unicode(self.getParameterValue(self.STATSATT))
stats = self.getParameterValue(self.STATS)
area = self.getParameterValue(self.AREA)
multi = self.getParameterValue(self.MULTI)
count = self.getParameterValue(self.COUNT)
fields = self.getParameterValue(self.FIELDS)
querystart = '-dialect sqlite -sql "SELECT ST_Union(' + geometry + ')'
queryend = ' FROM ' + layername + ' GROUP BY ' + field + '"'
if fields:
queryfields = ",*"
else:
queryfields = "," + field
if count:
querycount = ", COUNT(" + geometry + ") AS count"
else:
querycount = ""
if stats:
querystats = ", SUM(" + statsatt + ") AS sum_diss, MIN(" + statsatt + ") AS min_diss, MAX(" + statsatt + ") AS max_diss, AVG(" + statsatt + ") AS avg_diss"
else:
querystats = ""
if area:
queryarea = ", SUM(ST_area(" + geometry + ")) AS area_diss, ST_perimeter(ST_union(" + geometry + ")) AS peri_diss"
else:
queryarea = ""
query = querystart + queryfields + querycount + querystats + queryarea + queryend
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = ogrConnectionString(outFile)
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append(ogrLayerName(inLayer))
arguments.append(query)
if not multi:
arguments.append('-explodecollections')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def processAlgorithm(self, progress):
inLayerA = self.getParameterValue(self.INPUT_LAYER_A)
ogrLayerA = ogrConnectionString(inLayerA)[1:-1]
layernameA = ogrLayerName(inLayerA)
inLayerB = self.getParameterValue(self.INPUT_LAYER_B)
ogrLayerB = ogrConnectionString(inLayerB)[1:-1]
layernameB = ogrLayerName(inLayerB)
fieldA = unicode(self.getParameterValue(self.FIELD_A))
fieldB = unicode(self.getParameterValue(self.FIELD_B))
dsUriA = QgsDataSourceURI(self.getParameterValue(self.INPUT_LAYER_A))
geomColumnA = dsUriA.geometryColumn()
dsUriB = QgsDataSourceURI(self.getParameterValue(self.INPUT_LAYER_B))
geomColumnB = dsUriB.geometryColumn()
layerA = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER_A))
geomTypeA = layerA.geometryType()
wkbTypeA = layerA.wkbType()
sridA = layerA.crs().postgisSrid()
layerB = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER_B))
geomTypeB = layerB.geometryType()
wkbTypeB = layerB.wkbType()
sridB = layerB.crs().postgisSrid()
multi = self.getParameterValue(self.MULTI)
schema = unicode(self.getParameterValue(self.SCHEMA))
table = unicode(self.getParameterValue(self.TABLE))
if multi:
sqlstring = "-sql \"WITH temp_table AS (SELECT ST_Union(" + geomColumnB + ") AS geom FROM " + layernameB + ") SELECT ST_ShortestLine(g1." + geomColumnA + ",g2.geom) AS geom, ST_Distance(g1." + geomColumnA + ",g2.geom) AS distance, g1." + fieldA + " AS id_from FROM " + layernameA + " AS g1, temp_table AS g2\" -nln " + schema + "." + table + " -lco FID=gid -lco GEOMETRY_NAME=geom -nlt LINESTRING --config PG_USE_COPY YES -a_srs EPSG:" + str(sridA) + ""
else:
sqlstring = "-sql \"SELECT ST_ShortestLine(g1." + geomColumnA + ",g2." + geomColumnB + ") AS geom, ST_Distance(g1." + geomColumnA + ",g2." + geomColumnB + ") AS distance, g1." + fieldA + " AS id_from, g2." + fieldB + " AS id_to FROM " + layernameA + " AS g1, " + layernameB + " AS g2\" -nln " + schema + "." + table + " -lco FID=gid -lco GEOMETRY_NAME=geom -nlt LINESTRING --config PG_USE_COPY YES"
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append(ogrLayerA)
arguments.append(ogrLayerA)
arguments.append(sqlstring)
arguments.append('-overwrite')
if len(options) > 0:
arguments.append(options)
#print table
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
GdalUtils.runGdal(commands, progress)
output = self.getOutputValue(self.OUTPUT)
f = open(output, 'w')
f.write('<pre>')
for s in GdalUtils.getConsoleOutput()[1:]:
f.write(unicode(s))
f.write('</pre>')
f.close()
def getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT_LAYER)
operation = self.getParameterValue(self.OPERATION)
geometry = self.getParameterValue(self.GEOMETRY)
distance = self.getParameterValue(self.RADIUS)
leftright = self.getParameterValue(self.LEFTRIGHT)
dissolveall = self.getParameterValue(self.DISSOLVEALL)
field = self.getParameterValue(self.FIELD)
multi = self.getParameterValue(self.MULTI)
options = self.getParameterValue(self.OPTIONS)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
layername = "'" + ogrLayerName(inLayer) + "'"
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = ogrConnectionString(outFile)
layername = ogrLayerName(inLayer)
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append(layername)
arguments.append('-dialect')
arguments.append('sqlite')
arguments.append('-sql')
if dissolveall or field is not None:
if operation == 0:
sql = "SELECT ST_Union(ST_SingleSidedBuffer({}, {}, {})), * FROM '{}'".format(geometry, distance, leftright, layername)
else:
sql = "SELECT ST_Union(ST_OffsetCurve({}, {})) * FROM '{}'".format(geometry, distance, layername)
else:
if operation == 0:
sql = "SELECT ST_SingleSidedBuffer({},{},{}), * FROM '{}'".format(geometry, distance, leftright, layername)
else:
sql = "SELECT ST_OffsetCurve({}, {}), * FROM '{}'".format(geometry, distance, layername)
if field is not None:
sql = '"{} GROUP BY {}"'.format(sql, field)
arguments.append(sql)
if field is not None and multi:
arguments.append('-explodecollections')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
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, progress):
inLayerA = self.getParameterValue(self.INPUT_LAYER_A)
ogrLayerA = ogrConnectionString(inLayerA)[1:-1]
layernameA = ogrLayerName(inLayerA)
inLayerB = self.getParameterValue(self.INPUT_LAYER_B)
ogrLayerB = ogrConnectionString(inLayerB)[1:-1]
layernameB = ogrLayerName(inLayerB)
fieldsA = unicode(self.getParameterValue(self.FIELDS_A))
dsUriA = QgsDataSourceURI(self.getParameterValue(self.INPUT_LAYER_A))
geomColumnA = dsUriA.geometryColumn()
dsUriB = QgsDataSourceURI(self.getParameterValue(self.INPUT_LAYER_B))
geomColumnB = dsUriB.geometryColumn()
schema = unicode(self.getParameterValue(self.SCHEMA))
table = unicode(self.getParameterValue(self.TABLE))
single = self.getParameterValue(self.SINGLE)
if len(fieldsA) > 0:
fieldstring = fieldsA.replace(",", ", g1.")
fieldstring = ", g1." + fieldstring
else:
fieldstring = ""
if single:
sqlstring = "-sql \"SELECT (ST_Dump(ST_Difference(g1." + geomColumnA + ",ST_Union(g2." + geomColumnB + ")))).geom::geometry(Polygon) AS geom" + fieldstring + " FROM " + layernameA + " AS g1, " + layernameB + " AS g2 GROUP BY g1." + geomColumnA + fieldstring + "\""" -nln " + schema + "." + table + " -lco FID=gid -nlt POLYGON -lco GEOMETRY_NAME=geom --config PG_USE_COPY YES"
else:
sqlstring = "-sql \"SELECT (ST_Multi(ST_CollectionExtract(ST_Difference(g1." + geomColumnA + ",ST_Union(g2." + geomColumnB + ")),3)))::geometry(MultiPolygon) AS geom" + fieldstring + " FROM " + layernameA + " AS g1, " + layernameB + " AS g2 GROUP BY g1." + geomColumnA + fieldstring + "\""" -nln " + schema + "." + table + " -lco FID=gid -nlt MULTIPOLYGON -lco GEOMETRY_NAME=geom --config PG_USE_COPY YES"
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append(ogrLayerA)
arguments.append(ogrLayerA)
arguments.append(sqlstring)
arguments.append('-overwrite')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
GdalUtils.runGdal(commands, progress)
output = self.getOutputValue(self.OUTPUT)
f = open(output, 'w')
f.write('<pre>')
for s in GdalUtils.getConsoleOutput()[1:]:
f.write(unicode(s))
f.write('</pre>')
f.close()
def getConsoleCommands(self, parameters, context, feedback):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context)
replaceValue = self.parameterAsDouble(parameters, self.REPLACE, context)
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
arguments.append('-srcband')
arguments.append(str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-distunits')
arguments.append(self.distanceUnits[self.parameterAsEnum(parameters, self.UNITS, context)][1])
values = self.parameterAsString(parameters, self.VALUES, context)
if values:
arguments.append('-values')
arguments.append(values)
if distance:
arguments.append('-maxdist')
arguments.append(str(distance))
if nodata:
arguments.append('-nodata')
arguments.append(str(nodata))
if replaceValue:
arguments.append('-fixed-buf-val')
arguments.append(str(replaceValue))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(inLayer.source())
arguments.append(out)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'gdal_proximity.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_proximity.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
def processAlgorithm(self, progress):
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
layername = ogrLayerName(inLayer)
fields = unicode(self.getParameterValue(self.FIELDS))
dsUri = QgsDataSourceURI(self.getParameterValue(self.INPUT_LAYER))
geomColumn = dsUri.geometryColumn()
layer = dataobjects.getObjectFromUri(self.getParameterValue(self.INPUT_LAYER))
geomType = layer.geometryType()
wkbType = layer.wkbType()
srid = layer.crs().postgisSrid()
schema = unicode(self.getParameterValue(self.SCHEMA))
table = unicode(self.getParameterValue(self.TABLE))
if len(fields) > 0:
fieldstring = "," + fields
else:
fieldstring = ""
if wkbType == 3:
layertype = "POLYGON"
sqlstring = "-sql \"SELECT (ST_Dump(ST_MakeValid(g1." + geomColumn + "))).geom::geometry(" + layertype + "," + str(srid) + ") AS geom" + fieldstring + " FROM " + layername + " AS g1\" -nlt " + layertype + " -nln " + schema + "." + table + " -lco FID=gid -lco GEOMETRY_NAME=geom --config PG_USE_COPY YES"
else:
layertype = "MULTIPOLYGON"
sqlstring = "-sql \"SELECT (ST_MakeValid(g1." + geomColumn + "))::geometry(" + layertype + "," + str(srid) + ") AS geom" + fieldstring + " FROM " + layername + " AS g1\" -nlt " + layertype + " -nln " + schema + "." + table + " -lco FID=gid -lco GEOMETRY_NAME=geom --config PG_USE_COPY YES"
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append(ogrLayer)
arguments.append(ogrLayer)
arguments.append(sqlstring)
arguments.append('-overwrite')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
GdalUtils.runGdal(commands, progress)
output = self.getOutputValue(self.OUTPUT)
f = open(output, 'w')
f.write('<pre>')
for s in GdalUtils.getConsoleOutput()[1:]:
f.write(unicode(s))
f.write('</pre>')
f.close()
def getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = self.ogrConnectionString(inLayer)[1:-1]
layername = "'" + self.ogrLayerName(inLayer) + "'"
geometry = unicode(self.getParameterValue(self.GEOMETRY))
distance = unicode(self.getParameterValue(self.DISTANCE))
dissolveall = self.getParameterValue(self.DISSOLVEALL)
field = unicode(self.getParameterValue(self.FIELD))
multi = self.getParameterValue(self.MULTI)
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = self.ogrConnectionString(outFile)
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append(self.ogrLayerName(inLayer))
if dissolveall or field != 'None':
arguments.append('-dialect sqlite -sql "SELECT ST_Union(ST_Buffer(')
else:
arguments.append('-dialect sqlite -sql "SELECT ST_Buffer(')
arguments.append(geometry)
arguments.append(',')
arguments.append(distance)
if dissolveall or field != 'None':
arguments.append(')),*')
else:
arguments.append('),*')
arguments.append('FROM')
arguments.append(layername)
if field != 'None':
arguments.append('GROUP')
arguments.append('BY')
arguments.append(field)
arguments.append('"')
if field != 'None' and multi:
arguments.append('-explodecollections')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT_LAYER)
geometry = self.getParameterValue(self.GEOMETRY)
distance = self.getParameterValue(self.RADIUS)
leftright = self.getParameterValue(self.LEFTRIGHT)
dissolveall = self.getParameterValue(self.DISSOLVEALL)
field = self.getParameterValue(self.FIELD)
multi = self.getParameterValue(self.MULTI)
options = self.getParameterValue(self.OPTIONS)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
layername = ogrLayerName(inLayer)
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = ogrConnectionString(outFile)
layername = ogrLayerName(inLayer)
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append("-dialect")
arguments.append("sqlite")
arguments.append("-sql")
if dissolveall or field is not None:
sql = "SELECT ST_Union(ST_SingleSidedBuffer({}, {}, {})), * FROM '{}'".format(
geometry, distance, leftright, layername
)
else:
sql = "SELECT ST_SingleSidedBuffer({},{},{}), * FROM '{}'".format(geometry, distance, leftright, layername)
if field is not None:
sql = '"{} GROUP BY {}"'.format(sql, field)
arguments.append(sql)
if field is not None and multi:
arguments.append("-explodecollections")
if options is not None and len(options.strip()) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ["cmd.exe", "/C ", "ogr2ogr.exe", GdalUtils.escapeAndJoin(arguments)]
else:
commands = ["ogr2ogr", GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback):
inLayer = self.getParameterValue(self.INPUT_LAYER)
geometry = self.getParameterValue(self.GEOMETRY)
distance = self.getParameterValue(self.DISTANCE)
dissolveall = self.getParameterValue(self.DISSOLVEALL)
field = self.getParameterValue(self.FIELD)
multi = self.getParameterValue(self.MULTI)
options = self.getParameterValue(self.OPTIONS)
ogrLayer = GdalUtils.ogrConnectionString(inLayer, context)[1:-1]
layername = GdalUtils.ogrLayerName(inLayer)
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = GdalUtils.ogrConnectionString(outFile, context)
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append('-dialect')
arguments.append('sqlite')
arguments.append('-sql')
if dissolveall or field is not None:
sql = "SELECT ST_Union(ST_Buffer({}, {})), * FROM '{}'".format(geometry, distance, layername)
else:
sql = "SELECT ST_Buffer({}, {}), * FROM '{}'".format(geometry, distance, layername)
if field is not None:
sql = '{} GROUP BY {}'.format(sql, field)
arguments.append(sql)
if field is not None and multi:
arguments.append('-explodecollections')
if options is not None and len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
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, parameters, context, feedback, executing=True):
arguments = []
arguments.append('-resolution')
arguments.append(self.RESOLUTION_OPTIONS[self.parameterAsEnum(parameters, self.RESOLUTION, context)])
if self.parameterAsBool(parameters, buildvrt.SEPARATE, context):
arguments.append('-separate')
if self.parameterAsBool(parameters, buildvrt.PROJ_DIFFERENCE, context):
arguments.append('-allow_projection_difference')
if self.parameterAsBool(parameters, buildvrt.ADD_ALPHA, context):
arguments.append('-addalpha')
crs = self.parameterAsCrs(parameters, self.ASSIGN_CRS, context)
if crs.isValid():
arguments.append('-a_srs')
arguments.append(GdalUtils.gdal_crs_string(crs))
arguments.append('-r')
arguments.append(self.RESAMPLING_OPTIONS[self.parameterAsEnum(parameters, self.RESAMPLING, context)])
if self.SRC_NODATA in parameters and parameters[self.SRC_NODATA] not in (None, ''):
nodata = self.parameterAsString(parameters, self.SRC_NODATA, context)
arguments.append('-srcnodata "{}"'.format(nodata))
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
list_file = GdalUtils.writeLayerParameterToTextFile(filename='buildvrtInputFiles.txt', alg=self, parameters=parameters, parameter_name=self.INPUT, context=context, executing=executing, quote=False)
arguments.append('-input_file_list')
arguments.append(list_file)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing)
sql = self.parameterAsString(parameters, self.SQL, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
output, outputFormat = GdalUtils.ogrConnectionStringAndFormat(outFile, context)
if not sql:
raise QgsProcessingException(
self.tr('Empty SQL. Please enter valid SQL expression and try again.'))
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append('-sql')
arguments.append(sql)
dialect = self.dialects[self.parameterAsEnum(parameters, self.DIALECT, context)][1]
if dialect:
arguments.append('-dialect')
arguments.append(dialect)
if options:
arguments.append(options)
if outputFormat:
arguments.append('-f {}'.format(outputFormat))
return [self.commandName(), 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 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):
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):
arguments = []
if self.getParameterValue(self.RTYPE):
arguments.append('-ot')
arguments.append(self.TYPE[self.getParameterValue(self.RTYPE)])
arguments.append('-of')
arguments.append(
list(
GdalUtils.getSupportedRasters().keys())[self.getParameterValue(
self.FORMAT)])
if self.getParameterValue(self.PIXELSIZE):
pixelSize = self.getParameterValue(self.PIXELSIZE)
if re.match(r'\d+ \d+', pixelSize):
xsize, ysize = pixelSize.split(' ')
arguments.append('-ps')
arguments.append(xsize)
arguments.append(ysize)
if self.getParameterValue(self.ONLYPYRAMIDS):
arguments.append('-pyramidOnly')
if self.getParameterValue(self.USEDIRFOREACHROW):
arguments.append('-useDirForEachRow')
ssrs = str(self.getParameterValue(self.S_SRS))
if len(ssrs) > 0:
arguments.append('-s_srs')
arguments.append(ssrs)
if self.getParameterValue(self.PYRAMIDLEVELS):
arguments.append('-levels')
arguments.append(str(self.getParameterValue(self.PYRAMIDLEVELS)))
arguments.append('-r')
arguments.append(self.ALGO[self.getParameterValue(self.ALGORITHM)])
# Handle CSV
if self.getParameterValue(self.CSVFILE):
arguments.append('-csv')
arguments.append(self.getParameterValue(self.CSVFILE))
if self.getParameterValue(self.CSVFILE) and self.getParameterValue(
self.CSVDELIM):
arguments.append('-csvDelim')
arguments.append(self.getParameterValue(self.CSVDELIM))
# Handle Shp
if self.getParameterValue(self.TILEINDEX):
arguments.append('-tileIndex')
arguments.append(self.getParameterValue(self.TILEINDEX))
if self.getParameterValue(self.TILEINDEX) and self.getParameterValue(
self.TILEINDEXFIELD):
arguments.append('-tileIndexField')
arguments.append(self.getParameterValue(self.TILEINDEXFIELD))
arguments.append('-targetDir')
arguments.append(self.getOutputValue(self.TARGETDIR))
arguments.extend(self.getParameterValue(self.INPUT).split(';'))
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'gdal_retile.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['gdal_retile.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self):
connection = self.DB_CONNECTIONS[self.getParameterValue(self.DATABASE)]
settings = QSettings()
mySettings = '/PostgreSQL/connections/' + connection
dbname = settings.value(mySettings + '/database')
user = settings.value(mySettings + '/username')
host = settings.value(mySettings + '/host')
port = settings.value(mySettings + '/port')
password = settings.value(mySettings + '/password')
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = self.ogrConnectionString(inLayer)[1:-1]
schema = unicode(self.getParameterValue(self.SCHEMA))
schemastring = "-lco SCHEMA=" + schema
table = unicode(self.getParameterValue(self.TABLE))
pk = unicode(self.getParameterValue(self.PK))
pkstring = "-lco FID=" + pk
primary_key = self.getParameterValue(self.PRIMARY_KEY)
where = unicode(self.getParameterValue(self.WHERE))
wherestring = '-where "' + where + '"'
gt = unicode(self.getParameterValue(self.GT))
overwrite = self.getParameterValue(self.OVERWRITE)
append = self.getParameterValue(self.APPEND)
addfields = self.getParameterValue(self.ADDFIELDS)
launder = self.getParameterValue(self.LAUNDER)
launderstring = "-lco LAUNDER=NO"
skipfailures = self.getParameterValue(self.SKIPFAILURES)
precision = self.getParameterValue(self.PRECISION)
options = unicode(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-progress')
arguments.append('--config PG_USE_COPY YES')
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append('PG:"host=')
arguments.append(host)
arguments.append('port=')
arguments.append(port)
if len(dbname) > 0:
arguments.append('dbname=' + dbname)
if len(password) > 0:
arguments.append('password='******'user='******'"')
arguments.append(ogrLayer)
arguments.append('-nlt NONE')
arguments.append(self.ogrLayerName(inLayer))
if launder:
arguments.append(launderstring)
if append:
arguments.append('-append')
if addfields:
arguments.append('-addfields')
if overwrite:
arguments.append('-overwrite')
if len(schema) > 0:
arguments.append(schemastring)
if len(pk) > 0:
arguments.append(pkstring)
elif primary_key is not None:
arguments.append("-lco FID=" + primary_key)
if len(table) > 0:
arguments.append('-nln')
arguments.append(table)
if skipfailures:
arguments.append('-skipfailures')
if where:
arguments.append(wherestring)
if len(gt) > 0:
arguments.append('-gt')
arguments.append(gt)
if not precision:
arguments.append('-lco PRECISION=NO')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE,
context)
replaceValue = self.parameterAsDouble(parameters, self.REPLACE,
context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments = []
arguments.append('-srcband')
arguments.append(
str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-distunits')
arguments.append(self.distanceUnits[self.parameterAsEnum(
parameters, self.UNITS, context)][1])
values = self.parameterAsString(parameters, self.VALUES, context)
if values:
arguments.append('-values')
arguments.append(values)
if distance:
arguments.append('-maxdist')
arguments.append(str(distance))
if nodata is not None:
arguments.append('-nodata')
arguments.append(str(nodata))
if replaceValue:
arguments.append('-fixed-buf-val')
arguments.append(str(replaceValue))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ',
self.commandName() + '.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = [
self.commandName() + '.py',
GdalUtils.escapeAndJoin(arguments)
]
return commands
def getConsoleCommands(self, parameters):
arguments = []
if self.getParameterValue(self.PROFILE):
arguments.append('-p')
arguments.append(self.PROFILES[self.getParameterValue(
self.PROFILE)])
if self.getParameterValue(self.RESAMPLING):
arguments.append('-r')
arguments.append(self.RESAMPLINGS[self.getParameterValue(
self.RESAMPLING)])
ssrs = str(self.getParameterValue(self.S_SRS))
if len(ssrs) > 0:
arguments.append('-s')
arguments.append(ssrs)
if self.getParameterValue(self.ZOOM):
arguments.append('-z')
arguments.append(str(self.getParameterValue(self.ZOOM)))
if self.getParameterValue(self.RESUME):
arguments.append('-e')
if self.getParameterValue(self.NODATA):
arguments.append('-a')
arguments.append(str(self.getParameterValue(self.NODATA)))
# KML arguments
if self.getParameterValue(self.FORCEKML):
arguments.append('-k')
if self.getParameterValue(self.NOKML):
arguments.append('-n')
if self.getParameterValue(self.URL):
arguments.append('-u')
arguments.append(str(self.getParameterValue(self.URL)))
# Web viewer arguments
if self.getParameterValue(self.WEBVIEWER):
arguments.append('-w')
arguments.append(self.WEBVIEWERS[self.getParameterValue(
self.WEBVIEWER)])
parameters = {
self.TITLE: '-t',
self.COPYRIGHT: '-c',
self.GOOGLEKEY: '-g',
self.BINGKEY: '-b'
}
for arg, parameter in list(parameters.items()):
if self.getParameterValue(arg):
arguments.append(parameter)
arguments.append(self.getParameterValue(arg))
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(self.getOutputValue(self.OUTPUTDIR))
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'gdal2tiles.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['gdal2tiles.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
if self.parameterAsBoolean(parameters, self.PCT, context):
arguments.append('-pct')
if self.parameterAsBoolean(parameters, self.SEPARATE, context):
arguments.append('-separate')
if self.NODATA_INPUT in parameters and parameters[
self.NODATA_INPUT] is not None:
nodata_input = self.parameterAsDouble(parameters,
self.NODATA_INPUT, context)
arguments.append('-n')
arguments.append(str(nodata_input))
if self.NODATA_OUTPUT in parameters and parameters[
self.NODATA_OUTPUT] is not None:
nodata_output = self.parameterAsDouble(parameters,
self.NODATA_OUTPUT, context)
arguments.append('-a_nodata')
arguments.append(str(nodata_output))
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
if self.EXTRA in parameters and parameters[self.EXTRA] not in (None,
''):
extra = self.parameterAsString(parameters, self.EXTRA, context)
arguments.append(extra)
arguments.append('-o')
arguments.append(out)
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
list_file = GdalUtils.writeLayerParameterToTextFile(
filename='mergeInputFiles.txt',
alg=self,
parameters=parameters,
parameter_name=self.INPUT,
context=context,
quote=True,
executing=executing)
arguments.append('--optfile')
arguments.append(list_file)
return [
self.commandName() + ('.bat' if isWindows() else '.py'),
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")
arguments.append(self.getParameterValue(self.INPUT))
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
ogrLayer, layerName = self.getOgrCompatibleSource(
self.INPUT, parameters, context, feedback, executing)
arguments = ['-l']
arguments.append(layerName)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
if fieldName:
arguments.append('-a')
arguments.append(fieldName)
else:
arguments.append('-burn')
arguments.append(
self.parameterAsDouble(parameters, self.BURN, context))
units = self.parameterAsEnum(parameters, self.UNITS, context)
if units == 0:
arguments.append('-ts')
else:
arguments.append('-tr')
arguments.append(
self.parameterAsDouble(parameters, self.WIDTH, context))
arguments.append(
self.parameterAsDouble(parameters, self.HEIGHT, context))
if self.INIT in parameters and parameters[self.INIT] is not None:
initValue = self.parameterAsDouble(parameters, self.INIT, context)
arguments.append('-init')
arguments.append(initValue)
if self.parameterAsBool(parameters, self.INVERT, context):
arguments.append('-i')
if self.parameterAsBool(parameters, self.ALL_TOUCH, context):
arguments.append('-at')
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
arguments.append('-a_nodata')
arguments.append(nodata)
extent = self.parameterAsExtent(parameters, self.EXTENT, context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(ogrLayer)
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
fields = source.fields()
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing)
geometry = self.parameterAsString(parameters, self.GEOMETRY, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, outFile)
output, outputFormat = GdalUtils.ogrConnectionStringAndFormat(outFile, context)
other_fields = []
for f in fields:
if f.name() == geometry:
continue
other_fields.append(f.name())
if other_fields:
other_fields = ',*'
else:
other_fields = ''
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append('-nlt PROMOTE_TO_MULTI')
arguments.append('-dialect')
arguments.append('sqlite')
arguments.append('-sql')
tokens = []
if self.parameterAsBoolean(parameters, self.COUNT_FEATURES, context):
tokens.append("COUNT({}) AS count".format(geometry))
if self.parameterAsBoolean(parameters, self.COMPUTE_AREA, context):
tokens.append("SUM(ST_Area({0})) AS area, ST_Perimeter(ST_Union({0})) AS perimeter".format(geometry))
statsField = self.parameterAsString(parameters, self.STATISTICS_ATTRIBUTE, context)
if statsField and self.parameterAsBoolean(parameters, self.COMPUTE_STATISTICS, context):
tokens.append("SUM({0}) AS sum, MIN({0}) AS min, MAX({0}) AS max, AVG({0}) AS avg".format(statsField))
params = ','.join(tokens)
if params:
params = ', ' + params
group_by = ''
if fieldName:
group_by = ' GROUP BY {}'.format(fieldName)
if self.parameterAsBoolean(parameters, self.KEEP_ATTRIBUTES, context):
sql = "SELECT ST_Union({}) AS {}{}{} FROM '{}'{}".format(geometry, geometry, other_fields, params, layerName, group_by)
else:
sql = "SELECT ST_Union({}) AS {}{}{} FROM '{}'{}".format(geometry, geometry, ', ' + fieldName if fieldName else '',
params, layerName, group_by)
arguments.append(sql)
if self.parameterAsBoolean(parameters, self.EXPLODE_COLLECTIONS, context):
arguments.append('-explodecollections')
if options:
arguments.append(options)
if outputFormat:
arguments.append('-f {}'.format(outputFormat))
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
ogrLayer, layername = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing)
shapeEncoding = self.parameterAsString(parameters, self.SHAPE_ENCODING, context)
ssrs = self.parameterAsCrs(parameters, self.S_SRS, context).authid()
tsrs = self.parameterAsCrs(parameters, self.T_SRS, context).authid()
asrs = self.parameterAsCrs(parameters, self.A_SRS, context).authid()
table = self.parameterAsString(parameters, self.TABLE, context)
schema = self.parameterAsString(parameters, self.SCHEMA, context)
pk = self.parameterAsString(parameters, self.PK, context)
pkstring = "-lco FID=" + pk
primary_key = self.parameterAsString(parameters, self.PRIMARY_KEY, context)
geocolumn = self.parameterAsString(parameters, self.GEOCOLUMN, context)
geocolumnstring = "-lco GEOMETRY_NAME=" + geocolumn
dim = self.DIMLIST[self.parameterAsEnum(parameters, self.DIM, context)]
dimstring = "-lco DIM=" + dim
simplify = self.parameterAsString(parameters, self.SIMPLIFY, context)
segmentize = self.parameterAsString(parameters, self.SEGMENTIZE, context)
spat = self.parameterAsExtent(parameters, self.SPAT, context)
clip = self.parameterAsBool(parameters, self.CLIP, context)
where = self.parameterAsString(parameters, self.WHERE, context)
wherestring = '-where "' + where + '"'
gt = self.parameterAsString(parameters, self.GT, context)
overwrite = self.parameterAsBool(parameters, self.OVERWRITE, context)
append = self.parameterAsBool(parameters, self.APPEND, context)
addfields = self.parameterAsBool(parameters, self.ADDFIELDS, context)
launder = self.parameterAsBool(parameters, self.LAUNDER, context)
launderstring = "-lco LAUNDER=NO"
index = self.parameterAsBool(parameters, self.INDEX, context)
indexstring = "-lco SPATIAL_INDEX=OFF"
skipfailures = self.parameterAsBool(parameters, self.SKIPFAILURES, context)
promotetomulti = self.parameterAsBool(parameters, self.PROMOTETOMULTI, context)
precision = self.parameterAsBool(parameters, self.PRECISION, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
arguments = []
arguments.append('-progress')
arguments.append('--config PG_USE_COPY YES')
if len(shapeEncoding) > 0:
arguments.append('--config')
arguments.append('SHAPE_ENCODING')
arguments.append('"' + shapeEncoding + '"')
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append('PG:"')
arguments.append(self.getConnectionString(parameters, context))
arguments.append('"')
arguments.append(dimstring)
arguments.append(ogrLayer)
arguments.append(layername)
if index:
arguments.append(indexstring)
if launder:
arguments.append(launderstring)
if append:
arguments.append('-append')
if addfields:
arguments.append('-addfields')
if overwrite:
arguments.append('-overwrite')
if len(self.GEOMTYPE[self.parameterAsEnum(parameters, self.GTYPE, context)]) > 0:
arguments.append('-nlt')
arguments.append(self.GEOMTYPE[self.parameterAsEnum(parameters, self.GTYPE, context)])
if len(geocolumn) > 0:
arguments.append(geocolumnstring)
if len(pk) > 0:
arguments.append(pkstring)
elif primary_key is not None:
arguments.append("-lco FID=" + primary_key)
if len(table) == 0:
table = layername.lower()
if schema:
table = '{}.{}'.format(schema, table)
arguments.append('-nln')
arguments.append(table)
if len(ssrs) > 0:
arguments.append('-s_srs')
arguments.append(ssrs)
if len(tsrs) > 0:
arguments.append('-t_srs')
arguments.append(tsrs)
if len(asrs) > 0:
arguments.append('-a_srs')
arguments.append(asrs)
if not spat.isNull():
arguments.append('-spat')
arguments.append(spat.xMinimum())
arguments.append(spat.yMinimum())
arguments.append(spat.xMaximum())
arguments.append(spat.yMaximum())
if clip:
arguments.append('-clipsrc spat_extent')
if skipfailures:
arguments.append('-skipfailures')
if where:
arguments.append(wherestring)
if len(simplify) > 0:
arguments.append('-simplify')
arguments.append(simplify)
if len(segmentize) > 0:
arguments.append('-segmentize')
arguments.append(segmentize)
if len(gt) > 0:
arguments.append('-gt')
arguments.append(gt)
if promotetomulti:
arguments.append('-nlt PROMOTE_TO_MULTI')
if precision is False:
arguments.append('-lco PRECISION=NO')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
source = self.parameterAsSource(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
fields = source.fields()
ogrLayer, layerName = self.getOgrCompatibleSource(
self.INPUT, parameters, context, feedback, executing)
geometry = self.parameterAsString(parameters, self.GEOMETRY, context)
distance = self.parameterAsDouble(parameters, self.DISTANCE, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
dissolve = self.parameterAsBool(parameters, self.DISSOLVE, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
output, outputFormat = GdalUtils.ogrConnectionStringAndFormat(
outFile, context)
other_fields = []
for f in fields:
if f.name() == geometry:
continue
other_fields.append(f.name())
if other_fields:
other_fields = ', {}'.format(','.join(other_fields))
else:
other_fields = ''
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append('-dialect')
arguments.append('sqlite')
arguments.append('-sql')
if dissolve or fieldName:
sql = "SELECT ST_Union(ST_Buffer({}, {})) AS {}{} FROM '{}'".format(
geometry, distance, geometry, other_fields, layerName)
else:
sql = "SELECT ST_Buffer({}, {}) AS {}{} FROM '{}'".format(
geometry, distance, geometry, other_fields, layerName)
if fieldName:
sql = '{} GROUP BY {}'.format(sql, fieldName)
arguments.append(sql)
if self.parameterAsBool(parameters, self.EXPLODE_COLLECTIONS, context):
arguments.append('-explodecollections')
if options:
arguments.append(options)
if outputFormat:
arguments.append('-f {}'.format(outputFormat))
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
arguments.append('-p')
arguments.append(self.profiles[self.parameterAsEnum(parameters, self.PROFILE, context)][1])
zoom = self.parameterAsString(parameters, self.ZOOM, context)
if zoom:
arguments.append('-z')
arguments.append(str(zoom))
arguments.append('-w')
arguments.append(self.viewers[self.parameterAsEnum(parameters, self.VIEWER, context)][1])
title = self.parameterAsString(parameters, self.TITLE, context)
if title:
arguments.append('-t')
arguments.append(title)
copying = self.parameterAsString(parameters, self.COPYRIGHT, context)
if copying:
arguments.append('-c')
arguments.append(copying)
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1])
crs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
if crs.isValid():
arguments.append('-s')
arguments.append(GdalUtils.gdal_crs_string(crs))
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
arguments.append('-a')
arguments.append(str(nodata))
url = self.parameterAsString(parameters, self.URL, context)
if url:
arguments.append('-u')
arguments.append(url)
key = self.parameterAsString(parameters, self.GOOGLE_KEY, context)
if key:
arguments.append('-g')
arguments.append(key)
key = self.parameterAsString(parameters, self.BING_KEY, context)
if key:
arguments.append('-b')
arguments.append(key)
if self.parameterAsBool(parameters, self.RESUME, context):
arguments.append('-e')
if self.parameterAsBool(parameters, self.KML, context):
arguments.append('-k')
if self.parameterAsBool(parameters, self.NO_KML, context):
arguments.append('-n')
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
arguments.append(self.parameterAsString(parameters, self.OUTPUT, context))
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', self.commandName() + '.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = [self.commandName() + '.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
extra = self.parameterAsString(parameters, self.EXTRA, context)
# if extra is not None:
# extra = str(extra)
#debug = self.getParameterValue(parameters, self.DEBUG)
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)
if extra and len(extra) > 0:
arguments.append(extra)
#if debug:
# arguments.append('--debug')
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):
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)
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 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 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,
parameters,
context,
feedback,
executing=True):
arguments = ['hillshade']
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
arguments.append(inLayer.source())
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
arguments.append('-b')
arguments.append(
str(self.parameterAsInt(parameters, self.BAND, context)))
arguments.append('-z')
arguments.append(
str(self.parameterAsDouble(parameters, self.Z_FACTOR, context)))
arguments.append('-s')
arguments.append(
str(self.parameterAsDouble(parameters, self.SCALE, context)))
multidirectional = self.parameterAsBool(parameters,
self.MULTIDIRECTIONAL, context)
# azimuth and multidirectional are mutually exclusive
if not multidirectional:
arguments.append('-az')
arguments.append(
str(self.parameterAsDouble(parameters, self.AZIMUTH, context)))
arguments.append('-alt')
arguments.append(
str(self.parameterAsDouble(parameters, self.ALTITUDE, context)))
if self.parameterAsBool(parameters, self.COMPUTE_EDGES, context):
arguments.append('-compute_edges')
if self.parameterAsBool(parameters, self.ZEVENBERGEN, context):
arguments.append('-alg')
arguments.append('ZevenbergenThorne')
if self.parameterAsBool(parameters, self.COMBINED, context):
arguments.append('-combined')
if multidirectional:
arguments.append('-multidirectional')
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION,
context)
arguments = []
if sourceCrs.isValid():
arguments.append('-s_srs')
arguments.append(GdalUtils.gdal_crs_string(sourceCrs))
if targetCrs.isValid():
arguments.append('-t_srs')
arguments.append(GdalUtils.gdal_crs_string(targetCrs))
if nodata is not None:
arguments.append('-dstnodata')
arguments.append(str(nodata))
if resolution:
arguments.append('-tr')
arguments.append(str(resolution))
arguments.append(str(resolution))
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(
parameters, self.RESAMPLING, context)][1])
extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT,
context)
if not extent.isNull():
arguments.append('-te')
arguments.append(extent.xMinimum())
arguments.append(extent.yMinimum())
arguments.append(extent.xMaximum())
arguments.append(extent.yMaximum())
extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS,
context)
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs.authid())
if self.parameterAsBool(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
return [self.commandName(), 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,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
if inLayer is None:
raise QgsProcessingException(
self.invalidRasterError(parameters, self.INPUT))
maskLayer, maskLayerName = self.getOgrCompatibleSource(
self.MASK, parameters, context, feedback, executing)
sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
if self.NODATA in parameters and parameters[self.NODATA] is not None:
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
else:
nodata = None
options = self.parameterAsString(parameters, self.OPTIONS, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
if sourceCrs.isValid():
arguments.append('-s_srs')
arguments.append(GdalUtils.gdal_crs_string(sourceCrs))
if targetCrs.isValid():
arguments.append('-t_srs')
arguments.append(GdalUtils.gdal_crs_string(targetCrs))
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
if data_type:
arguments.append('-ot ' + self.TYPES[data_type])
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
if self.parameterAsBool(parameters, self.KEEP_RESOLUTION, context):
arguments.append('-tr')
arguments.append(str(inLayer.rasterUnitsPerPixelX()))
arguments.append(str(-inLayer.rasterUnitsPerPixelY()))
arguments.append('-tap')
if self.parameterAsBool(parameters, self.SET_RESOLUTION, context):
arguments.append('-tr')
if self.X_RESOLUTION in parameters and parameters[
self.X_RESOLUTION] is not None:
xres = self.parameterAsDouble(parameters, self.X_RESOLUTION,
context)
arguments.append('{}'.format(xres))
else:
arguments.append(str(inLayer.rasterUnitsPerPixelX()))
if self.Y_RESOLUTION in parameters and parameters[
self.Y_RESOLUTION] is not None:
yres = self.parameterAsDouble(parameters, self.Y_RESOLUTION,
context)
arguments.append('{}'.format(yres))
else:
arguments.append(str(-inLayer.rasterUnitsPerPixelY()))
arguments.append('-tap')
arguments.append('-cutline')
arguments.append(maskLayer)
if self.parameterAsBool(parameters, self.CROP_TO_CUTLINE, context):
arguments.append('-crop_to_cutline')
if self.parameterAsBool(parameters, self.ALPHA_BAND, context):
arguments.append('-dstalpha')
if nodata is not None:
arguments.append('-dstnodata {}'.format(nodata))
if self.parameterAsBool(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
arguments.append(inLayer.source())
arguments.append(out)
return [self.commandName(), GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
sourceCrs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
targetCrs = self.parameterAsCrs(parameters, self.TARGET_CRS, context)
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
resolution = self.parameterAsDouble(parameters, self.TARGET_RESOLUTION,
context)
arguments = []
if sourceCrs.isValid():
arguments.append('-s_srs')
arguments.append(sourceCrs.authid())
if targetCrs.isValid():
arguments.append('-t_srs')
arguments.append(targetCrs.authid())
if nodata:
arguments.append('-dstnodata')
arguments.append(str(nodata))
if resolution:
arguments.append('-tr')
arguments.append(str(resolution))
arguments.append(str(resolution))
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(
parameters, self.RESAMPLING, context)][1])
extent = self.parameterAsExtent(parameters, self.TARGET_EXTENT,
context)
if not extent.isNull():
arguments.append('-te')
arguments.append(rasterExtent.xMinimum())
arguments.append(rasterExtent.yMinimum())
arguments.append(rasterExtent.xMaximum())
arguments.append(rasterExtent.yMaximum())
extentCrs = self.parameterAsCrs(parameters, self.TARGET_EXTENT_CRS,
context)
if extentCrs:
arguments.append('-te_srs')
arguments.append(extentCrs.authid())
if self.parameterAsBool(parameters, self.MULTITHREADING, context):
arguments.append('-multi')
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append('-of')
arguments.append(
QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.append('-co')
arguments.append(options)
arguments.append(inLayer.source())
arguments.append(out)
return ['gdalwarp', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self):
connection = self.DB_CONNECTIONS[self.getParameterValue(self.DATABASE)]
uri = uri_from_name(connection)
if self.processing:
# to get credentials input when needed
uri = GeoDB(uri=uri).uri
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
shapeEncoding = self.getParameterValue(self.SHAPE_ENCODING)
ssrs = str(self.getParameterValue(self.S_SRS))
tsrs = str(self.getParameterValue(self.T_SRS))
asrs = str(self.getParameterValue(self.A_SRS))
schema = str(self.getParameterValue(self.SCHEMA))
table = str(self.getParameterValue(self.TABLE))
pk = str(self.getParameterValue(self.PK))
pkstring = "-lco FID=" + pk
primary_key = self.getParameterValue(self.PRIMARY_KEY)
geocolumn = str(self.getParameterValue(self.GEOCOLUMN))
geocolumnstring = "-lco GEOMETRY_NAME=" + geocolumn
dim = self.DIMLIST[self.getParameterValue(self.DIM)]
dimstring = "-lco DIM=" + dim
simplify = str(self.getParameterValue(self.SIMPLIFY))
segmentize = str(self.getParameterValue(self.SEGMENTIZE))
spat = self.getParameterValue(self.SPAT)
clip = self.getParameterValue(self.CLIP)
where = str(self.getParameterValue(self.WHERE))
wherestring = '-where "' + where + '"'
gt = str(self.getParameterValue(self.GT))
overwrite = self.getParameterValue(self.OVERWRITE)
append = self.getParameterValue(self.APPEND)
addfields = self.getParameterValue(self.ADDFIELDS)
launder = self.getParameterValue(self.LAUNDER)
launderstring = "-lco LAUNDER=NO"
index = self.getParameterValue(self.INDEX)
indexstring = "-lco SPATIAL_INDEX=OFF"
skipfailures = self.getParameterValue(self.SKIPFAILURES)
promotetomulti = self.getParameterValue(self.PROMOTETOMULTI)
precision = self.getParameterValue(self.PRECISION)
options = str(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-progress')
arguments.append('--config PG_USE_COPY YES')
if shapeEncoding:
arguments.append('--config')
arguments.append('SHAPE_ENCODING')
arguments.append('"' + shapeEncoding + '"')
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append('PG:"')
for token in uri.connectionInfo(self.processing).split(' '):
arguments.append(token)
arguments.append('active_schema={}'.format(schema or 'public'))
arguments.append('"')
arguments.append(dimstring)
arguments.append(ogrLayer)
arguments.append(ogrLayerName(inLayer))
if index:
arguments.append(indexstring)
if launder:
arguments.append(launderstring)
if append:
arguments.append('-append')
if addfields:
arguments.append('-addfields')
if overwrite:
arguments.append('-overwrite')
if len(self.GEOMTYPE[self.getParameterValue(self.GTYPE)]) > 0:
arguments.append('-nlt')
arguments.append(self.GEOMTYPE[self.getParameterValue(self.GTYPE)])
if len(geocolumn) > 0:
arguments.append(geocolumnstring)
if len(pk) > 0:
arguments.append(pkstring)
elif primary_key is not None:
arguments.append("-lco FID=" + primary_key)
if len(table) == 0:
table = ogrLayerName(inLayer).lower()
if schema:
table = '{}.{}'.format(schema, table)
arguments.append('-nln')
arguments.append(table)
if len(ssrs) > 0:
arguments.append('-s_srs')
arguments.append(ssrs)
if len(tsrs) > 0:
arguments.append('-t_srs')
arguments.append(tsrs)
if len(asrs) > 0:
arguments.append('-a_srs')
arguments.append(asrs)
if len(spat) > 0:
regionCoords = spat.split(',')
arguments.append('-spat')
arguments.append(regionCoords[0])
arguments.append(regionCoords[2])
arguments.append(regionCoords[1])
arguments.append(regionCoords[3])
if clip:
arguments.append('-clipsrc spat_extent')
if skipfailures:
arguments.append('-skipfailures')
if where:
arguments.append(wherestring)
if len(simplify) > 0:
arguments.append('-simplify')
arguments.append(simplify)
if len(segmentize) > 0:
arguments.append('-segmentize')
arguments.append(segmentize)
if len(gt) > 0:
arguments.append('-gt')
arguments.append(gt)
if promotetomulti:
arguments.append('-nlt PROMOTE_TO_MULTI')
if precision is False:
arguments.append('-lco PRECISION=NO')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self):
inLayer = self.getParameterValue(self.INPUT_LAYER)
geometry = self.getParameterValue(self.GEOMETRY)
field = self.getParameterValue(self.FIELD)
multi = self.getParameterValue(self.MULTI)
fields = self.getParameterValue(self.FIELDS)
count = self.getParameterValue(self.COUNT)
area = self.getParameterValue(self.AREA)
stats = self.getParameterValue(self.STATS)
statsatt = self.getParameterValue(self.STATSATT)
options = self.getParameterValue(self.OPTIONS)
ogrLayer = ogrConnectionString(inLayer)[1:-1]
layername = ogrLayerName(inLayer)
output = self.getOutputFromName(self.OUTPUT_LAYER)
outFile = output.value
output = ogrConnectionString(outFile)
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append('-dialect')
arguments.append('sqlite')
arguments.append('-sql')
sql = "SELECT ST_Union({})".format(geometry)
sqlOpts = ''
if fields:
sqlOpts += ',*'
else:
sqlOpts += ',{}'.format(field)
if count:
sqlOpts += ", COUNT({}) AS count".format(geometry)
if stats:
sqlOpts += ", SUM({0}) AS sum_diss, MIN({0}) AS min_diss, MAX({0}) AS max_diss, AVG({0}) AS avg_diss".format(statsatt)
if area:
sqlOpts += ", SUM(ST_Area({0})) AS area_diss, ST_Perimeter(ST_Union({0})) AS peri_diss".format(geometry)
sql = '{}{} FROM {} GROUP BY {}'.format(sql, sqlOpts, layername, field)
arguments.append(sql)
if not multi:
arguments.append('-explodecollections')
if options is not None and len(options.strip()) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
def getConsoleCommands(self, parameters, context, feedback, executing=True):
fields = self.parameterAsSource(parameters, self.INPUT, context).fields()
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing)
geometry = self.parameterAsString(parameters, self.GEOMETRY, context)
fieldName = self.parameterAsString(parameters, self.FIELD, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
output, outputFormat = GdalUtils.ogrConnectionStringAndFormat(outFile, context)
other_fields = []
for f in fields:
if f.name() == geometry:
continue
other_fields.append(f.name())
if other_fields:
other_fields = ', {}'.format(','.join(other_fields))
else:
other_fields = ''
arguments = []
arguments.append(output)
arguments.append(ogrLayer)
arguments.append('-dialect')
arguments.append('sqlite')
arguments.append('-sql')
tokens = []
if self.parameterAsBool(parameters, self.COUNT_FEATURES, context):
tokens.append("COUNT({}) AS count".format(geometry))
if self.parameterAsBool(parameters, self.COMPUTE_AREA, context):
tokens.append("SUM(ST_Area({0})) AS area, ST_Perimeter(ST_Union({0})) AS perimeter".format(geometry))
statsField = self.parameterAsString(parameters, self.FIELD, context)
if statsField and self.parameterAsBool(parameters, self.COMPUTE_STATISTICS, context):
tokens.append("SUM({0}) AS sum, MIN({0}) AS min, MAX({0}) AS max, AVG({0}) AS avg".format(statsField))
params = ','.join(tokens)
if params:
if self.parameterAsBool(parameters, self.KEEP_ATTRIBUTES, context):
sql = "SELECT ST_Union({}) AS {}{}, {} FROM {} GROUP BY {}".format(geometry, geometry, other_fields, params, layerName, fieldName)
else:
sql = "SELECT ST_Union({}) AS {}, {}, {} FROM {} GROUP BY {}".format(geometry, geometry, fieldName, params, layerName, fieldName)
else:
if self.parameterAsBool(parameters, self.KEEP_ATTRIBUTES, context):
sql = "SELECT ST_Union({}) AS {}{} FROM {} GROUP BY {}".format(geometry, geometry, other_fields, layerName, fieldName)
else:
sql = "SELECT ST_Union({}) AS {}, {} FROM {} GROUP BY {}".format(geometry, geometry, fieldName, layerName, fieldName)
arguments.append(sql)
if self.parameterAsBool(parameters, self.EXPLODE_COLLECTIONS, context):
arguments.append('-explodecollections')
if options:
arguments.append(options)
if outputFormat:
arguments.append('-f {}'.format(outputFormat))
return ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, executing)
outFile = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, outFile)
output, outputFormat = GdalUtils.ogrConnectionStringAndFormat(outFile, context)
if outputFormat in ('SQLite', 'GPKG') and os.path.isfile(output):
raise QgsProcessingException('Output file "{}" already exists.'.format(output))
direction = self.parameterAsEnum(parameters, self.TRANSF, context)
crs = self.parameterAsEnum(parameters, self.CRS, context)
grid = self.parameterAsEnum(parameters, self.GRID, context)
arguments = []
if direction == 0:
# Direct transformation
arguments.append('-t_srs')
if crs == 0:
arguments.append('EPSG:4258')
gridFile = os.path.join(pluginPath, 'grids', 'chenyx06etrs.gsb')
arguments.append('-s_srs')
arguments.append('+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=600000 +y_0=200000 +ellps=bessel +nadgrids={} +wktext +units=m +no_defs'.format(gridFile))
arguments.append('-f {}'.format(outputFormat))
arguments.append('-lco')
arguments.append('ENCODING=UTF-8')
arguments.append(output)
arguments.append(ogrLayer)
arguments.append(layerName)
else:
arguments.append('+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=2600000 +y_0=1200000 +ellps=bessel +nadgrids=@null +wktext +units=m')
gridFile = os.path.join(pluginPath, 'grids', 'CHENYX06a.gsb')
arguments.append('-s_srs')
arguments.append('+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=600000 +y_0=200000 +ellps=bessel +nadgrids={} +wktext +units=m +no_defs'.format(gridFile))
arguments.append('-f')
arguments.append('Geojson')
arguments.append('/vsistdout/')
arguments.append(ogrLayer)
arguments.append(layerName)
arguments.append('-lco')
arguments.append('ENCODING=UTF-8')
arguments.append('|')
arguments.append('ogr2ogr')
arguments.append('-f {}'.format(outputFormat))
arguments.append('-a_srs')
arguments.append('EPSG:2056')
arguments.append(output)
arguments.append('/vsistdin/')
else:
# Inverse transformation
arguments = ['-s_srs']
if crs == 0:
arguments.append('EPSG:4258')
gridFile = os.path.join(pluginPath, 'grids', 'chenyx06etrs.gsb')
arguments.append('-t_srs')
arguments.append('+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=600000 +y_0=200000 +ellps=bessel +nadgrids={} +wktext +units=m +no_defs'.format(gridFile))
arguments.append('-f')
arguments.append('Geojson')
arguments.append('/vsistdout/')
arguments.append(ogrLayer)
arguments.append(layerName)
arguments.append('-lco')
arguments.append('ENCODING=UTF-8')
arguments.append('|')
arguments.append('ogr2ogr')
arguments.append('-f {}'.format(outputFormat))
arguments.append('-a_srs')
arguments.append('EPSG:21781')
arguments.append(output)
arguments.append('/vsistdin/')
else:
gridFile = os.path.join(pluginPath, 'grids', 'CHENYX06a.gsb')
arguments.append('+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=2600000 +y_0=1200000 +ellps=bessel +nadgrids=@null +wktext +units=m')
arguments.append('-t_srs')
arguments.append('+proj=somerc +lat_0=46.95240555555556 +lon_0=7.439583333333333 +k_0=1 +x_0=600000 +y_0=200000 +ellps=bessel +nadgrids={} +wktext +units=m +no_defs'.format(gridFile))
arguments.append('-f')
arguments.append('Geojson')
arguments.append('/vsistdout/')
arguments.append(ogrLayer)
arguments.append(layerName)
arguments.append('-lco')
arguments.append('ENCODING=UTF-8')
arguments.append('|')
arguments.append('ogr2ogr')
arguments.append('-f {}'.format(outputFormat))
arguments.append('-a_srs')
arguments.append('EPSG:21781')
arguments.append(output)
arguments.append('/vsistdin/')
if not os.path.isfile(os.path.join(pluginPath, 'grids', 'CHENYX06a.gsb')):
urlretrieve('http://www.naturalgis.pt/downloads/ntv2grids/ch/CHENYX06a.gsb', os.path.join(pluginPath, 'grids', 'CHENYX06a.gsb'))
urlretrieve('http://www.naturalgis.pt/downloads/ntv2grids/ch/chenyx06etrs.gsb', os.path.join(pluginPath, 'grids', 'chenyx06etrs.gsb'))
return ['ogr2ogr', 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 getConsoleCommands(self, parameters, context, feedback, executing=True):
connection = self.DB_CONNECTIONS[self.getParameterValue(self.DATABASE)]
uri = uri_from_name(connection)
if executing:
# to get credentials input when needed
uri = GeoDB(uri=uri).uri
inLayer = self.getParameterValue(self.INPUT_LAYER)
ogrLayer = GdalUtils.ogrConnectionString(inLayer, context)[1:-1]
shapeEncoding = self.getParameterValue(self.SHAPE_ENCODING)
schema = str(self.getParameterValue(self.SCHEMA))
table = str(self.getParameterValue(self.TABLE))
pk = str(self.getParameterValue(self.PK))
pkstring = "-lco FID=" + pk
primary_key = self.getParameterValue(self.PRIMARY_KEY)
where = str(self.getParameterValue(self.WHERE))
wherestring = '-where "' + where + '"'
gt = str(self.getParameterValue(self.GT))
overwrite = self.getParameterValue(self.OVERWRITE)
append = self.getParameterValue(self.APPEND)
addfields = self.getParameterValue(self.ADDFIELDS)
launder = self.getParameterValue(self.LAUNDER)
launderstring = "-lco LAUNDER=NO"
skipfailures = self.getParameterValue(self.SKIPFAILURES)
precision = self.getParameterValue(self.PRECISION)
options = str(self.getParameterValue(self.OPTIONS))
arguments = []
arguments.append('-progress')
arguments.append('--config PG_USE_COPY YES')
if len(shapeEncoding) > 0:
arguments.append('--config')
arguments.append('SHAPE_ENCODING')
arguments.append('"' + shapeEncoding + '"')
arguments.append('-f')
arguments.append('PostgreSQL')
arguments.append('PG:"')
for token in uri.connectionInfo(executing).split(' '):
arguments.append(token)
arguments.append('active_schema={}'.format(schema or 'public'))
arguments.append('"')
arguments.append(ogrLayer)
arguments.append('-nlt NONE')
arguments.append(GdalUtils.ogrLayerName(inLayer))
if launder:
arguments.append(launderstring)
if append:
arguments.append('-append')
if addfields:
arguments.append('-addfields')
if overwrite:
arguments.append('-overwrite')
if len(pk) > 0:
arguments.append(pkstring)
elif primary_key is not None:
arguments.append("-lco FID=" + primary_key)
if len(table) == 0:
table = GdalUtils.ogrLayerName(inLayer).lower()
if schema:
table = '{}.{}'.format(schema, table)
arguments.append('-nln')
arguments.append(table)
if skipfailures:
arguments.append('-skipfailures')
if where:
arguments.append(wherestring)
if len(gt) > 0:
arguments.append('-gt')
arguments.append(gt)
if not precision:
arguments.append('-lco PRECISION=NO')
if len(options) > 0:
arguments.append(options)
commands = []
if isWindows():
commands = ['cmd.exe', '/C ', 'ogr2ogr.exe',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['ogr2ogr', GdalUtils.escapeAndJoin(arguments)]
return commands
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)
if noData is not None:
noData = str(noData)
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)
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 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 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 getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
arguments = []
arguments.append('-ps')
arguments.append(
str(self.parameterAsInt(parameters, self.TILE_SIZE_X, context)))
arguments.append(
str(self.parameterAsInt(parameters, self.TILE_SIZE_Y, context)))
arguments.append('-overlap')
arguments.append(
str(self.parameterAsInt(parameters, self.OVERLAP, context)))
arguments.append('-levels')
arguments.append(
str(self.parameterAsInt(parameters, self.LEVELS, context)))
crs = self.parameterAsCrs(parameters, self.SOURCE_CRS, context)
if crs.isValid():
arguments.append('-s_srs')
arguments.append(GdalUtils.gdal_crs_string(crs))
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(
parameters, self.RESAMPLING, context)][1])
arguments.append('-ot')
arguments.append(self.TYPES[self.parameterAsEnum(
parameters, self.DATA_TYPE, context)])
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
if self.parameterAsBool(parameters, self.DIR_FOR_ROW, context):
arguments.append('-pyramidOnly')
if self.parameterAsBool(parameters, self.ONLY_PYRAMIDS, context):
arguments.append('-useDirForEachRow')
csvFile = self.parameterAsFileOutput(parameters, self.OUTPUT_CSV,
context)
if csvFile:
arguments.append('-csv')
arguments.append(csvFile)
delimiter = self.parameterAsString(parameters, self.DELIMITER,
context)
if delimiter:
arguments.append('-csvDelim')
arguments.append('"{}"'.format(delimiter))
arguments.append('-targetDir')
arguments.append(
self.parameterAsString(parameters, self.OUTPUT, context))
layers = [
l.source()
for l in self.parameterAsLayerList(parameters, self.INPUT, context)
]
arguments.extend(layers)
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ',
self.commandName() + '.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = [
self.commandName() + '.py',
GdalUtils.escapeAndJoin(arguments)
]
return commands
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)]
