def check_layers(self):
        local_layers, unsupported_layers,  local_raster_layers = self.update_local_layers()
        
        
        if ((local_layers or local_raster_layers) and self.clouddb) or unsupported_layers:
            message = ""

            if local_layers or local_raster_layers:
                title = self.tr("Local layers found")
                message += self.tr(
                    "Some layers are using local data. Please upload local layers to your cloud database in the 'Upload Data' tab before publishing.\n\n")

            if unsupported_layers:
                title = self.tr("Unsupported layers found")
                message += self.tr(
                    "Raster, plugin or geometryless layers are not supported:\n\n")
                layer_types = ["No geometry", "Raster", "Plugin"]
                for layer in sorted(unsupported_layers, key=lambda layer: layer.name()):
                    message += self.tr("  -  %s (%s)\n") % (
                        layer.name(), layer_types[layer.type()])
                message += self.tr(
                    "\nPlease remove or replace above layers before publishing your map.\n")
                message += self.tr(
                    "For raster data you can use public WMS layers or the OpenLayers Plugin.")

            QMessageBox.warning(self, title, message)

            self.refresh_databases()
            self.ui.tabWidget.setCurrentWidget(self.ui.uploadTab)
            return False

        return True
 def create_database(self):
     if self.numDbs < self.maxDBs:
         db = self.api.create_database()
         self.show_api_error(db)
         self.refresh_databases()
     else:
         QMessageBox.warning(None, self.tr('Warning!'),  self.tr('Number of %s permitted databases exceeded! Please upgrade your account!') % self.maxDBs)
Ejemplo n.º 3
0
    def __init__(self, iface):
        'initialize'
        # Save reference to the QGIS interface
        self.iface = iface
        # initialize plugin directory
        self.plugin_dir = os.path.dirname(__file__)
        
        # initialize locale
        locale = QSettings().value("locale/userLocale", "nl")
        if not locale: locale == 'nl' 
        else: locale = locale[0:2]
        localePath = os.path.join(self.plugin_dir, 'i18n', 'geopunt4qgis_{}.qm'.format(locale))
        if os.path.exists(localePath):
            self.translator = QTranslator()
            self.translator.load(localePath)
            QCoreApplication.installTranslator(self.translator)

        #version check
        if locale == 'nl':  
           vc = versionChecker()
           if not vc.isUptoDate():
              QMessageBox.warning(self.iface.mainWindow(), QCoreApplication.translate("geopunt4Qgis", "Waarschuwing"), QCoreApplication.translate("geopunt4Qgis", 
          "Je versie van <a href='http://plugins.qgis.org/plugins/geopunt4Qgis' >geopunt4qgis</a> is niet meer up to date. <br/>Je kunt deze upgraden via het menu:<br/> "+
          "<strong>Plugins > Beheer en installeer Plugins > Op te waarderen.</strong><br/>Klik daarna op <strong>Plugin opwaarderen</strong>"))

        # Create the dialogs (after translation) and keep reference
        self.adresdlg = geopunt4QgisAdresDialog(self.iface)
        self.batchgeoDlg = geopunt4QgisBatcGeoCodeDialog(self.iface) 
        self.poiDlg = geopunt4QgisPoidialog(self.iface)        
        self.gipodDlg = geopunt4QgisGipodDialog(self.iface)
        self.settingsDlg = geopunt4QgisSettingsDialog()
        if mathplotlibWorks : self.elevationDlg = geopunt4QgisElevationDialog(self.iface)
        self.datacatalogusDlg = geopunt4QgisDataCatalog(self.iface)
        self.parcelDlg = geopunt4QgisParcelDlg(self.iface)
        self.aboutDlg = geopunt4QgisAboutDialog()
Ejemplo n.º 4
0
 def check_existing_id(self, group_id):
     gl = GroupsList()
     if group_id in gl.groups.keys():
         QMessageBox.critical(self, self.tr('Error on save group'),
                              self.tr('Group with such id already exists! Select new id for group!'))
         return False
     return True
Ejemplo n.º 5
0
    def getParamValues(self):
        if self.mUpdateExistingGroupBox.isChecked():
            fieldName = self.mExistingFieldComboBox.currentText()
        else:
            fieldName = self.mOutputFieldNameLineEdit.text()

        layer = self.cmbInputLayer.currentLayer()

        context = dataobjects.createContext()

        parameters = {}
        parameters['INPUT'] = layer
        parameters['FIELD_NAME'] = fieldName
        parameters['FIELD_TYPE'] = self.mOutputFieldTypeComboBox.currentIndex()
        parameters['FIELD_LENGTH'] = self.mOutputFieldWidthSpinBox.value()
        parameters['FIELD_PRECISION'] = self.mOutputFieldPrecisionSpinBox.value()
        parameters['NEW_FIELD'] = self.mNewFieldGroupBox.isChecked()
        parameters['FORMULA'] = self.builder.expressionText()
        output = QgsProcessingOutputLayerDefinition()
        if self.leOutputFile.text().strip():
            output.sink = QgsProperty.fromValue(self.leOutputFile.text().strip())
        else:
            output.sink = QgsProperty.fromValue('memory:')
        output.destinationProject = context.project()
        parameters['OUTPUT'] = output

        ok, msg = self.alg.checkParameterValues(parameters, context)
        if not ok:
            QMessageBox.warning(
                self, self.tr('Unable to execute algorithm'), msg)
            return {}
        return parameters
Ejemplo n.º 6
0
    def save_current_keywords(self):
        """Save keywords to the layer.

        It will write out the keywords for the current layer.
        This method is based on the KeywordsDialog class.
        """
        current_keywords = self.get_keywords()
        try:
            self.keyword_io.write_keywords(
                layer=self.layer, keywords=current_keywords)
        except InaSAFEError as e:
            error_message = get_error_message(e)
            # noinspection PyCallByClass,PyTypeChecker,PyArgumentList
            QMessageBox.warning(
                self,
                tr('InaSAFE'),
                tr('An error was encountered when saving the following '
                   'keywords:\n {error_message}').format(
                    error_message=error_message.to_html()))
        if self.dock is not None:
            # noinspection PyUnresolvedReferences
            self.dock.get_layers()

        # Save default value to QSetting
        if current_keywords.get('inasafe_default_values'):
            for key, value in (
                    list(current_keywords['inasafe_default_values'].items())):
                set_inasafe_default_value_qsetting(
                    self.setting, RECENT, key, value)
Ejemplo n.º 7
0
    def fetchAvailablePlugins(self, reloadMode):
        """ Fetch plugins from all enabled repositories."""
        """  reloadMode = true:  Fully refresh data from QSettings to mRepositories  """
        """  reloadMode = false: Fetch unready repositories only """
        QApplication.setOverrideCursor(Qt.WaitCursor)

        if reloadMode:
            repositories.load()
            plugins.clearRepoCache()
            plugins.getAllInstalled()

        for key in repositories.allEnabled():
            if reloadMode or repositories.all()[key]["state"] == 3:  # if state = 3 (error or not fetched yet), try to fetch once again
                repositories.requestFetching(key)

        if repositories.fetchingInProgress():
            fetchDlg = QgsPluginInstallerFetchingDialog(iface.mainWindow())
            fetchDlg.exec_()
            del fetchDlg
            for key in repositories.all():
                repositories.killConnection(key)

        QApplication.restoreOverrideCursor()

        # display error messages for every unavailable reposioty, unless Shift pressed nor all repositories are unavailable
        keepQuiet = QgsApplication.keyboardModifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier)
        if repositories.allUnavailable() and repositories.allUnavailable() != repositories.allEnabled():
            for key in repositories.allUnavailable():
                if not keepQuiet:
                    QMessageBox.warning(iface.mainWindow(), self.tr("QGIS Python Plugin Installer"), self.tr("Error reading repository:") + " " + key + "\n\n" + repositories.all()[key]["error"])
                if QgsApplication.keyboardModifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier):
                    keepQuiet = True
        # finally, rebuild plugins from the caches
        plugins.rebuild()
Ejemplo n.º 8
0
 def activateAlgorithm(self):
     if self.model.activateChildAlgorithm(self.element.childId()):
         self.scene.dialog.repaintModel()
     else:
         QMessageBox.warning(None, 'Could not activate Algorithm',
                             'The selected algorithm depends on other currently non-active algorithms.\n'
                             'Activate them them before trying to activate it.')
Ejemplo n.º 9
0
    def on_btnLoad_clicked(self):
        fileName, _ = QFileDialog.getOpenFileName(None,
                                                  self.tr('Import Colors and elevations from XML'),
                                                  QDir.homePath(),
                                                  self.tr('XML files (*.xml *.XML)'))
        if fileName == '':
            return

        doc = QDomDocument()
        with codecs.open(fileName, 'r', encoding='utf-8') as f:
            content = f.read()

        if not doc.setContent(content):
            QMessageBox.critical(None,
                                 self.tr('Error parsing XML'),
                                 self.tr('The XML file could not be loaded'))
            return

        self.reliefClassTree.clear()
        reliefColorList = doc.elementsByTagName('ReliefColor')
        for i in range(reliefColorList.length()):
            elem = reliefColorList.at(i).toElement()
            item = QTreeWidgetItem()
            item.setText(0, elem.attribute('MinElevation'))
            item.setText(1, elem.attribute('MaxElevation'))
            item.setBackground(2, QBrush(QColor(int(elem.attribute('red')),
                                                int(elem.attribute('green')),
                                                int(elem.attribute('blue')))))
            self.reliefClassTree.addTopLevelItem(item)
Ejemplo n.º 10
0
    def openModel(self):
        filename = unicode(QFileDialog.getOpenFileName(self,
                                                       self.tr('Open Model'), ModelerUtils.modelsFolder(),
                                                       self.tr('Processing models (*.model *.MODEL)')))
        if filename:
            try:
                alg = ModelerAlgorithm.fromFile(filename)
                self.alg = alg
                self.alg.setModelerView(self)
                self.textGroup.setText(alg.group)
                self.textName.setText(alg.name)
                self.repaintModel()

                self.view.centerOn(0, 0)
                self.hasChanged = False
            except WrongModelException as e:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       self.tr('Could not load model %s\n%s') % (filename, e.msg))
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
            except Exception as e:
                ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
                                       self.tr('Could not load model %s\n%s') % (filename, e.args[0]))
                QMessageBox.critical(self, self.tr('Could not open model'),
                                     self.tr('The selected model could not be loaded.\n'
                                             'See the log for more information.'))
Ejemplo n.º 11
0
    def execute(self):
        settings = QSettings()
        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)
            algList.reloadProvider('model')
 def checkPdokJson(self):
     myversion = self.getSettingsValue('pdokversion', '1')
     msgtxt = ''
     msglvl = 0  # QgsMessageBar.INFO
     try:
         response = urllib.request.urlopen('http://www.qgis.nl/pdok.version')
         str_response = response.read().decode('utf-8')
         pdokversion = json.loads(str_response)
         if pdokversion > int(myversion):
             response = urllib.request.urlopen('http://www.qgis.nl/pdok.json')
             str_response = response.read().decode('utf-8')
             pdokjson = json.loads(str_response)
             with open(self.plugin_dir +'/pdok.json', 'w') as outfile:
                 json.dump(pdokjson, outfile)
             msgtxt = "De laatste versie is opgehaald en zal worden gebruikt " + \
                 str(pdokversion) + ' (was ' + myversion +')'
             self.servicesLoaded = False # reset reading of json
             self.run()
             self.setSettingsValue('pdokversion', pdokversion)
         else:
             msgtxt = "Geen nieuwere versie beschikbaar dan " + str(pdokversion)
     except Exception as e:
         #print e
         msgtxt = "Fout bij ophalen van service info. Netwerk probleem?"
         msglvl = 2 # QgsMessageBar.CRITICAL
     # msg
     if hasattr(self.iface, 'messageBar'):
         self.iface.messageBar().pushMessage("PDOK services update", msgtxt, level=msglvl, duration=10)
     else: # 1.8
         QMessageBox.information(self.iface.mainWindow(), "Pdok Services Plugin", msgtxt)
Ejemplo n.º 13
0
    def saveModel(self, saveAs):
        if not self.can_save():
            return
        self.model.setName(str(self.textName.text()))
        self.model.setGroup(str(self.textGroup.text()))
        if self.model.sourceFilePath() and not saveAs:
            filename = self.model.sourceFilePath()
        else:
            filename, filter = QFileDialog.getSaveFileName(self,
                                                           self.tr('Save Model'),
                                                           ModelerUtils.modelsFolders()[0],
                                                           self.tr('Processing models (*.model3 *.MODEL3)'))
            if filename:
                if not filename.endswith('.model3'):
                    filename += '.model3'
                self.model.setSourceFilePath(filename)
        if filename:
            if not self.model.toFile(filename):
                if saveAs:
                    QMessageBox.warning(self, self.tr('I/O error'),
                                        self.tr('Unable to save edits. Reason:\n {0}').format(str(sys.exc_info()[1])))
                else:
                    QMessageBox.warning(self, self.tr("Can't save model"), QCoreApplication.translate('QgsPluginInstallerInstallingDialog', (
                        "This model can't be saved in its original location (probably you do not "
                        "have permission to do it). Please, use the 'Save as…' option."))
                    )
                return
            self.update_model.emit()
            if saveAs:
                self.bar.pushMessage("", self.tr("Model was correctly saved to <a href=\"{}\">{}</a>").format(QUrl.fromLocalFile(filename).toString(), QDir.toNativeSeparators(filename)), level=Qgis.Success, duration=5)
            else:
                self.bar.pushMessage("", self.tr("Model was correctly saved"), level=Qgis.Success, duration=5)

            self.hasChanged = False
Ejemplo n.º 14
0
 def execute(self):
     settings = QSettings()
     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:
             algList.reloadProvider('script')
         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))
Ejemplo n.º 15
0
    def batchFinished(self):
        self.base.stop()

        if len(self.errors) > 0:
            msg = u"Processing of the following files ended with error: <br><br>" + "<br><br>".join(self.errors)
            QErrorMessage(self).showMessage(msg)

        inDir = self.getInputFileName()
        outDir = self.getOutputFileName()
        if outDir is None or inDir == outDir:
            self.outFiles = self.inFiles

        # load layers managing the render flag to avoid waste of time
        canvas = self.iface.mapCanvas()
        previousRenderFlag = canvas.renderFlag()
        canvas.setRenderFlag(False)
        notCreatedList = []
        for item in self.outFiles:
            fileInfo = QFileInfo(item)
            if fileInfo.exists():
                if self.base.loadCheckBox.isChecked():
                    self.addLayerIntoCanvas(fileInfo)
            else:
                notCreatedList.append(item)
        canvas.setRenderFlag(previousRenderFlag)

        if len(notCreatedList) == 0:
            QMessageBox.information(self, self.tr("Finished"), self.tr("Operation completed."))
        else:
            QMessageBox.warning(self, self.tr("Warning"), self.tr("The following files were not created: \n{0}").format(', '.join(notCreatedList)))
Ejemplo n.º 16
0
    def setParamValues(self):
        if self.mUpdateExistingGroupBox.isChecked():
            fieldName = self.mExistingFieldComboBox.currentText()
        else:
            fieldName = self.mOutputFieldNameLineEdit.text()

        layer = dataobjects.getObjectFromName(self.cmbInputLayer.currentText())

        self.alg.setParameterValue('INPUT_LAYER', layer)
        self.alg.setParameterValue('FIELD_NAME', fieldName)
        self.alg.setParameterValue('FIELD_TYPE',
                                   self.mOutputFieldTypeComboBox.currentIndex())
        self.alg.setParameterValue('FIELD_LENGTH',
                                   self.mOutputFieldWidthSpinBox.value())
        self.alg.setParameterValue('FIELD_PRECISION',
                                   self.mOutputFieldPrecisionSpinBox.value())
        self.alg.setParameterValue('NEW_FIELD',
                                   self.mNewFieldGroupBox.isChecked())
        self.alg.setParameterValue('FORMULA', self.builder.expressionText())
        self.alg.setOutputValue('OUTPUT_LAYER', self.leOutputFile.text().strip() or None)

        msg = self.alg.checkParameterValuesBeforeExecuting()
        if msg:
            QMessageBox.warning(
                self, self.tr('Unable to execute algorithm'), msg)
            return False
        return True
Ejemplo n.º 17
0
 def activateAlgorithm(self):
     if self.model.activateAlgorithm(self.element.name):
         self.model.updateModelerView()
     else:
         QMessageBox.warning(None, 'Could not activate Algorithm',
                             'The selected algorithm depends on other currently non-active algorithms.\n'
                             'Activate them them before trying to activate it.')
 def __signal_checkBoxEnableMap_stateChanged(self, state):
     enable = False
     if state == Qt.Unchecked:
         self.__marker.reset()
     else:
         if self.__canvas.layerCount() == 0:
             QMessageBox.warning(self, QApplication.translate(
                 "OpenLayersOverviewWidget",
                 "OpenLayers Overview"), QApplication.translate(
                     "OpenLayersOverviewWidget",
                     "At least one layer in map canvas required"))
             self.checkBoxEnableMap.setCheckState(Qt.Unchecked)
         else:
             enable = True
             if not self.__initLayerOL:
                 self.__initLayerOL = True
                 self.__setWebViewMap(0)
             else:
                 self.__refreshMapOL()
     # GUI
     if enable:
         self.lbStatusRead.setVisible(False)
         self.webViewMap.setVisible(True)
     else:
         self.lbStatusRead.setText("")
         self.lbStatusRead.setVisible(True)
         self.webViewMap.setVisible(False)
     self.webViewMap.setEnabled(enable)
     self.comboBoxTypeMap.setEnabled(enable)
     self.pbRefresh.setEnabled(enable)
     self.pbAddRaster.setEnabled(enable)
     self.pbCopyKml.setEnabled(enable)
     self.pbSaveImg.setEnabled(enable)
     self.checkBoxHideCross.setEnabled(enable)
 def accept(self):
     try:
         self.setParamValues()
         msg = self.alg._checkParameterValuesBeforeExecuting()
         if msg:
             QMessageBox.warning(
                 self, self.tr('Unable to execute algorithm'), msg)
             return
         description = algAsDict(self.alg)
         description["name"] = self.settingsPanel.txtName.text().strip()
         description["group"] = self.settingsPanel.txtGroup.text().strip()
         if not (description["name"] and description["group"]):
             self.tabWidget.setCurrentIndex(self.tabWidget.count() - 1)
             return
         validChars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789:'
         filename = ''.join(c for c in description["name"] if c in validChars).lower() + ".json"
         filepath = os.path.join(preconfiguredAlgorithmsFolder(), filename)
         with open(filepath, "w") as f:
             json.dump(description, f)
         algList.reloadProvider('preconfigured')
     except AlgorithmDialogBase.InvalidParameterValue as e:
         try:
             self.buttonBox.accepted.connect(lambda:
                                             e.widget.setPalette(QPalette()))
             palette = e.widget.palette()
             palette.setColor(QPalette.Base, QColor(255, 255, 0))
             e.widget.setPalette(palette)
             self.lblProgress.setText(
                 self.tr('<b>Missing parameter value: %s</b>') % e.parameter.description)
             return
         except:
             QMessageBox.critical(self,
                                  self.tr('Unable to execute algorithm'),
                                  self.tr('Wrong or missing parameter values'))
     self.close()
Ejemplo n.º 20
0
 def remove(self):
     item = self.lessonsTree.currentItem()
     if hasattr(item, "lesson"):
         reply = QMessageBox.question(None,
                                  "Confirmation",
                                  "Are you sure you want to uninstall this lesson?",
                                  QMessageBox.Yes | QMessageBox.No,
                                  QMessageBox.No)
         if reply == QMessageBox.Yes:
             _removeLesson(item.lesson)
             item = self.lessonsTree.currentItem()
             parent = item.parent()
             parent.takeChild(parent.indexOfChild(item))
             if parent.childCount() == 0:
                 self.lessonsTree.takeTopLevelItem(self.lessonsTree.indexOfTopLevelItem(parent))
             item.lesson.uninstall()
     else:
         reply = QMessageBox.question(None,
                      "Confirmation",
                      "Are you sure you want to uninstall this group of lessons?",
                      QMessageBox.Yes | QMessageBox.No,
                      QMessageBox.No)
         if reply == QMessageBox.Yes:
             for i in range(item.childCount()):
                 child = item.child(i)
                 _removeLesson(child.lesson)
                 child.lesson.uninstall()
             self.lessonsTree.takeTopLevelItem(self.lessonsTree.indexOfTopLevelItem(item))
Ejemplo n.º 21
0
    def wkblify_raster(self,  options, infile, i, previous_gt = None):
        """Writes given raster dataset using GDAL features into HEX-encoded of
        WKB for WKT Raster output."""
        
        # Open source raster file
        ds = gdal.Open(infile, gdalc.GA_ReadOnly);
        if ds is None:
            QMessageBox.critical(None,'Error:','Cannot open input file: ' + str(infile))
    
# By default, translate all raster bands

# Calculate range for single-band request
        if options['band'] is not None and options['band'] > 0:
            band_range = ( options['band'], options['band'] + 1 )
        else:
            band_range = ( 1, ds.RasterCount + 1 )
    
        # Compare this px size with previous one
        current_gt = self.get_gdal_geotransform(ds)
        if previous_gt is not None:
            if previous_gt[1] != current_gt[1] or previous_gt[5] != current_gt[5]:
                QMessageBox.critical(None,'Error:', 'Cannot load raster with different pixel size in the same raster table')
    
        # Generate requested overview level (base raster if level = 1)
        summary = self.wkblify_raster_level(options, ds, options['overview_level'], band_range, infile, i)
        SUMMARY.append( summary )
        
        # Cleanup
        ds = None
    
        return current_gt
Ejemplo n.º 22
0
 def saveMessages(self):
     """
     Saves each KLIC message using pickle in textfile in a folder KLIC
     next to Quantum GIS projectfile. Save also reference to this
     pickled object in project file itself.
     """
     l_project = QgsProject.instance()
     l_project_file = str(l_project.fileName())
     l_title = self.tr("Opslaan in project")
     if l_project_file == "":
         l_msg = self.tr("Nog niet opgeslagen als project!\nKies Bestand - Project opslaan...")
         QMessageBox.warning(self, l_title, l_msg)
     else:
         # save the project setting 'b4udignl' 'wv_docs_file' in project.
         # first it is added to the project object
         l_wvs_file = l_project_file.replace(".qgs", "_wv_docs.txt")
         l_wvs_file_name = os.path.basename(l_wvs_file)
         # write project setting
         l_project.writeEntry('b4udignl', 'wv_docs_file', l_wvs_file_name)
         l_file = open(l_wvs_file, 'w')
         l_wv_docs = self.docsToPickle()
         # use pickle to write a textfile holding object instance
         # that can be recreated.
         pickle.dump(l_wv_docs, l_file)
         # save the project immediately, this should be done otherwise
         # the project setting 'wv_docs_file' could be missing when
         # user decides upon leaving the project to Discard the changes.
         # Adding the project setting was considered a project change.
         l_action = self.__iface.actionSaveProject()
         # activate(0) triggers the action save project!
         l_action.activate(0)
         # inform the user that changes have been included in project.
         l_msg = self.tr("KLIC berichten opgeslagen in project")
         QMessageBox.warning(self, l_title, l_msg)
 def calculateKappa(self):
     currentLayer = self.iface.mapCanvas().currentLayer()
     if currentLayer:
         d = CalculateKappaAndConvergenceDialog(self.iface)
         d.exec_()
     else:
         QMessageBox.warning(self.iface.mainWindow(), self.tr("Warning!"), self.tr("Please, open a layer and select a line or polygon feature."))
    def exportTxt(self):
        delimiter = self.__getDelimiter()
        decimalDelimiter = self.__getDecimalDelimiter()
        if delimiter == decimalDelimiter:
            msg = QApplication.translate("code", "Gleiches Dezimal- und Spaltentrennzeichen gewählt!")
            QMessageBox.warning(self.iface.mainWindow(), "VoGIS-Profiltool", msg)
            return

        u = Util(self.iface)
        caption = QApplication.translate("code", "Textdatei exportieren")
        fileName, file_ext = u.getFileName(caption, [["txt", "txt"]], self.filePath)
        if fileName == "":
            return
        fInfo = QFileInfo(fileName)
        self.filePath = fInfo.path()
        QgsSettings().setValue("vogisprofiltoolmain/savepath", self.filePath)
        hekto = (self.ui.IDC_chkHekto.checkState() == Qt.Checked)
        attribs = (self.ui.IDC_chkLineAttributes.checkState() == Qt.Checked)
        txt = open(fileName, "w")

        txt.write(self.profiles[0].writeHeader(self.settings.mapData.rasters.selectedRasters(), hekto, attribs, delimiter))
        for p in self.profiles:
            #txt.write("=====Profil {0}======{1}".format(p.id, os.linesep))
            #txt.write("Segments:{0}{1}".format(len(p.segments), os.linesep))
            #for s in p.segments:
            #    txt.write("Vertices:{0}{1}".format(len(s.vertices), os.linesep))
            txt.write(p.toString(hekto,
                                 attribs,
                                 delimiter,
                                 decimalDelimiter
                                 ))
        txt.close()
Ejemplo n.º 25
0
    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()
    def addToLayout(self):
        mgr = QgsProject.instance().layoutManager()
        layout = None
        layouts = mgr.layouts()
        if len(layouts) == 0:
            QMessageBox.warning(self,
                                QApplication.translate("code", "Keine Layouts"),
                                QApplication.translate("code", "Zuerst ein Layout erstellen"))
            return
        elif len(layouts) == 1:
            layout = layouts[0]
        else:
            d = VoGISProfilToolLayoutsDialog(self, layouts)
            result = d.exec_()
            if result == QDialog.Accepted:
                layout = mgr.layoutByName(d.ui.cmbLayouts.currentText())
            else:
                return

        u = Util(self.iface)
        caption = QApplication.translate("code", "PNG Datei")
        file_format = []
        file_format.append(["PNG files", "png"])
        fileName, fileExt = u.getFileName(caption, file_format, QgsProject.instance().homePath())
        if fileName == "":
            return
        fInfo = QFileInfo(fileName)
        self.filePath = fInfo.path()
        figure = self.subplot.figure
        figure.savefig(fileName, format="png")

        image = QgsLayoutItemPicture(layout)
        image.setPicturePath(fileName)
        image.attemptResize(QgsLayoutSize(200, 200))
        layout.addLayoutItem(image)
Ejemplo n.º 27
0
 def okPressed(self):
     self.alg = self.createAlgorithm()
     if self.alg is not None:
         self.close()
     else:
         QMessageBox.warning(self, self.tr('Unable to add algorithm'),
                             self.tr('Wrong or missing parameter values'))
Ejemplo n.º 28
0
 def show_api_error(self, result):
     if 'error' in result:
         QMessageBox.critical(None, "QGIS Cloud Error", "%s" % result['error'])
         self.status_bar.showMessage(u"Error")
         return True
     else:
         return False
Ejemplo n.º 29
0
 def test(self):
     if self.widget is not None and self.widget.isVisible():
         QMessageBox.warning(self.iface.mainWindow(), "Tester plugin", "A test cycle is currently being run")
         return
     dlg = TestSelector()
     dlg.exec_()
     if dlg.tests:
         settings = {}
         for test in dlg.tests:
             settings.update(test.settings)
         settings.update(self.lastSettings)
         if settings:
             settingsDlg = SettingsWindow(settings)
             settingsDlg.exec_()
             if not settingsDlg.settings:
                 return
             self.lastSettings = settingsDlg.settings
             for key, value in list(settingsDlg.settings.items()):
                 os.environ[key] = value
         self.widget = TesterWidget()
         self.widget.testingFinished.connect(self.testingFinished)
         self.iface.addDockWidget(Qt.TopDockWidgetArea, self.widget)
         self.widget.show()
         self.widget.setTests(dlg.tests)
         self.widget.startTesting()
Ejemplo n.º 30
0
    def copy_layer_settings(self, source_layer, target_layer):
        # copy filter

        if target_layer.type() == QgsVectorLayer:
            target_layer.setSubsetString(source_layer.subsetString())

        # copy symbology
        error = ""
        doc = QDomDocument()
        node = doc.createElement("symbology")
        doc.appendChild(node)
        source_layer.writeSymbology(node, doc, error,  QgsReadWriteContext())

        if not error:
            target_layer.readSymbology(node, error,  QgsReadWriteContext())
        if error:
            QMessageBox.warning(None, "Could not copy symbology", error)

        # copy scale based visibility
        try:
            target_layer.setScaleBasedVisibility(source_layer.hasScaleBasedVisibility())
        except:
            # Fall back to the deprecated function
            target_layer.toggleScaleBasedVisibility(source_layer.hasScaleBasedVisibility())
        target_layer.setMinimumScale(source_layer.minimumScale())
        target_layer.setMaximumScale(source_layer.maximumScale())

        #copy CRS
        target_layer.setCrs(source_layer.crs(), False)
Ejemplo n.º 31
0
def createTest(text):
    definition = {}

    alg_id, parameters = splitAlgIdAndParameters(text)

    alg = QgsApplication.processingRegistry().createAlgorithmById(alg_id)

    definition['name'] = 'Test ({})'.format(alg_id)
    definition['algorithm'] = alg_id

    params = {}
    results = {}

    i = 0
    for param in alg.parameterDefinitions():
        if param.flags() & QgsProcessingParameterDefinition.FlagHidden or param.isDestination():
            continue

        if not param.name() in parameters:
            continue

        i += 1
        token = parameters[param.name()]
        # Handle empty parameters that are optionals
        if param.flags() & QgsProcessingParameterDefinition.FlagOptional and token is None:
            continue

        if isinstance(param, (QgsProcessingParameterVectorLayer, QgsProcessingParameterFeatureSource)):
            schema, filepath = extractSchemaPath(token)
            p = {
                'type': 'vector',
                'name': filepath
            }
            if not schema:
                p['location'] = '[The source data is not in the testdata directory. Please use data in the processing/tests/testdata folder.]'

            params[param.name()] = p
        elif isinstance(param, QgsProcessingParameterRasterLayer):
            schema, filepath = extractSchemaPath(token)
            p = {
                'type': 'raster',
                'name': filepath
            }
            if not schema:
                p['location'] = '[The source data is not in the testdata directory. Please use data in the processing/tests/testdata folder.]'

            params[param.name()] = p
        elif isinstance(param, QgsProcessingParameterMultipleLayers):
            multiparams = token
            newparam = []

            # Handle datatype detection
            dataType = param.layerType()
            if dataType in [QgsProcessing.TypeVectorAnyGeometry, QgsProcessing.TypeVectorPoint, QgsProcessing.TypeVectorLine, QgsProcessing.TypeVectorPolygon, QgsProcessing.TypeVector]:
                dataType = 'vector'
            else:
                dataType = 'raster'

            schema = None
            for mp in multiparams:
                schema, filepath = extractSchemaPath(mp)
                newparam.append({
                    'type': dataType,
                    'name': filepath
                })
            p = {
                'type': 'multi',
                'params': newparam
            }
            if not schema:
                p['location'] = '[The source data is not in the testdata directory. Please use data in the processing/tests/testdata folder.]'

            params[param.name()] = p
        elif isinstance(param, QgsProcessingParameterFile):
            schema, filepath = extractSchemaPath(token)
            p = {
                'type': 'file',
                'name': filepath
            }
            if not schema:
                p['location'] = '[The source data is not in the testdata directory. Please use data in the processing/tests/testdata folder.]'

            params[param.name()] = p
        elif isinstance(param, QgsProcessingParameterString):
            params[param.name()] = token
        elif isinstance(param, QgsProcessingParameterBoolean):
            params[param.name()] = token
        elif isinstance(param, (QgsProcessingParameterNumber, QgsProcessingParameterDistance)):
            if param.dataType() == QgsProcessingParameterNumber.Integer:
                params[param.name()] = int(token)
            else:
                params[param.name()] = float(token)
        elif isinstance(param, QgsProcessingParameterEnum):
            if isinstance(token, list):
                params[param.name()] = [int(t) for t in token]
            else:
                params[param.name()] = int(token)
        elif isinstance(param, QgsProcessingParameterBand):
            params[param.name()] = int(token)
        elif token:
            if token[0] == '"':
                token = token[1:]
            if token[-1] == '"':
                token = token[:-1]
            params[param.name()] = token

    definition['params'] = params

    for i, out in enumerate([out for out in alg.destinationParameterDefinitions() if not out.flags() & QgsProcessingParameterDefinition.FlagHidden]):
        if not out.name() in parameters:
            continue

        token = parameters[out.name()]

        if isinstance(out, QgsProcessingParameterRasterDestination):
            if token is None:
                QMessageBox.warning(None,
                                    tr('Error'),
                                    tr('Seems some outputs are temporary '
                                       'files. To create test you need to '
                                       'redirect all algorithm outputs to '
                                       'files'))
                return

            dataset = gdal.Open(token, GA_ReadOnly)
            if dataset is None:
                QMessageBox.warning(None,
                                    tr('Error'),
                                    tr('Seems some outputs are temporary '
                                       'files. To create test you need to '
                                       'redirect all algorithm outputs to '
                                       'files'))
                return

            dataArray = nan_to_num(dataset.ReadAsArray(0))
            strhash = hashlib.sha224(dataArray.data).hexdigest()

            results[out.name()] = {
                'type': 'rasterhash',
                'hash': strhash
            }
        elif isinstance(out, (QgsProcessingParameterVectorDestination, QgsProcessingParameterFeatureSink)):
            schema, filepath = extractSchemaPath(token)
            results[out.name()] = {
                'type': 'vector',
                'name': filepath
            }
            if not schema:
                results[out.name()]['location'] = '[The expected result data is not in the testdata directory. Please write it to processing/tests/testdata/expected. Prefer gml files.]'
        elif isinstance(out, QgsProcessingParameterFileDestination):
            schema, filepath = extractSchemaPath(token)
            results[out.name()] = {
                'type': 'file',
                'name': filepath
            }
            if not schema:
                results[out.name()]['location'] = '[The expected result file is not in the testdata directory. Please redirect the output to processing/tests/testdata/expected.]'

    definition['results'] = results
    dlg = ShowTestDialog(yaml.dump([definition], default_flow_style=False))
    dlg.exec_()
    def accept(self):
        description = str(self.nameTextBox.text())
        if description.strip() == '':
            QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                self.tr('Invalid parameter name'))
            return
        if self.param is None:
            validChars = \
                'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
            safeName = ''.join(c for c in description if c in validChars)
            name = safeName.lower()
            i = 2
            while self.alg.parameterDefinition(name):
                name = safeName.lower() + str(i)
                i += 1
        else:
            name = self.param.name()
        if (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or
                isinstance(self.param, QgsProcessingParameterBoolean)):
            self.param = QgsProcessingParameterBoolean(name, description, self.state.isChecked())
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or
              isinstance(self.param, QgsProcessingParameterField)):
            if self.parentCombo.currentIndex() < 0:
                QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                    self.tr('Wrong or missing parameter values'))
                return
            parent = self.parentCombo.currentData()
            datatype = self.datatypeCombo.currentData()
            default = self.defaultTextBox.text()
            if not default:
                default = None
            self.param = QgsProcessingParameterField(name, description, defaultValue=default,
                                                     parentLayerParameterName=parent, type=datatype,
                                                     allowMultiple=self.multipleCheck.isChecked())
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BAND or
              isinstance(self.param, QgsProcessingParameterBand)):
            if self.parentCombo.currentIndex() < 0:
                QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                    self.tr('Wrong or missing parameter values'))
                return
            parent = self.parentCombo.currentData()
            self.param = QgsProcessingParameterBand(name, description, None, parent)
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MAP_LAYER or
              isinstance(self.param, QgsProcessingParameterMapLayer)):
            self.param = QgsProcessingParameterMapLayer(
                name, description)
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_RASTER or
              isinstance(self.param, QgsProcessingParameterRasterLayer)):
            self.param = QgsProcessingParameterRasterLayer(
                name, description)
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE or
              isinstance(self.param, QgsProcessingParameterVectorLayer)):
            self.param = QgsProcessingParameterVectorLayer(
                name, description,
                [self.shapetypeCombo.currentData()])
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or
              isinstance(self.param, QgsProcessingParameterFeatureSource)):
            self.param = QgsProcessingParameterFeatureSource(
                name, description,
                [self.shapetypeCombo.currentData()])
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or
              isinstance(self.param, QgsProcessingParameterMultipleLayers)):
            self.param = QgsProcessingParameterMultipleLayers(
                name, description,
                self.datatypeCombo.currentData())
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
              isinstance(self.param, QgsProcessingParameterNumber)):
            try:
                self.param = QgsProcessingParameterNumber(name, description, QgsProcessingParameterNumber.Double,
                                                          self.defaultTextBox.text())
                vmin = self.minTextBox.text().strip()
                if not vmin == '':
                    self.param.setMinimum(float(vmin))
                vmax = self.maxTextBox.text().strip()
                if not vmax == '':
                    self.param.setMaximum(float(vmax))
            except:
                QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                    self.tr('Wrong or missing parameter values'))
                return
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION or
              isinstance(self.param, QgsProcessingParameterExpression)):
            parent = self.parentCombo.currentData()
            self.param = QgsProcessingParameterExpression(name, description,
                                                          str(self.defaultEdit.expression()),
                                                          parent)
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or
              isinstance(self.param, QgsProcessingParameterString)):
            self.param = QgsProcessingParameterString(name, description,
                                                      str(self.defaultTextBox.text()))
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXTENT or
              isinstance(self.param, QgsProcessingParameterExtent)):
            self.param = QgsProcessingParameterExtent(name, description)
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or
              isinstance(self.param, QgsProcessingParameterFile)):
            isFolder = self.fileFolderCombo.currentIndex() == 1
            self.param = QgsProcessingParameterFile(name, description,
                                                    QgsProcessingParameterFile.Folder if isFolder else QgsProcessingParameterFile.File)
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or
              isinstance(self.param, QgsProcessingParameterPoint)):
            self.param = QgsProcessingParameterPoint(name, description,
                                                     str(self.defaultTextBox.text()))
        elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS or
              isinstance(self.param, QgsProcessingParameterCrs)):
            self.param = QgsProcessingParameterCrs(name, description, self.selector.crs().authid())
        if not self.requiredCheck.isChecked():
            self.param.setFlags(self.param.flags() | QgsProcessingParameterDefinition.FlagOptional)

        settings = QgsSettings()
        settings.setValue("/Processing/modelParametersDefinitionDialogGeometry", self.saveGeometry())

        QDialog.accept(self)
Ejemplo n.º 33
0
 def showHelp(self):
     helpText = u"""In this dialog you can set up versioning support for a table. The table will be modified so that all changes will be recorded: there will be a column with start time and end time. Every row will have its start time, end time is assigned when the feature gets deleted. When a row is modified, the original data is marked with end time and new row is created. With this system, it's possible to get back to state of the table any time in history. When selecting rows from the table, you will always have to specify at what time do you want the rows."""
     QMessageBox.information(self, "Help", helpText)
    def accept(self):
        description = self.nameTextBox.text()
        if description.strip() == '':
            QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                self.tr('Invalid parameter name'))
            return
        if self.param is None:
            validChars = \
                'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
            safeName = ''.join(c for c in description if c in validChars)
            name = safeName.lower()
            i = 2
            while self.alg.parameterDefinition(name):
                name = safeName.lower() + str(i)
                i += 1
        else:
            name = self.param.name()
        if (self.paramType == parameters.PARAMETER_BOOLEAN
                or isinstance(self.param, QgsProcessingParameterBoolean)):
            self.param = QgsProcessingParameterBoolean(name, description,
                                                       self.state.isChecked())
        elif (self.paramType == parameters.PARAMETER_TABLE_FIELD
              or isinstance(self.param, QgsProcessingParameterField)):
            if self.parentCombo.currentIndex() < 0:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return
            parent = self.parentCombo.currentData()
            datatype = self.datatypeCombo.currentData()
            default = self.defaultTextBox.text()
            if not default:
                default = None
            self.param = QgsProcessingParameterField(
                name,
                description,
                defaultValue=default,
                parentLayerParameterName=parent,
                type=datatype,
                allowMultiple=self.multipleCheck.isChecked())
        elif (self.paramType == parameters.PARAMETER_BAND
              or isinstance(self.param, QgsProcessingParameterBand)):
            if self.parentCombo.currentIndex() < 0:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return
            parent = self.parentCombo.currentData()
            self.param = QgsProcessingParameterBand(name, description, None,
                                                    parent)
        elif (self.paramType == parameters.PARAMETER_MAP_LAYER
              or isinstance(self.param, QgsProcessingParameterMapLayer)):
            self.param = QgsProcessingParameterMapLayer(name, description)
        elif (self.paramType == parameters.PARAMETER_RASTER
              or isinstance(self.param, QgsProcessingParameterRasterLayer)):
            self.param = QgsProcessingParameterRasterLayer(name, description)
        elif (self.paramType == parameters.PARAMETER_TABLE
              or isinstance(self.param, QgsProcessingParameterVectorLayer)):
            self.param = QgsProcessingParameterVectorLayer(
                name, description, [self.shapetypeCombo.currentData()])
        elif (self.paramType == parameters.PARAMETER_VECTOR
              or isinstance(self.param, QgsProcessingParameterFeatureSource)):
            self.param = QgsProcessingParameterFeatureSource(
                name, description, [self.shapetypeCombo.currentData()])
        elif (self.paramType == parameters.PARAMETER_MULTIPLE
              or isinstance(self.param, QgsProcessingParameterMultipleLayers)):
            self.param = QgsProcessingParameterMultipleLayers(
                name, description, self.datatypeCombo.currentData())
        elif (self.paramType == parameters.PARAMETER_DISTANCE
              or isinstance(self.param, QgsProcessingParameterDistance)):
            self.param = QgsProcessingParameterDistance(
                name, description, self.defaultTextBox.text())
            try:
                vmin = self.minTextBox.text().strip()
                if not vmin == '':
                    self.param.setMinimum(float(vmin))
                vmax = self.maxTextBox.text().strip()
                if not vmax == '':
                    self.param.setMaximum(float(vmax))
            except:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return

            if self.parentCombo.currentIndex() < 0:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return
            parent = self.parentCombo.currentData()
            if parent:
                self.param.setParentParameterName(parent)
        elif (self.paramType == parameters.PARAMETER_NUMBER
              or isinstance(self.param, QgsProcessingParameterNumber)):
            self.param = QgsProcessingParameterNumber(
                name, description, QgsProcessingParameterNumber.Double,
                self.defaultTextBox.text())
            try:
                vmin = self.minTextBox.text().strip()
                if not vmin == '':
                    self.param.setMinimum(float(vmin))
                vmax = self.maxTextBox.text().strip()
                if not vmax == '':
                    self.param.setMaximum(float(vmax))
            except:
                QMessageBox.warning(
                    self, self.tr('Unable to define parameter'),
                    self.tr('Wrong or missing parameter values'))
                return
        elif (self.paramType == parameters.PARAMETER_EXPRESSION
              or isinstance(self.param, QgsProcessingParameterExpression)):
            parent = self.parentCombo.currentData()
            self.param = QgsProcessingParameterExpression(
                name, description, str(self.defaultEdit.expression()), parent)
        elif (self.paramType == parameters.PARAMETER_STRING
              or isinstance(self.param, QgsProcessingParameterString)):
            self.param = QgsProcessingParameterString(
                name, description, str(self.defaultTextBox.text()))
        elif (self.paramType == parameters.PARAMETER_EXTENT
              or isinstance(self.param, QgsProcessingParameterExtent)):
            self.param = QgsProcessingParameterExtent(name, description)
        elif (self.paramType == parameters.PARAMETER_FILE
              or isinstance(self.param, QgsProcessingParameterFile)):
            isFolder = self.fileFolderCombo.currentIndex() == 1
            self.param = QgsProcessingParameterFile(
                name, description, QgsProcessingParameterFile.Folder
                if isFolder else QgsProcessingParameterFile.File)
        elif (self.paramType == parameters.PARAMETER_POINT
              or isinstance(self.param, QgsProcessingParameterPoint)):
            self.param = QgsProcessingParameterPoint(
                name, description, str(self.defaultTextBox.text()))
        elif (self.paramType == parameters.PARAMETER_CRS
              or isinstance(self.param, QgsProcessingParameterCrs)):
            self.param = QgsProcessingParameterCrs(
                name, description,
                self.selector.crs().authid())
        elif (self.paramType == parameters.PARAMETER_ENUM
              or isinstance(self.param, QgsProcessingParameterEnum)):
            self.param = QgsProcessingParameterEnum(
                name, description, self.widget.options(),
                self.widget.allowMultiple(), self.widget.defaultOptions())
        elif (self.paramType == parameters.PARAMETER_MATRIX
              or isinstance(self.param, QgsProcessingParameterMatrix)):
            self.param = QgsProcessingParameterMatrix(
                name,
                description,
                hasFixedNumberRows=self.widget.fixedRows(),
                headers=self.widget.headers(),
                defaultValue=self.widget.value())

        # Destination parameter
        elif (isinstance(self.param, QgsProcessingParameterFeatureSink)):
            self.param = QgsProcessingParameterFeatureSink(
                name=name,
                description=self.param.description(),
                type=self.param.dataType(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterFileDestination)):
            self.param = QgsProcessingParameterFileDestination(
                name=name,
                description=self.param.description(),
                fileFilter=self.param.fileFilter(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterFolderDestination)):
            self.param = QgsProcessingParameterFolderDestination(
                name=name,
                description=self.param.description(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterRasterDestination)):
            self.param = QgsProcessingParameterRasterDestination(
                name=name,
                description=self.param.description(),
                defaultValue=self.defaultWidget.getValue())
        elif (isinstance(self.param, QgsProcessingParameterVectorDestination)):
            self.param = QgsProcessingParameterVectorDestination(
                name=name,
                description=self.param.description(),
                type=self.param.dataType(),
                defaultValue=self.defaultWidget.getValue())

        else:
            if self.paramType:
                typeId = self.paramType
            else:
                typeId = self.param.type()

            paramTypeDef = QgsApplication.instance().processingRegistry(
            ).parameterType(typeId)
            if not paramTypeDef:
                msg = self.tr(
                    'The parameter `{}` is not registered, are you missing a required plugin?'
                    .format(typeId))
                raise UndefinedParameterException(msg)
            self.param = paramTypeDef.create(name)
            self.param.setDescription(description)
            self.param.setMetadata(paramTypeDef.metadata())

        if not self.requiredCheck.isChecked():
            self.param.setFlags(
                self.param.flags()
                | QgsProcessingParameterDefinition.FlagOptional)
        else:
            self.param.setFlags(
                self.param.flags()
                & ~QgsProcessingParameterDefinition.FlagOptional)

        settings = QgsSettings()
        settings.setValue(
            "/Processing/modelParametersDefinitionDialogGeometry",
            self.saveGeometry())

        QDialog.accept(self)
Ejemplo n.º 35
0
 def msgInfo(self, txt):
     QMessageBox.information(self, 'Informació', txt)
Ejemplo n.º 36
0
 def show_warn(self, msg):
     QMessageBox.warning(self.iface.mainWindow(), self.context, msg)
    def show_messagebox(self, **kwargs):
        """ Shows a message box with detail information """

        msg = kwargs['message'] if 'message' in kwargs else 'No message found'
        title = kwargs['title'] if 'title' in kwargs else 'New message'
        inf_text = kwargs['inf_text'] if 'inf_text' in kwargs else 'Info text'
        # color = "black"
        # bold = ''
        # if 'styleSheet' in kwargs:
        #     color = kwargs['styleSheet']['color'] if 'color' in kwargs['styleSheet'] else "black"
        #     if 'bold' in kwargs['styleSheet']:
        #         bold = 'b' if kwargs['styleSheet']['bold'] else ''
        #     else:
        #         bold = ''
        # msg = f'<font color="{color}"><{bold}>{msg}</font>'
        msg_box = QMessageBox()
        msg_box.setText(msg)
        if title:
            title = self.controller.tr(title)
            msg_box.setWindowTitle(title)
        if inf_text:
            inf_text = self.controller.tr(inf_text)
            msg_box.setInformativeText(inf_text)
        msg_box.setWindowFlags(Qt.WindowStaysOnTopHint)
        msg_box.setStandardButtons(QMessageBox.Ok)
        msg_box.setDefaultButton(QMessageBox.Ok)
        msg_box.open()
Ejemplo n.º 38
0
 def okPressed(self):
     description = str(self.nameTextBox.text())
     if description.strip() == '':
         QMessageBox.warning(self, self.tr('Unable to define parameter'),
                             self.tr('Invalid parameter name'))
         return
     if self.param is None:
         validChars = \
             'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
         safeName = ''.join(c for c in description if c in validChars)
         name = safeName.lower()
         i = 2
         while name in self.alg.inputs:
             name = safeName.lower() + str(i)
     else:
         name = self.param.name
     if (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_BOOLEAN or
             isinstance(self.param, ParameterBoolean)):
         self.param = ParameterBoolean(name, description, self.state.isChecked())
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE_FIELD or
           isinstance(self.param, ParameterTableField)):
         if self.parentCombo.currentIndex() < 0:
             QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                 self.tr('Wrong or missing parameter values'))
             return
         parent = self.parentCombo.currentData()
         datatype = self.datatypeCombo.currentData()
         self.param = ParameterTableField(name, description, parent, datatype, multiple=self.multipleCheck.isChecked())
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_RASTER or
             isinstance(self.param, ParameterRaster)):
         self.param = ParameterRaster(
             name, description)
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_TABLE or
             isinstance(self.param, ParameterTable)):
         self.param = ParameterTable(
             name, description)
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_VECTOR or
             isinstance(self.param, ParameterVector)):
         self.param = ParameterVector(
             name, description,
             [self.shapetypeCombo.currentIndex() - 1])
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_MULTIPLE or
             isinstance(self.param, ParameterMultipleInput)):
         self.param = ParameterMultipleInput(
             name, description,
             self.datatypeCombo.currentIndex() - 1)
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_NUMBER or
             isinstance(self.param, ParameterNumber)):
         try:
             vmin = self.minTextBox.text().strip()
             if vmin == '':
                 vmin = None
             else:
                 vmin = float(vmin)
             vmax = self.maxTextBox.text().strip()
             if vmax == '':
                 vmax = None
             else:
                 vmax = float(vmax)
             self.param = ParameterNumber(name, description, vmin, vmax,
                                          str(self.defaultTextBox.text()))
         except:
             QMessageBox.warning(self, self.tr('Unable to define parameter'),
                                 self.tr('Wrong or missing parameter values'))
             return
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXPRESSION or
             isinstance(self.param, ParameterExpression)):
         parent = self.parentCombo.currentData()
         self.param = ParameterExpression(name, description,
                                          default=str(self.defaultEdit.expression()),
                                          parent_layer=parent)
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_STRING or
             isinstance(self.param, ParameterString)):
         self.param = ParameterString(name, description,
                                      str(self.defaultTextBox.text()))
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_EXTENT or
             isinstance(self.param, ParameterExtent)):
         self.param = ParameterExtent(name, description)
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_FILE or
             isinstance(self.param, ParameterFile)):
         isFolder = self.fileFolderCombo.currentIndex() == 1
         self.param = ParameterFile(name, description, isFolder=isFolder)
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_POINT or
             isinstance(self.param, ParameterPoint)):
         self.param = ParameterPoint(name, description,
                                     str(self.defaultTextBox.text()))
     elif (self.paramType == ModelerParameterDefinitionDialog.PARAMETER_CRS or
             isinstance(self.param, ParameterCrs)):
         self.param = ParameterCrs(name, description, default=self.selector.crs().authid())
     self.param.optional = not self.requiredCheck.isChecked()
     self.close()
Ejemplo n.º 39
0
    def accept(self):
        feedback = self.createFeedback()
        context = dataobjects.createContext(feedback)

        checkCRS = ProcessingConfig.getSetting(
            ProcessingConfig.WARN_UNMATCHING_CRS)
        try:
            parameters = self.getParameterValues()

            if checkCRS and not self.algorithm().validateInputCrs(
                    parameters, context):
                reply = QMessageBox.question(
                    self, self.tr("Unmatching CRS's"),
                    self.tr('Parameters do not all use the same CRS. This can '
                            'cause unexpected results.\nDo you want to '
                            'continue?'), QMessageBox.Yes | QMessageBox.No,
                    QMessageBox.No)
                if reply == QMessageBox.No:
                    return
            ok, msg = self.algorithm().checkParameterValues(
                parameters, context)
            if msg:
                QMessageBox.warning(self,
                                    self.tr('Unable to execute algorithm'),
                                    msg)
                return
            self.runButton().setEnabled(False)
            self.cancelButton().setEnabled(False)
            buttons = self.mainWidget().iterateButtons
            self.iterateParam = None

            for i in range(len(list(buttons.values()))):
                button = list(buttons.values())[i]
                if button.isChecked():
                    self.iterateParam = list(buttons.keys())[i]
                    break

            self.clearProgress()
            self.setProgressText(
                QCoreApplication.translate('AlgorithmDialog',
                                           'Processing algorithm…'))

            self.setInfo(QCoreApplication.translate(
                'AlgorithmDialog',
                '<b>Algorithm \'{0}\' starting&hellip;</b>').format(
                    self.algorithm().displayName()),
                         escapeHtml=False)

            feedback.pushInfo(self.tr('Input parameters:'))
            display_params = []
            for k, v in parameters.items():
                display_params.append("'" + k + "' : " +
                                      self.algorithm().parameterDefinition(
                                          k).valueAsPythonString(v, context))
            feedback.pushCommandInfo('{ ' + ', '.join(display_params) + ' }')
            feedback.pushInfo('')
            start_time = time.time()

            if self.iterateParam:
                # Make sure the Log tab is visible before executing the algorithm
                try:
                    self.showLog()
                    self.repaint()
                except:
                    pass

                self.cancelButton().setEnabled(
                    self.algorithm().flags()
                    & QgsProcessingAlgorithm.FlagCanCancel)
                if executeIterating(self.algorithm(), parameters,
                                    self.iterateParam, context, feedback):
                    feedback.pushInfo(
                        self.tr('Execution completed in {0:0.2f} seconds').
                        format(time.time() - start_time))
                    self.cancelButton().setEnabled(False)
                    self.finish(True, parameters, context, feedback)
                else:
                    self.cancelButton().setEnabled(False)
                    self.resetGui()
            else:
                command = self.algorithm().asPythonCommand(parameters, context)
                if command:
                    ProcessingLog.addToLog(command)
                self.cancelButton().setEnabled(
                    self.algorithm().flags()
                    & QgsProcessingAlgorithm.FlagCanCancel)

                def on_complete(ok, results):
                    if ok:
                        feedback.pushInfo(
                            self.tr('Execution completed in {0:0.2f} seconds').
                            format(time.time() - start_time))
                        feedback.pushInfo(self.tr('Results:'))
                        feedback.pushCommandInfo(pformat(results))
                    else:
                        feedback.reportError(
                            self.tr('Execution failed after {0:0.2f} seconds').
                            format(time.time() - start_time))
                    feedback.pushInfo('')

                    if self.feedback_dialog is not None:
                        self.feedback_dialog.close()
                        self.feedback_dialog.deleteLater()
                        self.feedback_dialog = None

                    self.cancelButton().setEnabled(False)

                    self.finish(ok, results, context, feedback)

                if not (self.algorithm().flags()
                        & QgsProcessingAlgorithm.FlagNoThreading):
                    # Make sure the Log tab is visible before executing the algorithm
                    self.showLog()

                    task = QgsProcessingAlgRunnerTask(self.algorithm(),
                                                      parameters, context,
                                                      feedback)
                    task.executed.connect(on_complete)
                    self.setCurrentTask(task)
                else:
                    self.feedback_dialog = self.createProgressDialog()
                    self.feedback_dialog.show()
                    ok, results = execute(self.algorithm(), parameters,
                                          context, feedback)
                    on_complete(ok, results)

        except AlgorithmDialogBase.InvalidParameterValue as e:
            try:
                self.buttonBox().accepted.connect(
                    lambda e=e: e.widget.setPalette(QPalette()))
                palette = e.widget.palette()
                palette.setColor(QPalette.Base, QColor(255, 255, 0))
                e.widget.setPalette(palette)
            except:
                pass
            self.messageBar().clearWidgets()
            self.messageBar().pushMessage(
                "",
                self.tr("Wrong or missing parameter value: {0}").format(
                    e.parameter.description()),
                level=Qgis.Warning,
                duration=5)
Ejemplo n.º 40
0
 def initGui(self):
     QMessageBox.warning(
         self.iface.mainWindow(),
         'WfsOutputExtension plugin',
         'WfsOutputExtension is plugin for QGIS Server. There is nothing in QGIS Desktop.',
     )
Ejemplo n.º 41
0
    def run(self):
        """Run method that performs all the real work"""

        # Create the dialog with elements (after translation) and keep reference
        # Only create GUI ONCE in callback, so that it will only load when the plugin is started
        if self.first_start == True:
            self.first_start = False
            self.dlg = MappingEcosystemServicesDialog()
            self.dlg.helpButton.pressed.connect(self.helpAction)
            self.dlg.outputFolderButton.pressed.connect(self.selectFolder)
            self.dlg.sourceDeleteButton.clicked.connect(
                self.sourceButtonDelete)
            self.dlg.targetDeleteButton.clicked.connect(
                self.targetButtonDelete)
            self.dlg.maxDistanceSpinBox.valueChanged.connect(self.checkCRS)
            self.dlg.studyAreaLayerQbox.activated.connect(self.checkCRSWarning)
            self.dlg.landUseLayerQbox.activated.connect(self.checkCRSWarning)
            # self.dlg.landUseFieldQbox.activated.connect(self.checkCRS)
            self.dlg.searchFolder.textChanged.connect(self.checkCRS)
            self.dlg.outputRasterSizeBox.valueChanged.connect(self.checkCRS)
            self.dlg.target.itemChanged.connect(self.checkCRS)
            self.dlg.source.itemChanged.connect(self.checkSourceValue)

        # show the dialog
        self.dlg.show()
        self.dlg.formulaQBox.clear()
        self.dlg.formulaQBox.addItems(['Linear', 'Gaussian'])
        # self.dlg.searchFolder.clear()
        # connect check OK function

        ############## Load layers ######################
        # Fetch Study area
        layers = self.getLayers()
        # only vector layers
        # https://qgis.org/pyqgis/master/core/QgsMapLayerType.html#qgis.core.QgsMapLayerType
        # Clear the contents of the comboBox from previous runs
        self.dlg.studyAreaLayerQbox.clear()
        # Populate the comboBox with names of all vector layers
        self.dlg.studyAreaLayerQbox.addItem('')
        self.dlg.studyAreaLayerQbox.addItems(
            [layer.name() for layer in layers])
        # Fetch Land Use
        self.dlg.landUseLayerQbox.clear()
        self.dlg.landUseFieldQbox.clear()
        self.dlg.origin.clear()
        self.dlg.target.setRowCount(0)
        self.dlg.source.setRowCount(0)
        # Populate the comboBox with names of all vector layers
        self.dlg.landUseLayerQbox.addItem('')
        self.dlg.landUseLayerQbox.addItems([layer.name() for layer in layers])

        self.dlg.landUseLayerQbox.currentIndexChanged.connect(
            self.loadLandUseFields)
        self.dlg.landUseFieldQbox.currentIndexChanged.connect(
            self.loadLandUseTableData)

        ##############################
        self.dlg.source.setColumnCount(2)
        self.dlg.source.setHorizontalHeaderLabels(['Land use', 'Value'])
        # self.dlg.source.model().rowsAboutToBeInserted.connect(self.sourceRowsAdded)
        buttonOK = self.dlg.button_box.buttons()[0]
        buttonOK.setEnabled(False)
        #####################################
        # current timestamp usefull for output files
        self.timestamp = str(datetime.now().strftime("%d%m%Y_%H%M%S"))
        # Run the dialog event loop
        result = self.dlg.exec_()
        ########################################################
        # See if OK was pressed
        if result:
            outputFolder = self.dlg.searchFolder.displayText()
            if outputFolder == '':
                QMessageBox.information(
                    None, "Warning!",
                    "No datasets folder selected. Please select a folder.")
                iface.messageBar().clearWidgets()
                return
            studyAreaLayer = self.getSelectedStudyAreaLayer()
            landUseLayer = self.getSelectedLandUseLayer()
            currentCRSID = 4326
            try:
                currentCRSID = landUseLayer.crs().postgisSrid()
            except:
                try:
                    currentCRSID = QgsProject.instance().crs().postgisSrid()
                except:
                    currentCRSID = 4326

            # print(landUseLayer.source())
            context = dataobjects.createContext()
            context.setInvalidGeometryCheck(QgsFeatureRequest.GeometryNoCheck)
            formulaType = self.dlg.formulaQBox.currentText()
            analysisType = self.dlg.analysisTypeBox.currentText()
            # progressMessageBar.setText('Extracting polygons ...')
            # progress.setValue(10)
            outputFile = "ogr:dbname='" + \
                os.path.join(outputFolder, 'output_result_'+analysisType+'_'+formulaType+'_') + \
                self.timestamp+".gpkg' table=land_use (geom) sql="
            # extract poligons that intersect area of interest
            processing.run(
                "qgis:extractbylocation", {
                    'INPUT': landUseLayer,
                    'INTERSECT': studyAreaLayer,
                    'OUTPUT': outputFile,
                    'PREDICATE': [0]
                })
            outputFile = os.path.join(outputFolder, 'output_result_'+analysisType+'_'+formulaType+'_') + \
                self.timestamp+".gpkg"

            self.saveLayerIntoPkg(studyAreaLayer, outputFile, 'study_area')

            srcDataSource = ogr.Open(
                os.path.join(
                    outputFolder, 'output_result_' + analysisType + '_' +
                    formulaType + '_') + self.timestamp + '.gpkg', 1)
            # progressMessageBar.setText('Computing values ...')
            # progress.setValue(20)
            sourceItems = self.getSourceItems().get('items')
            sourceValues = self.getSourceItems().get('values')

            if analysisType == 'Boundaries':
                if formulaType == 'Linear':
                    sql = '''
                        with s as (
                            select *, case {landUseField} {caseStatment} end as value
                            from {landUseLayer}
                            where {landUseField} in ({sourceItems})
                        ),
                        t as (
                                select *
                        from {landUseLayer}
                        where {landUseField} in ({targetItems})
                        )
                        SELECT AsWKT(st_ShortestLine(s.geom,t.geom)) as geomText ,t.fid as tfid,s.fid as sfid,t.{landUseField}, st_distance(s.geom,t.geom) as distance, CASE
                                WHEN st_distance(s.geom,t.geom) = 0 then s.value
                                WHEN st_distance(s.geom,t.geom)>0 then (1-(st_distance(s.geom,t.geom)/{maxDistance}))*s.value
                        END as computed
                        FROM s,t
                        where PtDistWithin(s.geom,t.geom,{maxDistance})
                        '''.format(
                        landUseLayer="land_use",
                        studyArea="study_area",
                        landUseField=self.landUseSelectedField.name(),
                        targetItems=', '.join([
                            '"' + str(x) + '"' for x in self.getTargetItems()
                        ]),
                        sourceItems=', '.join(
                            ['"' + str(x) + '"' for x in sourceItems]),
                        # sourceValues=', '.join(
                        #     [str(x) for x in sourceValues]),
                        caseStatment=' '.join([
                            'WHEN "' + x + '" THEN ' + str(y)
                            for x, y in [[sourceItems[i], sourceValues[i]]
                                         for i in range(0, len(sourceItems))]
                        ]),
                        maxDistance=self.dlg.maxDistanceSpinBox.value(),
                        currentCRSID=currentCRSID)
                elif formulaType == 'Gaussian':
                    sql = '''
                        with s as (
                            select *, case {landUseField} {caseStatment} end as value
                            from {landUseLayer}
                            where {landUseField} in ({sourceItems})
                        ),
                        t as (
                                select *
                        from {landUseLayer}
                        where {landUseField} in ({targetItems})
                        )

                        SELECT AsWKT(st_ShortestLine(s.geom,t.geom)) as geomText ,t.fid as tfid,s.fid as sfid,t.{landUseField}, st_distance(s.geom,t.geom) as distance, 
                        s.value*((power(2.718281828459045235360287471352662497757247093699959574966,(((st_distance(s.geom,t.geom)/{maxDistance}) * (st_distance(s.geom,t.geom)/{maxDistance}) * -4) + 0.92)))/sqrt(6.283185307179586476925286766559005768394338798750211641949)) as computed
                        FROM s,t
                        where PtDistWithin(s.geom,t.geom,{maxDistance})
                        '''.format(
                        landUseLayer="land_use",
                        studyArea="study_area",
                        landUseField=self.landUseSelectedField.name(),
                        targetItems=', '.join([
                            '"' + str(x) + '"' for x in self.getTargetItems()
                        ]),
                        sourceItems=', '.join(
                            ['"' + str(x) + '"' for x in sourceItems]),
                        # sourceValues=', '.join(
                        #     [str(x) for x in sourceValues]),
                        caseStatment=' '.join([
                            'WHEN "' + x + '" THEN ' + str(y)
                            for x, y in [[sourceItems[i], sourceValues[i]]
                                         for i in range(0, len(sourceItems))]
                        ]),
                        maxDistance=self.dlg.maxDistanceSpinBox.value(),
                        currentCRSID=currentCRSID)
            elif analysisType == 'Bounding boxes':
                if formulaType == 'Linear':
                    sql = '''
                        with s as (
                            select *, case {landUseField} {caseStatment} end as value, ST_Envelope(geom) as bbox
                            from {landUseLayer}
                            where {landUseField} in ({sourceItems})
                        ),
                        t as (
                                select *, ST_Envelope(geom) as bbox
                        from {landUseLayer}
                        where {landUseField} in ({targetItems})
                        )
                        SELECT AsWKT(st_ShortestLine(s.bbox,t.bbox)) as geomText,AsWKT(s.bbox) as sbbox,AsWKT(t.bbox) as tbbox, t.fid as tfid,s.fid as sfid,t.{landUseField}, st_distance(s.bbox,t.bbox) as distance, CASE
                                WHEN st_distance(s.bbox,t.bbox) = 0 then s.value
                                WHEN st_distance(s.bbox,t.bbox)>0 then (1-(st_distance(s.bbox,t.bbox)/{maxDistance}))*s.value
                        END as computed
                        FROM s,t
                        where PtDistWithin(s.bbox,t.bbox,{maxDistance})
                        '''.format(
                        landUseLayer="land_use",
                        studyArea="study_area",
                        landUseField=self.landUseSelectedField.name(),
                        targetItems=', '.join([
                            '"' + str(x) + '"' for x in self.getTargetItems()
                        ]),
                        sourceItems=', '.join(
                            ['"' + str(x) + '"' for x in sourceItems]),
                        # sourceValues=', '.join(
                        #     [str(x) for x in sourceValues]),
                        caseStatment=' '.join([
                            'WHEN "' + x + '" THEN ' + str(y)
                            for x, y in [[sourceItems[i], sourceValues[i]]
                                         for i in range(0, len(sourceItems))]
                        ]),
                        maxDistance=self.dlg.maxDistanceSpinBox.value(),
                        currentCRSID=currentCRSID)
                elif formulaType == 'Gaussian':
                    sql = '''
                        with s as (
                            select *, case {landUseField} {caseStatment} end as value, ST_Envelope(geom) as bbox
                            from {landUseLayer}
                            where {landUseField} in ({sourceItems})
                        ),
                        t as (
                                select *, ST_Envelope(geom) as bbox
                        from {landUseLayer}
                        where {landUseField} in ({targetItems})
                        )

                        SELECT AsWKT(st_ShortestLine(s.bbox,t.bbox)) as geomText,AsWKT(s.bbox) as sbbox,AsWKT(t.bbox) as tbbox,t.fid as tfid,s.fid as sfid,t.{landUseField}, st_distance(s.bbox,t.bbox) as distance, 
                        s.value*((power(2.718281828459045235360287471352662497757247093699959574966,(((st_distance(s.bbox,t.bbox)/{maxDistance}) * (st_distance(s.bbox,t.bbox)/{maxDistance}) * -4) + 0.92)))/sqrt(6.283185307179586476925286766559005768394338798750211641949)) as computed
                        FROM s,t
                        where PtDistWithin(s.bbox,t.bbox,{maxDistance})
                        '''.format(
                        landUseLayer="land_use",
                        studyArea="study_area",
                        landUseField=self.landUseSelectedField.name(),
                        targetItems=', '.join([
                            '"' + str(x) + '"' for x in self.getTargetItems()
                        ]),
                        sourceItems=', '.join(
                            ['"' + str(x) + '"' for x in sourceItems]),
                        # sourceValues=', '.join(
                        #     [str(x) for x in sourceValues]),
                        caseStatment=' '.join([
                            'WHEN "' + x + '" THEN ' + str(y)
                            for x, y in [[sourceItems[i], sourceValues[i]]
                                         for i in range(0, len(sourceItems))]
                        ]),
                        maxDistance=self.dlg.maxDistanceSpinBox.value(),
                        currentCRSID=currentCRSID)
            ResultSet = srcDataSource.ExecuteSQL(sql, dialect='SQLite')
            self.log('saving raw data')
            self.saveLayerIntoOgrPkg(ResultSet, srcDataSource, 'raw_data')
            ResultSet = None
            # progressMessageBar.setText('Extracting distance lines ...')
            # progress.setValue(80)
            self.log('Extracting lines')
            sql = '''
            SELECT ST_GeomFromText(a.geomText,{currentCRSID}) as geom, a.tfid as tfid, a.distance as distance, a.geomText, a.sfid, a.{landUseField}, a.computed as computed_value
            FROM {rawData} as a
            where a.distance>0
            '''.format(rawData="raw_data",
                       currentCRSID=currentCRSID,
                       landUseField=self.landUseSelectedField.name())

            ResultSet = srcDataSource.ExecuteSQL(sql, dialect='SQLite')
            self.saveLayerIntoOgrPkg(ResultSet, srcDataSource,
                                     'distance_lines')
            ResultSet = None
            self.log('Joinning poligons lines')
            # progressMessageBar.setText(
            #     'Agregating polygon computed values ...')
            # progress.setValue(80)
            sql = '''
                select t.geom as geom, t.fid, sum(r.computed) as computed_value
                from {rawData} as r, {landUseLayer}  as t
                where r.tfid=t.fid
                group by t.fid
            '''.format(rawData="raw_data", landUseLayer="land_use")
            ResultSet = srcDataSource.ExecuteSQL(sql, dialect='SQLite')
            self.saveLayerIntoOgrPkg(ResultSet, srcDataSource,
                                     'computed_poligons')

            rasterResol = self.dlg.outputRasterSizeBox.value()
            # Prepare for Rasterize
            # progressMessageBar.setText('Rasterizing results')
            # progress.setValue(95)
            pixelWidth = pixelHeight = rasterResol
            x_min, x_max, y_min, y_max = ResultSet.GetExtent()
            cols = int((x_max - x_min) / pixelHeight)
            rows = int((y_max - y_min) / pixelWidth)
            rasterPath = os.path.join(
                outputFolder, self.timestamp + '_' + analysisType + '_' +
                formulaType + '_computed.tif')
            target_ds = gdal.GetDriverByName('GTiff').Create(
                rasterPath, cols, rows, 1, gdal.GDT_Float32)
            target_ds.SetGeoTransform(
                (x_min, pixelWidth, 0, y_min, 0, pixelHeight))
            band = target_ds.GetRasterBand(1)
            band.FlushCache()
            band.SetNoDataValue(0)
            gdal.RasterizeLayer(
                target_ds, [1],
                ResultSet,
                options=['ATTRIBUTE=computed_value', 'noData=0'])
            target_dsSRS = osr.SpatialReference()
            target_dsSRS.ImportFromEPSG(currentCRSID)
            target_ds.SetProjection(target_dsSRS.ExportToWkt())
            band.FlushCache()
            band = None
            target_ds = None
            self.log('Load datasets')
            path_to_gpkg = os.path.join(
                outputFolder, 'output_result_' + analysisType + '_' +
                formulaType + '_') + self.timestamp + '.gpkg'
            gpkg_distance_layer = path_to_gpkg + "|layername=distance_lines"
            gpkg_polygons_layer = path_to_gpkg + "|layername=computed_poligons"
            vlayer = iface.addVectorLayer(gpkg_polygons_layer, "Polygons",
                                          "ogr")
            if not vlayer:
                self.log("Layer Polygons failed to load!")
            vlayer = iface.addVectorLayer(gpkg_distance_layer,
                                          "Distance lines", "ogr")
            if not vlayer:
                self.log("Layer Distance Lines failed to load!")
            vlayer = None
            iface.addRasterLayer(rasterPath, "Computed Values")
            iface.messageBar().clearWidgets()
            self.log('Finalized')
Ejemplo n.º 42
0
 def show_info(self, msg):
     QMessageBox.information(self.iface.mainWindow(), self.context, msg)
Ejemplo n.º 43
0
    def charge_layer_sqlite(self, sito, area, us):

        cfg_rel_path = os.path.join(os.sep, 'HFF_DB_folder', 'config.cfg')

        file_path = '{}{}'.format(self.HOME, cfg_rel_path)

        conf = open(file_path, "r")

        con_sett = conf.read()

        conf.close()

        settings = Settings(con_sett)

        settings.set_configuration()

        sqliteDB_path = os.path.join(os.sep, 'HFF_DB_folder',
                                     settings.DATABASE)

        db_file_path = '{}{}'.format(self.HOME, sqliteDB_path)

        uri = QgsDataSourceUri()

        uri.setDatabase(db_file_path)

        #srs = QgsCoordinateReferenceSystem(self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)

        gidstr = "scavo_s = '%s' and area_s = '%s' and us_s = '%d'" % (
            sito, area, us)

        #uri = QgsDataSourceUri()

        #uri.setDatabase(db_file_path)

        uri.setDataSource('', 'hff_system__us_view', 'the_geom', gidstr,
                          "ROWID")

        self.layerUS = QgsVectorLayer(uri.uri(), 'hff_system__us_view',
                                      'spatialite')

        if self.layerUS.isValid():

            #self.layerUS.setCrs(srs)

            self.USLayerId = self.layerUS.id()

            # self.mapLayerRegistry.append(USLayerId)

            style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE,
                                       'us_view.qml')

            self.layerUS.loadNamedStyle(style_path)

            self.iface.mapCanvas().setExtent(self.layerUS.extent())

            QgsProject.instance().addMapLayer(self.layerUS, True)

        else:

            QMessageBox.warning(None, "Errore", "Non Valido", QMessageBox.Ok)

            return 0

            # QMessageBox.warning(self, "Messaggio", "Geometria inesistente", QMessageBox.Ok)

        gidstr = "sito_q = '%s' and area_q = '%s' and us_q = '%d'" % (sito,
                                                                      area, us)

        uri.setDataSource('', 'hff_system__quote_view', 'the_geom', gidstr,
                          "ROWID")

        self.layerQuote = QgsVectorLayer(uri.uri(), 'hff_system__quote_view',
                                         'spatialite')

        if self.layerQuote.isValid():

            #self.layerQuote.setCrs(srs)

            self.QuoteLayerId = self.layerQuote.id()

            # self.mapLayerRegistry.append(QuoteLayerId)

            style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE,
                                       'stile_quote.qml')

            self.layerQuote.loadNamedStyle(style_path)

            QgsProject.instance().addMapLayer(self.layerQuote, True)
Ejemplo n.º 44
0
 def setWarning(self, msg):
     QMessageBox.warning(None, 'Could not complete GeoGig command', msg,
                         QMessageBox.Ok)
Ejemplo n.º 45
0
    def __init__(self, conn, cursor, raster, max_size, progress_label):
        QObject.__init__(self)
        self.cursor = cursor
        self.conn = conn
        self.progress_label = progress_label
        self.messages = ""

        opts = {}
        opts['version'] = g_rt_version
        opts['endian'] = NDR
        opts['column'] = 'rast'
        opts['create_table'] = 1
        opts['drop_table'] = 1
        opts['overview_level'] = 1
        opts['block_size'] = 'auto'
        opts['band'] = None
        opts['register'] = None

        # Create PostGIS Raster Tool Functions
        raster_tools_file = "%s/raster_tools.sql" % os.path.dirname(__file__)
        with open(raster_tools_file) as f:
            sql = f.read().encode('ascii', errors='ignore')
            f.close()

        self.cursor.execute(sql)
        self.conn.commit()

        i = 0

        # Burn all specified input raster files into single WKTRaster table
        gt = None
        layer_info = raster
        opts['srid'] = layer_info['layer'].dataProvider().crs().postgisSrid()
        infile = layer_info['data_source']

        file_info = QFileInfo(infile)
        file_size = file_info.size()
        size = DbConnections().db_size()
        file_size /= 1024 * 1024
        size = size + file_size

        if size > float(max_size):
            QMessageBox.warning(
                None, self.tr("Database full"),
                self.
                tr("Upload would exceeded the maximum database size for your current QGIS Cloud plan. Please free up some space or upgrade your QGIS Cloud plan."
                   ))
            return False

        opts['schema_table'] = "\"%s\".\"%s\"" % (layer_info['schema_name'],
                                                  layer_info['table_name'])
        opts['table'] = layer_info['table_name']
        opts['schema'] = layer_info['schema_name']

        self.progress_label.setText(
            self.tr("Creating table '{table}'...").format(
                table=opts['schema_table'].replace('"', '')))
        QApplication.processEvents()

        self.cursor.execute(
            self.make_sql_drop_raster_table(opts['schema_table']))
        self.conn.commit()

        self.cursor.execute(
            self.make_sql_create_table(opts, opts['schema_table']))
        self.conn.commit()

        gt = self.wkblify_raster(opts, infile.replace('\\', '/'), i, gt)
        i += 1

        self.cursor.execute(
            self.make_sql_create_gist(opts['schema_table'], opts['column']))
        self.conn.commit()

        # create raster overviews
        for level in [4, 8, 16, 32]:

            sql = 'drop table if exists "%s"."o_%d_%s"' % (
                opts['schema'], level, opts['table'])
            self.cursor.execute(sql)
            self.conn.commit()
            sql = "select st_createoverview_qgiscloud('%s'::text, '%s'::name, %d)" % (
                opts['schema_table'].replace('"', ''), opts['column'], level)
            self.progress_label.setText(
                self.tr(
                    "Creating overview-level {level} for table '{table}'...").
                format(level=level,
                       table=opts['schema_table'].replace('"', '')))
            QApplication.processEvents()
            self.cursor.execute(sql)
            self.conn.commit()

            index_table = opts['schema'] + '.o_' + str(
                level) + '_' + opts['table']
            self.cursor.execute(
                self.make_sql_create_gist(index_table, opts['column']))
            self.conn.commit()

        self.progress_label.setText(
            self.tr("Registering raster columns of table '%s'..." %
                    (opts['schema_table'].replace('"', ''))))
        QApplication.processEvents()
        self.cursor.execute(self.make_sql_addrastercolumn(opts))
        self.conn.commit()
Ejemplo n.º 46
0
    def on_pushButton_search_go_pressed(self):
        if self.BROWSE_STATUS != "f":
            QMessageBox.warning(
                self, "ATTENZIONE",
                "Per eseguire una nuova ricerca clicca sul pulsante 'new search' ",
                QMessageBox.Ok)
        else:
            search_dict = {
                self.TABLE_FIELDS[0]:
                "'" + str(self.comboBox_nome_tabella.currentText()) +
                "'",  # 1 - Nome tabella
                self.TABLE_FIELDS[1]:
                "'" + str(self.comboBox_sigla.currentText()) +
                "'",  # 2 - sigla
                self.TABLE_FIELDS[2]:
                "'" + str(self.comboBox_sigla_estesa.currentText()) +
                "'",  # 3 - sigla estesa
                self.TABLE_FIELDS[4]:
                "'" + str(self.comboBox_tipologia_sigla.currentText()) + "'"
                # 3 - tipologia sigla
            }

            u = Utility()
            search_dict = u.remove_empty_items_fr_dict(search_dict)

            if not bool(search_dict):
                QMessageBox.warning(
                    self, "ATTENZIONE",
                    "Non e' stata impostata alcuna ricerca!!!", QMessageBox.Ok)
            else:
                res = self.DB_MANAGER.query_bool(search_dict,
                                                 self.MAPPER_TABLE_CLASS)
                if not bool(res):
                    QMessageBox.warning(self, "ATTENZIONE",
                                        "Non e' stato trovato alcun record!",
                                        QMessageBox.Ok)

                    self.set_rec_counter(len(self.DATA_LIST),
                                         self.REC_CORR + 1)
                    self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
                        0]

                    self.fill_fields(self.REC_CORR)
                    self.BROWSE_STATUS = "b"
                    self.label_status.setText(
                        self.STATUS_ITEMS[self.BROWSE_STATUS])

                    self.setComboBoxEditable(["self.comboBox_sigla"], 1)
                    self.setComboBoxEditable(["self.comboBox_sigla_estesa"], 1)
                    self.setComboBoxEditable(["self.comboBox_tipologia_sigla"],
                                             1)
                    self.setComboBoxEditable(["self.comboBox_nome_tabella"], 1)

                    self.setComboBoxEnable(["self.comboBox_sigla"], "False")
                    self.setComboBoxEnable(["self.comboBox_sigla_estesa"],
                                           "False")
                    self.setComboBoxEnable(["self.comboBox_tipologia_sigla"],
                                           "False")
                    self.setComboBoxEnable(["self.comboBox_nome_tabella"],
                                           "False")

                    self.setComboBoxEnable(["self.textEdit_descrizione_sigla"],
                                           "True")

                else:
                    self.DATA_LIST = []

                    for i in res:
                        self.DATA_LIST.append(i)

                    self.REC_TOT, self.REC_CORR = len(self.DATA_LIST), 0
                    self.DATA_LIST_REC_TEMP = self.DATA_LIST_REC_CORR = self.DATA_LIST[
                        0]
                    self.fill_fields()
                    self.BROWSE_STATUS = "b"
                    self.label_status.setText(
                        self.STATUS_ITEMS[self.BROWSE_STATUS])
                    self.set_rec_counter(len(self.DATA_LIST),
                                         self.REC_CORR + 1)

                    if self.REC_TOT == 1:
                        strings = ("E' stato trovato", self.REC_TOT, "record")
                    else:
                        strings = ("Sono stati trovati", self.REC_TOT,
                                   "records")

                        self.setComboBoxEditable(["self.comboBox_sigla"], 1)
                        self.setComboBoxEditable(
                            ["self.comboBox_sigla_estesa"], 1)
                        self.setComboBoxEditable(
                            ["self.comboBox_tipologia_sigla"], 1)
                        self.setComboBoxEditable(
                            ["self.comboBox_nome_tabella"], 1)

                        self.setComboBoxEnable(["self.comboBox_sigla"],
                                               "False")
                        self.setComboBoxEnable(["self.comboBox_sigla_estesa"],
                                               "False")
                        self.setComboBoxEnable(
                            ["self.comboBox_tipologia_sigla"], "False")
                        self.setComboBoxEnable(["self.comboBox_nome_tabella"],
                                               "False")

                        self.setComboBoxEnable(
                            ["self.textEdit_descrizione_sigla"], "True")

                    QMessageBox.warning(self, "Messaggio",
                                        "%s %d %s" % strings, QMessageBox.Ok)

        self.enable_button_search(1)
 def about(self):
     infoString =  "Written by Richard Duivenvoorde\nEmail - [email protected]\n"
     infoString += "Company - Zuidt - http://www.zuidt.nl\n"
     infoString += "Source: https://github.com/rduivenvoorde/pdokservicesplugin"
     QMessageBox.information(self.iface.mainWindow(), "Pdok Services Plugin About", infoString)
 def loadService(self):
     if self.currentLayer == None:
         return
     servicetype = self.currentLayer['type']
     url = self.currentLayer['url']
     # some services have an url with query parameters in it, we have to urlencode those:
     location,query = urllib.parse.splitquery(url)
     url = location
     # RD: 20200820: lijkt of het quoten van de query problemen geeft bij WFS, is/was dit nodig???
     #if query != None and query != '':
     #    url +=('?'+urllib.parse.quote_plus(query))
     title = self.currentLayer['title']
     if 'style' in self.currentLayer:
         style = self.currentLayer['style']
         title = title + ' [' + style + ']'
     else:
         style = '' # == default for this service
     layers = self.currentLayer['layers']
     # mmm, tricky: we take the first one while we can actually want png/gif or jpeg
     if servicetype == "wms":
         imgformat = self.currentLayer['imgformats'].split(',')[0]
         if self.dlg.ui.comboSelectProj.currentIndex() == -1:
             crs = 'EPSG:28992'
         else:
             crs = self.dlg.ui.comboSelectProj.currentText()
         if Qgis.QGIS_VERSION_INT < 10900:
             # qgis <= 1.8
             uri = url
             self.iface.addRasterLayer(
                 uri, # service uri
                 title, # name for layer (as seen in QGIS)
                 "wms", # dataprovider key
                 [layers], # array of layername(s) for provider (id's)
                 [""], # array of stylename(s)  NOTE: ignoring styles here!!!
                 imgformat, # image format searchstring
                 crs) # crs code searchstring
         else:
             # qgis > 1.8
             uri = "crs="+crs+"&layers="+layers+"&styles="+style+"&format="+imgformat+"&url="+url;
             self.iface.addRasterLayer(uri, title, "wms")
     elif servicetype == "wmts":
         if Qgis.QGIS_VERSION_INT < 10900:
             QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ("Sorry, dit type layer: '"+servicetype.upper()+"' \nkan niet worden geladen in deze versie van QGIS.\nMisschien kunt u QGIS 2.0 installeren (die kan het WEL)?\nOf is de laag niet ook beschikbaar als wms of wfs?"), QMessageBox.Ok, QMessageBox.Ok)
             return
         if self.dlg.ui.comboSelectProj.currentIndex() == -1:
             tilematrixset = 'EPSG:28992'
         else:
             tilematrixset = self.dlg.ui.comboSelectProj.currentText()
         imgformat = self.currentLayer['imgformats'].split(',')[0]
         # special case for luchtfoto
         #if layers=="luchtfoto":
         #    # tileMatrixSet=nltilingschema&crs=EPSG:28992&layers=luchtfoto&styles=&format=image/jpeg&url=http://geodata1.nationaalgeoregister.nl/luchtfoto/wmts/1.0.0/WMTSCapabilities.xml
         #    # {u'layers': u'luchtfoto', u'imgformats': u'image/jpeg', u'title': u'PDOK-achtergrond luchtfoto', u'url': u'http://geodata1.nationaalgeoregister.nl/luchtfoto/wms', u'abstract': u'', u'tilematrixsets': u'nltilingschema', u'type': u'wmts'}
         #    uri = "tileMatrixSet="+tilematrixsets+"&crs=EPSG:28992&layers="+layers+"&styles=&format="+imgformat+"&url="+url
         #else:
         #    uri = "tileMatrixSet="+tilematrixsets+"&crs=EPSG:28992&layers="+layers+"&styles=&format="+imgformat+"&url="+url;
         #uri = "tileMatrixSet="+tilematrixsets+"&crs=EPSG:28992&layers="+layers+"&styles=default&format="+imgformat+"&url="+url;
         if tilematrixset.startswith('EPSG:'):
             crs=tilematrixset
             i = crs.find(':', 5)
             if i > -1:
                 crs=crs[:i]
         elif tilematrixset.startswith('OGC:1.0'):
             crs='EPSG:3857'
         uri = "tileMatrixSet="+tilematrixset+"&crs="+crs+"&layers="+layers+"&styles=default&format="+imgformat+"&url="+url;
         #print "############ PDOK URI #################"
         #print uri
         self.iface.addRasterLayer(uri, title, "wms")
     elif servicetype == "wfs":
         location, query = urllib.parse.splitquery(url)
         #uri = location+"?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetFeature&TYPENAME="+layers+"&SRSNAME=EPSG:28992"
         #uri = location + "?SERVICE=WFS&REQUEST=GetFeature&TYPENAME=" + layers + "&SRSNAME=EPSG:28992"
         # adding a bbox paramater forces QGIS to NOT cache features but retrieve new features all the time
         # QGIS will update the BBOX to the right value
         #uri += "&BBOX=-10000,310000,290000,650000"
         uri = " pagingEnabled='true' restrictToRequestBBOX='1' srsname='EPSG:28992' typename='"+layers+"' url='"+url+"' version='2.0.0' "
         self.iface.addVectorLayer(uri, title, "WFS")
     elif servicetype == "wcs":
         # cache=AlwaysCache&crs=EPSG:28992&format=GeoTIFF&identifier=ahn25m:ahn25m&url=http://geodata.nationaalgeoregister.nl/ahn25m/wcs
         uri = ''
         # cache=AlwaysCache
         # cache=PreferNetwork
         # cache=AlwaysNetwork
         # cache=AlwaysNetwork&crs=EPSG:28992&format=GeoTIFF&identifier=ahn25m:ahn25m&url=http://geodata.nationaalgeoregister.nl/ahn25m/wcs
         #uri = "cache=AlwaysNetwork&crs=EPSG:28992&format=image/tiff&version=1.1.1&identifier="+layers+"&url="+url
         # working for ahn1 ahn2 and ahn3: GEOTIFF_FLOAT32
         format = 'GEOTIFF_FLOAT32'
         # working for ahn25m is only image/tiff
         if layers=='ahn25m':
             format = 'image/tiff'
         # we handcrated some wcs layers with 2 different image formats: tiff (RGB) and tiff (float32):
         if 'imgformats' in self.currentLayer:
             format = self.currentLayer['imgformats'].split(',')[0]
         uri = "cache=AlwaysNetwork&crs=EPSG:28992&format="+format+"&identifier=" + layers + "&url=" + url
         #uri = "cache=AlwaysNetwork&crs=EPSG:28992&format="+format+"&version=1.1.2&identifier=" + layers + "&url=" + url
         #uri = "cache=AlwaysNetwork&crs=EPSG:28992&format=image/tiff&version=1.1.2&identifier=" + layers + "&url=" + url
         self.iface.addRasterLayer(uri, title, "wcs")
     else:
         QMessageBox.warning(self.iface.mainWindow(), "PDOK plugin", ("Sorry, dit type layer: '"+servicetype.upper()+"' \nkan niet worden geladen door de plugin of door QGIS.\nIs het niet beschikbaar als wms, wmts of wfs?"), QMessageBox.Ok, QMessageBox.Ok)
         return
Ejemplo n.º 49
0
    def accept(self):
        # sanity checks
        if self.editOutputFile.text() == "":
            QMessageBox.information(self, self.tr("Export to file"),
                                    self.tr("Output file name is required"))
            return

        if self.chkSourceSrid.isEnabled() and self.chkSourceSrid.isChecked():
            try:
                sourceSrid = int(self.editSourceSrid.text())
            except ValueError:
                QMessageBox.information(
                    self, self.tr("Export to file"),
                    self.tr("Invalid source srid: must be an integer"))
                return

        if self.chkTargetSrid.isEnabled() and self.chkTargetSrid.isChecked():
            try:
                targetSrid = int(self.editTargetSrid.text())
            except ValueError:
                QMessageBox.information(
                    self, self.tr("Export to file"),
                    self.tr("Invalid target srid: must be an integer"))
                return

        with OverrideCursor(Qt.WaitCursor):
            # store current input layer crs, so I can restore it later
            prevInCrs = self.inLayer.crs()
            try:
                uri = self.editOutputFile.text()
                providerName = "ogr"

                options = {}

                # set the OGR driver will be used
                driverName = self.cboFileFormat.currentData()
                options['driverName'] = driverName

                # set the output file encoding
                if self.chkEncoding.isEnabled() and self.chkEncoding.isChecked(
                ):
                    enc = self.cboEncoding.currentText()
                    options['fileEncoding'] = enc

                if self.chkDropTable.isChecked():
                    options['overwrite'] = True

                outCrs = QgsCoordinateReferenceSystem()
                if self.chkTargetSrid.isEnabled(
                ) and self.chkTargetSrid.isChecked():
                    targetSrid = int(self.editTargetSrid.text())
                    outCrs = QgsCoordinateReferenceSystem(targetSrid)

                # update input layer crs
                if self.chkSourceSrid.isEnabled(
                ) and self.chkSourceSrid.isChecked():
                    sourceSrid = int(self.editSourceSrid.text())
                    inCrs = QgsCoordinateReferenceSystem(sourceSrid)
                    self.inLayer.setCrs(inCrs)

                # do the export!
                ret, errMsg = QgsVectorLayerExporter.exportLayer(
                    self.inLayer, uri, providerName, outCrs, False, options)
            except Exception as e:
                ret = -1
                errMsg = str(e)

            finally:
                # restore input layer crs and encoding
                self.inLayer.setCrs(prevInCrs)

        if ret != 0:
            QMessageBox.warning(self, self.tr("Export to file"),
                                self.tr("Error {0}\n{1}").format(ret, errMsg))
            return

        # create spatial index
        # if self.chkSpatialIndex.isEnabled() and self.chkSpatialIndex.isChecked():
        #       self.db.connector.createSpatialIndex( (schema, table), geom )

        QMessageBox.information(self, self.tr("Export to file"),
                                self.tr("Export finished."))
        return QDialog.accept(self)
    def convert(self):
        """
        Convert the project to a portable project.

        :param offline_editing: The offline editing instance
        :param export_folder:   The folder to export to
        """

        project = QgsProject.instance()
        original_project = project

        original_project_path = project.fileName()
        project_filename, _ = os.path.splitext(os.path.basename(original_project_path))

        # Write a backup of the current project to a temporary file
        project_backup_folder = tempfile.mkdtemp()
        backup_project_path = os.path.join(project_backup_folder, project_filename + '.qgs')
        QgsProject.instance().write(backup_project_path)

        try:
            if not os.path.exists(self.export_folder):
                os.makedirs(self.export_folder)

            QApplication.setOverrideCursor(Qt.WaitCursor)

            self.__offline_layers = list()
            self.__layers = list(project.mapLayers().values())

            original_layer_info = {}
            for layer in self.__layers:
                original_layer_info[layer.id()] = (layer.source(), layer.name())

            self.total_progress_updated.emit(0, 1, self.trUtf8('Creating base map…'))
            # Create the base map before layers are removed
            if self.project_configuration.create_base_map:
                if 'processing' not in qgis.utils.plugins:
                    QMessageBox.warning(None, self.tr('QFieldSync requires processing'), self.tr('Creating a basemap with QFieldSync requires the processing plugin to be enabled. Processing is not enabled on your system. Please go to Plugins > Manage and Install Plugins and enable processing.'))
                    return

                if self.project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER:
                    self.createBaseMapLayer(None, self.project_configuration.base_map_layer,
                                            self.project_configuration.base_map_tile_size,
                                            self.project_configuration.base_map_mupp)
                else:
                    self.createBaseMapLayer(self.project_configuration.base_map_theme, None,
                                            self.project_configuration.base_map_tile_size,
                                            self.project_configuration.base_map_mupp)

            # Loop through all layers and copy/remove/offline them
            pathResolver = QgsProject.instance().pathResolver()
            copied_files = list()
            for current_layer_index, layer in enumerate(self.__layers):
                self.total_progress_updated.emit(current_layer_index - len(self.__offline_layers), len(self.__layers),
                                                 self.trUtf8('Copying layers…'))

                layer_source = LayerSource(layer)
                if not layer_source.is_supported:
                     project.removeMapLayer(layer)
                     continue

                if layer.dataProvider() is not None:
                    md = QgsProviderRegistry.instance().providerMetadata(layer.dataProvider().name())
                    if md is not None:
                        decoded = md.decodeUri(layer.source())
                        if "path" in decoded:
                            path = pathResolver.writePath(decoded["path"])
                            if path.startswith("localized:"):
                                # Layer stored in localized data path, skip
                                continue

                if layer_source.action == SyncAction.OFFLINE:
                    if self.project_configuration.offline_copy_only_aoi:
                        layer.selectByRect(self.extent)
                    self.__offline_layers.append(layer)
                elif layer_source.action == SyncAction.NO_ACTION:
                    copied_files = layer_source.copy(self.export_folder, copied_files)
                elif layer_source.action == SyncAction.KEEP_EXISTENT:
                    layer_source.copy(self.export_folder, copied_files, True)
                elif layer_source.action == SyncAction.REMOVE:
                    project.removeMapLayer(layer)

            project_path = os.path.join(self.export_folder, project_filename + "_qfield.qgs")

            # save the original project path
            ProjectConfiguration(project).original_project_path = original_project_path

            # save the offline project twice so that the offline plugin can "know" that it's a relative path
            QgsProject.instance().write(project_path)

            # export the DCIM folder
            copy_images(os.path.join(os.path.dirname(original_project_path), "DCIM"),
                        os.path.join(os.path.dirname(project_path), "DCIM"))
            try:
                # Run the offline plugin for gpkg
                gpkg_filename = "data.gpkg"
                if self.__offline_layers:
                    offline_layer_ids = [l.id() for l in self.__offline_layers]
                    if not self.offline_editing.convertToOfflineProject(self.export_folder, gpkg_filename,
                                                                        offline_layer_ids,
                                                                        self.project_configuration.offline_copy_only_aoi, self.offline_editing.GPKG):
                        raise Exception(self.tr("Error trying to convert layers to offline layers"))

            except AttributeError:
                # Run the offline plugin for spatialite
                spatialite_filename = "data.sqlite"
                if self.__offline_layers:
                    offline_layer_ids = [l.id() for l in self.__offline_layers]
                    if not self.offline_editing.convertToOfflineProject(self.export_folder, spatialite_filename,
                                                                        offline_layer_ids,
                                                                        self.project_configuration.offline_copy_only_aoi):
                        raise Exception(self.tr("Error trying to convert layers to offline layers"))

            # Disable project options that could create problems on a portable
            # project with offline layers
            if self.__offline_layers:
                QgsProject.instance().setEvaluateDefaultValues(False)
                QgsProject.instance().setAutoTransaction(False)

                # check if value relations point to offline layers and adjust if necessary
                for layer in project.mapLayers().values():
                    if layer.type() == QgsMapLayer.VectorLayer:
                        for field in layer.fields():
                            ews = field.editorWidgetSetup()
                            if ews.type() == 'ValueRelation':
                                widget_config = ews.config()
                                online_layer_id = widget_config['Layer']
                                if project.mapLayer(online_layer_id):
                                    continue

                                layer_id = None
                                loose_layer_id = None
                                for offline_layer in project.mapLayers().values():
                                    if offline_layer.customProperty('remoteSource') == original_layer_info[online_layer_id][0]:
                                        #  First try strict matching: the offline layer should have a "remoteSource" property
                                        layer_id = offline_layer.id()
                                        break
                                    elif offline_layer.name().startswith(original_layer_info[online_layer_id][1] + ' '):
                                        #  If that did not work, go with loose matching
                                        #    The offline layer should start with the online layer name + a translated version of " (offline)"
                                        loose_layer_id = offline_layer.id()
                                widget_config['Layer'] = layer_id or loose_layer_id
                                offline_ews = QgsEditorWidgetSetup(ews.type(), widget_config)
                                layer.setEditorWidgetSetup(layer.fields().indexOf(field.name()), offline_ews)

            # Now we have a project state which can be saved as offline project
            QgsProject.instance().write(project_path)
        finally:
            # We need to let the app handle events before loading the next project or QGIS will crash with rasters
            QCoreApplication.processEvents()
            QgsProject.instance().clear()
            QCoreApplication.processEvents()
            QgsProject.instance().read(backup_project_path)
            QgsProject.instance().setFileName(original_project_path)
            QApplication.restoreOverrideCursor()

        self.offline_editing.layerProgressUpdated.disconnect(self.on_offline_editing_next_layer)
        self.offline_editing.progressModeSet.disconnect(self.on_offline_editing_max_changed)
        self.offline_editing.progressUpdated.disconnect(self.offline_editing_task_progress)

        self.total_progress_updated.emit(100, 100, self.tr('Finished'))
Ejemplo n.º 51
0
 def veureInfo(self):
     if self.info is not None:
         box = QMessageBox(self)
         box.setWindowTitle('Info del mapa simbòlic')
         txt = '<table width="600">'
         params = self.info.split('\n')
         for param in params:
             linea = param.strip()
             if linea.endswith(':'):
                 linea += ' ---'
             txt += '<tr><td><nobr>&middot;&nbsp;{}</nobr></td></tr>'.format(linea)
         txt += '</table>'
         box.setTextFormat(Qt.RichText)
         box.setText("Paràmetres d'agregació de dades:")
         box.setInformativeText(txt)
         box.setIcon(QMessageBox.Information)
         box.setStandardButtons(QMessageBox.Ok)
         box.setDefaultButton(QMessageBox.Ok)
         box.exec()
Ejemplo n.º 52
0
try:
    import visvis
except Exception as e:
    missing_libraries.append(str(e))

install_libraries = []
for l in missing_libraries:
    p = re.findall(r"'(.*?)'", l)
    install_libraries.append(p[0])

if install_libraries:
    from qgis.PyQt.QtWidgets import QMessageBox

    res = QMessageBox.warning(
        None, 'PyArchInit',
        "Some of the required packages are missing from your machine:\n{}\n\n"
        "Do you want install the missing packages?".format(
            ',\n'.join(missing_libraries)),
        QMessageBox.Ok | QMessageBox.Cancel)
    if res == QMessageBox.Ok:
        import subprocess

        try:
            cmd = 'python3'
            subprocess.call(
                [
                    cmd, '{}'.format(
                        os.path.join(os.path.dirname(__file__), 'scripts',
                                     'modules_installer.py')),
                    ','.join(install_libraries)
                ],
                shell=True if Pyarchinit_OS_Utility.isWindows() else False)
Ejemplo n.º 53
0
 def msgAvis(self, txt):
     QMessageBox.warning(self, 'Avís', txt)
Ejemplo n.º 54
0
 def msgError(self, txt):
     QMessageBox.critical(self, 'Error', txt)
Ejemplo n.º 55
0
    def __init__(self):
        """ Initialize data objects, starts fetching if appropriate, and warn about/removes obsolete plugins """

        QObject.__init__(
            self)  # initialize QObject in order to to use self.tr()
        repositories.load()
        plugins.getAllInstalled()

        if repositories.checkingOnStart() and repositories.timeForChecking(
        ) and repositories.allEnabled():
            # start fetching repositories
            self.statusLabel = QLabel(
                self.tr("Looking for new plugins...") + " ",
                iface.mainWindow().statusBar())
            iface.mainWindow().statusBar().insertPermanentWidget(
                0, self.statusLabel)
            self.statusLabel.linkActivated.connect(
                self.showPluginManagerWhenReady)
            repositories.checkingDone.connect(self.checkingDone)
            for key in repositories.allEnabled():
                repositories.requestFetching(key)
        else:
            # no fetching at start, so mark all enabled repositories as requesting to be fetched.
            for key in repositories.allEnabled():
                repositories.setRepositoryData(key, "state", 3)

        # look for obsolete plugins (the user-installed one is newer than core one)
        for key in plugins.obsoletePlugins:
            plugin = plugins.localCache[key]
            msg = QMessageBox()
            msg.setIcon(QMessageBox.Warning)
            msg.setWindowTitle(self.tr("QGIS Python Plugin Installer"))
            msg.addButton(self.tr("Uninstall (recommended)"),
                          QMessageBox.AcceptRole)
            msg.addButton(self.tr("I will uninstall it later"),
                          QMessageBox.RejectRole)
            msg.setText("%s <b>%s</b><br/><br/>%s" % (
                self.tr("Obsolete plugin:"), plugin["name"],
                self.
                tr("QGIS has detected an obsolete plugin that masks its more recent version shipped with this copy of QGIS. This is likely due to files associated with a previous installation of QGIS. Do you want to remove the old plugin right now and unmask the more recent version?"
                   )))
            msg.exec_()
            if not msg.result():
                # uninstall, update utils and reload if enabled
                self.uninstallPlugin(key, quiet=True)
                updateAvailablePlugins()
                settings = QSettings()
                if settings.value("/PythonPlugins/" + key, False, type=bool):
                    settings.setValue("/PythonPlugins/watchDog/" + key, True)
                    loadPlugin(key)
                    startPlugin(key)
                    settings.remove("/PythonPlugins/watchDog/" + key)
Ejemplo n.º 56
0
 def msgContinuarProces(self, txt):
     QApplication.instance().restoreOverrideCursor()
     res = QMessageBox.question(self, 'Atenció', txt + "\n\nVol continuar?")
     QApplication.instance().setOverrideCursor(Qt.WaitCursor)
     return res == QMessageBox.Yes
Ejemplo n.º 57
0
 def error(self, text):
     QMessageBox.critical(self, "Error", text)
     QgsMessageLog.logMessage(text, self.tr('Processing'), Qgis.Critical)
Ejemplo n.º 58
0
 def clearTable(self, removeAll=False):
     res = QMessageBox.question(
         self, self.tr('Clear?'),
         self.tr('Are you sure you want to clear table?'))
     if res == QMessageBox.Yes:
         self.tblView.model().clear()
Ejemplo n.º 59
0
    def installPlugin(self, key, quiet=False):
        """ Install given plugin """
        error = False
        infoString = ('', '')
        plugin = plugins.all()[key]
        previousStatus = plugin["status"]
        if not plugin:
            return
        if plugin["status"] == "newer" and not plugin[
                "error"]:  # ask for confirmation if user downgrades an usable plugin
            if QMessageBox.warning(
                    iface.mainWindow(),
                    self.tr("QGIS Python Plugin Installer"),
                    self.
                    tr("Are you sure you want to downgrade the plugin to the latest available version? The installed one is newer!"
                       ), QMessageBox.Yes, QMessageBox.No) == QMessageBox.No:
                return

        dlg = QgsPluginInstallerInstallingDialog(iface.mainWindow(), plugin)
        dlg.exec_()

        if dlg.result():
            error = True
            infoString = (self.tr("Plugin installation failed"), dlg.result())
        elif not QDir(qgis.utils.home_plugin_path + "/" + key).exists():
            error = True
            infoString = (
                self.tr("Plugin has disappeared"),
                self.
                tr("The plugin seems to have been installed but I don't know where. Probably the plugin package contained a wrong named directory.\nPlease search the list of installed plugins. I'm nearly sure you'll find the plugin there, but I just can't determine which of them it is. It also means that I won't be able to determine if this plugin is installed and inform you about available updates. However the plugin may work. Please contact the plugin author and submit this issue."
                   ))
            QApplication.setOverrideCursor(Qt.WaitCursor)
            plugins.getAllInstalled()
            plugins.rebuild()
            self.exportPluginsToManager()
            QApplication.restoreOverrideCursor()
        else:
            QApplication.setOverrideCursor(Qt.WaitCursor)
            # update the list of plugins in plugin handling routines
            updateAvailablePlugins()
            # try to load the plugin
            loadPlugin(plugin["id"])
            plugins.getAllInstalled(testLoad=True)
            plugins.rebuild()
            plugin = plugins.all()[key]
            if not plugin["error"]:
                if previousStatus in ["not installed", "new"]:
                    infoString = (self.tr("Plugin installed successfully"), "")
                    if startPlugin(plugin["id"]):
                        settings = QSettings()
                        settings.setValue("/PythonPlugins/" + plugin["id"],
                                          True)
                else:
                    settings = QSettings()
                    if settings.value(
                            "/PythonPlugins/" + key, False, type=bool
                    ):  # plugin will be reloaded on the fly only if currently loaded
                        reloadPlugin(
                            key)  # unloadPlugin + loadPlugin + startPlugin
                        infoString = (
                            self.tr("Plugin reinstalled successfully"), "")
                    else:
                        unloadPlugin(
                            key
                        )  # Just for a case. Will exit quietly if really not loaded
                        loadPlugin(key)
                        infoString = (
                            self.tr("Plugin reinstalled successfully"),
                            self.
                            tr("Python plugin reinstalled.\nYou need to restart QGIS in order to reload it."
                               ))
                if quiet:
                    infoString = (None, None)
                QApplication.restoreOverrideCursor()
            else:
                QApplication.restoreOverrideCursor()
                if plugin["error"] == "incompatible":
                    message = self.tr(
                        "The plugin is not compatible with this version of QGIS. It's designed for QGIS versions:"
                    )
                    message += " <b>" + plugin["error_details"] + "</b>"
                elif plugin["error"] == "dependent":
                    message = self.tr(
                        "The plugin depends on some components missing on your system. You need to install the following Python module in order to enable it:"
                    )
                    message += "<b> " + plugin["error_details"] + "</b>"
                else:
                    message = self.tr("The plugin is broken. Python said:")
                    message += "<br><b>" + plugin["error_details"] + "</b>"
                dlg = QgsPluginInstallerPluginErrorDialog(
                    iface.mainWindow(), message)
                dlg.exec_()
                if dlg.result():
                    # revert installation
                    pluginDir = qgis.utils.home_plugin_path + "/" + plugin["id"]
                    result = removeDir(pluginDir)
                    if QDir(pluginDir).exists():
                        error = True
                        infoString = (self.tr("Plugin uninstall failed"),
                                      result)
                        try:
                            exec("sys.path_importer_cache.clear()")
                            exec("import %s" % plugin["id"])
                            exec("reload (%s)" % plugin["id"])
                        except:
                            pass
                    else:
                        try:
                            exec("del sys.modules[%s]" % plugin["id"])
                        except:
                            pass
                    plugins.getAllInstalled()
                    plugins.rebuild()

            self.exportPluginsToManager()

        if infoString[0]:
            level = error and QgsMessageBar.CRITICAL or QgsMessageBar.INFO
            msg = "<b>%s:</b>%s" % (infoString[0], infoString[1])
            iface.pluginManagerInterface().pushMessage(msg, level)
Ejemplo n.º 60
0
def showWarning(msg):
    QMessageBox.information(iface.mainWindow(), 'Warning', msg)