def openScript(self):
if self.hasChanged:
ret = QMessageBox.warning(self, self.tr('Unsaved changes'),
self.tr('There are unsaved changes in script. Continue?'),
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if ret == QMessageBox.No:
return
if self.algType == self.SCRIPT_PYTHON:
scriptDir = ScriptUtils.scriptsFolders()[0]
filterName = self.tr('Python scripts (*.py)')
elif self.algType == self.SCRIPT_R:
scriptDir = RUtils.RScriptsFolders()[0]
filterName = self.tr('Processing R script (*.rsx)')
self.filename, fileFilter = QFileDialog.getOpenFileName(
self, self.tr('Open script'), scriptDir, filterName)
if self.filename == '':
return
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
with codecs.open(self.filename, 'r', encoding='utf-8') as f:
txt = f.read()
self.editor.setText(txt)
self.hasChanged = False
self.editor.setModified(False)
self.editor.recolor()
QApplication.restoreOverrideCursor()
def canvasReleaseEvent(self, e):
point = self.plugin.transform(
self.iface.mapCanvas().getCoordinateTransform().toMapCoordinates(e.x(), e.y())
)
QApplication.setOverrideCursor(Qt.WaitCursor)
fs = self.plugin.highlight(
where=u"st_contains(wkb_geometry,st_geomfromtext('POINT(%.3lf %.3lf)'::text,%d))" % (
point.x(), point.y(), self.plugin.getepsg()
)
)
if len(fs) == 0:
QApplication.restoreOverrideCursor()
QMessageBox.information(None, u"Fehler", u"Kein Flurstück gefunden.")
return
try:
s = QSettings("norBIT", "EDBSgen/PRO")
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("localhost", int(s.value("norGISPort", "6102"))))
sock.send("NORGIS_MAIN#EDBS#ALBKEY#{}#".format(fs[0]['flsnr']).encode("utf-8"))
sock.close()
if win32:
window = win32gui.FindWindow(None, s.value("albWin", "norGIS"))
win32gui.SetForegroundWindow(window)
except socket.error:
QMessageBox.information(None, u"Fehler", u"Verbindung zu norGIS schlug fehl.")
QApplication.restoreOverrideCursor()
def canvasReleaseEvent(self, e):
point = self.iface.mapCanvas().getCoordinateTransform().toMapCoordinates(e.x(), e.y())
point = self.plugin.transform(point)
p = "POINT(%.3lf %.3lf)" % (point.x(), point.y())
try:
QApplication.setOverrideCursor(Qt.WaitCursor)
fs = self.plugin.retrieve(u"st_contains(wkb_geometry,st_geomfromtext('{}'::text,{}))".format(
p, self.plugin.getepsg()
))
if not self.plugin.logQuery("eigentuemerInfo", p, [i['flsnr'] for i in fs]):
QMessageBox.information(None, u"Hinweis", u"Flurstücke werden ohne Protokollierung nicht angezeigt.")
return
if len(fs) == 0:
QMessageBox.information(None, u"Hinweis", u"Kein Flurstück gefunden.")
return
fs = self.plugin.highlight(fs=fs, zoomTo=False)
finally:
QApplication.restoreOverrideCursor()
page = self.getPage(fs)
if page is not None:
Info.showInfo(self.plugin, page, fs[0]['gmlid'], self.iface.mainWindow())
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()
def runAction(self, action):
action = unicode(action)
if action.startswith("vacuumanalyze/"):
if action == "vacuumanalyze/run":
self.runVacuumAnalyze()
return True
elif action.startswith("rule/"):
parts = action.split('/')
rule_name = parts[1]
rule_action = parts[2]
msg = u"Do you want to %s rule %s?" % (rule_action, rule_name)
QApplication.restoreOverrideCursor()
try:
if QMessageBox.question(None, self.tr("Table rule"), msg,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return False
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
if rule_action == "delete":
self.aboutToChange.emit()
self.database().connector.deleteTableRule(rule_name, (self.schemaName(), self.name))
self.refreshRules()
return True
return Table.runAction(self, action)
def runAction(self, action):
action = str(action)
if action.startswith("spatialindex/"):
parts = action.split('/')
spatialIndex_action = parts[1]
msg = QApplication.translate("DBManagerPlugin", "Do you want to %s spatial index for field %s?") % (
spatialIndex_action, self.geomColumn)
QApplication.restoreOverrideCursor()
try:
if QMessageBox.question(None, QApplication.translate("DBManagerPlugin", "Spatial Index"), msg,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return False
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
if spatialIndex_action == "create":
self.createSpatialIndex()
return True
elif spatialIndex_action == "delete":
self.deleteSpatialIndex()
return True
if action.startswith("extent/"):
if action == "extent/get":
self.refreshTableExtent()
return True
if action == "extent/estimated/get":
self.refreshTableEstimatedExtent()
return True
return Table.runAction(self, action)
def refresh_databases(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
if self.clouddb:
db_list = self.api.read_databases()
if self.show_api_error(db_list):
QApplication.restoreOverrideCursor()
return
self.db_connections = DbConnections()
for db in db_list:
self.db_connections.add_from_json(db)
self.ui.tabDatabases.clear()
self.ui.btnDbDelete.setEnabled(False)
self.ui.cbUploadDatabase.clear()
self.ui.cbUploadDatabase.setEditable(True)
self.ui.cbUploadDatabase.lineEdit().setReadOnly(True)
if self.db_connections.count() == 0:
self.ui.cbUploadDatabase.setEditText(self.tr("No databases"))
else:
for name, db in list(self.db_connections.iteritems()):
it = QListWidgetItem(name)
it.setToolTip(db.description())
self.ui.tabDatabases.addItem(it)
self.ui.cbUploadDatabase.addItem(name)
if self.ui.cbUploadDatabase.count() > 1:
# Display the "Select database" text if more than one db is available
self.ui.cbUploadDatabase.setCurrentIndex(-1)
self.ui.cbUploadDatabase.setEditText(self.tr("Select database"))
self.db_connections.refresh(self.user)
self.db_size(self.db_connections)
QApplication.restoreOverrideCursor()
def zip_db(self):
force_another_db = False
dbpath=None
if self.db:
use_current_db = utils.Askuser("YesNo",'Vill du göra backup av %s?'%self.db,'Which database?')
if use_current_db.result == 1:
dbpath = self.db
force_another_db = False
elif use_current_db.result == 0:
force_another_db = True
elif use_current_db.result == '':
return
if not self.db or force_another_db:
dbpath = QFileDialog.getOpenFileName(None, 'Ange db som du vill skapa backup utav','',"Spatialite (*.sqlite)")[0]
if dbpath:
QApplication.setOverrideCursor(Qt.WaitCursor)
connection = utils.dbconnection(dbpath)
connection.connect2db()
connection.conn.cursor().execute("begin immediate")
file_path = os.path.realpath(dbpath)
dir_path = os.path.dirname(file_path)
current_dir = dir_path.split(os.sep)[-1]
bkupname = dbpath + datetime.datetime.now().strftime('%Y%m%dT%H%M') + '.zip'
zf = zipfile.ZipFile(bkupname, mode='w')
zf.write(dbpath,os.path.basename(dbpath), compress_type=compression) #compression will depend on if zlib is found or not
zf.close()
connection.conn.rollback()
connection.closedb()
self.iface.messageBar().pushMessage("Information","Database backup was written to " + bkupname, 1,duration=15)
QApplication.restoreOverrideCursor()
def createGeomColumn(self):
""" first check whether everything's fine """
if self.editName.text() == "":
QMessageBox.critical(self, self.tr("DB Manager"), self.tr("field name must not be empty"))
return
name = self.editName.text()
geom_type = self.GEOM_TYPES[self.cboType.currentIndex()]
dim = self.spinDim.value()
try:
srid = int(self.editSrid.text())
except ValueError:
srid = -1
createSpatialIndex = False
# now create the geometry column
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.table.addGeometryColumn(name, geom_type, srid, dim, createSpatialIndex)
except DbError as e:
DlgDbError.showError(e, self)
return
finally:
QApplication.restoreOverrideCursor()
self.accept()
def editColumn(self):
""" open dialog to change column info and alter table appropriately """
index = self.currentColumn()
if index == -1:
return
m = self.viewFields.model()
# get column in table
# (there can be missing number if someone deleted a column)
fld = m.getObject(index)
dlg = DlgFieldProperties(self, fld, self.table)
if not dlg.exec_():
return
new_fld = dlg.getField(True)
QApplication.setOverrideCursor(Qt.WaitCursor)
self.aboutToChangeTable.emit()
try:
fld.update(new_fld.name, new_fld.type2String(), new_fld.notNull, new_fld.default2String())
self.populateViews()
except BaseError as e:
DlgDbError.showError(e, self)
return
finally:
QApplication.restoreOverrideCursor()
def setData(self, index, value, role):
if role != Qt.EditRole or index.column() != 0:
return False
item = index.internalPointer()
new_value = unicode(value)
if isinstance(item, SchemaItem) or isinstance(item, TableItem):
obj = item.getItemData()
# rename schema or table or view
if new_value == obj.name:
return False
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
obj.rename(new_value)
self._onDataChanged(index)
except BaseError as e:
DlgDbError.showError(e, self.treeView)
return False
finally:
QApplication.restoreOverrideCursor()
return True
return False
def deleteConstraint(self):
""" delete a constraint """
index = self.currentConstraint()
if index == -1:
return
m = self.viewConstraints.model()
constr = m.getObject(index)
res = QMessageBox.question(self, self.tr("Are you sure"),
self.tr("really delete constraint '%s'?") % constr.name,
QMessageBox.Yes | QMessageBox.No)
if res != QMessageBox.Yes:
return
QApplication.setOverrideCursor(Qt.WaitCursor)
self.aboutToChangeTable.emit()
try:
constr.delete()
self.populateViews()
except BaseError as e:
DlgDbError.showError(e, self)
return
finally:
QApplication.restoreOverrideCursor()
def updateAlgsList():
"""Call this method when there has been any change that
requires the list of algorithms to be created again from
algorithm providers.
"""
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
Processing.loadFromProviders()
QApplication.restoreOverrideCursor()
def execute(func):
try:
QCoreApplication.processEvents()
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
return func()
finally:
QApplication.restoreOverrideCursor()
QCoreApplication.processEvents()
def addLessons(self):
ret, __ = QFileDialog.getOpenFileName(self, "Select lessons ZIP file" , "", '*.zip')
if ret:
try:
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
installLessonsFromZipFile(ret)
self.fillTree()
finally:
QApplication.restoreOverrideCursor()
def runAction(self, action):
action = str(action)
if action.startswith("rows/"):
if action == "rows/count":
self.refreshRowCount()
return True
elif action.startswith("triggers/"):
parts = action.split('/')
trigger_action = parts[1]
msg = QApplication.translate("DBManagerPlugin", "Do you want to %s all triggers?") % trigger_action
QApplication.restoreOverrideCursor()
try:
if QMessageBox.question(None, QApplication.translate("DBManagerPlugin", "Table triggers"), msg,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return False
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
if trigger_action == "enable" or trigger_action == "disable":
enable = trigger_action == "enable"
self.aboutToChange.emit()
self.database().connector.enableAllTableTriggers(enable, (self.schemaName(), self.name))
self.refreshTriggers()
return True
elif action.startswith("trigger/"):
parts = action.split('/')
trigger_name = parts[1]
trigger_action = parts[2]
msg = QApplication.translate("DBManagerPlugin", "Do you want to %s trigger %s?") % (
trigger_action, trigger_name)
QApplication.restoreOverrideCursor()
try:
if QMessageBox.question(None, QApplication.translate("DBManagerPlugin", "Table trigger"), msg,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return False
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
if trigger_action == "delete":
self.aboutToChange.emit()
self.database().connector.deleteTableTrigger(trigger_name, (self.schemaName(), self.name))
self.refreshTriggers()
return True
elif trigger_action == "enable" or trigger_action == "disable":
enable = trigger_action == "enable"
self.aboutToChange.emit()
self.database().connector.enableTableTrigger(trigger_name, enable, (self.schemaName(), self.name))
self.refreshTriggers()
return True
return False
def tabChanged(self, index):
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.refreshTabs()
except BaseError as e:
DlgDbError.showError(e, self)
return
finally:
QApplication.restoreOverrideCursor()
def createTable(self):
""" create table with chosen fields, optionally add a geometry column """
if not self.hasSchemas:
schema = None
else:
schema = str(self.cboSchema.currentText())
if len(schema) == 0:
QMessageBox.information(self, self.tr("DB Manager"), self.tr("select schema!"))
return
table = str(self.editName.text())
if len(table) == 0:
QMessageBox.information(self, self.tr("DB Manager"), self.tr("enter table name!"))
return
m = self.fields.model()
if m.rowCount() == 0:
QMessageBox.information(self, self.tr("DB Manager"), self.tr("add some fields!"))
return
useGeomColumn = self.chkGeomColumn.isChecked()
if useGeomColumn:
geomColumn = str(self.editGeomColumn.text())
if len(geomColumn) == 0:
QMessageBox.information(self, self.tr("DB Manager"), self.tr("set geometry column name"))
return
geomType = self.GEOM_TYPES[self.cboGeomType.currentIndex()]
geomDim = self.spinGeomDim.value()
try:
geomSrid = int(self.editGeomSrid.text())
except ValueError:
geomSrid = 0
useSpatialIndex = self.chkSpatialIndex.isChecked()
flds = m.getFields()
pk_index = self.cboPrimaryKey.currentIndex()
if pk_index >= 0:
flds[pk_index].primaryKey = True
# commit to DB
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
if not useGeomColumn:
self.db.createTable(table, flds, schema)
else:
geom = geomColumn, geomType, geomSrid, geomDim, useSpatialIndex
self.db.createVectorTable(table, flds, geom, schema)
except (ConnectionError, DbError) as e:
DlgDbError.showError(e, self)
return
finally:
QApplication.restoreOverrideCursor()
QMessageBox.information(self, self.tr("Good"), self.tr("everything went fine"))
def grabHTTP(self, url, loadFunction, arguments=None):
"""Grab distant content via QGIS internal classes and QtNetwork."""
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
request = QUrl(url)
reply = self.manager.get(QNetworkRequest(request))
if arguments:
reply.finished.connect(partial(loadFunction, reply, arguments))
else:
reply.finished.connect(partial(loadFunction, reply))
def run(item, action, mainwindow):
from .dlg_versioning import DlgVersioning
dlg = DlgVersioning(item, mainwindow)
QApplication.restoreOverrideCursor()
try:
dlg.exec_()
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
def loadSqlLayer(self):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
try:
layer = self._getSqlLayer(self.filter)
if layer is None:
return
QgsProject.instance().addMapLayers([layer], True)
finally:
QApplication.restoreOverrideCursor()
def getHtmlFromTemplate(self, tplPath, replaceDict):
'''
Get the content of a template file
and replace all variables with given data
'''
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
return super().getHtmlFromTemplate(tplPath, replaceDict)
finally:
QApplication.restoreOverrideCursor()
def deleteActionSlot(self, item, action, parent):
if isinstance(item, Schema):
self.deleteSchemaActionSlot(item, action, parent)
elif isinstance(item, Table):
self.deleteTableActionSlot(item, action, parent)
else:
QApplication.restoreOverrideCursor()
parent.infoBar.pushMessage(QApplication.translate("DBManagerPlugin", "Cannot delete the selected item."),
QgsMessageBar.INFO, parent.iface.messageTimeout())
QApplication.setOverrideCursor(Qt.WaitCursor)
def uninstallPlugin(self, key, quiet=False):
""" Uninstall given plugin """
if key in plugins.all():
plugin = plugins.all()[key]
else:
plugin = plugins.localCache[key]
if not plugin:
return
if not quiet:
warning = self.tr("Are you sure you want to uninstall the following plugin?") + "\n(" + plugin["name"] + ")"
if plugin["status"] == "orphan" and not plugin["error"]:
warning += "\n\n" + self.tr("Warning: this plugin isn't available in any accessible repository!")
if (
QMessageBox.warning(
iface.mainWindow(),
self.tr("QGIS Python Plugin Installer"),
warning,
QMessageBox.Yes,
QMessageBox.No,
)
== QMessageBox.No
):
return
# unload the plugin
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
unloadPlugin(key)
except:
pass
pluginDir = qgis.utils.home_plugin_path + "/" + plugin["id"]
result = removeDir(pluginDir)
if result:
QApplication.restoreOverrideCursor()
msg = "<b>%s:</b>%s" % (self.tr("Plugin uninstall failed"), result)
iface.pluginManagerInterface().pushMessage(msg, QgsMessageBar.CRITICAL)
else:
# safe remove
try:
unloadPlugin(plugin["id"])
except:
pass
try:
exec("plugins[%s].unload()" % plugin["id"])
exec("del plugins[%s]" % plugin["id"])
except:
pass
try:
exec("del sys.modules[%s]" % plugin["id"])
except:
pass
plugins.getAllInstalled()
plugins.rebuild()
self.exportPluginsToManager()
QApplication.restoreOverrideCursor()
iface.pluginManagerInterface().pushMessage(self.tr("Plugin uninstalled successfully"), QgsMessageBar.INFO)
def publish_map(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
srs=QgsMapSettings().destinationCrs()
if "USER" in srs.authid():
QMessageBox.warning(None, self.tr('Warning!'), self.tr("The project has a user defined CRS. The use of user defined CRS is not supported. Please correct the project CRS before publishing!"))
QApplication.restoreOverrideCursor()
return
layer_dict = QgsProject.instance().mapLayers()
layers = list(layer_dict.values())
layerList = ''
for layer in layers:
if "USER" in layer.crs().authid():
layerList += "'"+layer.name()+"' "
if len(layerList) > 0:
QMessageBox.warning(None, self.tr('Warning!'), self.tr("The layer(s) {layerlist}have user defined CRS. The use of user defined CRS is not supported. Please correct the CRS before publishing!").format(layerlist=layerList))
QApplication.restoreOverrideCursor()
return
saved = self.check_project_saved()
if not saved:
self.statusBar().showMessage(self.tr("Cancelled"))
elif self.check_login() and self.check_layers():
self.statusBar().showMessage(self.tr("Publishing map"))
try:
fullExtent = self.iface.mapCanvas().fullExtent()
config = {
'fullExtent': {
'xmin': fullExtent.xMinimum(),
'ymin': fullExtent.yMinimum(),
'xmax': fullExtent.xMaximum(),
'ymax': fullExtent.yMaximum()
#},
# 'svgPaths': QgsApplication.svgPaths() #For resolving absolute symbol paths in print composer
}
}
fname = str(QgsProject.instance().fileName())
map = self.api.create_map( self.map(), fname, config)['map']
self.show_api_error(map)
if map['config']['missingSvgSymbols']:
self.publish_symbols(map['config']['missingSvgSymbols'])
self.update_urls()
self._push_message(self.tr("QGIS Cloud"), self.tr(
"Map successfully published"), level=0, duration=2)
self.statusBar().showMessage(
self.tr("Map successfully published"))
except Exception as e:
self.statusBar().showMessage("")
ErrorReportDialog(self.tr("Error uploading project"), self.tr("An error occured."), str(e) + "\n" + traceback.format_exc(), self.user, self).exec_()
self.refresh_maps()
QApplication.restoreOverrideCursor()
def navigate(self):
"""manage navigation / paging"""
caller = self.sender().objectName()
if caller == 'btnFirst':
self.startfrom = 0
elif caller == 'btnLast':
self.startfrom = self.catalog.results['matches'] - self.maxrecords
elif caller == 'btnNext':
self.startfrom += self.maxrecords
if self.startfrom >= self.catalog.results["matches"]:
msg = self.tr('End of results. Go to start?')
res = QMessageBox.information(self, self.tr('Navigation'),
msg,
(QMessageBox.Ok |
QMessageBox.Cancel))
if res == QMessageBox.Ok:
self.startfrom = 0
else:
return
elif caller == "btnPrev":
self.startfrom -= self.maxrecords
if self.startfrom <= 0:
msg = self.tr('Start of results. Go to end?')
res = QMessageBox.information(self, self.tr('Navigation'),
msg,
(QMessageBox.Ok |
QMessageBox.Cancel))
if res == QMessageBox.Ok:
self.startfrom = (self.catalog.results['matches'] -
self.maxrecords)
else:
return
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
try:
self.catalog.getrecords2(constraints=self.constraints,
maxrecords=self.maxrecords,
startposition=self.startfrom, esn='full')
except ExceptionReport as err:
QApplication.restoreOverrideCursor()
QMessageBox.warning(self, self.tr('Search error'),
self.tr('Search error: %s') % err)
return
except Exception as err:
QApplication.restoreOverrideCursor()
QMessageBox.warning(self, self.tr('Connection error'),
self.tr('Connection error: %s') % err)
return
QApplication.restoreOverrideCursor()
self.display_results()
def runVacuumActionSlot(self, item, action, parent):
QApplication.restoreOverrideCursor()
try:
if not isinstance(item, (DBPlugin, Table)) or item.database() is None:
parent.infoBar.pushMessage(self.tr("No database selected or you are not connected to it."),
QgsMessageBar.INFO, parent.iface.messageTimeout())
return
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
self.runVacuum()
def runRefreshMaterializedViewSlot(self, item, action, parent):
QApplication.restoreOverrideCursor()
try:
if not isinstance(item, PGTable) or item._relationType != 'm':
parent.infoBar.pushMessage(self.tr("Select a materialized view for refresh."), QgsMessageBar.INFO,
parent.iface.messageTimeout())
return
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
item.runRefreshMaterializedView()
def createTableActionSlot(self, item, action, parent):
QApplication.restoreOverrideCursor()
if not hasattr(item, 'database') or item.database() is None:
parent.infoBar.pushMessage(
QApplication.translate("DBManagerPlugin", "No database selected or you are not connected to it."),
QgsMessageBar.INFO, parent.iface.messageTimeout())
return
from ..dlg_create_table import DlgCreateTable
DlgCreateTable(item, parent).exec_()
QApplication.setOverrideCursor(Qt.WaitCursor)
def moveTableToSchemaActionSlot(self, item, action, parent, new_schema):
QApplication.restoreOverrideCursor()
try:
if not isinstance(item, Table):
parent.infoBar.pushMessage(QApplication.translate("DBManagerPlugin", "Select a table/view."),
QgsMessageBar.INFO, parent.iface.messageTimeout())
return
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
item.moveToSchema(new_schema)
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
self.project_dir = self.settings.value("project/projectdir")
self.project_id = self.settings.value("project/id")
locale = QSettings().value('locale/userLocale')[
0:2] # this is for multilingual legends
if locale == "fr":
pass
elif locale == "it":
pass
else:
locale = "de"
if not project_id:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_PNF_Baugebiet", "project_id not "
"set", None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_PNF_Baugebiet",
"Checklayer - Bebautes Gebiet", None)
group += " (" + str(project_id) + ")"
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "BB.Objektname 'u.'", None),
"featuretype":
"t_bbobj_u",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Objektname 'u.'", None),
"featuretype":
"t_eoobj_u",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.Treppe nicht ein Objekt", None),
"featuretype":
"t_treppe_modellbildung",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.Flächenelement 'übrig. Geb.teil' freistehend",
None),
"featuretype":
"t_gebteil_frei",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate(
"VeriSO_PNF_Baugebiet",
"EO.Linienelement 'übrig. Geb.teil' ausserhalb Gebäude",
None),
"featuretype":
"t_gebteil_ausserhalb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate(
"VeriSO_PNF_Baugebiet",
"EO.Flächenelement 'übrig. Geb.teil' innerhalb Gebäude",
None),
"featuretype":
"t_gebteil_geb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Pfeiler im Gebäude",
None),
"featuretype":
"t_pfeiler_gebaeude",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.uebriger_Gebaeudeteil < 1.5 m2", None),
"featuretype":
"t_gebteil_15",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "Ein EO.Objekt pro Element",
None),
"featuretype":
"t_eo_modellbildung",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB. Wasserbecken mit EO.Mauer", None),
"featuretype":
"t_mauer_wasserbecken",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Linienelement Mauer",
None),
"featuretype":
"t_mauer_linien",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate(
"VeriSO_PNF_Baugebiet",
"EO Linienelement Mauer ausserhalb EO.Flächenelement Mauer",
None),
"featuretype":
"t_mauer_ausserhalb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Mauer freistehend",
None),
"featuretype":
"t_mauer_freistehend",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Mauer nicht ein Objekt",
None),
"featuretype":
"t_mauer_modellbildung",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB.Gebaeude ohne Gartenanlage", None),
"featuretype":
"t_abgrenzung_gartenanlage",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB.Gebaeude ohne Erschliessung", None),
"featuretype":
"t_geb_ohne_ersch",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "BB.Parkplatz < 100 m2",
None),
"featuretype":
"t_pp_kleiner_100",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"BB.Gebaeude mit mehreren Adressen", None),
"featuretype":
"t_2_gebein",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "BB.Gebaeude < 6 m2", None),
"featuretype":
"t_gebaeude_kleiner_6",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet",
"EO.Linienelement unterird. Gebaeude", None),
"featuretype":
"t_u_geb_linien",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_PNF_Baugebiet", "EO.Unterstand auf Gebäude",
None),
"featuretype":
"t_unterstand_auf_geb",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"checks/checklayer_punkt.qml"
}
vlayer = self.layer_loader.load(layer, True, False)
except Exception:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage(
"Error",
str(traceback.format_exc(exc_traceback)),
level=QgsMessageBar.CRITICAL,
duration=0)
QApplication.restoreOverrideCursor()
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_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())
self.total_progress_updated.emit(0, 1,
self.tr('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
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.tr('Copying layers'))
layer_source = LayerSource(layer)
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)
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"
))
# 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.total_progress_updated.emit(100, 100, self.tr('Finished'))
def accept(self):
alg_parameters = []
load = []
feedback = self.createFeedback()
context = dataobjects.createContext(feedback)
for row in range(self.mainWidget.tblParameters.rowCount()):
col = 0
parameters = {}
for param in self.alg.parameterDefinitions():
if param.flags(
) & QgsProcessingParameterDefinition.FlagHidden or param.isDestination(
):
continue
wrapper = self.mainWidget.wrappers[row][col]
parameters[param.name()] = wrapper.value()
if not param.checkValueIsAcceptable(wrapper.value(), context):
self.bar.pushMessage(
"",
self.tr(
'Wrong or missing parameter value: {0} (row {1})').
format(param.description(), row + 1),
level=QgsMessageBar.WARNING,
duration=5)
return
col += 1
count_visible_outputs = 0
for out in self.alg.destinationParameterDefinitions():
if out.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
count_visible_outputs += 1
widget = self.mainWidget.tblParameters.cellWidget(row, col)
text = widget.getValue()
if param.checkValueIsAcceptable(text, context):
if isinstance(out, (QgsProcessingParameterRasterOutput,
QgsProcessingParameterFeatureSink)):
# load rasters and sinks on completion
parameters[
out.name()] = QgsProcessingOutputLayerDefinition(
text, context.project())
else:
parameters[out.name()] = text
col += 1
else:
self.bar.pushMessage(
"",
self.tr('Wrong or missing output value: {0} (row {1})'
).format(out.description(), row + 1),
level=QgsMessageBar.WARNING,
duration=5)
return
alg_parameters.append(parameters)
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.mainWidget.setEnabled(False)
self.buttonCancel.setEnabled(True)
# Make sure the Log tab is visible before executing the algorithm
try:
self.tabWidget.setCurrentIndex(1)
self.repaint()
except:
pass
start_time = time.time()
algorithm_results = []
for count, parameters in enumerate(alg_parameters):
if feedback.isCanceled():
break
self.setText(
self.tr('\nProcessing algorithm {0}/{1}...').format(
count + 1, len(alg_parameters)))
self.setInfo(self.tr('<b>Algorithm {0} starting...</b>').format(
self.alg.displayName()),
escape_html=False)
feedback.pushInfo(self.tr('Input parameters:'))
feedback.pushCommandInfo(pformat(parameters))
feedback.pushInfo('')
alg_start_time = time.time()
ret, results = execute(self.alg, parameters, context, feedback)
if ret:
self.setInfo(
self.tr('Algorithm {0} correctly executed...').format(
self.alg.displayName()),
escape_html=False)
feedback.setProgress(100)
feedback.pushInfo(
self.tr('Execution completed in {0:0.2f} seconds'.format(
time.time() - alg_start_time)))
feedback.pushInfo(self.tr('Results:'))
feedback.pushCommandInfo(pformat(results))
feedback.pushInfo('')
algorithm_results.append(results)
else:
break
feedback.pushInfo(
self.tr('Batch execution completed in {0:0.2f} seconds'.format(
time.time() - start_time)))
handleAlgorithmResults(self.alg, context, feedback, False)
self.finish(algorithm_results)
self.buttonCancel.setEnabled(False)
def execute(func):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
try:
return func()
finally:
QApplication.restoreOverrideCursor()
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
locale = QSettings().value('locale/userLocale')[0:2]
if not project_id:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_EE_Geb_LokTest", "project_id not set",
None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_EE_Geb_LokTest",
"Gebaeudeadressen - Lokalisationstest", None)
group += " (" + str(project_id) + ")"
# TODO: Check "tid" vs. t_ili_tid... in queries. Do not import
# i_ili_tid?
# define layer names here
lokalisation = _translate("VeriSO_EE_Geb_LokTest",
"Lokalisation Lokalisationstest", None)
strassenstueck_geometrie = _translate(
"VeriSO_EE_Geb_LokTest", "Strassenstueck (geometrie) "
"Lokalisationstest", None)
strassenstueck_anfangspunkt = _translate(
"VeriSO_EE_Geb_LokTest", "Strassenstueck ("
"anfangspunkt) "
"Lokalisationstest", None)
benanntesgebiet = _translate("VeriSO_EE_Geb_LokTest",
"Benanntes Gebiet Lokalisationstest",
None)
gebaeudeeingang = _translate("VeriSO_EE_Geb_LokTest",
"Gebaeudeeingang Lokalisationstest",
None)
shortestline = _translate("VeriSO_EE_Geb_LokTest",
"Kuerzeste Linie Lokalisationstest",
None)
hausnummerpos = _translate("VeriSO_EE_Geb_LokTest",
"HausnummerPos Lokalisationstest", None)
lokalisationsname = _translate("VeriSO_EE_Geb_LokTest",
"LokalisationsName", None)
vlayer_lokalisation = self.get_vector_layer_by_name(lokalisation)
if not vlayer_lokalisation:
layer = {
"type": "postgres",
"title": lokalisation,
"featuretype": "gebaeudeadressen_lokalisation",
"key": "ogc_fid",
"sql": "ogc_fid = -1",
"readonly": True,
"group": group
}
vlayer_lokalisation = self.layer_loader.load(layer)
vlayer_strassenstueck_geometrie = self.get_vector_layer_by_name(
strassenstueck_geometrie)
if not vlayer_strassenstueck_geometrie:
layer = {
"type":
"postgres",
"title":
"Strassenstueck (geometrie) Lokalisationstest",
"featuretype":
"gebaeudeadressen_strassenstueck",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"strassenstueck_von = -1",
"readonly":
True,
"group":
group,
"style":
"global_qml/gebaeudeadressen/strassenachsen_rot"
".qml"
}
vlayer_strassenstueck_geometrie = self.layer_loader.load(layer)
vlayer_strassenstueck_anfangspunkt = self.get_vector_layer_by_name(
strassenstueck_anfangspunkt)
if not vlayer_strassenstueck_anfangspunkt:
layer = {
"type": "postgres",
"title": "Strassenstueck (anfangspunkt) Lokalisationstest",
"featuretype": "gebaeudeadressen_strassenstueck",
"geom": "anfangspunkt",
"key": "ogc_fid",
"sql": "strassenstueck_von = -1",
"readonly": True,
"group": group,
"style": "global_qml/gebaeudeadressen/anfangspunkt_rot.qml"
}
vlayer_strassenstueck_anfangspunkt = self.layer_loader.load(
layer)
vlayer_benanntesgebiet = self.get_vector_layer_by_name(
benanntesgebiet)
if not vlayer_benanntesgebiet:
layer = {
"type":
"postgres",
"title":
"Benanntes Gebiet Lokalisationstest",
"featuretype":
"gebaeudeadressen_benanntesgebiet",
"geom":
"flaeche",
"key":
"ogc_fid",
"sql":
"benanntesgebiet_von = -1",
"readonly":
True,
"group":
group,
"style":
"global_qml/gebaeudeadressen/benanntesgebiet_rot"
".qml"
}
vlayer_benanntesgebiet = self.layer_loader.load(layer)
vlayer_gebaeudeeingang = self.get_vector_layer_by_name(
gebaeudeeingang)
if not vlayer_gebaeudeeingang:
layer = {
"type":
"postgres",
"title":
"Gebaeudeeingang Lokalisationstest",
"featuretype":
"gebaeudeadressen_gebaeudeeingang",
"geom":
"lage",
"key":
"ogc_fid",
"sql":
"gebaeudeeingang_von = -1",
"readonly":
True,
"group":
group,
"style":
"global_qml/gebaeudeadressen/gebaeudeeingang_rot"
".qml"
}
vlayer_gebaeudeeingang = self.layer_loader.load(layer)
vlayer_shortestline = self.get_vector_layer_by_name(shortestline)
if not vlayer_shortestline:
layer = {
"type":
"postgres",
"title":
"Kuerzeste Linie Lokalisationstest",
"featuretype":
"t_shortestline_hausnummerpos",
"geom":
"the_geom",
"key":
"ogc_fid",
"sql":
"lok_tid = -1",
"readonly":
True,
"group":
group,
"style":
"global_qml/gebaeudeadressen/shortestline_linie_rot.qml"
}
vlayer_shortestline = self.layer_loader.load(layer)
vlayer_hausnummerpos = self.get_vector_layer_by_name(hausnummerpos)
if not vlayer_hausnummerpos:
layer = {
"type": "postgres",
"title": "HausnummerPos Lokalisationstest",
"featuretype": "v_gebaeudeadressen_hausnummerpos",
"geom": "pos",
"key": "ogc_fid",
"sql": "lok_tid = -1",
"readonly": True,
"group": group,
"style":
"global_qml/gebaeudeadressen/hausnummerpos_rot.qml"
}
vlayer_hausnummerpos = self.layer_loader.load(layer)
vlayer_lokalisationsname = self.get_vector_layer_by_name(
lokalisationsname)
if not vlayer_lokalisationsname:
self.message_bar.pushMessage(
"Error",
_translate("VeriSO_EE_Geb_LokTest",
"Layer _LokalisationsName_ not found.", None),
level=Qgis.Critical,
duration=0)
QApplication.restoreOverrideCursor()
return
iterator = vlayer_lokalisationsname.getFeatures()
ids = []
for feature in iterator:
ids.append(feature.id())
if vlayer_lokalisationsname.selectedFeatureCount() < 1:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_EE_Geb_LokTest",
"No _LokalisationsName_ selected.", None))
QApplication.restoreOverrideCursor()
return
if vlayer_lokalisationsname.selectedFeatureCount() > 1:
self.message_bar.pushCritical(
"Error",
_translate(
"VeriSO_EE_Geb_LokTest",
"Please select only one (1) _LokalisationsName_.",
None))
QApplication.restoreOverrideCursor()
return
feat = QgsFeature()
id = vlayer_lokalisationsname.selectedFeatureIds()[0]
feat = vlayer_lokalisationsname.selectedFeatures()[0]
idx = ids.index(id)
benannte_idx = vlayer_lokalisationsname.lookupField("benannte")
text_idx = vlayer_lokalisationsname.lookupField("atext")
if benannte_idx == -1 or text_idx == -1:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_EE_Geb_LokTest",
"Field _benannte_ or _text_ not found.", None))
QApplication.restoreOverrideCursor()
return
benannte = feat.attributes()[benannte_idx]
lokalisationsname = feat.attributes()[text_idx]
vlayer_strassenstueck_geometrie.setSubsetString(
"(strassenstueck_von = " + str(benannte) + ")")
vlayer_strassenstueck_anfangspunkt.setSubsetString(
"(strassenstueck_von = " + str(benannte) + ")")
vlayer_benanntesgebiet.setSubsetString("(benanntesgebiet_von = " +
str(benannte) + ")")
vlayer_gebaeudeeingang.setSubsetString("(gebaeudeeingang_von = " +
str(benannte) + ")")
vlayer_lokalisation.setSubsetString("(ogc_fid = " + str(benannte) +
")")
vlayer_shortestline.setSubsetString("(lok_tid = " + str(benannte) +
")")
vlayer_hausnummerpos.setSubsetString("(lok_tid = " +
str(benannte) + ")")
if vlayer_strassenstueck_geometrie.featureCount() > 0:
x_min = vlayer_strassenstueck_geometrie.extent().xMinimum()
y_min = vlayer_strassenstueck_geometrie.extent().yMinimum()
x_max = vlayer_strassenstueck_geometrie.extent().xMaximum()
y_max = vlayer_strassenstueck_geometrie.extent().yMaximum()
if vlayer_benanntesgebiet.featureCount() > 0:
x_min = vlayer_benanntesgebiet.extent().xMinimum()
y_min = vlayer_benanntesgebiet.extent().yMinimum()
x_max = vlayer_benanntesgebiet.extent().xMaximum()
y_max = vlayer_benanntesgebiet.extent().yMaximum()
try:
if vlayer_gebaeudeeingang.featureCount() > 0:
if vlayer_gebaeudeeingang.extent().xMinimum() < x_min:
x_min = vlayer_gebaeudeeingang.extent().xMinimum()
if vlayer_gebaeudeeingang.extent().yMinimum() < y_min:
y_min = vlayer_gebaeudeeingang.extent().yMinimum()
if vlayer_gebaeudeeingang.extent().xMaximum() > x_max:
x_max = vlayer_gebaeudeeingang.extent().xMaximum()
if vlayer_gebaeudeeingang.extent().yMaximum() > y_max:
y_max = vlayer_gebaeudeeingang.extent().yMaximum()
rect = QgsRectangle(x_min, y_min, x_max, y_max)
rect.scale(1.3)
except UnboundLocalError:
vlayer_gemeindegrenze = self.getVectorLayerByName(
"Gemeindegrenze")
if vlayer_gemeindegrenze is None:
rect = self.canvas.fullExtent()
else:
rect = vlayer_gemeindegrenze.extent()
self.iface.mapCanvas().setExtent(rect)
self.iface.mapCanvas().refresh()
iterator = vlayer_lokalisation.getFeatures()
# only one feature is selected
for feature in iterator:
prinzip_idx = vlayer_lokalisation.lookupField(
"nummerierungsprinzip_txt")
attributeprovisorisch_idx = vlayer_lokalisation.lookupField(
"attributeprovisorisch_txt")
offiziell_idx = vlayer_lokalisation.lookupField(
"istoffiziellebezeichnung_txt")
status_idx = vlayer_lokalisation.lookupField("status_txt")
inaenderung_idx = vlayer_lokalisation.lookupField(
"inaenderung_txt")
art_idx = vlayer_lokalisation.lookupField("art_txt")
something_missing = (prinzip_idx == -1
or attributeprovisorisch_idx == -1
or offiziell_idx == -1 or status_idx == -1
or inaenderung_idx == -1 or art_idx == -1)
if something_missing:
self.message_bar.pushMessage("Error",
_translate(
"VeriSO_EE_Geb_LokTest",
"Field not found.", None),
level=Qgis.Critical,
duration=0)
QApplication.restoreOverrideCursor()
return
prinzip = feature.attributes()[prinzip_idx]
attributeprovisorisch = feature.attributes(
)[attributeprovisorisch_idx]
offiziell = feature.attributes()[offiziell_idx]
status = feature.attributes()[status_idx]
inaenderung = feature.attributes()[inaenderung_idx]
art = feature.attributes()[art_idx]
map_extent = self.canvas.extent()
x = map_extent.xMinimum()
y = map_extent.yMaximum()
text_item_found = False
items = list(self.iface.mapCanvas().scene().items())
for i in range(len(items)):
try:
name = items[i].data(0)
if str(name) == "LokalisationsInfo":
text_item = items[i]
text_item_found = True
except Exception:
pass
if not text_item_found:
text_item = QgsTextAnnotation(self.canvas)
# text_item.setData(0, "LokalisationsInfo")
# noinspection PyUnboundLocalVariable
text_item.setMapPosition(
QgsPointXY(x + 10 * self.canvas.mapUnitsPerPixel(),
y - 10 * self.canvas.mapUnitsPerPixel()))
text_item.setHasFixedMapPosition(False)
# text_item.setFrameBorderWidth(0.0)
# text_item.setFrameColor(QColor(250, 250, 250, 255))
# text_item.setFrameBackgroundColor(QColor(250, 250, 250, 123))
text_item.setFrameSize(QSizeF(250, 150))
text_document = QTextDocument()
text_document.setHtml(
"<table style='font-size:12px;'><tr><td>Lok.Name: </td><td>" +
lokalisationsname + "</td></tr><tr><td>TID: </td><td>" +
str(benannte) + "</td></tr> <tr><td>Num.prinzip: "
"</td><td>" + str(prinzip) +
"</td></tr> <tr><td>Attr. prov.: </td><td>" +
str(attributeprovisorisch) + "</td></tr> <tr><td>ist "
"offiziell: </td><td>" + str(offiziell) +
"</td></tr> <tr><td>Status: "
"</td><td>" + str(status) + "</td></tr> <tr><td>in Aenderung: "
"</td><td>" + str(inaenderung) + "</td></tr> <tr><td>Art: "
"</td><td>" + str(art) + "</td></tr> </table>")
text_item.setDocument(text_document)
# This is a workaround: first ever position is not correct.
text_item.setMapPosition(
QgsPointXY(x + 10 * self.canvas.mapUnitsPerPixel(),
y - 10 * self.canvas.mapUnitsPerPixel()))
text_item.update()
self.iface.mapCanvas().refresh()
try:
vlayer_lokalisationsname.selectByIds([ids[idx + 1]])
except IndexError:
self.message_bar.pushInfo(
"Information",
_translate("VeriSO_EE_Geb_LokTest", "End of table.", None))
except Exception as e:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage(
"Error",
str(traceback.format_exc(exc_traceback)),
level=Qgis.Critical,
duration=0)
QApplication.restoreOverrideCursor()
def get_z_max_z_min(self):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
rec = QgsRectangle(self.roi_x_min, self.roi_y_min, self.roi_x_max, self.roi_y_max)
canvasCRS = self.map_crs
dataCRS = self.layer.crs()
if canvasCRS != dataCRS:
transform = QgsCoordinateTransform(canvasCRS, dataCRS, QgsProject.instance())
rec = transform.transform(rec)
x_max = rec.xMaximum()
x_min = rec.xMinimum()
y_max = rec.yMaximum()
y_min = rec.yMinimum()
x_off = int(math.floor((x_min - self.raster_x_min) * self.cols / (self.raster_x_max - self.raster_x_min)))
y_off = int(math.floor((self.raster_y_max - y_max) * self.rows / (self.raster_y_max - self.raster_y_min)))
col_size = int(math.floor((x_max - x_min) / self.cell_size))
row_size = int(math.floor((y_max - y_min) / self.cell_size))
if x_off < 0:
x_off = 0
if y_off < 0:
y_off = 0
if x_off >= self.cols:
x_off = self.cols - 1
if y_off >= self.rows:
y_off = self.rows - 1
if x_off + col_size > self.cols:
col_size = self.cols - x_off
if row_size + row_size > self.rows:
row_size = self.rows - y_off
provider = self.layer.dataProvider()
path = provider.dataSourceUri()
path_layer = path.split('|')
dem_dataset = gdal.Open(path_layer[0])
data = Model.get_dem_z(dem_dataset, x_off, y_off, col_size, row_size)
if data is not None:
self.z_max = max(data)
self.z_min = self.z_max
no_data = dem_dataset.GetRasterBand(1).GetNoDataValue()
if min(data) == no_data:
for z_cell in data:
if z_cell != no_data and z_cell < self.z_min:
self.z_min = z_cell
elif math.isnan(min(data)):
self.z_max = 0
self.z_min = 0
for z_cell in data:
if not math.isnan(z_cell):
if self.z_min > z_cell:
self.z_min = z_cell
if self.z_max < z_cell:
self.z_max = z_cell
else:
self.z_min = min(data)
self.z_max = round(self.z_max, 3)
self.z_min = round(self.z_min, 3)
self.ui.ZMaxLabel.setText(str(self.z_max) + ' m')
self.ui.ZMinLabel.setText(str(self.z_min) + ' m')
dem_dataset = None
QApplication.restoreOverrideCursor()
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
# this is for multilingual legends
locale = QSettings().value('locale/userLocale')[0:2]
# If locale is different to frence or italian, german will be used.
# Otherwise we get into troubles with the legends, e.g. locale = "en"
# but
# there is no english legend (qml file).
if locale == "fr":
pass
elif locale == "it":
pass
else:
locale = "de"
if not project_id:
self.message_bar.pushCritical(
"Error",
_translate("Isolierte Uebrigen Gebaeudeteile",
"project_id not set", None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("Veribe", "Isolierte_Uebrigen_Gebaeudeteile",
None)
group += " (" + str(project_id) + ")"
layer = {
"type":
"postgres",
"title":
_translate("Veribe",
"Isolierte Uebrigen Gebaeudeteile Flachen", None),
"featuretype":
"v_uebriger_gebaeudeteil_isolierte_flaeche",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("Veribe", "Isolierte Uebrigen Gebaeudeteile Linien",
None),
"featuretype":
"v_uebriger_gebaeudeteil_isolierte_linien",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("Veribe", "Isolierte Uebrigen Gebaeudeteile Punkte",
None),
"featuretype":
"v_uebriger_gebaeudeteil_isolierte_punkte",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
}
vlayer = self.layer_loader.load(layer)
# Visibility and if legend and/or groupd should be collapsed can
# be set with parameters in the self.layer_loader.load()
# method:
# load(layer, visibility=True, collapsed_legend=False,
# collapsed_group=False)
# vlayer = self.layer_loader.load(layer)
except Exception:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage(
"Error",
str(traceback.format_exc(exc_traceback)),
level=Qgis.Critical,
duration=0)
QApplication.restoreOverrideCursor()
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
# override cursor
QApplication.setOverrideCursor(QCursor(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)
# restore cursor
QApplication.restoreOverrideCursor()
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 accept(self):
self.settings.setValue("/Processing/dialogBase", self.saveGeometry())
checkCRS = ProcessingConfig.getSetting(
ProcessingConfig.WARN_UNMATCHING_CRS)
try:
self.setParamValues()
if checkCRS and not self.alg.checkInputCRS():
reply = QMessageBox.question(
self, self.tr("Unmatching CRS's"),
self.tr('Layers 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
checkExtentCRS = ProcessingConfig.getSetting(
ProcessingConfig.WARN_UNMATCHING_EXTENT_CRS)
if checkExtentCRS and self.checkExtentCRS():
reply = QMessageBox.question(
self, self.tr("Extent CRS"),
self.
tr('Extent parameters must use the same CRS as the input layers.\n'
'Your input layers do not have the same extent as the project, '
'so the extent might be in a wrong CRS if you have selected it from the canvas.\n'
'Do you want to continue?'),
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.No:
return
msg = self.alg._checkParameterValuesBeforeExecuting()
if msg:
QMessageBox.warning(self,
self.tr('Unable to execute algorithm'),
msg)
return
self.btnRun.setEnabled(False)
self.btnClose.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.progressBar.setMaximum(0)
self.lblProgress.setText(self.tr('Processing algorithm...'))
# Make sure the Log tab is visible before executing the algorithm
try:
self.tabWidget.setCurrentIndex(1)
self.repaint()
except:
pass
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.setInfo(
self.tr('<b>Algorithm {0} starting...</b>').format(
self.alg.displayName()))
if self.iterateParam:
if executeIterating(self.alg, self.iterateParam,
self.feedback):
self.finish()
else:
QApplication.restoreOverrideCursor()
self.resetGUI()
else:
command = self.alg.getAsCommand()
if command:
ProcessingLog.addToLog(ProcessingLog.LOG_ALGORITHM,
command)
if execute(self.alg, self.feedback):
self.finish()
else:
QApplication.restoreOverrideCursor()
self.resetGUI()
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.bar.clearWidgets()
self.bar.pushMessage(
"",
self.tr("Wrong or missing parameter value: {0}").format(
e.parameter.description),
level=QgsMessageBar.WARNING,
duration=5)
def accept(self):
self.algs = []
self.load = []
self.canceled = False
for row in range(self.mainWidget.tblParameters.rowCount()):
alg = self.alg.getCopy()
col = 0
for param in alg.parameters:
if param.hidden:
continue
wrapper = self.mainWidget.wrappers[row][col]
if not self.mainWidget.setParamValue(param, wrapper, alg):
self.bar.pushMessage(
"",
self.tr(
'Wrong or missing parameter value: %s (row %d)') %
(param.description, row + 1),
level=QgsMessageBar.WARNING,
duration=5)
self.algs = None
return
col += 1
for out in alg.outputs:
if out.hidden:
continue
widget = self.mainWidget.tblParameters.cellWidget(row, col)
text = widget.getValue()
if text.strip() != '':
out.value = text
col += 1
else:
self.bar.pushMessage(
"",
self.tr('Wrong or missing output value: %s (row %d)') %
(out.description, row + 1),
level=QgsMessageBar.WARNING,
duration=5)
self.algs = None
return
self.algs.append(alg)
if self.alg.getVisibleOutputsCount():
widget = self.mainWidget.tblParameters.cellWidget(row, col)
self.load.append(widget.currentIndex() == 0)
else:
self.load.append(False)
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
self.mainWidget.setEnabled(False)
self.progressBar.setMaximum(len(self.algs))
# Make sure the Log tab is visible before executing the algorithm
try:
self.tabWidget.setCurrentIndex(1)
self.repaint()
except:
pass
for count, alg in enumerate(self.algs):
self.setText(
self.tr('\nProcessing algorithm %d/%d...') %
(count + 1, len(self.algs)))
self.setInfo(self.tr('<b>Algorithm %s starting...</b>' % alg.name))
if runalg(alg, self) and not self.canceled:
if self.load[count]:
handleAlgorithmResults(alg, self, False)
self.setInfo(
self.tr('Algorithm %s correctly executed...') % alg.name)
else:
QApplication.restoreOverrideCursor()
return
self.finish()
def runAlgorithm(algOrName, onFinish, *args, **kwargs):
if isinstance(algOrName, GeoAlgorithm):
alg = algOrName
else:
alg = Processing.getAlgorithm(algOrName)
if alg is None:
# fix_print_with_import
print('Error: Algorithm not found\n')
QgsMessageLog.logMessage(
Processing.tr('Error: Algorithm {0} not found\n').format(
algOrName), Processing.tr("Processing"))
return
alg = alg.getCopy()
if len(args) == 1 and isinstance(args[0], dict):
# Set params by name and try to run the alg even if not all parameter values are provided,
# by using the default values instead.
setParams = []
for (name, value) in list(args[0].items()):
param = alg.getParameterFromName(name)
if param and param.setValue(value):
setParams.append(name)
continue
output = alg.getOutputFromName(name)
if output and output.setValue(value):
continue
# fix_print_with_import
print('Error: Wrong parameter value %s for parameter %s.' %
(value, name))
QgsMessageLog.logMessage(
Processing.tr(
'Error: Wrong parameter value {0} for parameter {1}.').
format(value, name), Processing.tr("Processing"))
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
Processing.
tr('Error in {0}. Wrong parameter value {1} for parameter {2}.'
).format(alg.name, value, name))
return
# fill any missing parameters with default values if allowed
for param in alg.parameters:
if param.name not in setParams:
if not param.setDefaultValue():
# fix_print_with_import
print(
'Error: Missing parameter value for parameter %s.'
% param.name)
QgsMessageLog.logMessage(
Processing.
tr('Error: Missing parameter value for parameter {0}.'
).format(param.name),
Processing.tr("Processing"))
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
Processing.
tr('Error in {0}. Missing parameter value for parameter {1}.'
).format(alg.name, param.name))
return
else:
if len(args) != alg.getVisibleParametersCount(
) + alg.getVisibleOutputsCount():
# fix_print_with_import
print('Error: Wrong number of parameters')
QgsMessageLog.logMessage(
Processing.tr('Error: Wrong number of parameters'),
Processing.tr("Processing"))
processing.alghelp(algOrName)
return
i = 0
for param in alg.parameters:
if not param.hidden:
if not param.setValue(args[i]):
# fix_print_with_import
print('Error: Wrong parameter value: ' + str(args[i]))
QgsMessageLog.logMessage(
Processing.tr('Error: Wrong parameter value: ') +
str(args[i]), Processing.tr("Processing"))
return
i = i + 1
for output in alg.outputs:
if not output.hidden:
if not output.setValue(args[i]):
# fix_print_with_import
print('Error: Wrong output value: ' + str(args[i]))
QgsMessageLog.logMessage(
Processing.tr('Error: Wrong output value: ') +
str(args[i]), Processing.tr("Processing"))
return
i = i + 1
msg = alg._checkParameterValuesBeforeExecuting()
if msg:
# fix_print_with_import
print('Unable to execute algorithm\n' + str(msg))
QgsMessageLog.logMessage(
Processing.tr('Unable to execute algorithm\n{0}').format(msg),
Processing.tr("Processing"))
return
if not alg.checkInputCRS():
print('Warning: Not all input layers use the same CRS.\n' +
'This can cause unexpected results.')
QgsMessageLog.logMessage(
Processing.
tr('Warning: Not all input layers use the same CRS.\nThis can cause unexpected results.'
), Processing.tr("Processing"))
# Don't set the wait cursor twice, because then when you
# restore it, it will still be a wait cursor.
overrideCursor = False
if iface is not None:
cursor = QApplication.overrideCursor()
if cursor is None or cursor == 0:
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
overrideCursor = True
elif cursor.shape() != Qt.WaitCursor:
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
overrideCursor = True
feedback = None
if kwargs is not None and "feedback" in list(kwargs.keys()):
feedback = kwargs["feedback"]
elif iface is not None:
feedback = MessageBarProgress(alg.name)
ret = runalg(alg, feedback)
if ret:
if onFinish is not None:
onFinish(alg, feedback)
else:
QgsMessageLog.logMessage(
Processing.tr("There were errors executing the algorithm."),
Processing.tr("Processing"))
if overrideCursor:
QApplication.restoreOverrideCursor()
if isinstance(feedback, MessageBarProgress):
feedback.close()
return alg
def installPlugin(self, key, quiet=False, stable=True):
""" Install given plugin """
error = False
status_key = 'status' if stable else 'status_exp'
infoString = ('', '')
plugin = plugins.all()[key]
previousStatus = plugin[status_key]
if not plugin:
return
if plugin[status_key] == "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,
stable=stable)
dlg.exec_()
plugin_path = qgis.utils.home_plugin_path + "/" + key
if dlg.result():
error = True
infoString = (self.tr("Plugin installation failed"), dlg.result())
elif not QDir(plugin_path).exists():
error = True
infoString = (
self.tr("Plugin has disappeared"),
self.
tr("The plugin seems to have been installed but it's not possible to know where. The directory \"{}\" "
"has not been found. Probably the plugin package contained a wrong named directory.\nPlease search "
"the list of installed plugins. You should find the plugin there, but it's not possible to "
"determine which of them it is and it's also not possible to inform you about available updates. "
"Please contact the plugin author and submit this issue."
).format(plugin_path))
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()
self.processDependencies(plugin["id"])
# try to load the plugin
loadPlugin(plugin["id"])
plugins.getAllInstalled()
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 = QgsSettings()
settings.setValue("/PythonPlugins/" + plugin["id"],
True)
else:
settings = QgsSettings()
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 Qgis.Critical or Qgis.Info
msg = "<b>%s</b>" % infoString[0]
if infoString[1]:
msg += "<b>:</b> %s" % infoString[1]
iface.pluginManagerInterface().pushMessage(msg, level)
def accept(self, *args, **kwargs):
"""Run the processing"""
try:
if not self.validate():
return False
# disable form via a frame, this will still allow interaction with the message bar
self.fraMain.setDisabled(True)
# clean gui and Qgis messagebars
self.cleanMessageBars(True)
# Change cursor to Wait cursor
QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
self.iface.mainWindow().statusBar().showMessage('Processing {}'.format(self.windowTitle()))
LOGGER.info('{st}\nProcessing {}'.format(self.windowTitle(), st='*' * 50))
self.send_to_messagebar("Please wait.. QGIS will be locked... See log panel for progress.",
level=Qgis.Warning,
duration=0, addToLog=False, core_QGIS=False, showLogPanel=True)
selectedIndices = [x.text() for x in self.chkgrpIndices.buttons() if x.isChecked()]
# Add settings to log
settingsStr = 'Parameters:---------------------------------------'
settingsStr += '\n {:20}\t{}'.format('Image layer:', self.mcboRasterLayer.currentLayer().name())
settingsStr += '\n {:20}\t{}'.format('Image nodata value:', self.lblNoDataVal.text())
if self.mcboPolygonLayer.currentLayer() is not None:
if self.chkUseSelected.isChecked():
settingsStr += '\n {:20}\t{} with {} selected features'.format('Layer:',
self.mcboPolygonLayer.currentLayer().name(),
self.mcboPolygonLayer.currentLayer().selectedFeatureCount())
else:
settingsStr += '\n {:20}\t{}'.format('Boundary layer:',
self.mcboPolygonLayer.currentLayer().name())
if self.mFieldComboBox.currentField():
settingsStr += '\n {:20}\t{}'.format('Block ID field:', self.mFieldComboBox.currentField())
settingsStr += '\n {:20}\t{}'.format('Resample pixel size: ', self.dsbPixelSize.value())
for k, v in self.band_mapping.items():
if v > 0:
settingsStr += '\n {:20}\t{}'.format('{} Band:'.format(k.title()), v)
settingsStr += '\n {:20}\t{}'.format('Calculate Indices: ', ', '.join(selectedIndices))
settingsStr += '\n {:30}\t{} - {}'.format('Output Coordinate System:',
self.mCRSoutput.crs().authid(),
self.mCRSoutput.crs().description())
settingsStr += '\n {:30}\t{}\n'.format('Output Folder:', self.lneOutputFolder.text())
LOGGER.info(settingsStr)
lyrRaster = self.mcboRasterLayer.currentLayer()
filePoly=None
if self.mcboPolygonLayer.currentLayer() is not None:
lyrBoundary = self.mcboPolygonLayer.currentLayer()
if self.chkUseSelected.isChecked():
savePlyName = lyrBoundary.name() + '_poly.shp'
filePoly = os.path.join(TEMPDIR, savePlyName)
if os.path.exists(filePoly): removeFileFromQGIS(filePoly)
QgsVectorFileWriter.writeAsVectorFormat(lyrBoundary, filePoly, "utf-8", lyrBoundary.crs(),
driverName="ESRI Shapefile", onlySelected=True)
if self.DISP_TEMP_LAYERS:
addVectorFileToQGIS(filePoly, layer_name=os.path.splitext(os.path.basename(filePoly))[0]
, group_layer_name='DEBUG', atTop=True)
else:
filePoly = get_layer_source(lyrBoundary)
# convert string to float or int without knowing which
x = self.lneNoDataVal.text()
nodata_val = int(float(x)) if int(float(x)) == float(x) else float(x)
files = calc_indices_for_block(get_layer_source(lyrRaster),
self.dsbPixelSize.value(),
self.band_mapping,
self.lneOutputFolder.text(),
indices=selectedIndices,
image_epsg=int(lyrRaster.crs().authid().replace('EPSG:', '')),
image_nodata=nodata_val,
polygon_shapefile=filePoly,
groupby=self.mFieldComboBox.currentField() if self.mFieldComboBox.currentField() else None,
out_epsg=int(self.mCRSoutput.crs().authid().replace('EPSG:', '')))
if self.chkAddToDisplay.isChecked():
for ea_file in files:
raster_sym = RASTER_SYMBOLOGY['Image Indices (ie PCD, NDVI)']
group_name = os.path.basename(os.path.dirname(ea_file))
if self.mFieldComboBox.currentField():
group_name = os.path.basename(ea_file).split('_')[0] + ' - ' + os.path.basename(os.path.dirname(ea_file))
raster_lyr = addRasterFileToQGIS(ea_file,atTop=False, group_layer_name=group_name)
raster_apply_classified_renderer(raster_lyr,
rend_type=raster_sym['type'],
num_classes=raster_sym['num_classes'],
color_ramp=raster_sym['colour_ramp'])
self.cleanMessageBars(True)
self.fraMain.setDisabled(False)
self.iface.mainWindow().statusBar().clearMessage()
self.iface.messageBar().popWidget()
QApplication.restoreOverrideCursor()
return super(CalculateImageIndicesDialog, self).accept(*args, **kwargs)
except Exception as err:
QApplication.restoreOverrideCursor()
self.iface.mainWindow().statusBar().clearMessage()
self.cleanMessageBars(True)
self.fraMain.setDisabled(False)
self.send_to_messagebar(str(err), level=Qgis.Critical,
duration=0, addToLog=True, core_QGIS=False, showLogPanel=True,
exc_info=sys.exc_info())
return False # leave dialog open
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
locale = QSettings().value('locale/userLocale')[0:2]
if not project_id:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_EE_Geb_Basis", "project_id not set", None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_EE_Geb_Basis",
"Gebaeudeadressen - Basislayer", None)
group += " (" + str(project_id) + ")"
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Bodenbedeckung", None),
"featuretype":
"bodenbedeckung_boflaeche",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"art_txt LIKE 'Gebaeude%' OR art_txt LIKE "
"'befestigt.Strasse_Weg%' OR art_txt LIKE "
"'befestigt.Trottoir%' OR art_txt LIKE "
"'befestigt.uebrige_befestigte%'",
"readonly":
True,
"group":
group,
"style":
"bodenbedeckung/gebaeude_strassen_trottoir_erschliessung"
".qml"
}
# Use 'LIKE' instead of 'IN' or '='. Now you can model extensions
# like different kinds of 'uebrige_befestigte'.
# Visibility and if legend and/or groupd should be collapsed can
# be set with parameters in the self.layer_loader.load()
# method:
# load(layer, visibility=True, collapsed_legend=False,
# collapsed_group=False)
vlayer = self.layer_loader.load(layer)
# noinspection PyPep8
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "EO.Flaechenelemente", None),
"featuretype":
"v_einzelobjekte_flaechenelement",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"art_txt LIKE 'unterirdisches_Gebaeude%' OR "
"art_txt LIKE 'uebriger_Gebaeudeteil%' OR art_txt "
"LIKE 'Reservoir%' OR art_txt LIKE 'Unterstand%'",
"readonly":
True,
"group":
group,
"style":
"einzelobjekte/eo_flaeche_gebdetail_unterstand_reservoir_unterirdisch.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "EO.Linienelemente", None),
"featuretype":
"v_einzelobjekte_linienelement",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"art_txt LIKE 'uebriger_Gebaeudeteil%'",
"readonly":
True,
"group":
group,
"style":
"einzelobjekte/eo_linie_gebdetail.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_Geb_Basis", "GEB.Nachführung",
None),
"featuretype": "gebaeudeadressen_gebnachfuehrung",
"key": "ogc_fid",
"sql": "",
"readonly": True,
"group": group
}
# layer["geom"] = "perimeter" # Will be loaded as geometryless
# layer.
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Benanntes Gebiet", None),
"featuretype":
"gebaeudeadressen_benanntesgebiet",
"geom":
"flaeche",
"key":
"ogc_fid",
"sql":
"",
"readonly":
True,
"group":
group,
"style":
"global_qml/gebaeudeadressen/benanntesgebiet_gruen.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Strassenstueck (geometrie)",
None),
"featuretype":
"gebaeudeadressen_strassenstueck",
"geom":
"geometrie",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/strassenachsen_gruen.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis",
"Strassenstueck (anfangspunkt)", None),
"featuretype":
"gebaeudeadressen_strassenstueck",
"geom":
"anfangspunkt",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/anfangspunkt_gruen.qml"
}
vlayer = self.layer_loader.load(layer)
# noinspection PyPep8
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "Gebaeudeeingang", None),
"featuretype":
"gebaeudeadressen_gebaeudeeingang",
"geom":
"lage",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/gebaeudeeingang_blaues_viereck_mit_label.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_Geb_Basis", "HausnummerPos",
None),
"featuretype": "v_gebaeudeadressen_hausnummerpos",
"geom": "pos",
"key": "ogc_fid",
"sql": "",
"group": group,
"style": "global_qml/gebaeudeadressen/hausnummerpos.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "LokalisationsName", None),
"featuretype":
"gebaeudeadressen_lokalisationsname",
"key":
"ogc_fid",
"sql":
"",
"group":
group
}
vlayer = self.layer_loader.load(layer)
layer = {
"type":
"postgres",
"title":
_translate("VeriSO_EE_Geb_Basis", "LokalisationsNamePos",
None),
"featuretype":
"t_gebaeudeadressen_lokalisationsnamepos",
"geom":
"pos",
"key":
"ogc_fid",
"sql":
"",
"group":
group,
"style":
"global_qml/gebaeudeadressen/lokalisationsnamepos.qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_Geb_Basis", "Gemeindegrenze",
None),
"featuretype": "gemeindegrenzen_gemeindegrenze",
"geom": "geometrie",
"key": "ogc_fid",
"sql": "",
"readonly": True,
"group": group,
"style": "global_qml/gemeindegrenze/gemgre_strichliert.qml"
}
gemgrelayer = self.layer_loader.load(layer)
if gemgrelayer:
rect = gemgrelayer.extent()
rect.scale(5)
self.iface.mapCanvas().setExtent(rect)
self.iface.mapCanvas().refresh()
except Exception as e:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage(
"Error",
str(traceback.format_exc(exc_traceback)),
level=Qgis.Critical,
duration=0)
QApplication.restoreOverrideCursor()
def create_project(self, project_name, project_dir, is_public, namespace):
"""
Create new Mergin project.
If project_dir is None, we are creating empty project without upload.
"""
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
self.mc.create_project(project_name, is_public, namespace)
except Exception as e:
QApplication.restoreOverrideCursor()
QMessageBox.critical(None, "Create Project",
"Failed to create Mergin project.\n" + str(e))
return False
QApplication.restoreOverrideCursor()
if not project_dir:
# not going to upload anything so just pop a "success" message and exit
QMessageBox.information(
None, "Create Project",
"An empty project has been created on the server",
QMessageBox.Close)
return True
# let's do initial upload of the project data
mp = MerginProject(project_dir)
full_project_name = "{}/{}".format(namespace, project_name)
mp.metadata = {"name": full_project_name, "version": "v0", "files": []}
if not mp.inspect_files():
QMessageBox.warning(
None, "Create Project",
"The project directory is empty - nothing to upload.")
return True
dlg = SyncDialog()
dlg.push_start(self.mc, project_dir, full_project_name)
dlg.exec_() # blocks until success, failure or cancellation
if dlg.exception:
# push failed for some reason
if isinstance(dlg.exception, LoginError):
login_error_message(dlg.exception)
elif isinstance(dlg.exception, ClientError):
QMessageBox.critical(None, "Project sync",
"Client error: " + str(dlg.exception))
else:
unhandled_exception_message(
dlg.exception_details(),
"Project sync",
f"Failed to sync project {project_name} due to an unhandled exception.",
)
return True
if not dlg.is_complete:
# we were cancelled - but no need to show a message box about that...?
return True
settings = QSettings()
server_url = self.mc.url.rstrip("/")
settings.setValue(f"Mergin/localProjects/{full_project_name}/path",
project_dir)
settings.setValue(f"Mergin/localProjects/{full_project_name}/server",
server_url)
if (project_dir == QgsProject.instance().absolutePath()
or project_dir + "/" in QgsProject.instance().absolutePath()):
write_project_variables(self.mc.username(), project_name,
full_project_name, "v1", server_url)
QMessageBox.information(
None, "Create Project",
"Mergin project created and uploaded successfully",
QMessageBox.Close)
return True
def run_query(self):
"""
Process for running the query
"""
# Block the button and save the initial text
QApplication.setOverrideCursor(Qt.WaitCursor)
self.output_directory.setDisabled(True)
self.pushButton_showQuery.setDisabled(True)
self.start_process()
QApplication.processEvents()
# Get all values
key = str(self.comboBox_key.currentText())
value = str(self.comboBox_value.currentText())
nominatim = self.nominatim_value()
timeout = self.spinBox_timeout.value()
output_directory = self.output_directory.filePath()
prefix_file = self.lineEdit_filePrefix.text()
if self.comboBox_in_around.currentIndex() == 1:
is_around = True
else:
is_around = False
distance = self.spinBox_distance_point.value()
# Which geometry at the end ?
output_geometry_types = self.get_output_geometry_types()
# Which osm objects ?
osm_objects = self._get_osm_objects()
try:
# Test values
if not osm_objects:
raise OsmObjectsException
if not output_geometry_types:
raise OutPutGeomTypesException
# If bbox, we must set None to nominatim, we can't have both
bbox = None
if self.radioButton_extentLayer.isChecked() or \
self.radioButton_extentMapCanvas.isChecked():
nominatim = None
bbox = self.get_bounding_box()
if nominatim == '':
nominatim = None
if output_directory and not isdir(output_directory):
raise DirectoryOutPutException
num_layers = process_quick_query(
dialog=self,
key=key,
value=value,
nominatim=nominatim,
is_around=is_around,
distance=distance,
bbox=bbox,
osm_objects=osm_objects,
timeout=timeout,
output_directory=output_directory,
prefix_file=prefix_file,
output_geometry_types=output_geometry_types)
# We can test numLayers to see if there are some results
if num_layers:
self.label_progress.setText(
tr('QuickOSM', u'Successful query !'))
display_message_bar(tr('QuickOSM', u'Successful query !'),
level=Qgis.Success,
duration=5)
else:
self.label_progress.setText(tr("QuickOSM", u'No result'))
display_message_bar(tr('QuickOSM',
u'Successful query, but no result.'),
level=Qgis.Warning,
duration=7)
except QuickOsmException as e:
self.display_geo_algorithm_exception(e)
except Exception as e: # pylint: disable=broad-except
self.display_exception(e)
finally:
# Resetting the button
self.output_directory.setDisabled(False)
self.pushButton_showQuery.setDisabled(False)
QApplication.restoreOverrideCursor()
self.end_process()
QApplication.processEvents()
def set_cursor_wait():
""" Change cursor to 'WaitCursor' """
while get_override_cursor() is not None:
restore_cursor()
QApplication.setOverrideCursor(Qt.WaitCursor)
def accept(self):
if self.mode == self.ASK_FOR_INPUT_MODE:
# create the input layer (if not already done) and
# update available options
self.reloadInputLayer()
# sanity checks
if self.inLayer is None:
QMessageBox.information(
self, self.tr("Import to database"),
self.tr("Input layer missing or not valid"))
return
if self.cboTable.currentText() == "":
QMessageBox.information(self, self.tr("Import to database"),
self.tr("Output table name is required"))
return
if self.chkSourceSrid.isEnabled() and self.chkSourceSrid.isChecked():
try:
sourceSrid = self.editSourceSrid.text()
except ValueError:
QMessageBox.information(
self, self.tr("Import to database"),
self.tr("Invalid source srid: must be an integer"))
return
if self.chkTargetSrid.isEnabled() and self.chkTargetSrid.isChecked():
try:
targetSrid = self.editTargetSrid.text()
except ValueError:
QMessageBox.information(
self, self.tr("Import to database"),
self.tr("Invalid target srid: must be an integer"))
return
# override cursor
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
# store current input layer crs and encoding, so I can restore it
prevInCrs = self.inLayer.crs()
prevInEncoding = self.inLayer.dataProvider().encoding()
try:
schema = self.outUri.schema() if not self.cboSchema.isEnabled(
) else self.cboSchema.currentText()
table = self.cboTable.currentText()
# get pk and geom field names from the source layer or use the
# ones defined by the user
srcUri = qgis.core.QgsDataSourceURI(self.inLayer.source())
pk = srcUri.keyColumn() if not self.chkPrimaryKey.isChecked(
) else self.editPrimaryKey.text()
if not pk:
pk = self.default_pk
if self.inLayer.hasGeometryType() and self.chkGeomColumn.isEnabled(
):
geom = srcUri.geometryColumn(
) if not self.chkGeomColumn.isChecked(
) else self.editGeomColumn.text()
if not geom:
geom = self.default_geom
else:
geom = None
# get output params, update output URI
self.outUri.setDataSource(schema, table, geom, "", pk)
uri = self.outUri.uri(False)
providerName = self.db.dbplugin().providerName()
options = {}
if self.chkDropTable.isChecked():
options['overwrite'] = True
if self.chkSinglePart.isEnabled() and self.chkSinglePart.isChecked(
):
options['forceSinglePartGeometryType'] = True
outCrs = None
if self.chkTargetSrid.isEnabled() and self.chkTargetSrid.isChecked(
):
targetSrid = int(self.editTargetSrid.text())
outCrs = qgis.core.QgsCoordinateReferenceSystem(targetSrid)
# update input layer crs and encoding
if self.chkSourceSrid.isEnabled() and self.chkSourceSrid.isChecked(
):
sourceSrid = int(self.editSourceSrid.text())
inCrs = qgis.core.QgsCoordinateReferenceSystem(sourceSrid)
self.inLayer.setCrs(inCrs)
if self.chkEncoding.isEnabled() and self.chkEncoding.isChecked():
enc = self.cboEncoding.currentText()
self.inLayer.setProviderEncoding(enc)
onlySelected = self.chkSelectedFeatures.isChecked()
# do the import!
ret, errMsg = qgis.core.QgsVectorLayerImport.importLayer(
self.inLayer, uri, providerName, outCrs, onlySelected, False,
options)
except Exception as e:
ret = -1
errMsg = unicode(e)
finally:
# restore input layer crs and encoding
self.inLayer.setCrs(prevInCrs)
self.inLayer.setProviderEncoding(prevInEncoding)
# restore cursor
QApplication.restoreOverrideCursor()
if ret != 0:
output = qgis.gui.QgsMessageViewer()
output.setTitle(self.tr("Import to database"))
output.setMessageAsPlainText(
self.tr("Error %d\n%s") % (ret, errMsg))
output.showMessage()
return
# create spatial index
if self.chkSpatialIndex.isEnabled() and self.chkSpatialIndex.isChecked(
):
self.db.connector.createSpatialIndex((schema, table), geom)
QMessageBox.information(self, self.tr("Import to database"),
self.tr("Import was successful."))
return QDialog.accept(self)
def set_cursor(self, cursor):
if cursor != self._lastCursor:
self.unset_cursor()
QApplication.setOverrideCursor(
NavigationToolbar.Cursor.toQCursor(cursor))
self._lastCursor = cursor
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
locale = QSettings().value('locale/userLocale')[
0:2] # this is for multilingual legends
# If locale is different to frence or italian, german will be used.
# Otherwise we get into troubles with the legends, e.g. locale = "en"
# but
# there is no english legend (qml file).
if locale == "fr":
pass
elif locale == "it":
pass
else:
locale = "de"
if not project_id:
self.message_bar.pushCritical("Error",
_translate("VeriSO_EE_FP3",
"project_id not set",
None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_EE_FP3", "FixpunkteKategorie3", None)
group += " (" + str(project_id) + ")"
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_FP3", "Toleranzstufen",
None),
"featuretype": "tseinteilung_toleranzstufe",
"geom": "geometrie", "key": "ogc_fid", "sql": "",
"readonly": True, "group": group,
"style": "tseinteilung/toleranzstufe_" + locale + ".qml"
}
# Visibility and if legend and/or groupd should be collapsed can
# be set with parameters in the self.layer_loader.load()
# method:
# load(layer, visibility=True, collapsed_legend=False,
# collapsed_group=False)
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_FP3", "LFP3 Nachführung",
None),
"featuretype": "fixpunktekategorie3_lfp3nachfuehrung",
"geom": "perimeter", "key": "ogc_fid", "sql": "",
"readonly": True, "group": group
}
vlayer = self.layer_loader.load(layer, False, True)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_FP3", "LFP3", None),
"featuretype": "fixpunktekategorie3_lfp3", "geom": "geometrie",
"key": "ogc_fid", "sql": "", "readonly": True, "group": group,
"style": "fixpunkte/lfp3_" + locale + ".qml"
}
vlayer = self.layer_loader.load(layer)
layer = {
"type": "postgres", "title": _translate("VeriSO_EE_FP3",
"LFP3 ausserhalb "
"Gemeinde",
None),
"featuretype": "t_lfp3_ausserhalb_gemeinde",
"geom": "geometrie", "key": "ogc_fid", "sql": "",
"readonly": True, "group": group,
"style": "fixpunkte/lfp3ausserhalb.qml"
}
vlayer = self.layer_loader.load(layer)
# This is how WMS layer work.
layer = {
"type": "wms",
"title": _translate("VeriSO_EE_FP3", "LFP1 + LFP2 Schweiz",
None),
"url": "http://wms.geo.admin.ch/",
"layers": "ch.swisstopo.fixpunkte-lfp1,"
"ch.swisstopo.fixpunkte-lfp2",
"format": "image/png", "crs": "EPSG:" + str(epsg),
"group": group
}
vlayer = self.layer_loader.load(layer, False, True)
layer = {
"type": "postgres",
"title": _translate("VeriSO_EE_FP3", "Gemeindegrenze",
None),
"featuretype": "gemeindegrenzen_gemeindegrenze",
"geom": "geometrie", "key": "ogc_fid", "sql": "",
"readonly": True, "group": group,
"style": "global_qml/gemeindegrenze/gemgre_strichliert.qml"
}
gemgrelayer = self.layer_loader.load(layer)
# Change map extent.
# Bug (?) in QGIS: http://hub.qgis.org/issues/10980
# Closed for the lack of feedback. Upsi...
# Still a problem? (sz / 2015-04-12)
if gemgrelayer:
rect = gemgrelayer.extent()
rect.scale(5)
self.iface.mapCanvas().setExtent(rect)
self.iface.mapCanvas().refresh()
# Sometimes it does make much more sense
# to zoom to maximal extent:
# self.iface.mapCanvas().zoomToFullExtent()
except Exception:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage("Error", str(
traceback.format_exc(exc_traceback)),
level=Qgis.Critical,
duration=0)
QApplication.restoreOverrideCursor()
def CreateMISB(self):
''' Create MISB Video '''
''' Only tested using DJI Data '''
# Create ProgressBar
self.iface.messageBar().clearWidgets()
progressMessageBar = self.iface.messageBar().createMessage(
"Creating video packets...")
progress = QProgressBar()
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, QGis.Info)
QApplication.setOverrideCursor(Qt.WaitCursor)
QApplication.processEvents()
HFOV = self.sp_hfov.value()
index = self.cmb_telemetry.currentIndex()
out_record = self.cmb_telemetry.itemData(index)
rowCount = self.GetRows(out_record)
progress.setMaximum(rowCount)
d = {}
with open(out_record, encoding=encoding) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
date_start = datetime.strptime(row["CUSTOM.updateTime"],
'%Y/%m/%d %H:%M:%S.%f')
break
with open(out_record, encoding=encoding) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
for k in row:
stripK = k.strip()
stripV = row[k].strip()
d[stripK] = stripV
# We create the klv file for every moment
sizeTotal = 0
bufferData = b''
cnt = 0
for k, v in d.items():
try:
if k == "CUSTOM.updateTime":
# We prevent it from failing in the exact times that don't have milliseconds
try:
date_end = datetime.strptime(
v, '%Y/%m/%d %H:%M:%S.%f')
except Exception:
date_end = datetime.strptime(
v, '%Y/%m/%d %H:%M:%S')
_bytes = datetime_to_bytes(date_end)
_len = int_to_bytes(len(_bytes))
_bytes = _key2 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Platform Heading Angle
if k == "OSD.yaw":
OSD_yaw = float(v)
if OSD_yaw < 0:
OSD_yaw = OSD_yaw + 360
_bytes = float_to_bytes(round(OSD_yaw, 4),
_domain5, _range5)
_len = int_to_bytes(len(_bytes))
_bytes = _key5 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Platform Pitch Angle
if k == "OSD.pitch":
OSD_pitch = float(v)
_bytes = float_to_bytes(round(OSD_pitch, 4),
_domain6, _range6)
_len = int_to_bytes(len(_bytes))
_bytes = _key6 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Platform Roll Angle
if k == "OSD.roll":
OSD_roll = float(v)
_bytes = float_to_bytes(round(OSD_roll, 4),
_domain7, _range7)
_len = int_to_bytes(len(_bytes))
_bytes = _key7 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Latitude
if k == "OSD.latitude":
OSD_latitude = float(v)
_bytes = float_to_bytes(round(OSD_latitude, 4),
_domain13, _range13)
_len = int_to_bytes(len(_bytes))
_bytes = _key13 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Longitude
if k == "OSD.longitude":
OSD_longitude = float(v)
_bytes = float_to_bytes(OSD_longitude, _domain14,
_range14)
_len = int_to_bytes(len(_bytes))
_bytes = _key14 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor True Altitude
if k == "OSD.altitude [m]":
OSD_altitude = float(v)
_bytes = float_to_bytes(round(OSD_altitude, 4),
_domain15, _range15)
_len = int_to_bytes(len(_bytes))
_bytes = _key15 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Ellipsoid Height
if k == "OSD.height [m]":
OSD_height = float(v)
_bytes = float_to_bytes(round(OSD_height, 4),
_domain75, _range75)
_len = int_to_bytes(len(_bytes))
_bytes = _key75 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Relative Azimuth Angle
if k == "GIMBAL.yaw":
# GIMBAL_yaw = float(v)
GIMBAL_yaw = 0.0
_bytes = float_to_bytes(round(GIMBAL_yaw, 4),
_domain18, _range18)
_len = int_to_bytes(len(_bytes))
_bytes = _key18 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Relative Elevation Angle
if k == "GIMBAL.pitch":
GIMBAL_pitch = float(v)
_bytes = float_to_bytes(round(GIMBAL_pitch, 4),
_domain19, _range19)
_len = int_to_bytes(len(_bytes))
_bytes = _key19 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Relative Roll Angle
if k == "GIMBAL.roll":
GIMBAL_roll = float(v)
_bytes = float_to_bytes(round(GIMBAL_roll, 4),
_domain20, _range20)
_len = int_to_bytes(len(_bytes))
_bytes = _key20 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
except Exception:
print("Multiplexer error")
continue
try:
# Diference time
td = date_end - date_start
end_path = self.klv_folder + "/%.1f.klv" % (round(
td.total_seconds(), 1))
# CheckSum
v = abs(hash(end_path)) % (10**4)
_bytes = int_to_bytes(v, 4)
_len = int_to_bytes(len(_bytes))
_bytes = _key1 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Horizontal Field of View
v = self.sp_hfov.value()
_bytes = float_to_bytes(float(v), _domain16, _range16)
_len = int_to_bytes(len(_bytes))
_bytes = _key16 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Sensor Vertical Field of View
v = self.sp_vfov.value()
_bytes = float_to_bytes(float(v), _domain17, _range17)
_len = int_to_bytes(len(_bytes))
_bytes = _key17 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# TODO : Check these calculations
# Slant Range
anlge = 180 + (OSD_pitch + GIMBAL_pitch)
slantRange = abs(OSD_altitude / (cos(radians(anlge))))
_bytes = float_to_bytes(round(slantRange, 4), _domain21,
_range21)
_len = int_to_bytes(len(_bytes))
_bytes = _key21 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Target Width
# targetWidth = 0.0
targetWidth = 2.0 * slantRange * tan(radians(HFOV / 2.0))
_bytes = float_to_bytes(round(targetWidth, 4), _domain22,
_range22)
_len = int_to_bytes(len(_bytes))
_bytes = _key22 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Frame Center Latitude
angle = 90 + (OSD_pitch + GIMBAL_pitch)
tgHzDist = OSD_altitude * tan(radians(angle))
r_earth = 6371008.8
dy = tgHzDist * cos(radians(OSD_yaw))
framecenterlatitude = OSD_latitude + (dy /
r_earth) * (180 / pi)
_bytes = float_to_bytes(round(framecenterlatitude, 4),
_domain23, _range23)
_len = int_to_bytes(len(_bytes))
_bytes = _key23 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Frame Center Longitude
dx = tgHzDist * sin(radians(OSD_yaw))
framecenterlongitude = OSD_longitude + (dx / r_earth) * (
180 / pi) / cos(OSD_latitude * pi / 180)
_bytes = float_to_bytes(round(framecenterlongitude, 4),
_domain24, _range24)
_len = int_to_bytes(len(_bytes))
_bytes = _key24 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Frame Center Elevation
frameCenterElevation = 0.0
_bytes = float_to_bytes(frameCenterElevation, _domain25,
_range25)
_len = int_to_bytes(len(_bytes))
_bytes = _key25 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# TODO : If we save the corners in the klv have a overflow
# # CALCULATE CORNERS COORDINATES
# sensor = (OSD_longitude, OSD_latitude, OSD_altitude)
# frameCenter = (destPoint[0], destPoint[1], frameCenterElevation)
# FOV = (VFOV, HFOV)
# others = (OSD_yaw, GIMBAL_yaw, targetWidth, slantRange)
# cornerPointUL, cornerPointUR, cornerPointLR, cornerPointLL = CornerEstimationWithoutOffsets(sensor=sensor, frameCenter=frameCenter, FOV=FOV, others=others)
#
# # Corner Latitude Point 1 (Full)
# _bytes = float_to_bytes(round(cornerPointUL[0],4), _domain82, _range82)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key82 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
#
# # Corner Longitude Point 1 (Full)
# _bytes = float_to_bytes(round(cornerPointUL[1],4), _domain83, _range83)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key83 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
#
# # Corner Latitude Point 2 (Full)
# _bytes = float_to_bytes(round(cornerPointUR[0],4), _domain84, _range84)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key84 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
#
# # Corner Longitude Point 2 (Full)
# _bytes = float_to_bytes(round(cornerPointUR[1],4), _domain85, _range85)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key85 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
#
# # Corner Latitude Point 3 (Full)
# _bytes = float_to_bytes(round(cornerPointLR[0],4), _domain86, _range86)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key86 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
#
# # Corner Longitude Point 3 (Full)
# _bytes = float_to_bytes(round(cornerPointLR[1],4), _domain87, _range87)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key87 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
#
# # Corner Latitude Point 4 (Full)
# _bytes = float_to_bytes(round(cornerPointLL[0],4), _domain88, _range88)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key88 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
#
# # Corner Longitude Point 4 (Full)
# _bytes = float_to_bytes(round(cornerPointLL[1],4), _domain89, _range89)
# _len = int_to_bytes(len(_bytes))
# _bytes = _key89 + _len + _bytes
# sizeTotal += len(_bytes)
# bufferData += _bytes
# Platform Pitch Angle (Full)
_bytes = float_to_bytes(round(OSD_pitch, 4), _domain90,
_range90)
_len = int_to_bytes(len(_bytes))
_bytes = _key90 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# Platform Roll Angle (Full)
_bytes = float_to_bytes(round(OSD_roll, 4), _domain91,
_range91)
_len = int_to_bytes(len(_bytes))
_bytes = _key91 + _len + _bytes
sizeTotal += len(_bytes)
bufferData += _bytes
# set packet header
writeData = cle
writeData += int_to_bytes(sizeTotal)
writeData += bufferData
# Write packet
f_write = open(end_path, "wb+")
f_write.write(writeData)
f_write.close()
cnt += 1
progress.setValue(cnt)
except Exception as e:
print("Multiplexer error : " + str(e))
QApplication.restoreOverrideCursor()
QApplication.processEvents()
progress.setValue(rowCount)
self.iface.messageBar().clearWidgets()
# We add it to the manager
_, name = os.path.split(self.video_file)
self.parent.AddFileRowToManager(name,
self.video_file,
islocal=True,
klv_folder=self.klv_folder)
# Close dialog
self.close()
return
def run_stats(self):
"""Main function which do the process."""
# Get the common fields.
self.admin_layer = self.cbx_aggregation_layer.currentLayer()
if self.use_point_layer:
# If we use a point layer.
point_layer = self.cbx_case_layer.currentLayer()
else:
# If we use a column with number of case.
case_column = self.cbx_case_field.currentField()
index_case = self.admin_layer.fields().indexFromName(case_column)
#Replace laer.fieldNameIndex(name) to layer.fields().lookup\Field(name)
#http://learn.openwaterfoundation.org/owf-app-geoprocessor-python-doc-dev/resources/migrate-qgis2-qgis3/
if not self.use_area:
# If we don't use density.
population = self.cbx_population_field.currentField()
index_population = self.admin_layer.fields().indexFromName(population)
self.name_field=self.le_new_column.text()
if not self.name_field:
self.name_field = self.le_new_column.placeholderText()
# Add new column.
add_nb_intersections = self.checkBox_addNbIntersections.isChecked()
# Ratio
ratio = self.cbx_ratio.currentText()
ratio = ratio.replace(' ', '')
# Output.
self.output_file_path = self.le_output_filepath.text()
try:
self.button_box_ok.setDisabled(True)
# noinspection PyArgumentList
QApplication.setOverrideCursor(Qt.WaitCursor)
# noinspection PyArgumentList
QApplication.processEvents()
if not self.admin_layer:
QMessageBox.information(None, "DEBUG:", str("There is no layer"))
raise NoLayerProvidedException
if not self.admin_layer and self.use_point_layer:
QMessageBox.information(None, "DEBUG:", str("There is no layer"))
raise NoLayerProvidedException
crs_admin_layer = self.admin_layer.crs()
if self.use_point_layer:
crs_point_layer = point_layer.crs()
if crs_admin_layer != crs_point_layer:
QMessageBox.information(None, "DEBUG:", str("CRS of two layers are not the same. Please set CRS."))
raise DifferentCrsException(
epsg1=crs_point_layer.authid(),
epsg2=crs_admin_layer.authid())
if not self.use_point_layer and not self.use_area:
if index_population == index_case:
QMessageBox.information(None, "DEBUG:", str("You are using the same variable for case and population. Please change."))
raise FieldException(field_1='Population', field_2='Case')
try:
ratio = float(ratio)
except ValueError:
QMessageBox.information(None, "DEBUG:", str("The variable is not number."))
raise NotANumberException(suffix=ratio)
# Output
if not self.output_file_path:
temp_file = NamedTemporaryFile(
delete=False,
suffix='-geohealth.shp')
self.output_file_path = temp_file.name
temp_file.flush()
temp_file.close()
else:
with open(self.output_file_path, 'w') as document: pass
admin_layer_provider = self.admin_layer.dataProvider()
fields = self.admin_layer.fields()
if admin_layer_provider.fields().indexFromName(self.name_field) != -1:
QMessageBox.information(None, "DEBUG:", str("The field name already exist."))
raise FieldExistingException(field=self.name_field)
fields.append(QgsField(self.name_field, QVariant.Double))
if add_nb_intersections:
fields.append(QgsField('nb_of_intersections', QVariant.Int))
data = []
file_writer = QgsVectorFileWriter(
self.output_file_path,
'utf-8',
fields,
QgsWkbTypes.Polygon,
self.admin_layer.crs(),
'ESRI Shapefile')
if self.use_point_layer:
total_case = point_layer.featureCount()
else:
total_case = 0
for i, feature in enumerate(self.admin_layer.getFeatures()):
attributes = feature.attributes()
if self.use_point_layer:
count = 0
for f in point_layer.getFeatures():
if f.geometry().intersects(feature.geometry()):
count += 1
else:
count = int(attributes[index_case])
total_case += count
try:
if self.use_area:
area = feature.geometry().area()
value = float(count) / area * ratio
else:
try:
population = float(attributes[index_population])
except ValueError:
QMessageBox.information(None, "DEBUG:", str("This is not a number."))
raise NotANumberException(
suffix=attributes[index_population])
value = float(count) / population * ratio
except ZeroDivisionError:
value = None
except TypeError:
value = None
data.append(value)
attributes.append(value)
if add_nb_intersections:
attributes.append(count)
new_feature = QgsFeature()
new_geom = QgsGeometry(feature.geometry())
new_feature.setAttributes(attributes)
new_feature.setGeometry(new_geom)
file_writer.addFeature(new_feature)
del file_writer
self.output_layer = QgsVectorLayer(
self.output_file_path,
self.name_field,
'ogr')
QgsProject.instance().addMapLayer(self.output_layer)
if self.checkBox_incidence_runStats.isChecked():
stats = Stats(data)
items_stats = [
'Incidence null,%d' % stats.null_values(),
'Count(point),%d' % total_case,
'Count(polygon),%d' % self.admin_layer.featureCount(),
'Min,%d' % stats.min(),
'Average,%f' % stats.average(),
'Max,%d' % stats.max(),
'Median,%f' % stats.median(),
'Range,%d' % stats.range(),
'Variance,%f' % stats.variance(),
'Standard deviation,%f' % stats.standard_deviation()
]
self.tableWidget.clear()
self.tableWidget.setColumnCount(2)
labels = ['Parameters', 'Values']
self.tableWidget.setHorizontalHeaderLabels(labels)
self.tableWidget.setRowCount(len(items_stats))
for i, item in enumerate(items_stats):
s = item.split(',')
self.tableWidget.setItem(i, 0, QTableWidgetItem(s[0]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(s[1]))
self.tableWidget.resizeRowsToContents()
self.draw_plot(data)
else:
self.hide()
if self.symbology.isChecked():
self.add_symbology()
self.signalStatus.emit(3, tr('Successful process'))
except GeoPublicHealthException as e:
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
finally:
self.button_box_ok.setDisabled(False)
# noinspection PyArgumentList
QApplication.restoreOverrideCursor()
# noinspection PyArgumentList
QApplication.processEvents()
def writeOL(cls, iface, feedback, layers, groups, popup, visible, json,
clustered, getFeatureInfo, settings, folder):
QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
mapSettings = iface.mapCanvas().mapSettings()
controlCount = 0
stamp = datetime.now().strftime("%Y_%m_%d-%H_%M_%S_%f")
folder = os.path.join(folder, 'qgis2web_' + stamp)
restrictToExtent = settings["Scale/Zoom"]["Restrict to extent"]
matchCRS = settings["Appearance"]["Match project CRS"]
precision = settings["Data export"]["Precision"]
optimize = settings["Data export"]["Minify GeoJSON files"]
extent = settings["Scale/Zoom"]["Extent"]
mapbounds = bounds(iface, extent == "Canvas extent", layers, matchCRS)
fullextent = bounds(iface, False, layers, matchCRS)
geolocateUser = settings["Appearance"]["Geolocate user"]
maxZoom = int(settings["Scale/Zoom"]["Max zoom level"])
minZoom = int(settings["Scale/Zoom"]["Min zoom level"])
popupsOnHover = settings["Appearance"]["Show popups on hover"]
highlightFeatures = settings["Appearance"]["Highlight on hover"]
geocode = settings["Appearance"]["Add address search"]
measureTool = settings["Appearance"]["Measure tool"]
addLayersList = settings["Appearance"]["Add layers list"]
htmlTemplate = settings["Appearance"]["Template"]
layerSearch = settings["Appearance"]["Layer search"]
searchLayer = settings["Appearance"]["Search layer"]
widgetAccent = settings["Appearance"]["Widget Icon"]
widgetBackground = settings["Appearance"]["Widget Background"]
writeFiles(folder, restrictToExtent, feedback)
exportLayers(iface, layers, folder, precision, optimize, popup, json,
restrictToExtent, extent, feedback, matchCRS)
mapUnitsLayers = exportStyles(layers, folder, clustered, feedback)
mapUnitLayers = getMapUnitLayers(mapUnitsLayers)
osmb = writeLayersAndGroups(layers, groups, visible, folder, popup,
settings, json, matchCRS, clustered,
getFeatureInfo, iface, restrictToExtent,
extent, mapbounds,
mapSettings.destinationCrs().authid())
(jsAddress, cssAddress,
controlCount) = writeHTMLstart(settings, controlCount, osmb, feedback)
(geojsonVars, wfsVars,
styleVars) = writeScriptIncludes(layers, json, matchCRS)
popupLayers = "popupLayers = [%s];" % ",".join(
['1' for field in popup])
project = QgsProject.instance()
controls = getControls(project, measureTool, geolocateUser)
layersList = getLayersList(addLayersList)
pageTitle = project.title()
backgroundColor = getBackground(mapSettings, widgetAccent,
widgetBackground)
(geolocateCode, controlCount) = geolocateStyle(geolocateUser,
controlCount)
backgroundColor += geolocateCode
mapextent = "extent: %s," % mapbounds if restrictToExtent else ""
onHover = str(popupsOnHover).lower()
highlight = str(highlightFeatures).lower()
highlightFill = mapSettings.selectionColor().name()
(proj, proj4, view) = getCRSView(mapextent, fullextent, maxZoom,
minZoom, matchCRS, mapSettings)
(measureControl, measuring, measure, measureUnit, measureStyle,
controlCount) = getMeasure(measureTool, controlCount)
geolocateHead = geolocationHead(geolocateUser)
geolocate = geolocation(geolocateUser)
geocodingLinks = geocodeLinks(geocode)
geocodingJS = geocodeJS(geocode)
geocodingScript = geocodeScript(geocode)
m2px = getM2px(mapUnitsLayers)
(extracss, controlCount) = getCSS(geocode, geolocateUser, layerSearch,
controlCount)
(jsAddress, cssAddress, layerSearch,
controlCount) = writeLayerSearch(cssAddress, jsAddress, controlCount,
layerSearch, searchLayer, feedback)
ol3layerswitcher = getLayerSwitcher()
ol3popup = getPopup()
ol3qgis2webjs = getJS(osmb)
ol3layers = getLayers()
mapSize = iface.mapCanvas().size()
exp_js = getExpJS()
grid = getGrid(project)
values = {
"@PAGETITLE@": pageTitle,
"@CSSADDRESS@": cssAddress,
"@EXTRACSS@": extracss,
"@JSADDRESS@": jsAddress,
"@MAP_WIDTH@": str(mapSize.width()) + "px",
"@MAP_HEIGHT@": str(mapSize.height()) + "px",
"@OL3_STYLEVARS@": styleVars,
"@OL3_BACKGROUNDCOLOR@": backgroundColor,
"@OL3_POPUP@": ol3popup,
"@OL3_GEOJSONVARS@": geojsonVars,
"@OL3_WFSVARS@": wfsVars,
"@OL3_PROJ4@": proj4,
"@OL3_PROJDEF@": proj,
"@OL3_GEOCODINGLINKS@": geocodingLinks,
"@OL3_GEOCODINGJS@": geocodingJS,
"@QGIS2WEBJS@": ol3qgis2webjs,
"@OL3_LAYERSWITCHER@": ol3layerswitcher,
"@OL3_LAYERS@": ol3layers,
"@OL3_MEASURESTYLE@": measureStyle,
"@EXP_JS@": exp_js,
"@LEAFLET_ADDRESSCSS@": "",
"@LEAFLET_MEASURECSS@": "",
"@LEAFLET_EXTRAJS@": "",
"@LEAFLET_ADDRESSJS@": "",
"@LEAFLET_MEASUREJS@": "",
"@LEAFLET_CRSJS@": "",
"@LEAFLET_LAYERSEARCHCSS@": "",
"@LEAFLET_LAYERSEARCHJS@": "",
"@LEAFLET_CLUSTERCSS@": "",
"@LEAFLET_CLUSTERJS@": ""
}
with open(os.path.join(folder, "index.html"), "w") as f:
htmlTemplate = htmlTemplate
if htmlTemplate == "":
htmlTemplate = "full-screen"
templateOutput = replaceInTemplate(htmlTemplate + ".html", values)
templateOutput = re.sub(r'\n[\s_]+\n', '\n', templateOutput)
f.write(templateOutput)
values = {
"@GEOLOCATEHEAD@": geolocateHead,
"@BOUNDS@": mapbounds,
"@CONTROLS@": ",".join(controls),
"@LAYERSLIST@": layersList,
"@POPUPLAYERS@": popupLayers,
"@VIEW@": view,
"@LAYERSEARCH@": layerSearch,
"@ONHOVER@": onHover,
"@DOHIGHLIGHT@": highlight,
"@HIGHLIGHTFILL@": highlightFill,
"@GEOLOCATE@": geolocate,
"@GEOCODINGSCRIPT@": geocodingScript,
"@MEASURECONTROL@": measureControl,
"@MEASURING@": measuring,
"@MEASURE@": measure,
"@MEASUREUNIT@": measureUnit,
"@GRID@": grid,
"@M2PX@": m2px,
"@MAPUNITLAYERS@": mapUnitLayers
}
with open(os.path.join(folder, "resources", "qgis2web.js"), "w") as f:
out = replaceInScript("qgis2web.js", values)
f.write(out)
QApplication.restoreOverrideCursor()
return os.path.join(folder, "index.html")
def __enter__(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
Logger().status(self.msg)
def CreateMISB(self):
""" Create MISB Video """
""" Only tested using DJI Data """
# Create ProgressBar
self.iface.messageBar().clearWidgets()
progressMessageBar = self.iface.messageBar().createMessage(
"Creating video packets...")
progress = QProgressBar()
progress.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
progressMessageBar.layout().addWidget(progress)
self.iface.messageBar().pushWidget(progressMessageBar, QGis.Info)
QApplication.setOverrideCursor(Qt.WaitCursor)
QApplication.processEvents()
HFOV = self.sp_hfov.value()
VFOV = self.sp_vfov.value()
index = self.cmb_telemetry.currentIndex()
out_record = self.cmb_telemetry.itemData(index)
rowCount = self.GetRows(out_record)
progress.setMaximum(rowCount)
d = {}
with open(out_record, encoding=encoding) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
date_start = datetime.strptime(row["CUSTOM.updateTime"],
"%Y/%m/%d %H:%M:%S.%f")
break
with open(out_record, encoding=encoding) as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
for k in row:
stripK = k.strip()
stripV = row[k].strip()
d[stripK] = stripV
# We create the klv file for every moment
bufferData = b""
cnt = 0
for k, v in d.items():
try:
if k == "CUSTOM.updateTime":
# We prevent it from failing in the exact times
# that don't have milliseconds
try:
date_end = datetime.strptime(
v, "%Y/%m/%d %H:%M:%S.%f")
except Exception:
date_end = datetime.strptime(
v, "%Y/%m/%d %H:%M:%S")
_bytes = bytes(
PrecisionTimeStamp(
datetime_to_bytes(date_end)))
bufferData += _bytes
# Platform Heading Angle
if k == "OSD.yaw":
OSD_yaw = float(v)
if OSD_yaw < 0:
OSD_yaw = OSD_yaw + 360
_bytes = bytes(PlatformHeadingAngle(OSD_yaw))
bufferData += _bytes
# Platform Pitch Angle
if k == "OSD.pitch":
OSD_pitch = float(v)
_bytes = bytes(PlatformPitchAngle(OSD_pitch))
bufferData += _bytes
# Platform Roll Angle
if k == "OSD.roll":
OSD_roll = float(v)
_bytes = bytes(PlatformRollAngle(OSD_roll))
bufferData += _bytes
# Sensor Latitude
if k == "OSD.latitude":
OSD_latitude = float(v)
_bytes = bytes(SensorLatitude(OSD_latitude))
bufferData += _bytes
# Sensor Longitude
if k == "OSD.longitude":
OSD_longitude = float(v)
_bytes = bytes(SensorLongitude(OSD_longitude))
bufferData += _bytes
# Sensor True Altitude
if k == "OSD.altitude [m]":
OSD_altitude = float(v)
_bytes = bytes(SensorTrueAltitude(OSD_altitude))
bufferData += _bytes
# Sensor Ellipsoid Height
if k == "OSD.height [m]":
OSD_height = float(v)
_bytes = bytes(
SensorEllipsoidHeightConversion(OSD_height))
bufferData += _bytes
# Sensor Relative Azimuth Angle
if k == "GIMBAL.yaw":
# GIMBAL_yaw = float(v)
GIMBAL_yaw = 0.0
_bytes = bytes(
SensorRelativeAzimuthAngle(GIMBAL_yaw))
bufferData += _bytes
# Sensor Relative Elevation Angle
if k == "GIMBAL.pitch":
GIMBAL_pitch = float(v)
_bytes = bytes(
SensorRelativeElevationAngle(GIMBAL_pitch))
bufferData += _bytes
# Sensor Relative Roll Angle
if k == "GIMBAL.roll":
GIMBAL_roll = float(v)
_bytes = bytes(
SensorRelativeRollAngle(GIMBAL_roll))
bufferData += _bytes
except Exception as e:
qgsu.showUserAndLogMessage(
QCoreApplication.translate(
"Multiplexor", "Multiplexer error") + e,
onlyLog=True,
)
continue
try:
# Diference time
td = date_end - date_start
end_path = self.klv_folder + "/%.1f.klv" % (round(
td.total_seconds(), 1))
# CheckSum
v = abs(hash(end_path)) % (10**4)
_bytes = bytes(Checksum(v))
bufferData += _bytes
# Sensor Horizontal Field of View
v = self.sp_hfov.value()
_bytes = bytes(SensorHorizontalFieldOfView(float(v)))
bufferData += _bytes
# Sensor Vertical Field of View
v = self.sp_vfov.value()
_bytes = bytes(SensorVerticalFieldOfView(float(v)))
bufferData += _bytes
# TODO : Check these calculations
# Slant Range
anlge = 180 + (OSD_pitch + GIMBAL_pitch)
slantRange = abs(OSD_altitude / (cos(radians(anlge))))
_bytes = bytes(SlantRange(slantRange))
bufferData += _bytes
# Target Width
# targetWidth = 0.0
targetWidth = 2.0 * slantRange * tan(radians(HFOV / 2.0))
try:
_bytes = bytes(TargetWidth(targetWidth))
except Exception:
_bytes = bytes(TargetWidth(0.0))
bufferData += _bytes
# Frame Center Latitude
angle = 90 + (OSD_pitch + GIMBAL_pitch)
tgHzDist = OSD_altitude * tan(radians(angle))
dy = tgHzDist * cos(radians(OSD_yaw))
framecenterlatitude = OSD_latitude + degrees(
(dy / EARTH_MEAN_RADIUS))
_bytes = bytes(FrameCenterLatitude(framecenterlatitude))
bufferData += _bytes
# Frame Center Longitude
dx = tgHzDist * sin(radians(OSD_yaw))
framecenterlongitude = OSD_longitude + degrees(
(dx / EARTH_MEAN_RADIUS)) / cos(radians(OSD_latitude))
_bytes = bytes(FrameCenterLongitude(framecenterlongitude))
bufferData += _bytes
# Frame Center Elevation
frameCenterElevation = 0.0
_bytes = bytes(FrameCenterElevation(frameCenterElevation))
bufferData += _bytes
# CALCULATE CORNERS COORDINATES
# FIXME : If we add this values, the klv parse has a overflow
# Probably the packets is not created correctly
# sensor = (OSD_longitude, OSD_latitude, OSD_altitude)
# frameCenter = (framecenterlongitude, framecenterlatitude, frameCenterElevation)
# FOV = (VFOV, HFOV)
# others = (OSD_yaw, GIMBAL_yaw, targetWidth, slantRange)
# cornerPointUL, cornerPointUR, cornerPointLR, cornerPointLL = CornerEstimationWithoutOffsets(sensor=sensor, frameCenter=frameCenter, FOV=FOV, others=others)
#
# # Corner Latitude Point 1 (Full) CornerLatitudePoint1Full
# _bytes = bytes(CornerLatitudePoint1Full(cornerPointUL[0]))
# bufferData += _bytes
#
# # Corner Longitude Point 1 (Full)
# _bytes = bytes(CornerLongitudePoint1Full(cornerPointUL[1]))
# bufferData += _bytes
#
# # Corner Latitude Point 2 (Full)
# _bytes = bytes(CornerLatitudePoint2Full(cornerPointUR[0]))
# bufferData += _bytes
#
# # Corner Longitude Point 2 (Full)
# _bytes = bytes(CornerLongitudePoint2Full(cornerPointUR[1]))
# bufferData += _bytes
#
# # Corner Latitude Point 3 (Full)
# _bytes = bytes(CornerLatitudePoint3Full(cornerPointLR[0]))
# bufferData += _bytes
#
# # Corner Longitude Point 3 (Full)
# _bytes = bytes(CornerLongitudePoint3Full(cornerPointLR[1]))
# bufferData += _bytes
#
# # Corner Latitude Point 4 (Full)
# _bytes = bytes(CornerLatitudePoint4Full(cornerPointLL[0]))
# bufferData += _bytes
#
# # Corner Longitude Point 4 (Full)
# _bytes = bytes(CornerLongitudePoint4Full(cornerPointLL[1]))
# bufferData += _bytes
# Platform Pitch Angle (Full)
_bytes = bytes(PlatformPitchAngleFull(OSD_pitch))
bufferData += _bytes
# Platform Roll Angle (Full)
_bytes = bytes(PlatformRollAngleFull(OSD_roll))
bufferData += _bytes
# set packet header
writeData = UASLocalMetadataSet
sizeTotal = len(bufferData)
writeData += int_to_bytes(sizeTotal)
writeData += bufferData
# Write packet
f_write = open(end_path, "wb+")
f_write.write(writeData)
f_write.close()
cnt += 1
progress.setValue(cnt)
except Exception as e:
qgsu.showUserAndLogMessage(
QCoreApplication.translate(
"Multiplexor", "Multiplexer error") + str(e),
onlyLog=True,
)
QApplication.restoreOverrideCursor()
QApplication.processEvents()
progress.setValue(rowCount)
self.iface.messageBar().clearWidgets()
# We add it to the manager
_, name = os.path.split(self.video_file)
self.parent.AddFileRowToManager(name,
self.video_file,
islocal=True,
klv_folder=self.klv_folder)
# Close dialog
self.close()
return
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
self.project_dir = self.settings.value("project/projectdir")
self.project_id = self.settings.value("project/id")
locale = QSettings().value('locale/userLocale')[
0:2] # this is for multilingual legends
if locale == "fr":
pass
elif locale == "it":
pass
else:
locale = "de"
if not project_id:
self.message_bar.pushCritical(
"Error",
_translate("VeriSO_NPLSO_Gesamtplan", "project_id not set",
None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_NPLSO_Gesamtplan",
"Grundlagelayer - Gesamtplan", None)
group += " (" + str(project_id) + ")"
layer = {
"type":
"wms",
"title":
_translate("VeriSO_NPLSO_Gesamtplan",
"Hintergrundkarte schwarz-weiss (WMS)", None),
"url":
"https://geo.so.ch/wms?",
"layers":
"ch.so.agi.hintergrundkarte_sw",
"format":
"image/png",
"crs":
"EPSG:" + str(epsg),
"group":
group
}
vlayer = self.layer_loader.load(layer, True, True, False)
layer = {
"type":
"wms",
"title":
_translate("VeriSO_NPLSO_Gesamtplan", "Orthofoto RGB", None),
"url":
"https://geo.so.ch/wms?",
"layers":
"ch.so.agi.orthofoto_rgb",
"format":
"image/jpeg",
"crs":
"EPSG:" + str(epsg),
"group":
group
}
vlayer = self.layer_loader.load(layer, False, True, False)
except Exception:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage(
"Error",
str(traceback.format_exc(exc_traceback)),
level=QgsMessageBar.CRITICAL,
duration=0)
QApplication.restoreOverrideCursor()
def __enter__(self):
QApplication.setOverrideCursor(self.cursor)
def open_file(self):
"""
Open the osm file with the osmconf
"""
QApplication.setOverrideCursor(Qt.WaitCursor)
self.start_process()
QApplication.processEvents()
# Get fields
osm_file = self.osm_file.filePath()
osm_conf = self.osm_conf.filePath()
output_directory = self.output_directory.filePath()
prefix_file = self.lineEdit_filePrefix.text()
load_only = self.radioButton_osmConf.isChecked()
# Which geometry at the end ?
output_geometry_types = self.get_output_geometry_types()
try:
if not output_geometry_types:
raise OutPutGeomTypesException
if not isfile(osm_file):
raise FileDoesntExistException(suffix="*.osm or *.pbf")
if load_only:
if not isfile(osm_conf):
raise FileDoesntExistException(suffix="*.ini")
if output_directory and not isdir(output_directory):
raise DirectoryOutPutException
if load_only:
# Legacy, waiting to remove the OsmParser for QGIS >= 3.6
# Change in osm_file_dialog.py L131 too
output_geom_legacy = [
l.value.lower() for l in output_geometry_types
]
osm_parser = OsmParser(osm_file,
load_only=True,
osm_conf=osm_conf,
layers=output_geom_legacy)
layers = osm_parser.parse()
for item in list(layers.values()):
QgsProject.instance().addMapLayer(item)
else:
open_file(dialog=self,
osm_file=osm_file,
output_geom_types=output_geometry_types,
output_dir=output_directory,
prefix_file=prefix_file)
display_message_bar(tr('Successful query'),
level=Qgis.Success,
duration=5)
except QuickOsmException as e:
self.display_geo_algorithm_exception(e)
except Exception as e: # pylint: disable=broad-except
self.display_exception(e)
finally:
QApplication.restoreOverrideCursor()
self.end_process()
QApplication.processEvents()
def run(self):
project_id = self.settings.value("project/id")
epsg = self.settings.value("project/epsg")
self.project_dir = self.settings.value("project/projectdir")
self.project_id = self.settings.value("project/id")
locale = QSettings().value('locale/userLocale')[
0:2] # this is for multilingual legends
if locale == "fr":
pass
elif locale == "it":
pass
else:
locale = "de"
if not project_id:
self.message_bar.pushCritical("Error",
_translate("VeriSO_PNF_Bestockt",
"project_id not set",
None))
return
QApplication.setOverrideCursor(Qt.WaitCursor)
try:
group = _translate("VeriSO_PNF_Bestockt", "Maengel - Bestockte Flaeche" , None)
group += " (" + str(project_id) + ")"
layer = {
"type": "postgres",
"title": _translate("VeriSO_PNF_Bestockt", "Fehlerarten",
None),
"featuretype": "t_maengel_fehler",
"geom": "", "key": "ogc_fid", "sql": "",
"readonly": True, "group": group
}
lyr_fehlerarten = self.layer_loader.load(layer, False, True)
layer = {
"type": "postgres", "title": _translate("VeriSO_PNF_Bestockt",
"Maengelarten",
None),
"featuretype": "t_maengel_art",
"geom": "", "key": "ogc_fid",
"sql": "gruppe = 'Bestockte Flaeche'", "readonly": True,
"group": group
}
lyr_maengelarten = self.layer_loader.load(layer, False, True)
layer = {
"type": "postgres", "title": _translate("VeriSO_PNF_Bestockt",
"Maengelliste (Punkte)",
None),
"featuretype": "t_maengel",
"geom": "the_geom", "key": "ogc_fid",
"sql": "gruppe = 'Bestockte Flaeche'", "readonly": False,
"group": group, "style": "maengel/maengel.qml"
}
vlayer = self.layer_loader.load(layer, False, True)
if vlayer <> False:
self.iface.legendInterface().setLayerVisible(vlayer, True)
vlayer.setLayerName(u"Mängelliste (Punkte)")
#vlayer.saveDefaultStyle()
provider = vlayer.dataProvider()
provider.attributeIndexes()
ogc_fid_idx = provider.fieldNameIndex("ogc_fid")
gruppe_idx = provider.fieldNameIndex("gruppe")
art_idx = provider.fieldNameIndex("art")
fehler_idx = provider.fieldNameIndex("fehler")
feld_idx = provider.fieldNameIndex("feldkontrolle")
lnf_idx = provider.fieldNameIndex("lnf")
terr_idx = provider.fieldNameIndex("terrestrisch")
bemerkung_idx = provider.fieldNameIndex("bemerkung")
datum_idx = provider.fieldNameIndex("datum")
vlayer.addAttributeAlias(gruppe_idx, "Gruppe:")
vlayer.addAttributeAlias(art_idx, "Art:")
vlayer.addAttributeAlias(fehler_idx, "Fehler:")
vlayer.addAttributeAlias(feld_idx, "Feldkontrolle:")
vlayer.addAttributeAlias(lnf_idx, u"Laufende Nachführung:")
vlayer.addAttributeAlias(terr_idx, "Terrestrische Aufnahme:")
vlayer.addAttributeAlias(bemerkung_idx, "Bemerkung:")
vlayer.setEditorWidgetV2(0,"Hidden")
vlayer.setEditorWidgetV2(1, "ValueRelation")
vlayer.setEditorWidgetV2(2, "ValueRelation")
vlayer.setEditorWidgetV2(3, "ValueRelation")
vlayer.setEditorWidgetV2(4, "CheckBox")
vlayer.setEditorWidgetV2(5, "CheckBox")
vlayer.setEditorWidgetV2(6, "CheckBox")
vlayer.setEditorWidgetV2(7, "TextEdit")
vlayer.setEditorWidgetV2(8, "Hidden")
vlayer.setEditorWidgetV2Config(1, {'Layer':lyr_maengelarten.id(), 'Key':'gruppe', 'Value':'gruppe', 'OrderByValue':"1", 'AllowNull':"0", 'AllowMutli':'0'})
vlayer.setEditorWidgetV2Config(2, {'Layer':lyr_maengelarten.id(), 'Key':'art_txt', 'Value':'art_txt', 'OrderByValue':"1", 'AllowNull':"1", 'AllowMutli':'0' })
vlayer.setEditorWidgetV2Config(3, {'Layer':lyr_fehlerarten.id(), 'Key':'fehler_txt', 'Value':'fehler_txt', 'OrderByValue':"1", 'AllowNull':"1", 'AllowMutli':'0' })
vlayer.setEditorWidgetV2Config(4, {'fieldEditable':"1", 'UncheckedState':'f','CheckedState':'t'})
vlayer.setEditorWidgetV2Config(5, {'fieldEditable':"1", 'UncheckedState':'f','CheckedState':'t'})
vlayer.setEditorWidgetV2Config(6, {'fieldEditable':"1", 'UncheckedState':'f','CheckedState':'t'})
vlayer.setEditorWidgetV2Config(7, {'IsMultiline':"1", 'fieldEditable':"1", 'UseHtml':"0", 'labelOnTop':"0"})
layer = {
"type": "postgres", "title": _translate("VeriSO_PNF_Bestockt",
"Maengelliste (Linien)",
None),
"featuretype": "t_maengel_linie",
"geom": "the_geom", "key": "ogc_fid",
"sql": "gruppe = 'Bestockte Flaeche'", "readonly": False,
"group": group, "style": "maengel/maengel_linie.qml"
}
vlayer = self.layer_loader.load(layer, False, True)
if vlayer <> False:
self.iface.legendInterface().setLayerVisible(vlayer, True)
vlayer.setLayerName(u"Mängelliste (Linie)")
#vlayer.saveDefaultStyle()
provider = vlayer.dataProvider()
provider.attributeIndexes()
ogc_fid_idx = provider.fieldNameIndex("ogc_fid")
gruppe_idx = provider.fieldNameIndex("gruppe")
art_idx = provider.fieldNameIndex("art")
fehler_idx = provider.fieldNameIndex("fehler")
feld_idx = provider.fieldNameIndex("feldkontrolle")
lnf_idx = provider.fieldNameIndex("lnf")
terr_idx = provider.fieldNameIndex("terrestrisch")
bemerkung_idx = provider.fieldNameIndex("bemerkung")
datum_idx = provider.fieldNameIndex("datum")
vlayer.addAttributeAlias(gruppe_idx, "Gruppe:")
vlayer.addAttributeAlias(art_idx, "Art:")
vlayer.addAttributeAlias(fehler_idx, "Fehler:")
vlayer.addAttributeAlias(feld_idx, "Feldkontrolle:")
vlayer.addAttributeAlias(lnf_idx, u"Laufende Nachführung:")
vlayer.addAttributeAlias(terr_idx, "Terrestrische Aufnahme:")
vlayer.addAttributeAlias(bemerkung_idx, "Bemerkung:")
vlayer.setEditorWidgetV2(0,"Hidden")
vlayer.setEditorWidgetV2(1, "ValueRelation")
vlayer.setEditorWidgetV2(2, "ValueRelation")
vlayer.setEditorWidgetV2(3, "ValueRelation")
vlayer.setEditorWidgetV2(4, "CheckBox")
vlayer.setEditorWidgetV2(5, "CheckBox")
vlayer.setEditorWidgetV2(6, "CheckBox")
vlayer.setEditorWidgetV2(7, "TextEdit")
vlayer.setEditorWidgetV2(8, "Hidden")
vlayer.setEditorWidgetV2Config(1, {'Layer':lyr_maengelarten.id(), 'Key':'gruppe', 'Value':'gruppe', 'OrderByValue':"1", 'AllowNull':"0", 'AllowMutli':'0'})
vlayer.setEditorWidgetV2Config(2, {'Layer':lyr_maengelarten.id(), 'Key':'art_txt', 'Value':'art_txt', 'OrderByValue':"1", 'AllowNull':"1", 'AllowMutli':'0' })
vlayer.setEditorWidgetV2Config(3, {'Layer':lyr_fehlerarten.id(), 'Key':'fehler_txt', 'Value':'fehler_txt', 'OrderByValue':"1", 'AllowNull':"1", 'AllowMutli':'0' })
vlayer.setEditorWidgetV2Config(4, {'fieldEditable':"1", 'UncheckedState':'f','CheckedState':'t'})
vlayer.setEditorWidgetV2Config(5, {'fieldEditable':"1", 'UncheckedState':'f','CheckedState':'t'})
vlayer.setEditorWidgetV2Config(6, {'fieldEditable':"1", 'UncheckedState':'f','CheckedState':'t'})
vlayer.setEditorWidgetV2Config(7, {'IsMultiline':"1", 'fieldEditable':"1", 'UseHtml':"0", 'labelOnTop':"0"})
except Exception:
QApplication.restoreOverrideCursor()
exc_type, exc_value, exc_traceback = sys.exc_info()
self.message_bar.pushMessage("Error", str(
traceback.format_exc(exc_traceback)),
level=QgsMessageBar.CRITICAL,
duration=0)
QApplication.restoreOverrideCursor()
def runAction(self, action):
action = str(action)
if action.startswith("rows/"):
if action == "rows/count":
self.refreshRowCount()
return True
elif action.startswith("triggers/"):
parts = action.split('/')
trigger_action = parts[1]
msg = QApplication.translate(
"DBManagerPlugin",
"Do you want to {0} all triggers?").format(trigger_action)
QApplication.restoreOverrideCursor()
try:
if QMessageBox.question(
None,
QApplication.translate("DBManagerPlugin",
"Table triggers"), msg,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return False
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
if trigger_action == "enable" or trigger_action == "disable":
enable = trigger_action == "enable"
self.aboutToChange.emit()
self.database().connector.enableAllTableTriggers(
enable, (self.schemaName(), self.name))
self.refreshTriggers()
return True
elif action.startswith("trigger/"):
parts = action.split('/')
trigger_name = parts[1]
trigger_action = parts[2]
msg = QApplication.translate(
"DBManagerPlugin", "Do you want to {0} trigger {1}?").format(
trigger_action, trigger_name)
QApplication.restoreOverrideCursor()
try:
if QMessageBox.question(
None,
QApplication.translate("DBManagerPlugin",
"Table trigger"), msg,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return False
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
if trigger_action == "delete":
self.aboutToChange.emit()
self.database().connector.deleteTableTrigger(
trigger_name, (self.schemaName(), self.name))
self.refreshTriggers()
return True
elif trigger_action == "enable" or trigger_action == "disable":
enable = trigger_action == "enable"
self.aboutToChange.emit()
self.database().connector.enableTableTrigger(
trigger_name, enable, (self.schemaName(), self.name))
self.refreshTriggers()
return True
return False