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