def initialize(): # Add the basic providers Processing.addProvider(QGISAlgorithmProvider()) Processing.addProvider(ModelerOnlyAlgorithmProvider()) Processing.addProvider(GdalOgrAlgorithmProvider()) Processing.addProvider(LidarToolsAlgorithmProvider()) Processing.addProvider(OTBAlgorithmProvider()) Processing.addProvider(RAlgorithmProvider()) Processing.addProvider(SagaAlgorithmProvider()) Processing.addProvider(GrassAlgorithmProvider()) Processing.addProvider(Grass7AlgorithmProvider()) Processing.addProvider(ScriptAlgorithmProvider()) Processing.addProvider(TauDEMAlgorithmProvider()) Processing.addProvider(ModelerAlgorithmProvider()) Processing.modeler.initializeSettings() # And initialize AlgorithmDecorator.loadClassification() ProcessingLog.startLogging() ProcessingConfig.initialize() ProcessingConfig.readSettings() RenderingStyles.loadStyles() Processing.loadFromProviders()
class Processing: listeners = [] providers = [] # A dictionary of algorithms. Keys are names of providers # and values are list with all algorithms from that provider algs = {} # Same structure as algs actions = {} # All the registered context menu actions for the toolbox contextMenuActions = [] modeler = ModelerAlgorithmProvider() @staticmethod def addProvider(provider, updateList=False): """Use this method to add algorithms from external providers. """ # Note: this might slow down the initialization process if # there are many new providers added. Should think of a # different solution try: provider.initializeSettings() Processing.providers.append(provider) ProcessingConfig.readSettings() if updateList: Processing.updateAlgsList() except: ProcessingLog.addToLog( ProcessingLog.LOG_ERROR, Processing.tr('Could not load provider: %s\n%s') % (provider.getDescription(), unicode(sys.exc_info()[1]))) Processing.removeProvider(provider) @staticmethod def removeProvider(provider): """Use this method to remove a provider. This method should be called when unloading a plugin that contributes a provider. """ try: provider.unload() Processing.providers.remove(provider) ProcessingConfig.readSettings() Processing.updateAlgsList() except: # This try catch block is here to avoid problems if the # plugin with a provider is unloaded after the Processing # framework itself has been unloaded. It is a quick fix # before I found out how to properly avoid that. pass @staticmethod def getProviderFromName(name): """Returns the provider with the given name.""" for provider in Processing.providers: if provider.getName() == name: return provider return Processing.modeler @staticmethod def initialize(): # Add the basic providers Processing.addProvider(QGISAlgorithmProvider()) Processing.addProvider(ModelerOnlyAlgorithmProvider()) Processing.addProvider(GdalOgrAlgorithmProvider()) Processing.addProvider(LidarToolsAlgorithmProvider()) Processing.addProvider(OTBAlgorithmProvider()) Processing.addProvider(RAlgorithmProvider()) Processing.addProvider(SagaAlgorithmProvider()) Processing.addProvider(GrassAlgorithmProvider()) Processing.addProvider(Grass7AlgorithmProvider()) Processing.addProvider(ScriptAlgorithmProvider()) Processing.addProvider(TauDEMAlgorithmProvider()) Processing.addProvider(Processing.modeler) Processing.modeler.initializeSettings() # And initialize AlgorithmDecorator.loadClassification() ProcessingLog.startLogging() ProcessingConfig.initialize() ProcessingConfig.readSettings() RenderingStyles.loadStyles() Processing.loadFromProviders() # Inform registered listeners that all providers' algorithms have been loaded Processing.fireAlgsListHasChanged() @staticmethod def updateAlgsList(): """Call this method when there has been any change that requires the list of algorithms to be created again from algorithm providers. """ Processing.loadFromProviders() Processing.fireAlgsListHasChanged() @staticmethod def loadFromProviders(): Processing.loadAlgorithms() Processing.loadActions() Processing.loadContextMenuActions() @staticmethod def updateProviders(): providers = [p for p in Processing.providers if p.getName() != "model"] for provider in providers: provider.loadAlgorithms() @staticmethod def addAlgListListener(listener): """ Listener should implement a algsListHasChanged() method. Whenever the list of algorithms changes, that method will be called for all registered listeners. """ Processing.listeners.append(listener) @staticmethod def removeAlgListListener(listener): try: Processing.listeners.remove(listener) except: pass @staticmethod def fireAlgsListHasChanged(): for listener in Processing.listeners: listener.algsListHasChanged() @staticmethod def loadAlgorithms(): Processing.algs = {} Processing.updateProviders() providers = [p for p in Processing.providers if p.getName() != "model"] for provider in providers: providerAlgs = provider.algs algs = {} for alg in providerAlgs: algs[alg.commandLineName()] = alg Processing.algs[provider.getName()] = algs provs = {} for provider in Processing.providers: provs[provider.getName()] = provider ModelerUtils.allAlgs = Processing.algs ModelerUtils.providers = provs Processing.modeler.loadAlgorithms() algs = {} for alg in Processing.modeler.algs: algs[alg.commandLineName()] = alg Processing.algs[Processing.modeler.getName()] = algs @staticmethod def loadActions(): for provider in Processing.providers: providerActions = provider.actions actions = list() for action in providerActions: actions.append(action) Processing.actions[provider.getName()] = actions Processing.actions[provider.getName()] = actions @staticmethod def loadContextMenuActions(): Processing.contextMenuActions = [] for provider in Processing.providers: providerActions = provider.contextMenuActions for action in providerActions: Processing.contextMenuActions.append(action) @staticmethod def getAlgorithm(name): for provider in Processing.algs.values(): if name in provider: return provider[name] return None @staticmethod def getAlgorithmFromFullName(name): for provider in Processing.algs.values(): for alg in provider.values(): if alg.name == name: return alg return None @staticmethod def getObject(uri): """Returns the QGIS object identified by the given URI.""" return dataobjects.getObjectFromUri(uri) @staticmethod def runandload(name, *args): Processing.runAlgorithm(name, handleAlgorithmResults, *args) @staticmethod def runAlgorithm(algOrName, onFinish, *args): if isinstance(algOrName, GeoAlgorithm): alg = algOrName else: alg = Processing.getAlgorithm(algOrName) if alg is None: print 'Error: Algorithm not found\n' return alg = alg.getCopy() if len(args) == 1 and isinstance(args[0], dict): # Set params by name and try to run the alg even if not all parameter values are provided, # by using the default values instead. setParams = [] for (name, value) in args[0].items(): param = alg.getParameterFromName(name) if param and param.setValue(value): setParams.append(name) continue output = alg.getOutputFromName(name) if output and output.setValue(value): continue print 'Error: Wrong parameter value %s for parameter %s.' \ % (value, name) ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, Processing.tr('Error in %s. Wrong parameter value %s for parameter %s.') \ % (alg.name, value, name)) return # fill any missing parameters with default values if allowed for param in alg.parameters: if param.name not in setParams: if not param.setValue(None): print( 'Error: Missing parameter value for parameter %s.' % (param.name)) ProcessingLog.addToLog(ProcessingLog.LOG_ERROR, Processing.tr('Error in %s. Missing parameter value for parameter %s.') \ % (alg.name, param.name)) return else: if len(args) != alg.getVisibleParametersCount() \ + alg.getVisibleOutputsCount(): print 'Error: Wrong number of parameters' processing.alghelp(algOrName) return i = 0 for param in alg.parameters: if not param.hidden: if not param.setValue(args[i]): print 'Error: Wrong parameter value: ' \ + unicode(args[i]) return i = i + 1 for output in alg.outputs: if not output.hidden: if not output.setValue(args[i]): print 'Error: Wrong output value: ' + unicode(args[i]) return i = i + 1 msg = alg.checkParameterValuesBeforeExecuting() if msg: print 'Unable to execute algorithm\n' + msg return if not alg.checkInputCRS(): print 'Warning: Not all input layers use the same CRS.\n' \ + 'This can cause unexpected results.' if iface is not None: # Don't set the wait cursor twice, because then when you # restore it, it will still be a wait cursor. cursor = QApplication.overrideCursor() if cursor is None or cursor == 0: QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) elif cursor.shape() != Qt.WaitCursor: QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) progress = None if iface is not None: progress = MessageBarProgress() ret = runalg(alg, progress) if onFinish is not None and ret: onFinish(alg, progress) if iface is not None: QApplication.restoreOverrideCursor() progress.close() return alg @staticmethod def tr(string, context=''): if context == '': context = 'Processing' return QCoreApplication.translate(context, string)