def __init__(self):
AlgorithmProvider.__init__(self)
self.activate = False
self.algsList = []
if isWindows():
lastools = [
lasground(), lasheight(), lasclassify(), lasclip(), lastile(),
lasgrid(), las2dem(), blast2dem(), las2iso(), blast2iso(),
lasview(), lasboundary(), lasinfo(), lasprecision(),
lasvalidate(), lasduplicate(), las2txt(), txt2las(), laszip(),
lasindex(), lasthin(), lassort(), lascanopy(), lasmerge(),
las2shp(), shp2las(), lasnoise(), lassplit(), las2las_filter(),
las2las_transform(), lasoverage(), lasoverlap()
]
else:
lastools = [
lasinfo(), lasprecision(), lasvalidate(), las2txt(), txt2las(),
laszip(), lasindex(), lasmerge(), las2las_filter(),
las2las_transform()
]
for alg in lastools:
alg.group = 'LAStools'
self.algsList.extend(lastools)
if isWindows():
self.actions.append(OpenViewerAction())
fusiontools = [
CloudMetrics(), CanopyMaxima(), CanopyModel(), ClipData(),
Cover(), FilterData(), GridMetrics(), GroundFilter(),
GridSurfaceCreate(), MergeData()
]
for alg in fusiontools:
alg.group = 'Fusion'
self.algsList.extend(fusiontools)
def grassPath():
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:
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
else:
folder = os.path.join(str(QgsApplication.prefixPath()), "grass7")
if not os.path.isdir(folder):
folder = "/Applications/GRASS-7.0.app/Contents/MacOS"
return folder or ""
def grassPath():
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:
if isWindows():
if "OSGEO4W_ROOT" in os.environ:
testfolder = os.path.join(unicode(os.environ['OSGEO4W_ROOT']), "apps")
else:
testfolder = unicode(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)
fn = os.path.join(folder, "etc", "VERSIONNUMBER")
if not os.path.isfile(fn):
continue
f = open(fn, "r")
Grass7Utils.version = f.read().split(' ')[0]
f.close()
major, minor, patch = Grass7Utils.version.split('.')
Grass7Utils.command = "grass{}{}".format(major, minor)
break
else:
folder = os.path.join(unicode(QgsApplication.prefixPath()), 'grass7')
if not os.path.isdir(folder):
folder = '/Applications/GRASS-7.0.app/Contents/MacOS'
return folder or ''
def grassPath():
if not isWindows() and not isMac():
return ''
folder = ProcessingConfig.getSetting(GrassUtils.GRASS_FOLDER) or ''
if not os.path.exists(folder):
folder = None
if folder is None:
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-6'):
folder = os.path.join(testfolder, subfolder)
break
else:
folder = os.path.join(QgsApplication.prefixPath(), 'grass')
if not os.path.isdir(folder):
folder = '/Applications/GRASS-6.4.app/Contents/MacOS'
if folder:
ProcessingConfig.setSettingValue(GrassUtils.GRASS_FOLDER, folder)
return folder or ''
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 ''
if isMac():
folder = ProcessingConfig.getSetting(Grass7Utils.GRASS_FOLDER) or ''
if not os.path.exists(folder):
folder = None
else:
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):
grassfolders = sorted([f for f in os.listdir(testfolder) if f.startswith("grass-7.") and os.path.isdir(os.path.join(testfolder, f))], reverse=True, key=lambda x: [int(v) for v in x[len("grass-"):].split('.')])
if grassfolders:
folder = os.path.join(testfolder, grassfolders[0])
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)
if inLayer is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.INPUT))
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)
if isWindows():
commands = ["python3", "-m", self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
self.setOutputValue(self.OUTPUT, fileName)
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 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)
def unload(self):
AlgorithmProvider.unload(self)
ProcessingConfig.removeSetting(RUtils.RSCRIPTS_FOLDER)
if isWindows():
ProcessingConfig.removeSetting(RUtils.R_FOLDER)
ProcessingConfig.removeSetting(RUtils.R_LIBS_USER)
ProcessingConfig.removeSetting(RUtils.R_USE64)
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/grass76/manuals/'
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 unload(self):
AlgorithmProvider.unload(self)
if (isWindows() or isMac()) and SagaUtils.findSagaFolder() is None:
ProcessingConfig.removeSetting(SagaUtils.SAGA_FOLDER)
ProcessingConfig.removeSetting(SagaUtils.SAGA_LOG_CONSOLE)
ProcessingConfig.removeSetting(SagaUtils.SAGA_LOG_COMMANDS)
def unload(self):
AlgorithmProvider.unload(self)
if isWindows() or isMac():
ProcessingConfig.removeSetting(Grass7Utils.GRASS_FOLDER)
ProcessingConfig.removeSetting(Grass7Utils.GRASS_WIN_SHELL)
ProcessingConfig.removeSetting(Grass7Utils.GRASS_LOG_COMMANDS)
ProcessingConfig.removeSetting(Grass7Utils.GRASS_LOG_CONSOLE)
def RFolder():
folder = ProcessingConfig.getSetting(RUtils.R_FOLDER)
if folder is None:
if isWindows():
if 'ProgramW6432' in list(os.environ.keys()) and os.path.isdir(os.path.join(os.environ['ProgramW6432'], 'R')):
testfolder = os.path.join(os.environ['ProgramW6432'], 'R')
elif 'PROGRAMFILES(x86)' in list(os.environ.keys()) and os.path.isdir(os.path.join(os.environ['PROGRAMFILES(x86)'], 'R')):
testfolder = os.path.join(os.environ['PROGRAMFILES(x86)'], 'R')
elif 'PROGRAMFILES' in list(os.environ.keys()) and os.path.isdir(os.path.join(os.environ['PROGRAMFILES'], 'R')):
testfolder = os.path.join(os.environ['PROGRAMFILES'], 'R')
else:
testfolder = 'C:\\R'
if os.path.isdir(testfolder):
subfolders = os.listdir(testfolder)
subfolders.sort(reverse=True)
for subfolder in subfolders:
if subfolder.startswith('R-'):
folder = os.path.join(testfolder, subfolder)
break
else:
folder = ''
else:
folder = ''
return os.path.abspath(str(folder))
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 exportRasterLayersIntoDirectory(self, name, parameters, context, colorTable=True, wholeDB=False):
"""
Creates a dedicated loop command to export rasters from
temporary GRASS DB into a directory via gdal.
:param name: name of the output directory parameter.
:param parameters: Algorithm parameters dict.
:param context: Algorithm context.
:param colorTable: preserve color Table.
:param wholeDB: export every raster layer from the GRASSDB
"""
# Grab directory name and temporary basename
outDir = os.path.normpath(
self.parameterAsString(parameters, name, context))
basename = ''
if not wholeDB:
basename = name + self.uniqueSuffix
# Add a loop export from the basename
for cmd in [self.commands, self.outputCommands]:
# TODO Format/options support
if isWindows():
cmd.append("if not exist {0} mkdir {0}".format(outDir))
cmd.append("for /F %%r IN ('g.list type^=rast pattern^=\"{0}*\"') do r.out.gdal -m{1} input=%%r output={2}/%%r.tif {3}".format(
basename,
' -t' if colorTable else '',
outDir,
'--overwrite -c createopt="TFW=YES,COMPRESS=LZW"'
))
else:
cmd.append("for r in $(g.list type=rast pattern='{}*'); do".format(basename))
cmd.append(" r.out.gdal -m{0} input=${{r}} output={1}/${{r}}.tif {2}".format(
' -t' if colorTable else '', outDir,
'--overwrite -c createopt="TFW=YES,COMPRESS=LZW"'
))
cmd.append("done")
def initializeSettings(self):
AlgorithmProvider.initializeSettings(self)
ProcessingConfig.addSetting(
Setting(
self.getDescription(),
RUtils.RSCRIPTS_FOLDER,
self.tr("R Scripts folder"),
RUtils.defaultRScriptsFolder(),
valuetype=Setting.MULTIPLE_FOLDERS,
)
)
if isWindows():
ProcessingConfig.addSetting(
Setting(
self.getDescription(),
RUtils.R_FOLDER,
self.tr("R folder"),
RUtils.RFolder(),
valuetype=Setting.FOLDER,
)
)
ProcessingConfig.addSetting(
Setting(
self.getDescription(),
RUtils.R_LIBS_USER,
self.tr("R user library folder"),
RUtils.RLibs(),
valuetype=Setting.FOLDER,
)
)
ProcessingConfig.addSetting(
Setting(self.getDescription(), RUtils.R_USE64, self.tr("Use 64 bit version"), False)
)
def RFolder():
folder = ProcessingConfig.getSetting(RUtils.R_FOLDER)
if folder is None:
if isWindows():
if "ProgramW6432" in list(os.environ.keys()) and os.path.isdir(
os.path.join(os.environ["ProgramW6432"], "R")
):
testfolder = os.path.join(os.environ["ProgramW6432"], "R")
elif "PROGRAMFILES(x86)" in list(os.environ.keys()) and os.path.isdir(
os.path.join(os.environ["PROGRAMFILES(x86)"], "R")
):
testfolder = os.path.join(os.environ["PROGRAMFILES(x86)"], "R")
elif "PROGRAMFILES" in list(os.environ.keys()) and os.path.isdir(
os.path.join(os.environ["PROGRAMFILES"], "R")
):
testfolder = os.path.join(os.environ["PROGRAMFILES"], "R")
else:
testfolder = "C:\\R"
if os.path.isdir(testfolder):
subfolders = os.listdir(testfolder)
subfolders.sort(reverse=True)
for subfolder in subfolders:
if subfolder.startswith("R-"):
folder = os.path.join(testfolder, subfolder)
break
else:
folder = ""
else:
folder = ""
return os.path.abspath(str(folder))
def initializeSettings(self):
AlgorithmProvider.initializeSettings(self)
if isWindows() or isMac():
ProcessingConfig.addSetting(Setting(self.getDescription(),
GrassUtils.GRASS_FOLDER, self.tr('GRASS folder'),
GrassUtils.grassPath(), valuetype=Setting.FOLDER))
if isWindows():
ProcessingConfig.addSetting(Setting(self.getDescription(),
GrassUtils.GRASS_WIN_SHELL, self.tr('Msys folder'),
GrassUtils.grassWinShell(), valuetype=Setting.FOLDER))
ProcessingConfig.addSetting(Setting(self.getDescription(),
GrassUtils.GRASS_LOG_COMMANDS,
self.tr('Log execution commands'), False))
ProcessingConfig.addSetting(Setting(self.getDescription(),
GrassUtils.GRASS_LOG_CONSOLE,
self.tr('Log console output'), False))
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 checkGrassIsInstalled(ignorePreviousState=False):
if isWindows():
path = GrassUtils.grassPath()
if path == "":
return GrassUtils.tr(
"GRASS folder is not configured.\nPlease configure " "it before running GRASS algorithms."
)
cmdpath = os.path.join(path, "bin", "r.out.gdal.exe")
if not os.path.exists(cmdpath):
return GrassUtils.tr(
'The specified GRASS folder "{}" does not contain a valid '
"set of GRASS modules. Please, go to the Processing "
"settings dialog, and check that the GRASS folder is "
"correctly configured".format(os.path.join(path, "bin"))
)
if not ignorePreviousState:
if GrassUtils.isGrassInstalled:
return
try:
from processing import runalg
result = runalg("grass:v.voronoi", points(), False, False, None, -1, 0.0001, 0, None)
if not os.path.exists(result["output"]):
return GrassUtils.tr(
"It seems that GRASS is not correctly installed and "
"configured in your system.\nPlease install it before "
"running GRASS algorithms."
)
except:
return GrassUtils.tr(
"Error while checking GRASS installation. GRASS might not " "be correctly configured.\n"
)
GrassUtils.isGrassInstalled = True
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 help(self):
localDoc = None
html = self.grass7Name + ".html"
if system.isWindows():
# For MS-Windows, use the configured GRASS7 path
localPath = os.path.join(Grass7Utils.grassPath(), "docs/html", html)
if os.path.exists(localPath):
localDoc = os.path.abspath(localPath)
elif system.isMac():
# For MacOSX official package
localPath = os.path.join("/Applications/GRASS-7.0.app/Contents/MacOS/docs/html", html)
if os.path.exists(localPath):
localDoc = os.path.abspath(localPath)
else:
# For GNU/Linux distributions
searchPaths = ["/usr/share/doc/grass-doc/html", "/opt/grass/docs/html", "/usr/share/doc/grass/docs/html"]
for path in searchPaths:
localPath = os.path.join(path, html)
if os.path.exists(localPath):
localDoc = os.path.abspath(localPath)
# Found the local documentation
if localDoc:
localDoc = QUrl.fromLocalFile(localDoc).toString()
return False, localDoc
# Return the URL if local doc is not found
return False, "http://grass.osgeo.org/grass70/manuals/" + self.grass7Name + ".html"
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 executeSaga(progress):
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'))
proc = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=open(os.devnull),
stderr=subprocess.STDOUT,
universal_newlines=True,
).stdout
try:
for line in iter(proc.readline, ''):
if '%' in line:
s = ''.join([x for x in line if x.isdigit()])
try:
progress.setPercentage(int(s))
except:
pass
else:
line = line.strip()
if line != '/' and line != '-' and line != '\\' and line != '|':
loglines.append(line)
progress.setConsoleInfo(line)
except:
pass
if ProcessingConfig.getSetting(SAGA_LOG_CONSOLE):
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
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 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()))
ProcessingConfig.readSettings()
self.refreshAlgorithms()
return True
def getConsoleCommands(self, parameters, context, feedback, executing=True):
spectral = self.parameterAsRasterLayer(parameters, self.SPECTRAL, context)
if spectral is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.SPECTRAL))
panchromatic = self.parameterAsRasterLayer(parameters, self.PANCHROMATIC, context)
if panchromatic is None:
raise QgsProcessingException(self.invalidRasterError(parameters, self.PANCHROMATIC))
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
self.setOutputValue(self.OUTPUT, out)
arguments = []
arguments.append(panchromatic.source())
arguments.append(spectral.source())
arguments.append(out)
arguments.append('-r')
arguments.append(self.methods[self.parameterAsEnum(parameters, self.RESAMPLING, context)][1])
arguments.append('-of')
arguments.append(QgsRasterFileWriter.driverForExtension(os.path.splitext(out)[1]))
options = self.parameterAsString(parameters, self.OPTIONS, context)
if options:
arguments.extend(GdalUtils.parseCreationOptions(options))
if isWindows():
commands = ['python3', '-m', self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
return commands
def getConsoleCommands(self):
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 prepareGrassExecution(commands):
env = os.environ.copy()
if isWindows():
GrassUtils.createGrassScript(commands)
command = ["cmd.exe", "/C ", GrassUtils.grassScriptFilename()]
else:
gisrc = os.path.join(userFolder(), "processing.gisrc")
env["GISRC"] = gisrc
env["GRASS_MESSAGE_FORMAT"] = "gui"
env["GRASS_BATCH_JOB"] = GrassUtils.grassBatchJobFilename()
if "GISBASE" in env:
del env["GISBASE"]
GrassUtils.createGrassBatchJobFileFromGrassCommands(commands)
os.chmod(GrassUtils.grassBatchJobFilename(), stat.S_IEXEC | stat.S_IREAD | stat.S_IWRITE)
if isMac():
command = (
os.path.join(GrassUtils.grassPath(), "grass.sh")
+ " "
+ os.path.join(GrassUtils.grassMapsetFolder(), "PERMANENT")
)
else:
command = "grass64 " + os.path.join(GrassUtils.grassMapsetFolder(), "PERMANENT")
return command, env
def grassBin():
"""
Find GRASS binary path on the operating system.
Sets global variable Grass7Utils.command
"""
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
vn = os.path.join(path, "etc", "VERSIONNUMBER")
if os.path.isfile(vn):
with open(vn, "r") as f:
major, minor, patch = f.readlines()[0].split(' ')[0].split('.')
if patch != 'svn':
patch = ''
cmdList = [
"grass{}{}{}".format(major, minor, patch),
"grass",
"grass{}{}{}.sh".format(major, minor, patch),
"grass.sh"
]
else:
cmdList = [
"grass76", "grass74", "grass72", "grass70", "grass",
"grass76.sh", "grass74.sh", "grass72.sh", "grass70.sh", "grass.sh"
]
# 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)
# 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 getConsoleCommands(self):
connection = 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 = self.getParameterValue(self.S_SRS)
tsrs = self.getParameterValue(self.T_SRS)
asrs = self.getParameterValue(self.A_SRS)
schema = self.getParameterValue(self.SCHEMA)
table = self.getParameterValue(self.TABLE)
pk = self.getParameterValue(self.PK)
primary_key = self.getParameterValue(self.PRIMARY_KEY)
geocolumn = self.getParameterValue(self.GEOCOLUMN)
dim = self.DIMLIST[self.getParameterValue(self.DIM)]
simplify = self.getParameterValue(self.SIMPLIFY)
segmentize = self.getParameterValue(self.SEGMENTIZE)
spat = self.getParameterValue(self.SPAT)
clip = self.getParameterValue(self.CLIP)
where = self.getParameterValue(self.WHERE)
gt = self.getParameterValue(self.GT)
overwrite = self.getParameterValue(self.OVERWRITE)
append = self.getParameterValue(self.APPEND)
addfields = self.getParameterValue(self.ADDFIELDS)
launder = self.getParameterValue(self.LAUNDER)
index = self.getParameterValue(self.INDEX)
skipfailures = self.getParameterValue(self.SKIPFAILURES)
promotetomulti = self.getParameterValue(self.PROMOTETOMULTI)
precision = self.getParameterValue(self.PRECISION)
options = 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("-lco DIM=" + dim)
arguments.append(ogrLayer)
arguments.append(ogrLayerName(inLayer))
if index:
arguments.append("-lco SPATIAL_INDEX=OFF")
if launder:
arguments.append("-lco LAUNDER=NO")
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 geocolumn:
arguments.append("-lco GEOMETRY_NAME=" + geocolumn)
if pk:
arguments.append("-lco FID=" + pk)
elif primary_key is not None:
arguments.append("-lco FID=" + primary_key)
if not table:
table = ogrLayerName(inLayer).lower()
if schema:
table = '{}.{}'.format(schema, table)
arguments.append('-nln')
arguments.append(table)
if ssrs:
arguments.append('-s_srs')
arguments.append(ssrs)
if tsrs:
arguments.append('-t_srs')
arguments.append(tsrs)
if asrs:
arguments.append('-a_srs')
arguments.append(asrs)
if spat:
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('-where "' + where + '"')
if simplify:
arguments.append('-simplify')
arguments.append(simplify)
if segmentize:
arguments.append('-segmentize')
arguments.append(segmentize)
if gt:
arguments.append('-gt')
arguments.append(gt)
if promotetomulti:
arguments.append('-nlt PROMOTE_TO_MULTI')
if precision is False:
arguments.append('-lco PRECISION=NO')
if options:
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):
if system.isWindows():
path = CircuitscapeUtils.circuitscapePath()
if path == '':
raise GeoAlgorithmExecutionException(
'Circuitscape folder is not configured.\nPlease '
'configure it before running Circuitscape algorithms.')
resistance = self.getParameterValue(self.RESISTANCE_MAP)
useConductance = str(not self.getParameterValue(self.IS_CONDUCTANCES))
focal = self.getParameterValue(self.FOCAL_NODE)
writeCurrent = str(self.getParameterValue(self.WRITE_CURRENT_MAP))
writeVoltage = str(self.getParameterValue(self.WRITE_VOLTAGE_MAP))
# advanced parameters
mask = self.getParameterValue(self.MASK)
shortCircuit = self.getParameterValue(self.SHORT_CIRCUIT)
focalPairs = self.getParameterValue(self.EXCLUDE_INCLUDE)
lowMemory = str(self.getParameterValue(self.LOW_MEMORY))
baseName = self.getParameterValue(self.BASENAME)
directory = self.getOutputValue(self.DIRECTORY)
progress.setInfo('basename: %s' % baseName)
progress.setInfo('directory: %s' % directory)
basePath = os.path.join(directory, baseName)
iniPath = CircuitscapeUtils.writeConfiguration()
cfg = ConfigParser.SafeConfigParser()
cfg.read(iniPath)
commands = self.prepareInputs()
# set parameters
cfg.set('Circuitscape mode', 'scenario', 'pairwise')
cfg.set('Habitat raster or graph', 'habitat_map_is_resistances',
useConductance)
if resistance in self.exportedLayers.keys():
resistance = self.exportedLayers[resistance]
cfg.set('Habitat raster or graph', 'habitat_file', resistance)
if focal in self.exportedLayers.keys():
focal = self.exportedLayers[focal]
cfg.set('Options for pairwise and one-to-all and all-to-one modes',
'point_file', focal)
if focalPairs is not None:
cfg.set('Options for pairwise and one-to-all and all-to-one modes',
'included_pairs_file', focalPairs)
cfg.set('Options for pairwise and one-to-all and all-to-one modes',
'use_included_pairs', 'True')
if mask is not None:
if mask in self.exportedLayers.keys():
mask = self.exportedLayers[mask]
cfg.set('Mask file', 'mask_file', mask)
cfg.set('Mask file', 'use_mask', 'True')
if shortCircuit is not None:
if shortCircuit in self.exportedLayers.keys():
shortCircuit = self.exportedLayers[shortCircuit]
cfg.set('Short circuit regions (aka polygons)', 'polygon_file',
shortCircuit)
cfg.set('Short circuit regions (aka polygons)', 'use_polygons',
'True')
cfg.set('Calculation options', 'low_memory_mode', lowMemory)
cfg.set('Output options', 'write_cur_maps', writeCurrent)
cfg.set('Output options', 'write_volt_maps', writeVoltage)
cfg.set('Output options', 'output_file', basePath)
# write configuration back to file
with open(iniPath, 'wb') as f:
cfg.write(f)
if system.isWindows():
commands.append('"' + os.path.join(path, 'cs_run.exe') + '" ' +
iniPath)
else:
commands.append('csrun.py ' + iniPath)
CircuitscapeUtils.createBatchJobFileFromCommands(commands)
loglines = []
loglines.append('Circuitscape execution commands')
for line in commands:
progress.setCommand(line)
loglines.append(line)
if ProcessingConfig.getSetting(CircuitscapeUtils.LOG_COMMANDS):
ProcessingLog.addToLog(ProcessingLog.LOG_INFO, loglines)
CircuitscapeUtils.executeCircuitscape(commands, progress)
def getConsoleCommands(self):
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 normalizeLayerSource(source):
if isWindows():
source = source.replace('\\', '/')
source = source.replace('"', "'")
return source
def executeGrass(commands, feedback, outputCommands=None):
loglines = []
loglines.append(Grass7Utils.tr('GRASS GIS 7 execution console output'))
grassOutDone = False
command, grassenv = Grass7Utils.prepareGrassExecution(commands)
# QgsMessageLog.logMessage('exec: {}'.format(command), 'DEBUG', Qgis.Info)
# For MS-Windows, we need to hide the console window.
kw = {}
if isWindows():
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
si.wShowWindow = subprocess.SW_HIDE
kw['startupinfo'] = si
if sys.version_info >= (3, 6):
kw['encoding'] = "cp{}".format(Grass7Utils.getWindowsCodePage())
with subprocess.Popen(
command,
shell=False,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
env=grassenv,
**kw
) as proc:
for line in iter(proc.stdout.readline, ''):
if 'GRASS_INFO_PERCENT' in line:
try:
feedback.setProgress(int(line[len('GRASS_INFO_PERCENT') + 2:]))
except:
pass
else:
if 'r.out' in line or 'v.out' in line:
grassOutDone = True
loglines.append(line)
if any([l in line for l in ['WARNING', 'ERROR']]):
feedback.reportError(line.strip())
elif 'Segmentation fault' in line:
feedback.reportError(line.strip())
feedback.reportError('\n' + Grass7Utils.tr('GRASS command crashed :( Try a different set of input parameters and consult the GRASS algorithm manual for more information.') + '\n')
if ProcessingConfig.getSetting(Grass7Utils.GRASS_USE_VEXTERNAL):
feedback.reportError(Grass7Utils.tr(
'Suggest disabling the experimental "use v.external" option from the Processing GRASS Provider options.') + '\n')
elif line.strip():
feedback.pushConsoleInfo(line.strip())
# Some GRASS scripts, like r.mapcalculator or r.fillnulls, call
# other GRASS scripts during execution. This may override any
# commands that are still to be executed by the subprocess, which
# are usually the output ones. If that is the case runs the output
# commands again.
if not grassOutDone and outputCommands:
command, grassenv = Grass7Utils.prepareGrassExecution(outputCommands)
# For MS-Windows, we need to hide the console window.
kw = {}
if isWindows():
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
si.wShowWindow = subprocess.SW_HIDE
kw['startupinfo'] = si
if sys.version_info >= (3, 6):
kw['encoding'] = "cp{}".format(Grass7Utils.getWindowsCodePage())
with subprocess.Popen(
command,
shell=False,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
env=grassenv,
**kw
) as proc:
for line in iter(proc.stdout.readline, ''):
if 'GRASS_INFO_PERCENT' in line:
try:
feedback.setProgress(int(
line[len('GRASS_INFO_PERCENT') + 2:]))
except:
pass
if any([l in line for l in ['WARNING', 'ERROR']]):
loglines.append(line.strip())
feedback.reportError(line.strip())
elif line.strip():
loglines.append(line.strip())
feedback.pushConsoleInfo(line.strip())
if ProcessingConfig.getSetting(Grass7Utils.GRASS_LOG_CONSOLE):
QgsMessageLog.logMessage('\n'.join(loglines), 'Processing', Qgis.Info)
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 copyFile(alg, fromFile, toFile):
""" Generates a copy command for GRASS7 script """
createDestDir(alg, toFile)
command = "{} {} {}".format("COPY /Y" if isWindows() else "cp -f",
fromFile, toFile)
alg.commands.append(command)
def getConsoleCommands(self, parameters, context, feedback):
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(crs.authid())
nodata = self.parameterAsDouble(parameters, self.NODATA, context)
if nodata:
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 createDestDir(alg, toFile):
""" Generates an mkdir command for GRASS7 script """
# Creates the destination directory
command = "{} {}".format("MD" if isWindows() else "mkdir -p",
path.dirname(toFile))
alg.commands.append(command)
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 executeGrass(commands, feedback, outputCommands=None):
loglines = []
loglines.append(Grass7Utils.tr('GRASS GIS 7 execution console output'))
grassOutDone = False
command, grassenv = Grass7Utils.prepareGrassExecution(commands)
#QgsMessageLog.logMessage('exec: {}'.format(command), 'DEBUG', Qgis.Info)
# For MS-Windows, we need to hide the console window.
if isWindows():
si = subprocess.STARTUPINFO()
si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
si.wShowWindow = subprocess.SW_HIDE
with subprocess.Popen(command,
shell=True if isMac() else False,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
env=grassenv,
startupinfo=si if isWindows() else None) as proc:
for line in iter(proc.stdout.readline, ''):
if 'GRASS_INFO_PERCENT' in line:
try:
feedback.setProgress(
int(line[len('GRASS_INFO_PERCENT') + 2:]))
except:
pass
else:
if 'r.out' in line or 'v.out' in line:
grassOutDone = True
loglines.append(line)
feedback.pushConsoleInfo(line)
# Some GRASS scripts, like r.mapcalculator or r.fillnulls, call
# other GRASS scripts during execution. This may override any
# commands that are still to be executed by the subprocess, which
# are usually the output ones. If that is the case runs the output
# commands again.
if not grassOutDone and outputCommands:
command, grassenv = Grass7Utils.prepareGrassExecution(
outputCommands)
with subprocess.Popen(
command,
shell=True if isMac() else False,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
env=grassenv,
startupinfo=si if isWindows() else None) as proc:
for line in iter(proc.stdout.readline, ''):
if 'GRASS_INFO_PERCENT' in line:
try:
feedback.setProgress(
int(line[len('GRASS_INFO_PERCENT') + 2:]))
except:
pass
else:
loglines.append(line)
feedback.pushConsoleInfo(line)
if ProcessingConfig.getSetting(Grass7Utils.GRASS_LOG_CONSOLE):
QgsMessageLog.logMessage('\n'.join(loglines), 'Processing',
Qgis.Info)
def moveFile(alg, fromFile, toFile):
""" Generates a move command for GRASS7 script """
createDestDir(alg, toFile)
command = "{} {} {}".format("MOVE /Y" if isWindows() else "mv -f",
fromFile, toFile)
alg.commands.append(command)
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 getValue(self):
s = self.leText.text()
if isWindows():
s = s.replace('\\', '/')
return s
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 ''
if isMac():
folder = ProcessingConfig.getSetting(
Grass7Utils.GRASS_FOLDER) or ''
if not os.path.exists(folder):
folder = None
else:
folder = None
if folder is None:
# Under MS-Windows, we use OSGEO4W or QGIS Path for folder
if isWindows():
if "GISBASE" in os.environ:
folder = os.environ["GISBASE"]
else:
testfolder = os.path.join(
os.path.dirname(QgsApplication.prefixPath()), 'grass')
if os.path.isdir(testfolder):
grassfolders = sorted(
[
f for f in os.listdir(testfolder)
if f.startswith("grass-7.")
and os.path.isdir(os.path.join(testfolder, f))
],
reverse=True,
key=lambda x: [
int(v) for v in x[len("grass-"):].split('.')
if v != 'svn'
])
if grassfolders:
folder = os.path.join(testfolder, grassfolders[0])
elif isMac():
# For MacOSX, we scan some well-known directories
# Start with QGIS bundle
for version in ['', '7', '76', '74', '72', '71', '70']:
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 ['6', '4', '2', '1', '0']:
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 commandName(self):
return 'gdal_calc' if isWindows() else 'gdal_calc.py'
def getImportCommands(self):
commands = []
# Just use main mirror
commands.append('options("repos"="http://cran.at.r-project.org/")')
# Try to install packages if needed
if isWindows():
commands.append('.libPaths(\"' +
unicode(RUtils.RLibs()).replace('\\', '/') + '\")')
packages = RUtils.getRequiredPackages(self.script)
packages.extend(['rgdal', 'raster'])
for p in packages:
commands.append('tryCatch(find.package("' + p +
'"), error=function(e) install.packages("' + p +
'", dependencies=TRUE))')
commands.append('library("raster")')
commands.append('library("rgdal")')
for param in self.parameters:
if isinstance(param, ParameterRaster):
value = param.value
value = value.replace('\\', '/')
if self.passFileNames:
commands.append(param.name + ' = "' + value + '"')
elif self.useRasterPackage:
commands.append(param.name + ' = ' + 'brick("' + value +
'")')
else:
commands.append(param.name + ' = ' + 'readGDAL("' + value +
'")')
if isinstance(param, ParameterVector):
value = param.getSafeExportedLayer()
value = value.replace('\\', '/')
filename = os.path.basename(value)
filename = filename[:-4]
folder = os.path.dirname(value)
if self.passFileNames:
commands.append(param.name + ' = "' + value + '"')
else:
commands.append(param.name + ' = readOGR("' + folder +
'",layer="' + filename + '")')
if isinstance(param, ParameterTable):
value = param.value
if not value.lower().endswith('csv'):
raise GeoAlgorithmExecutionException(
'Unsupported input file format.\n' + value)
if self.passFileNames:
commands.append(param.name + ' = "' + value + '"')
else:
commands.append(param.name + ' <- read.csv("' + value +
'", head=TRUE, sep=",")')
elif isinstance(
param,
(ParameterTableField, ParameterString, ParameterFile)):
commands.append(param.name + '="' + param.value + '"')
elif isinstance(param, (ParameterNumber, ParameterSelection)):
commands.append(param.name + '=' + unicode(param.value))
elif isinstance(param, ParameterBoolean):
if param.value:
commands.append(param.name + '=TRUE')
else:
commands.append(param.name + '=FALSE')
elif isinstance(param, ParameterMultipleInput):
iLayer = 0
if param.datatype == ParameterMultipleInput.TYPE_RASTER:
layers = param.value.split(';')
for layer in layers:
layer = layer.replace('\\', '/')
if self.passFileNames:
commands.append('tempvar' + unicode(iLayer) +
' <- "' + layer + '"')
elif self.useRasterPackage:
commands.append('tempvar' + unicode(iLayer) +
' <- ' + 'brick("' + layer + '")')
else:
commands.append('tempvar' + unicode(iLayer) +
' <- ' + 'readGDAL("' + layer +
'")')
iLayer += 1
else:
exported = param.getSafeExportedLayers()
layers = exported.split(';')
for layer in layers:
if not layer.lower().endswith('shp') \
and not self.passFileNames:
raise GeoAlgorithmExecutionException(
'Unsupported input file format.\n' + layer)
layer = layer.replace('\\', '/')
filename = os.path.basename(layer)
filename = filename[:-4]
if self.passFileNames:
commands.append('tempvar' + unicode(iLayer) +
' <- "' + layer + '"')
else:
commands.append('tempvar' + unicode(iLayer) +
' <- ' + 'readOGR("' + layer +
'",layer="' + filename + '")')
iLayer += 1
s = ''
s += param.name
s += ' = c('
iLayer = 0
for layer in layers:
if iLayer != 0:
s += ','
s += 'tempvar' + unicode(iLayer)
iLayer += 1
s += ')\n'
commands.append(s)
if self.showPlots:
htmlfilename = self.getOutputValue(RAlgorithm.RPLOTS)
self.plotsFilename = htmlfilename + '.png'
self.plotsFilename = self.plotsFilename.replace('\\', '/')
commands.append('png("' + self.plotsFilename + '")')
return commands
def rliPath():
"""Return r.li GRASS7 user dir"""
if isWindows():
return path.join(userFolder(), 'GRASS7', 'r.li')
else:
return path.join(userFolder(), '.grass7', 'r.li')
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
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 sagaPath():
if not isWindows() and not isMac() and not platform.system() == 'FreeBSD':
return ''
folder = findSagaFolder()
return folder or ''
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))
if isWindows():
commands = ["python3", "-m", self.commandName()]
else:
commands = [self.commandName() + '.py']
commands.append(GdalUtils.escapeAndJoin(arguments))
return commands
