def grassPath():
"""
Find GRASS path on the operating system.
Sets global variable Grass7Utils.path
"""
if Grass7Utils.path is not None:
return Grass7Utils.path
if not isWindows() and not isMac():
return ''
folder = ProcessingConfig.getSetting(Grass7Utils.GRASS_FOLDER) or ''
if not os.path.exists(folder):
folder = None
if folder is None:
# Under MS-Windows, we use OSGEO4W or QGIS Path for folder
if isWindows():
if "OSGEO4W_ROOT" in os.environ:
testfolder = os.path.join(str(os.environ['OSGEO4W_ROOT']),
"apps")
else:
testfolder = str(QgsApplication.prefixPath())
testfolder = os.path.join(testfolder, 'grass')
if os.path.isdir(testfolder):
for subfolder in os.listdir(testfolder):
if subfolder.startswith('grass-7'):
folder = os.path.join(testfolder, subfolder)
break
elif isMac():
# For MacOSX, we scan some well-known directories
# Start with QGIS bundle
for version in ['', '7', '70', '71', '72', '74']:
testfolder = os.path.join(str(QgsApplication.prefixPath()),
'grass{}'.format(version))
if os.path.isdir(testfolder):
folder = testfolder
break
# If nothing found, try standalone GRASS installation
if folder is None:
for version in ['0', '1', '2', '4']:
testfolder = '/Applications/GRASS-7.{}.app/Contents/MacOS'.format(
version)
if os.path.isdir(testfolder):
folder = testfolder
break
if folder is not None:
Grass7Utils.path = folder
return folder or ''
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
fileName = inLayer.source()
crs = self.parameterAsCrs(parameters, self.CRS, context)
arguments = []
arguments.append('-a_srs')
arguments.append(GdalUtils.gdal_crs_string(crs))
arguments.append(fileName)
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'gdal_edit.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['gdal_edit.py', GdalUtils.escapeAndJoin(arguments)]
self.setOutputValue(self.OUTPUT, fileName)
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 rliPath():
"""Return r.li GRASS7 user dir"""
if isWindows():
homeDir = win32api.GetShortPathName(os.path.expanduser('~'))
return os.path.join(homeDir, 'AppData', 'Roaming', 'GRASS7', 'r.li')
else:
return os.path.join(os.path.expanduser("~"), '.grass7', 'r.li')
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
arguments = []
arguments.append('-n')
arguments.append(
str(self.parameterAsInt(parameters, self.NCOLORS, context)))
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)
if isWindows():
commands = [
'cmd.exe', '/C ', 'rgb2pct.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['rgb2pct.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def grassHelpPath():
helpPath = ProcessingConfig.getSetting(Grass7Utils.GRASS_HELP_PATH)
if helpPath is None:
if isWindows() or isMac():
if Grass7Utils.path is not None:
localPath = os.path.join(Grass7Utils.path, 'docs/html')
if os.path.exists(localPath):
helpPath = os.path.abspath(localPath)
else:
searchPaths = [
'/usr/share/doc/grass-doc/html', '/opt/grass/docs/html',
'/usr/share/doc/grass/docs/html'
]
for path in searchPaths:
if os.path.exists(path):
helpPath = os.path.abspath(path)
break
if helpPath is not None:
return helpPath
elif Grass7Utils.version:
version = Grass7Utils.version.replace('.', '')[:2]
return 'https://grass.osgeo.org/grass{}/manuals/'.format(version)
else:
# GRASS not available!
return 'https://grass.osgeo.org/grass72/manuals/'
def load(self):
ProcessingConfig.settingIcons[self.name()] = self.icon()
ProcessingConfig.addSetting(Setting(self.name(), 'ACTIVATE_GRASS7',
self.tr('Activate'), True))
if isWindows() or isMac():
ProcessingConfig.addSetting(Setting(
self.name(),
Grass7Utils.GRASS_FOLDER, self.tr('GRASS7 folder'),
Grass7Utils.grassPath(), valuetype=Setting.FOLDER))
ProcessingConfig.addSetting(Setting(
self.name(),
Grass7Utils.GRASS_LOG_COMMANDS,
self.tr('Log execution commands'), False))
ProcessingConfig.addSetting(Setting(
self.name(),
Grass7Utils.GRASS_LOG_CONSOLE,
self.tr('Log console output'), False))
ProcessingConfig.addSetting(Setting(
self.name(),
Grass7Utils.GRASS_HELP_PATH,
self.tr('Location of GRASS docs'),
Grass7Utils.grassHelpPath()))
# Add a setting for using v.external instead of v.in.ogr
# But set it to False by default because some algorithms
# can't be used with external data (need a solid v.in.ogr).
ProcessingConfig.addSetting(Setting(
self.name(),
Grass7Utils.GRASS_USE_VEXTERNAL,
self.tr('For vector layers, use v.external (faster) instead of v.in.ogr'),
False))
ProcessingConfig.readSettings()
self.refreshAlgorithms()
return True
def executeSaga(feedback):
if isWindows():
command = ['cmd.exe', '/C ', sagaBatchJobFilename()]
else:
os.chmod(sagaBatchJobFilename(), stat.S_IEXEC |
stat.S_IREAD | stat.S_IWRITE)
command = ["'" + sagaBatchJobFilename() + "'"]
loglines = []
loglines.append(QCoreApplication.translate('SagaUtils', 'SAGA execution console output'))
with subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
) as proc:
try:
for line in iter(proc.stdout.readline, ''):
if '%' in line:
s = ''.join([x for x in line if x.isdigit()])
try:
feedback.setProgress(int(s))
except:
pass
else:
line = line.strip()
if line != '/' and line != '-' and line != '\\' and line != '|':
loglines.append(line)
feedback.pushConsoleInfo(line)
except:
pass
if ProcessingConfig.getSetting(SAGA_LOG_CONSOLE):
QgsMessageLog.logMessage('\n'.join(loglines), 'Processing', Qgis.Info)
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
arguments = []
arguments.append('-band')
arguments.append(
str(self.parameterAsInt(parameters, self.BAND, context)))
if self.parameterAsBool(parameters, self.CSV, context):
arguments.append('-csv')
arguments.append(
self.parameterAsRasterLayer(parameters, self.INPUT,
context).source())
arguments.append(
self.parameterAsFileOutput(parameters, self.OUTPUT, context))
commands = []
if isWindows():
commands = [
'cmd.exe', '/C ', 'gdal2xyz.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = ['gdal2xyz.py', GdalUtils.escapeAndJoin(arguments)]
return commands
def removeConfigFile(alg, parameters, context):
""" Remove the r.li user dir config file """
configPath = alg.parameterAsString(parameters, 'config', context)
if isWindows():
command = "DEL {}".format(os.path.join(rliPath(), configPath))
else:
command = "rm {}".format(os.path.join(rliPath(), configPath))
alg.commands.append(command)
def unload(self):
ProcessingConfig.removeSetting('ACTIVATE_GRASS7')
if isWindows() or isMac():
ProcessingConfig.removeSetting(Grass7Utils.GRASS_FOLDER)
ProcessingConfig.removeSetting(Grass7Utils.GRASS_LOG_COMMANDS)
ProcessingConfig.removeSetting(Grass7Utils.GRASS_LOG_CONSOLE)
ProcessingConfig.removeSetting(Grass7Utils.GRASS_HELP_PATH)
ProcessingConfig.removeSetting(Grass7Utils.GRASS_USE_VEXTERNAL)
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 ', 'gdal_retile.bat',
GdalUtils.escapeAndJoin(arguments)]
else:
commands = ['gdal_retile.py',
GdalUtils.escapeAndJoin(arguments)]
return commands
def sagaBatchJobFilename():
if isWindows():
filename = 'saga_batch_job.bat'
else:
filename = 'saga_batch_job.sh'
batchfile = os.path.join(userFolder(), filename)
return batchfile
def createGrassBatchJobFileFromGrassCommands(commands):
with open(Grass7Utils.grassBatchJobFilename(), 'w') as fout:
if not isWindows():
fout.write('#!/bin/sh\n')
else:
fout.write('chcp {}>NUL\n'.format(
Grass7Utils.getWindowsCodePage()))
for command in commands:
Grass7Utils.writeCommand(fout, command)
fout.write('exit')
def grassBin():
"""
Find GRASS binary path on the operating system.
Sets global variable Grass7Utils.command
"""
cmdList = [
"grass74", "grass72", "grass71", "grass70", "grass", "grass74.sh",
"grass72.sh", "grass71.sh", "grass70.sh", "grass.sh"
]
def searchFolder(folder):
"""
Inline function to search for grass binaries into a folder
with os.walk
"""
if os.path.exists(folder):
for root, dirs, files in os.walk(folder):
for cmd in cmdList:
if cmd in files:
return os.path.join(root, cmd)
return None
if Grass7Utils.command:
return Grass7Utils.command
path = Grass7Utils.grassPath()
command = None
# For MS-Windows there is a difference between GRASS Path and GRASS binary
if isWindows():
# If nothing found, use OSGEO4W or QgsPrefix:
if "OSGEO4W_ROOT" in os.environ:
testFolder = str(os.environ['OSGEO4W_ROOT'])
else:
testFolder = str(QgsApplication.prefixPath())
testFolder = os.path.join(testFolder, 'bin')
command = searchFolder(testFolder)
elif isMac():
# Search in grassPath
command = searchFolder(path)
# Under GNU/Linux or if everything has failed, use shutil
if not command:
for cmd in cmdList:
testBin = shutil.which(cmd)
if testBin:
command = os.path.abspath(testBin)
break
if command:
Grass7Utils.command = command
if path is '':
Grass7Utils.path = os.path.dirname(command)
return command
def grassBatchJobFilename():
"""
The Batch file is executed by GRASS binary.
On GNU/Linux and MacOSX it will be executed by a shell.
On MS-Windows, it will be executed by cmd.exe.
"""
gisdbase = Grass7Utils.grassDataFolder()
if isWindows():
batchFile = os.path.join(gisdbase, 'grass_batch_job.cmd')
else:
batchFile = os.path.join(gisdbase, 'grass_batch_job.sh')
return batchFile
def checkGrassIsInstalled(ignorePreviousState=False):
if not ignorePreviousState:
if Grass7Utils.isGrassInstalled:
return
# We check the version of Grass7
if Grass7Utils.installedVersion() is not None:
# For Ms-Windows, we check GRASS binaries
if isWindows():
cmdpath = os.path.join(Grass7Utils.path, 'bin',
'r.out.gdal.exe')
if not os.path.exists(cmdpath):
return Grass7Utils.tr(
'The specified GRASS 7 folder "{}" does not contain '
'a valid set of GRASS 7 modules.\nPlease, go to the '
'Processing settings dialog, and check that the '
'GRASS 7\nfolder is correctly configured'.format(
os.path.join(Grass7Utils.path, 'bin')))
Grass7Utils.isGrassInstalled = True
return
# Return error messages
else:
# MS-Windows or MacOSX
if isWindows() or isMac():
if Grass7Utils.path is None:
return Grass7Utils.tr(
'GRASS GIS 7 folder is not configured. Please configure '
'it before running GRASS GIS 7 algorithms.')
if Grass7Utils.command is None:
return Grass7Utils.tr(
'GRASS GIS 7 binary {0} can\'t be found on this system from a shell. '
'Please install it or configure your PATH {1} environment variable.'
.format('(grass.bat)' if isWindows() else '(grass.sh)',
'or OSGEO4W_ROOT' if isWindows() else ''))
# GNU/Linux
else:
return Grass7Utils.tr(
'GRASS 7 can\'t be found on this system from a shell. '
'Please install it or configure your PATH environment variable.'
)
def moveOutputTxtFile(alg, parameters, context):
# Find output file name:
txtPath = alg.parameterAsString(parameters, 'output_txt', context)
userGrass7Path = rliPath()
output = os.path.join(userGrass7Path, 'output',
alg.parameterAsString(parameters, 'output', context))
# move the file
if isWindows():
command = "MOVE /Y {} {}".format(output, txtPath)
else:
command = "mv -f {} {}".format(output, txtPath)
alg.commands.append(command)
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
arguments = []
arguments.append('-md')
arguments.append(
str(self.parameterAsInt(parameters, self.DISTANCE, context)))
nIterations = self.parameterAsInt(parameters, self.ITERATIONS, context)
if nIterations:
arguments.append('-si')
arguments.append(str(nIterations))
arguments.append('-b')
arguments.append(
str(self.parameterAsInt(parameters, self.BAND, context)))
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_fillnodata.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = [
'gdal_fillnodata.py',
GdalUtils.escapeAndJoin(arguments)
]
return commands
def installedVersion(run=False):
"""
Returns the installed version of GRASS by
launching the GRASS command with -v parameter.
"""
if Grass7Utils.isGrassInstalled and not run:
return Grass7Utils.version
if Grass7Utils.grassBin() is None:
return None
# Launch GRASS command with -v parameter
# For MS-Windows, hide the console
if isWindows():
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
si.wShowWindow = subprocess.SW_HIDE
with subprocess.Popen([Grass7Utils.command, '-v'],
shell=True if isMac() else False,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
startupinfo=si if isWindows() else None) as proc:
try:
lines = proc.stdout.readlines()
for line in lines:
if "GRASS GIS " in line:
line = line.split(" ")[-1].strip()
if line.startswith("7."):
Grass7Utils.version = line
return Grass7Utils.version
except:
pass
return None
def getInstalledVersion(runSaga=False):
global _installedVersion
global _installedVersionFound
maxRetries = 5
retries = 0
if _installedVersionFound and not runSaga:
return _installedVersion
if isWindows():
commands = [os.path.join(sagaPath(), "saga_cmd.exe"), "-v"]
elif isMac():
commands = [os.path.join(sagaPath(), "saga_cmd -v")]
else:
# for Linux use just one string instead of separated parameters as the list
# does not work well together with shell=True option
# (python docs advices to use subprocess32 instead of python2.7's subprocess)
commands = ["saga_cmd -v"]
while retries < maxRetries:
with subprocess.Popen(
commands,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
) as proc:
if isMac(): # This trick avoids having an uninterrupted system call exception if SAGA is not installed
time.sleep(1)
try:
lines = proc.stdout.readlines()
for line in lines:
if line.startswith("SAGA Version:"):
_installedVersion = line[len("SAGA Version:"):].strip().split(" ")[0]
_installedVersionFound = True
return _installedVersion
return None
except IOError:
retries += 1
except:
return None
return _installedVersion
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
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 createSagaBatchJobFileFromSagaCommands(commands):
with open(sagaBatchJobFilename(), 'w') as fout:
if isWindows():
fout.write('set SAGA=' + sagaPath() + '\n')
fout.write('set SAGA_MLB=' + os.path.join(sagaPath(), 'modules') + '\n')
fout.write('PATH=%PATH%;%SAGA%;%SAGA_MLB%\n')
elif isMac():
fout.write('export SAGA_MLB=' + os.path.join(sagaPath(), '../lib/saga') + '\n')
fout.write('export PATH=' + sagaPath() + ':$PATH\n')
else:
pass
for command in commands:
try:
# Python 2
fout.write('saga_cmd ' + command.encode('utf8') + '\n')
except TypeError:
# Python 3
fout.write('saga_cmd ' + command + '\n')
fout.write('exit')
def findSagaFolder():
folder = None
if isMac():
testfolder = os.path.join(QgsApplication.prefixPath(), 'bin')
if os.path.exists(os.path.join(testfolder, 'saga_cmd')):
folder = testfolder
else:
testfolder = '/usr/local/bin'
if os.path.exists(os.path.join(testfolder, 'saga_cmd')):
folder = testfolder
elif isWindows():
folders = []
folders.append(os.path.join(os.path.dirname(QgsApplication.prefixPath()), 'saga-ltr'))
folders.append(os.path.join(os.path.dirname(QgsApplication.prefixPath()), 'saga'))
if "OSGEO4W_ROOT" in os.environ:
folders.append(os.path.join(str(os.environ['OSGEO4W_ROOT']), "apps", "saga-ltr"))
folders.append(os.path.join(str(os.environ['OSGEO4W_ROOT']), "apps", "saga"))
for testfolder in folders:
if os.path.exists(os.path.join(testfolder, 'saga_cmd.exe')):
folder = testfolder
break
return folder
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)
arguments.append(inLayer.source())
arguments.append(self.parameterAsString(parameters, self.OUTPUT, context))
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):
inLayer = self.parameterAsRasterLayer(parameters, self.INPUT, context)
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 ', 'gdal_proximity.bat',
GdalUtils.escapeAndJoin(arguments)
]
else:
commands = [
'gdal_proximity.py',
GdalUtils.escapeAndJoin(arguments)
]
return commands
def sagaPath():
if not isWindows() and not isMac():
return ''
folder = findSagaFolder()
return folder or ''
def getValue(self):
s = self.leText.text()
if isWindows():
s = s.replace('\\', '/')
return s
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)
tsrs = self.parameterAsCrs(parameters, self.T_SRS, context)
asrs = self.parameterAsCrs(parameters, self.A_SRS, context)
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 ssrs.isValid():
arguments.append('-s_srs')
arguments.append(GdalUtils.gdal_crs_string(ssrs))
if tsrs.isValid():
arguments.append('-t_srs')
arguments.append(GdalUtils.gdal_crs_string(tsrs))
if asrs.isValid():
arguments.append('-a_srs')
arguments.append(GdalUtils.gdal_crs_string(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 processAlgorithm(self, parameters, context, feedback):
if isWindows():
path = Grass7Utils.grassPath()
if path == '':
raise QgsProcessingException(
self.tr(
'GRASS GIS 7 folder is not configured. Please '
'configure it before running GRASS GIS 7 algorithms.'))
# Create brand new commands lists
self.commands = []
self.outputCommands = []
self.exportedLayers = {}
# If GRASS session has been created outside of this algorithm then
# get the list of layers loaded in GRASS otherwise start a new
# session
existingSession = Grass7Utils.sessionRunning
if existingSession:
self.exportedLayers = Grass7Utils.getSessionLayers()
else:
Grass7Utils.startGrassSession()
# Handle default GRASS parameters
self.grabDefaultGrassParameters(parameters, context)
# Handle ext functions for inputs/command/outputs
for fName in ['Inputs', 'Command', 'Outputs']:
fullName = 'process{}'.format(fName)
if self.module and hasattr(self.module, fullName):
getattr(self.module, fullName)(self, parameters, context,
feedback)
else:
getattr(self, fullName)(parameters, context, feedback)
# Run GRASS
loglines = []
loglines.append(self.tr('GRASS GIS 7 execution commands'))
for line in self.commands:
feedback.pushCommandInfo(line)
loglines.append(line)
if ProcessingConfig.getSetting(Grass7Utils.GRASS_LOG_COMMANDS):
QgsMessageLog.logMessage("\n".join(loglines),
self.tr('Processing'), Qgis.Info)
Grass7Utils.executeGrass(self.commands, feedback, self.outputCommands)
# If the session has been created outside of this algorithm, add
# the new GRASS GIS 7 layers to it otherwise finish the session
if existingSession:
Grass7Utils.addSessionLayers(self.exportedLayers)
else:
Grass7Utils.endGrassSession()
# Return outputs map
outputs = {}
for out in self.outputDefinitions():
outName = out.name()
if outName in parameters:
outputs[outName] = parameters[outName]
if isinstance(out, QgsProcessingOutputHtml):
self.convertToHtml(parameters[outName])
return outputs
