Python QgsApplication.processingRegistry方法代码示例

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
 def unload(self):
     '''Unload LatLonTools from the QGIS interface'''
     self.zoomToDialog.removeMarker()
     self.multiZoomDialog.removeMarkers()
     self.canvas.unsetMapTool(self.mapTool)
     self.canvas.unsetMapTool(self.showMapTool)
     self.iface.removePluginMenu('Lat Lon Tools', self.copyAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.copyCanvasAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.externMapAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.zoomToAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.multiZoomToAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.conversionsAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.settingsAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.helpAction)
     self.iface.removePluginMenu('Lat Lon Tools', self.digitizeAction)
     self.iface.removeDockWidget(self.zoomToDialog)
     self.iface.removeDockWidget(self.multiZoomDialog)
     # Remove Toolbar Icons
     self.iface.removeToolBarIcon(self.copyAction)
     self.iface.removeToolBarIcon(self.copyCanvasAction)
     self.iface.removeToolBarIcon(self.zoomToAction)
     self.iface.removeToolBarIcon(self.externMapAction)
     self.iface.removeToolBarIcon(self.multiZoomToAction)
     self.iface.removeToolBarIcon(self.digitizeAction)
     del self.toolbar
     
     self.zoomToDialog = None
     self.multiZoomDialog = None
     self.settingsDialog = None
     self.showMapTool = None
     self.mapTool = None
     self.digitizerDialog = None
     QgsApplication.processingRegistry().removeProvider(self.provider)

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def checkConstructWrapper(self, param, expected_wrapper_class):
        alg = QgsApplication.processingRegistry().createAlgorithmById('native:centroids')

        # algorithm dialog
        dlg = AlgorithmDialog(alg)
        wrapper = WidgetWrapperFactory.create_wrapper_from_class(param, dlg)
        self.assertIsNotNone(wrapper)
        self.assertIsInstance(wrapper, expected_wrapper_class)
        self.assertEqual(wrapper.dialog, dlg)
        self.assertIsNotNone(wrapper.widget)

        alg = QgsApplication.processingRegistry().createAlgorithmById('native:centroids')
        # batch dialog
        dlg = BatchAlgorithmDialog(alg)
        wrapper = WidgetWrapperFactory.create_wrapper_from_class(param, dlg)
        self.assertIsNotNone(wrapper)
        self.assertIsInstance(wrapper, expected_wrapper_class)
        self.assertEqual(wrapper.dialog, dlg)
        self.assertIsNotNone(wrapper.widget)

        alg = QgsApplication.processingRegistry().createAlgorithmById('native:centroids')

        # modeler dialog
        model = QgsProcessingModelAlgorithm()
        dlg = ModelerParametersDialog(alg, model)
        wrapper = WidgetWrapperFactory.create_wrapper_from_class(param, dlg)
        self.assertIsNotNone(wrapper)
        self.assertIsInstance(wrapper, expected_wrapper_class)
        self.assertEqual(wrapper.dialog, dlg)
        self.assertIsNotNone(wrapper.widget)

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def fillTreeUsingProviders(self):
        self.algorithmTree.clear()
        self.disabledProviderItems = {}

        # TODO - replace with proper model for toolbox!

        # first add qgis/native providers, since they create top level groups
        for provider in QgsApplication.processingRegistry().providers():
            if provider.id() in ('qgis', 'native', '3d'):
                self.addAlgorithmsFromProvider(provider, self.algorithmTree.invisibleRootItem())
            else:
                continue
        self.algorithmTree.sortItems(0, Qt.AscendingOrder)

        for provider in QgsApplication.processingRegistry().providers():
            if provider.id() in ('qgis', 'native', '3d'):
                # already added
                continue
            else:
                providerItem = TreeProviderItem(provider, self.algorithmTree, self)

                # insert non-native providers at end of tree, alphabetically
                for i in range(self.algorithmTree.invisibleRootItem().childCount()):
                    child = self.algorithmTree.invisibleRootItem().child(i)
                    if isinstance(child, TreeProviderItem):
                        if child.text(0) > providerItem.text(0):
                            break

                self.algorithmTree.insertTopLevelItem(i + 1, providerItem)
                if not provider.isActive():
                    providerItem.setHidden(True)
                    self.disabledProviderItems[provider.id()] = providerItem

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def test_OTBParameterChoice_Gui(self):
        """
        This test is similar to GuiTests in processing that is done on other parameter widget in processing
        Main difference is this test uses create_wrapper_from_metadata() rather than create_wrapper_from_class()
        like rest of processing widgets.
        """
        param = OtbParameterChoice('test')

        alg = QgsApplication.processingRegistry().createAlgorithmById('otb:Smoothing')
        # algorithm dialog
        dlg = AlgorithmDialog(alg)
        wrapper = WidgetWrapperFactory.create_wrapper_from_metadata(param, dlg)
        self.assertIsNotNone(wrapper)
        self.assertIsInstance(wrapper, OtbChoiceWidgetWrapper)
        self.assertEqual(wrapper.dialog, dlg)
        self.assertIsNotNone(wrapper.widget)

        alg = QgsApplication.processingRegistry().createAlgorithmById('otb:Smoothing')
        # batch dialog
        dlg = BatchAlgorithmDialog(alg)
        wrapper = WidgetWrapperFactory.create_wrapper_from_metadata(param, dlg)
        self.assertIsNotNone(wrapper)
        self.assertIsInstance(wrapper, OtbChoiceWidgetWrapper)
        self.assertEqual(wrapper.dialog, dlg)
        self.assertIsNotNone(wrapper.widget)

        alg = QgsApplication.processingRegistry().createAlgorithmById('otb:Smoothing')
        # modeler dialog
        model = QgsProcessingModelAlgorithm()
        dlg = ModelerParametersDialog(alg, model)
        wrapper = WidgetWrapperFactory.create_wrapper_from_metadata(param, dlg)
        self.assertIsNotNone(wrapper)
        self.assertIsInstance(wrapper, OtbChoiceWidgetWrapper)
        self.assertEqual(wrapper.dialog, dlg)
        self.assertIsNotNone(wrapper.widget)

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
 def execute(self):
     settings = QgsSettings()
     lastDir = settings.value('Processing/lastScriptsDir', '')
     filenames, selected_filter = QFileDialog.getOpenFileNames(self.toolbox,
                                                               self.tr('Script files', 'AddScriptFromFileAction'), lastDir,
                                                               self.tr('Script files (*.py *.PY)', 'AddScriptFromFileAction'))
     if filenames:
         validAlgs = 0
         wrongAlgs = []
         for filename in filenames:
             try:
                 settings.setValue('Processing/lastScriptsDir',
                                   QFileInfo(filename).absoluteDir().absolutePath())
                 script = ScriptAlgorithm(filename)
                 destFilename = os.path.join(ScriptUtils.scriptsFolders()[0], os.path.basename(filename))
                 with open(destFilename, 'w') as f:
                     f.write(script.script)
                 validAlgs += 1
             except WrongScriptException:
                 wrongAlgs.append(os.path.basename(filename))
         if validAlgs:
             QgsApplication.processingRegistry().providerById('script').refreshAlgorithms()
         if wrongAlgs:
             QMessageBox.warning(self.toolbox,
                                 self.tr('Error reading scripts', 'AddScriptFromFileAction'),
                                 self.tr('The following files do not contain a valid script:\n-', 'AddScriptFromFileAction') +
                                 "\n-".join(wrongAlgs))

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def saveScript(self, saveAs):
        newPath = None
        if self.filePath is None or saveAs:
            scriptDir = ScriptUtils.scriptsFolders()[0]
            newPath, _ = QFileDialog.getSaveFileName(self,
                                                     self.tr("Save script"),
                                                     scriptDir,
                                                     self.tr("Processing scripts (*.py *.PY)"))

            if newPath:
                if not newPath.lower().endswith(".py"):
                    newPath += ".py"

                self.filePath = newPath

        if self.filePath:
            text = self.editor.text()
            try:
                with codecs.open(self.filePath, "w", encoding="utf-8") as f:
                    f.write(text)
            except IOError as e:
                QMessageBox.warning(self,
                                    self.tr("I/O error"),
                                    self.tr("Unable to save edits:\n{}").format(str(e))
                                    )
                return

            self.setHasChanged(False)

        QgsApplication.processingRegistry().providerById("script").refreshAlgorithms()

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def __init__(self):
        super(ProcessingToolbox, self).__init__(None)
        self.tipWasClosed = False
        self.setupUi(self)
        self.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)

        self.searchBox.textChanged.connect(self.textChanged)
        self.algorithmTree.customContextMenuRequested.connect(
            self.showPopupMenu)
        self.algorithmTree.doubleClicked.connect(self.executeAlgorithm)
        self.txtDisabled.setVisible(False)
        self.txtTip.setVisible(self.disabledProviders())
        self.txtDisabled.linkActivated.connect(self.showDisabled)

        def openSettings(url):
            if url == "close":
                self.txtTip.setVisible(False)
                self.tipWasClosed = True
            else:
                iface.showOptionsDialog(iface.mainWindow(), 'processingOptions')
                self.txtTip.setVisible(self.disabledProviders())
        self.txtTip.linkActivated.connect(openSettings)
        if hasattr(self.searchBox, 'setPlaceholderText'):
            self.searchBox.setPlaceholderText(self.tr('Search...'))

        self.fillTree()

        # connect to existing providers
        for p in QgsApplication.processingRegistry().providers():
            p.algorithmsLoaded.connect(self.updateProvider)

        QgsApplication.processingRegistry().providerRemoved.connect(self.removeProvider)
        QgsApplication.processingRegistry().providerAdded.connect(self.addProvider)
        settingsWatcher.settingsChanged.connect(self.fillTree)

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def initGui(self):
        """Create the menu entries and toolbar icons inside the QGIS GUI."""
        
        QgsApplication.processingRegistry().addProvider(self.provider)

        icon_path = ':/plugins/dzetsaka/img/icon.png'
        self.add_action(
            icon_path,
            text=self.tr(u'welcome message'),
            callback=self.showWelcomeWidget,
            add_to_toolbar=False,
            parent=self.iface.mainWindow())
        
        icon_path = ':/plugins/dzetsaka/img/icon.png'
        self.add_action(
            icon_path,
            text=self.tr(u'classification dock'),
            callback=self.run,
            parent=self.iface.mainWindow())
        
        icon_settings_path = ':/plugins/dzetsaka/img/dzetsaka_settings.png'
        self.add_action(
            icon_settings_path,
            text=self.tr(u'settings'),
            callback=self.loadSettings,
            add_to_toolbar=True,
            parent=self.iface.mainWindow())

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def execute(self):
        settings = QgsSettings()
        lastDir = settings.value('Processing/lastModelsDir', '')
        filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
                                                                self.tr('Open model', 'AddModelFromFileAction'), lastDir,
                                                                self.tr('Processing model files (*.model *.MODEL)', 'AddModelFromFileAction'))
        if filename:
            try:
                settings.setValue('Processing/lastModelsDir',
                                  QFileInfo(filename).absoluteDir().absolutePath())

                ModelerAlgorithm.fromFile(filename)
            except WrongModelException:
                QMessageBox.warning(
                    self.toolbox,
                    self.tr('Error reading model', 'AddModelFromFileAction'),
                    self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
                return
            except:
                QMessageBox.warning(self.toolbox,
                                    self.tr('Error reading model', 'AddModelFromFileAction'),
                                    self.tr('Cannot read file', 'AddModelFromFileAction'))
                return
            destFilename = os.path.join(ModelerUtils.modelsFolders()[0], os.path.basename(filename))
            shutil.copyfile(filename, destFilename)
            QgsApplication.processingRegistry().providerById('model').refreshAlgorithms()

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def initGui(self):

        # Toolbar
        self.toolbar = self.iface.addToolBar("TomBioToolbar")
        
        # OSGR tool
        icon_path = os.path.join(os.path.dirname(__file__),'images/osgrPoly.png')
        self.actionOsgr = QAction(QIcon(icon_path), u"OSGR Tool", self.iface.mainWindow())
        self.iface.addPluginToMenu(u"&FSC Tools", self.actionOsgr)
        self.actionOsgr.triggered.connect(self.showOsgrDialog)
        self.toolbar.addAction(self.actionOsgr)
        self.dwOsgr = None
        
        # Display Biological Records Tool
        icon_path = os.path.join(os.path.dirname(__file__),'images/maptaxa.png')
        self.actionBiorec = QAction(QIcon(icon_path), u"Biological Records Tool", self.iface.mainWindow())
        self.iface.addPluginToMenu(u"&FSC Tools", self.actionBiorec)
        self.actionBiorec.triggered.connect(self.showBiorecDialog)
        self.toolbar.addAction(self.actionBiorec)
        self.dwBiorec = None
        
        # NBN Tool
        icon_path = os.path.join(os.path.dirname(__file__),'images/nbn.png')
        self.actionNbn = QAction(QIcon(icon_path), u"NBN Atlas Tool", self.iface.mainWindow())
        self.iface.addPluginToMenu(u"&FSC Tools", self.actionNbn)
        self.actionNbn.triggered.connect(self.showNbnDialog)
        self.toolbar.addAction(self.actionNbn)
        self.dwNbn = None
        
        # Map Mashup Tool
        icon_path = os.path.join(os.path.dirname(__file__),'images/mashup.png')
        self.actionMapMash = QAction(QIcon(icon_path), u"Map Mashup Tool", self.iface.mainWindow())
        self.iface.addPluginToMenu(u"&FSC Tools", self.actionMapMash)
        self.actionMapMash.triggered.connect(self.showMapmashupDialog)
        self.toolbar.addAction(self.actionMapMash)
        self.dwMapmashup = None

        # GRs to points Processing tool
        icon_path = os.path.join(os.path.dirname(__file__),'images/gr2point.png')
        self.actionGRs2Points = QAction(QIcon(icon_path), u"Add GRs to layers", self.iface.mainWindow())
        self.iface.addPluginToMenu(u"&FSC Tools", self.actionGRs2Points)
        self.actionGRs2Points.triggered.connect(self.showGRs2PointsProcessingTools)
        self.toolbar.addAction(self.actionGRs2Points)
        
        # Help dialog
        icon_path = os.path.join(os.path.dirname(__file__),'images/info.png')
        self.actionHelp = QAction(QIcon(icon_path), u"Help and Info on FSC QGIS plugin", self.iface.mainWindow())
        self.iface.addPluginToMenu(u"&FSC Tools", self.actionHelp)
        self.actionHelp.triggered.connect(self.showHelp)
        self.toolbar.addAction(self.actionHelp)
        
        # Environment Options
        self.actionEnv = QAction(u"Environment Options", self.iface.mainWindow())
        self.iface.addPluginToMenu(u"&FSC Tools", self.actionEnv)
        self.actionEnv.triggered.connect(self.showEnvDialog)
        self.guiEnv = None

        # Add Grid Ref to point layer Processing tool
        QgsApplication.processingRegistry().addProvider(self.provider)

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
 def setUpClass(cls):
     start_app()
     from processing.core.Processing import Processing
     Processing.initialize()
     QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
     cls.cleanup_paths = []
     cls.in_place_layers = {}
     cls.vector_layer_params = {}

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
    def __init__(self):
        super().__init__()
        self.actions = [CreateNewModelAction(), AddModelFromFileAction(), GetModelsAction()]
        self.contextMenuActions = [EditModelAction(), DeleteModelAction()]
        self.algs = []

        # must reload models if providers list is changed - previously unavailable algorithms
        # which models depend on may now be available
        QgsApplication.processingRegistry().providerAdded.connect(self.refreshAlgorithms)

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
 def setUpClass(cls):
     """Run before all tests"""
     QCoreApplication.setOrganizationName("QGIS_Test")
     QCoreApplication.setOrganizationDomain(
         "QGIS_TestPyQgsProcessingInPlace.com")
     QCoreApplication.setApplicationName("QGIS_TestPyQgsProcessingInPlace")
     QgsSettings().clear()
     Processing.initialize()
     QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
     cls.registry = QgsApplication.instance().processingRegistry()

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
 def setUpClass(cls):
     start_app()
     from processing.core.Processing import Processing
     Processing.initialize()
     ProcessingConfig.setSettingValue(ModelerUtils.MODELS_FOLDER, os.path.join(os.path.dirname(__file__), 'models'))
     QgsApplication.processingRegistry().addProvider(QgsNativeAlgorithms())
     cls.cleanup_paths = []
     cls.in_place_layers = {}
     cls.vector_layer_params = {}
     cls._original_models_folder = ProcessingConfig.getSetting(ModelerUtils.MODELS_FOLDER)

# 需要导入模块: from qgis.core import QgsApplication [as 别名]
# 或者: from qgis.core.QgsApplication import processingRegistry [as 别名]
 def execute(self):
     reply = QMessageBox.question(None,
                                  self.tr('Confirmation', 'DeletePreconfiguredAlgorithmAction'),
                                  self.tr('Are you sure you want to delete this algorithm?',
                                          'DeletePreconfiguredAlgorithmAction'),
                                  QMessageBox.Yes | QMessageBox.No,
                                  QMessageBox.No)
     if reply == QMessageBox.Yes:
         os.remove(self.itemData.descriptionFile)
         QgsApplication.processingRegistry().providerById('preconfigured').refreshAlgorithms()