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)