def connect(self, parent=None):
conn_name = self.connectionName()
settings = QSettings()
settings.beginGroup(u"/%s/%s" % (self.connectionSettingsKey(), conn_name))
if not settings.contains("database"): # non-existent entry?
raise InvalidDataException(self.tr('There is no defined database connection "%s".') % conn_name)
from qgis.core import QgsDataSourceUri
uri = QgsDataSourceUri()
settingsList = ["service", "host", "port", "database", "username", "password", "authcfg"]
service, host, port, database, username, password, authcfg = [settings.value(x, "", type=str) for x in settingsList]
useEstimatedMetadata = settings.value("estimatedMetadata", False, type=bool)
sslmode = settings.value("sslmode", QgsDataSourceUri.SslPrefer, type=int)
settings.endGroup()
if service:
uri.setConnection(service, database, username, password, sslmode, authcfg)
else:
uri.setConnection(host, port, database, username, password, sslmode, authcfg)
uri.setUseEstimatedMetadata(useEstimatedMetadata)
try:
return self.connectToUri(uri)
except ConnectionError:
return False
def showSelectionDialog(self):
if isinstance(self.output, OutputDirectory):
self.selectDirectory()
return
filefilter = self.output.getFileFilter(self.alg)
settings = QSettings()
if settings.contains('/Processing/LastBatchOutputPath'):
path = str(settings.value('/Processing/LastBatchOutputPath'))
else:
path = ''
filename, selectedFileFilter = QFileDialog.getSaveFileName(self,
self.tr('Save file'), path, filefilter)
if filename:
if not filename.lower().endswith(
tuple(re.findall("\*(\.[a-z]{1,10})", filefilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
filename += ext.group(1)
settings.setValue('/Processing/LastBatchOutputPath', os.path.dirname(filename))
dlg = AutofillDialog(self.alg)
dlg.exec_()
if dlg.mode is not None:
try:
if dlg.mode == AutofillDialog.DO_NOT_AUTOFILL:
self.table.cellWidget(self.row,
self.col).setValue(filename)
elif dlg.mode == AutofillDialog.FILL_WITH_NUMBERS:
n = self.table.rowCount() - self.row
for i in range(n):
name = filename[:filename.rfind('.')] \
+ str(i + 1) + filename[filename.rfind('.'):]
self.table.cellWidget(i + self.row,
self.col).setValue(name)
elif dlg.mode == AutofillDialog.FILL_WITH_PARAMETER:
n = self.table.rowCount() - self.row
for i in range(n):
widget = self.table.cellWidget(i + self.row,
dlg.param)
param = self.alg.parameters[dlg.param]
if isinstance(param, (ParameterRaster,
ParameterVector, ParameterTable,
ParameterMultipleInput)):
s = str(widget.getText())
s = os.path.basename(s)
s = os.path.splitext(s)[0]
elif isinstance(param, ParameterBoolean):
s = str(widget.currentIndex() == 0)
elif isinstance(param, ParameterSelection):
s = str(widget.currentText())
elif isinstance(param, ParameterFixedTable):
s = str(widget.table)
else:
s = str(widget.text())
name = filename[:filename.rfind('.')] + s \
+ filename[filename.rfind('.'):]
self.table.cellWidget(i + self.row,
self.col).setValue(name)
except:
pass
def saveToSpatialite(self):
fileFilter = self.output.tr("Spatialite files(*.sqlite)", "OutputFile")
settings = QSettings()
if settings.contains("/Processing/LastOutputPath"):
path = settings.value("/Processing/LastOutputPath")
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
encoding = settings.value("/Processing/encoding", "System")
fileDialog = QgsEncodingFileDialog(self, self.tr("Save Spatialite"), path, fileFilter, encoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setConfirmOverwrite(False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = unicode(fileDialog.encoding())
self.output.encoding = encoding
fileName = unicode(files[0])
selectedFileFilter = unicode(fileDialog.selectedNameFilter())
if not fileName.lower().endswith(tuple(re.findall("\*(\.[a-z]{1,10})", fileFilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
fileName += ext.group(1)
settings.setValue("/Processing/LastOutputPath", os.path.dirname(fileName))
settings.setValue("/Processing/encoding", encoding)
uri = QgsDataSourceUri()
uri.setDatabase(fileName)
uri.setDataSource("", self.output.name.lower(), "the_geom" if self.output.hasGeometry() else None)
self.leText.setText("spatialite:" + uri.uri())
def selectFile(self):
output = self.alg.getOutputFromName("OUTPUT_LAYER")
fileFilter = output.getFileFilter(self.alg)
settings = QSettings()
if settings.contains("/Processing/LastOutputPath"):
path = settings.value("/Processing/LastOutputPath")
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
lastEncoding = settings.value("/Processing/encoding", "System")
fileDialog = QgsEncodingFileDialog(self, self.tr("Save file"), path, fileFilter, lastEncoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setOption(QFileDialog.DontConfirmOverwrite, False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = str(fileDialog.encoding())
output.encoding = encoding
filename = str(files[0])
selectedFileFilter = str(fileDialog.selectedNameFilter())
if not filename.lower().endswith(tuple(re.findall("\*(\.[a-z]{1,10})", fileFilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
filename = filename + ext.group(1)
self.leOutputFile.setText(filename)
settings.setValue("/Processing/LastOutputPath", os.path.dirname(filename))
settings.setValue("/Processing/encoding", encoding)
def selectFile(self):
fileFilter = self.output.getFileFilter(self.alg)
settings = QSettings()
if settings.contains('/Processing/LastOutputPath'):
path = settings.value('/Processing/LastOutputPath')
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
encoding = settings.value('/Processing/encoding', 'System')
fileDialog = QgsEncodingFileDialog(
self, self.tr('Save file'), path, fileFilter, encoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setOption(QFileDialog.DontConfirmOverwrite, False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = str(fileDialog.encoding())
self.output.encoding = encoding
fileName = str(files[0])
selectedFileFilter = str(fileDialog.selectedNameFilter())
if not fileName.lower().endswith(
tuple(re.findall("\\*(\\.[a-z]{1,10})", fileFilter))):
ext = re.search("\\*(\\.[a-z]{1,10})", selectedFileFilter)
if ext:
fileName += ext.group(1)
self.leText.setText(fileName)
settings.setValue('/Processing/LastOutputPath',
os.path.dirname(fileName))
settings.setValue('/Processing/encoding', encoding)
def showFileSelectionDialog(self):
settings = QSettings()
text = str(self.text.text())
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif settings.contains('/Processing/LastInputPath'):
path = str(settings.value('/Processing/LastInputPath'))
else:
path = ''
ret, selected_filter = QFileDialog.getOpenFileNames(self, self.tr('Open file'), path,
self.tr('All files(*.*);;') + self.param.getFileFilter())
if ret:
files = list(ret)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(files[0])))
for i, filename in enumerate(files):
files[i] = dataobjects.getRasterSublayer(filename, self.param)
if len(files) == 1:
self.text.setText(files[0])
self.textEditingFinished()
else:
if isinstance(self.param, ParameterMultipleInput):
self.text.setText(';'.join(str(f) for f in files))
else:
rowdif = len(files) - (self._table().rowCount() - self.row)
for i in range(rowdif):
self._panel().addRow()
for i, f in enumerate(files):
self._table().cellWidget(i + self.row,
self.col).setValue(f)
def uri_from_name(conn_name):
settings = QSettings()
settings.beginGroup(u"/PostgreSQL/connections/%s" % conn_name)
if not settings.contains("database"): # non-existent entry?
raise DbError('There is no defined database connection "%s".' % conn_name)
uri = QgsDataSourceUri()
settingsList = ["service", "host", "port", "database", "username", "password", "authcfg"]
service, host, port, database, username, password, authcfg = [settings.value(x, "", type=str) for x in settingsList]
useEstimatedMetadata = settings.value("estimatedMetadata", False, type=bool)
sslmode = settings.value("sslmode", QgsDataSourceUri.SslPrefer, type=int)
settings.endGroup()
if hasattr(authcfg, 'isNull') and authcfg.isNull():
authcfg = ''
if service:
uri.setConnection(service, database, username, password, sslmode, authcfg)
else:
uri.setConnection(host, port, database, username, password, sslmode, authcfg)
uri.setUseEstimatedMetadata(useEstimatedMetadata)
return uri
def connect(self, selected, parent=None):
settings = QSettings()
settings.beginGroup(u"/%s/connections/%s" % (self.getSettingsKey(), selected))
if not settings.contains("database"): # non-existent entry?
raise DbError('there is no defined database connection "%s".' % selected)
get_value_str = lambda x: str(settings.value(x) if Utils.isSIPv2() else settings.value(x).toString())
service, host, port, database, username, password = list(map(get_value_str, ["service", "host", "port", "database", "username", "password"]))
# qgis1.5 use 'savePassword' instead of 'save' setting
isSave = settings.value("save") if Utils.isSIPv2() else settings.value("save").toBool()
isSavePassword = settings.value("savePassword") if Utils.isSIPv2() else settings.value("savePassword").toBool()
if not (isSave or isSavePassword):
(password, ok) = QInputDialog.getText(parent, "Enter password", 'Enter password for connection "%s":' % selected, QLineEdit.Password)
if not ok: return
settings.endGroup()
uri = QgsDataSourceUri()
if service:
uri.setConnection(service, database, username, password)
else:
uri.setConnection(host, port, database, username, password)
return Connection(uri)
def showSelectionDialog(self):
# Find the file dialog's working directory
settings = QSettings()
text = self.leText.text()
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif settings.contains('/Processing/LastInputPath'):
path = settings.value('/Processing/LastInputPath')
else:
path = ''
if self.isFolder:
folder = QFileDialog.getExistingDirectory(self,
self.tr('Select folder'), path)
if folder:
self.leText.setText(folder)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(folder))
else:
filenames, selected_filter = QFileDialog.getOpenFileNames(self,
self.tr('Select file'), path, '*.' + self.ext)
if filenames:
self.leText.setText(u';'.join(filenames))
settings.setValue('/Processing/LastInputPath',
os.path.dirname(filenames[0]))
def postgis_path_to_uri(path):
"""Convert layer path from QgsBrowserModel to full QgsDataSourceUri.
:param path: The layer path from QgsBrowserModel
:type path: string
:returns: layer uri.
:rtype: QgsDataSourceUri
"""
connection_name = path.split('/')[1]
schema = path.split('/')[2]
table_name = path.split('/')[3]
settings = QSettings()
key = "/PostgreSQL/connections/" + connection_name
service = settings.value(key + "/service")
host = settings.value(key + "/host")
port = settings.value(key + "/port")
if not port:
port = "5432"
db = settings.value(key + "/database")
use_estimated_metadata = settings.value(
key + "/estimatedMetadata", False, type=bool)
sslmode = settings.value(
key + "/sslmode", QgsDataSourceUri.SSLprefer, type=int)
username = ""
password = ""
if settings.value(key + "/saveUsername") == "true":
username = settings.value(key + "/username")
if settings.value(key + "/savePassword") == "true":
password = settings.value(key + "/password")
# Old save setting
if settings.contains(key + "/save"):
username = settings.value(key + "/username")
if settings.value(key + "/save") == "true":
password = settings.value(key + "/password")
uri = QgsDataSourceUri()
if service:
uri.setConnection(service, db, username, password, sslmode)
else:
uri.setConnection(host, port, db, username, password, sslmode)
uri.setUseEstimatedMetadata(use_estimated_metadata)
# Obtain the geometry column name
connector = PostGisDBConnector(uri)
tables = connector.getVectorTables(schema)
tables = [table for table in tables if table[1] == table_name]
if not tables:
return None
table = tables[0]
geom_col = table[8]
uri.setDataSource(schema, table_name, geom_col)
return uri
class NewConnectionDialog(QDialog, BASE_CLASS):
"""Dialogue to add a new CSW entry"""
def __init__(self, conn_name=None):
"""init"""
QDialog.__init__(self)
self.setupUi(self)
self.settings = QSettings()
self.conn_name = None
self.conn_name_orig = conn_name
def accept(self):
"""add CSW entry"""
conn_name = self.leName.text().strip()
conn_url = self.leURL.text().strip()
if any([conn_name == '', conn_url == '']):
QMessageBox.warning(self, self.tr('Save connection'),
self.tr('Both Name and URL must be provided'))
return
if '/' in conn_name:
QMessageBox.warning(self, self.tr('Save connection'),
self.tr('Name cannot contain \'/\''))
return
if conn_name is not None:
key = '/MetaSearch/%s' % conn_name
keyurl = '%s/url' % key
key_orig = '/MetaSearch/%s' % self.conn_name_orig
# warn if entry was renamed to an existing connection
if all([self.conn_name_orig != conn_name,
self.settings.contains(keyurl)]):
res = QMessageBox.warning(self, self.tr('Save connection'),
self.tr('Overwrite %s?') % conn_name,
QMessageBox.Ok | QMessageBox.Cancel)
if res == QMessageBox.Cancel:
return
# on rename delete original entry first
if all([self.conn_name_orig is not None,
self.conn_name_orig != conn_name]):
self.settings.remove(key_orig)
self.settings.setValue(keyurl, conn_url)
self.settings.setValue('/MetaSearch/selected', conn_name)
QDialog.accept(self)
def reject(self):
"""back out of dialogue"""
QDialog.reject(self)
def connect(self, parent=None):
conn_name = self.connectionName()
settings = QSettings()
settings.beginGroup(u"/%s/%s" % (self.connectionSettingsKey(), conn_name))
if not settings.contains("sqlitepath"): # non-existent entry?
raise InvalidDataException(u'there is no defined database connection "%s".' % conn_name)
database = settings.value("sqlitepath")
uri = QgsDataSourceUri()
uri.setDatabase(database)
return self.connectToUri(uri)
def selectDirectory(self):
settings = QSettings()
if settings.contains('/Processing/LastBatchOutputPath'):
lastDir = str(settings.value('/Processing/LastBatchOutputPath'))
else:
lastDir = ''
dirName = QFileDialog.getExistingDirectory(self,
self.tr('Select directory'), lastDir, QFileDialog.ShowDirsOnly)
if dirName:
self.table.cellWidget(self.row, self.col).setValue(dirName)
settings.setValue('/Processing/LastBatchOutputPath', dirName)
def selectDirectory(self):
settings = QSettings()
if settings.contains('/Processing/LastBatchOutputPath'):
lastDir = str(settings.value('/Processing/LastBatchOutputPath'))
else:
lastDir = ''
dirName = QFileDialog.getExistingDirectory(self,
self.tr('Select directory'),
lastDir,
QFileDialog.ShowDirsOnly)
if dirName:
self.table.cellWidget(self.row, self.col).setValue(dirName)
settings.setValue('/Processing/LastBatchOutputPath', dirName)
def storeConnection(self, server, database):
'''
Stores database connection in the QSettings
'''
(host, port, user, password) = self.getServerConfiguration(server)
connection = server+'_'+database
settings = QSettings()
if not settings.contains('PostgreSQL/connections/'+connection+'/database'):
settings.beginGroup('PostgreSQL/connections/'+connection)
settings.setValue('database', database)
settings.setValue('host', host)
settings.setValue('port', port)
settings.setValue('username', user)
settings.setValue('password', password)
settings.endGroup()
return True
return False
def addDirectory(self):
settings = QSettings()
if settings.contains("/Processing/lastDirectory"):
path = settings.value("/Processing/lastDirectory")
else:
path = ""
folder = QFileDialog.getExistingDirectory(self, self.tr("Select directory"), path, QFileDialog.ShowDirsOnly)
if folder == "":
return
model = self.lstLayers.model()
item = QStandardItem(folder)
model.appendRow(item)
settings.setValue("/Processing/lastDirectory", os.path.dirname(folder))
def checkRIsInstalled(ignoreRegistrySettings=False):
if isWindows():
path = RUtils.RFolder()
if path == '':
return RUtils.tr(
'R folder is not configured.\nPlease configure '
'it before running R scripts.')
R_INSTALLED = 'R_INSTALLED'
settings = QSettings()
if not ignoreRegistrySettings:
if settings.contains(R_INSTALLED):
return
if isWindows():
if ProcessingConfig.getSetting(RUtils.R_USE64):
execDir = 'x64'
else:
execDir = 'i386'
command = [
os.path.join(RUtils.RFolder(), 'bin', execDir, 'R.exe'),
'--version'
]
else:
command = ['R --version']
proc = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
).stdout
for line in iter(proc.readline, ''):
if 'R version' in line:
settings.setValue(R_INSTALLED, True)
return
html = RUtils.tr(
'<p>This algorithm requires R to be run. Unfortunately, it '
'seems that R is not installed in your system, or it is not '
'correctly configured to be used from QGIS</p>'
'<p><a href="http://docs.qgis.org/testing/en/docs/user_manual/processing/3rdParty.html">Click here</a> '
'to know more about how to install and configure R to be used with QGIS</p>'
)
return html
def connect(self, parent=None):
conn_name = self.connectionName()
settings = QSettings()
settings.beginGroup(u"/%s/%s" %
(self.connectionSettingsKey(), conn_name))
if not settings.contains("database"): # non-existent entry?
raise InvalidDataException(
self.tr('There is no defined database connection "%s".') %
conn_name)
from qgis.core import QgsDataSourceUri
uri = QgsDataSourceUri()
settingsList = [
"service", "host", "port", "database", "username", "password",
"authcfg"
]
service, host, port, database, username, password, authcfg = [
settings.value(x, "", type=str) for x in settingsList
]
useEstimatedMetadata = settings.value("estimatedMetadata",
False,
type=bool)
sslmode = settings.value("sslmode",
QgsDataSourceUri.SslPrefer,
type=int)
settings.endGroup()
if service:
uri.setConnection(service, database, username, password, sslmode,
authcfg)
else:
uri.setConnection(host, port, database, username, password,
sslmode, authcfg)
uri.setUseEstimatedMetadata(useEstimatedMetadata)
try:
return self.connectToUri(uri)
except ConnectionError:
return False
def storeConnectionConfiguration(self, server, database):
'''
Stores connection configuration in thw QSettings
server: server name
database: database name
'''
name = self.connectionEdit.text()
(host, port, user, password) = self.getServerConfiguration(server)
settings = QSettings()
if not settings.contains('PostgreSQL/servers/'+name+'/host'):
settings.beginGroup('PostgreSQL/connections/'+name)
settings.setValue('database', database)
settings.setValue('host', host)
settings.setValue('port', port)
settings.setValue('username', user)
settings.setValue('password', password)
settings.endGroup()
def checkAccessControlIsActive(self):
settings = QSettings("PostNAS", "PostNAS-Suche")
if (settings.contains("accessControl") == True):
if (settings.value("accessControl", 0) == 1):
if (self.checkAccessTable() == False):
settings.setValue("accessControl", 0)
return False
else:
return True
else:
return False
else:
if (self.checkAccessTable() == True):
settings.setValue("accessControl", 1)
return True
else:
settings.setValue("accessControl", 0)
return False
def use_obs_points(self):
QSWATMOD_path_dict = self.dirs_and_paths()
settings = QSettings()
if settings.contains('/QSWATMOD2/LastInputPath'):
path = str(settings.value('/QSWATMOD2/LastInputPath'))
else:
path = ''
title = "Choose RT3D observation point shapefile"
inFileName, __ = QFileDialog.getOpenFileName(
None, title, path, "Shapefiles (*.shp);; All files (*.*)")
if inFileName:
settings.setValue('/QSWATMOD2/LastInputPath',
os.path.dirname(str(inFileName)))
Out_folder = QSWATMOD_path_dict['org_shps']
inInfo = QFileInfo(inFileName)
inFile = inInfo.fileName()
pattern = os.path.splitext(inFileName)[0] + '.*'
# inName = os.path.splitext(inFile)[0]
inName = 'rt3d_obs_points'
for f in glob.iglob(pattern):
suffix = os.path.splitext(f)[1]
if os.name == 'nt':
outfile = ntpath.join(Out_folder, inName + suffix)
else:
outfile = posixpath.join(Out_folder, inName + suffix)
shutil.copy(f, outfile)
if os.name == 'nt':
rt3d_obs_points = ntpath.join(Out_folder, inName + ".shp")
else:
rt3d_obs_points = posixpath.join(Out_folder, inName + ".shp")
layer = QgsVectorLayer(rt3d_obs_points,
'{0} ({1})'.format("rt3d_obs_points",
"RT3D"), 'ogr')
# Put in the group
root = QgsProject.instance().layerTreeRoot()
rt3d_group = root.findGroup("RT3D")
QgsProject.instance().addMapLayer(layer, False)
rt3d_group.insertChildNode(0, QgsLayerTreeLayer(layer))
self.lineEdit_rt3d_obs_points.setText(rt3d_obs_points)
def getFileName(self, initial_value=''):
"""Shows a file open dialog"""
settings = QSettings()
if os.path.isdir(initial_value):
path = initial_value
elif os.path.isdir(os.path.dirname(initial_value)):
path = os.path.dirname(initial_value)
elif settings.contains('/Processing/LastInputPath'):
path = str(settings.value('/Processing/LastInputPath'))
else:
path = ''
filename, selected_filter = QFileDialog.getOpenFileName(self.widget, self.tr('Select file'),
path, self.tr(
'All files (*.*);;') + self.param.getFileFilter())
if filename:
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(filename)))
return filename, selected_filter
def getFileName(self, initial_value=''):
"""Shows a file open dialog"""
settings = QSettings()
if os.path.isdir(initial_value):
path = initial_value
elif os.path.isdir(os.path.dirname(initial_value)):
path = os.path.dirname(initial_value)
elif settings.contains('/Processing/LastInputPath'):
path = str(settings.value('/Processing/LastInputPath'))
else:
path = ''
filename, selected_filter = QFileDialog.getOpenFileName(self.widget, self.tr('Select file'),
path, self.tr(
'All files (*.*);;') + self.param.getFileFilter())
if filename:
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(filename)))
return filename, selected_filter
def checkRIsInstalled(ignoreRegistrySettings=False):
if isWindows():
path = RUtils.RFolder()
if path == '':
return RUtils.tr('R folder is not configured.\nPlease configure '
'it before running R scripts.')
R_INSTALLED = 'R_INSTALLED'
settings = QSettings()
if not ignoreRegistrySettings:
if settings.contains(R_INSTALLED):
return
if isWindows():
if ProcessingConfig.getSetting(RUtils.R_USE64):
execDir = 'x64'
else:
execDir = 'i386'
command = [RUtils.RFolder() + os.sep + 'bin' + os.sep + execDir
+ os.sep + 'R.exe', '--version']
else:
command = ['R --version']
proc = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=open(os.devnull),
stderr=subprocess.STDOUT,
universal_newlines=True,
).stdout
for line in iter(proc.readline, ''):
if 'R version' in line:
settings.setValue(R_INSTALLED, True)
return
html = RUtils.tr(
'<p>This algorithm requires R to be run. Unfortunately, it '
'seems that R is not installed in your system, or it is not '
'correctly configured to be used from QGIS</p>'
'<p><a href="http://docs.qgis.org/testing/en/docs/user_manual/processing/3rdParty.html">Click here</a> '
'to know more about how to install and configure R to be used with QGIS</p>')
return html
def read(self, items):
"""
Get the value of the user defined items from the STDM registry tree
param items: List of registry keys to fetch.
type items: list
"""
userKeys = {}
settings = QSettings()
settings.beginGroup("/")
groups = settings.childGroups()
for group in groups:
if str(group) == self._base_group():
for t in items:
tKey = self.groupPath + "/" + t
if settings.contains(tKey):
tValue = settings.value(tKey)
userKeys[t] = tValue
break
return userKeys
def showSelectionDialog(self):
settings = QSettings()
text = str(self.cmbText.currentText())
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif settings.contains('/Processing/LastInputPath'):
path = str(settings.value('/Processing/LastInputPath'))
else:
path = ''
filename, selected_filter = QFileDialog.getOpenFileName(self, self.tr('Select file'),
path, self.tr('All files (*.*);;') + self.param.getFileFilter())
if filename:
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(filename)))
filename = dataobjects.getRasterSublayer(filename, self.param)
self.cmbText.addItem(filename, filename)
self.cmbText.setCurrentIndex(self.cmbText.count() - 1)
def addDirectory(self):
settings = QSettings()
if settings.contains('/Processing/lastDirectory'):
path = settings.value('/Processing/lastDirectory')
else:
path = ''
folder = QFileDialog.getExistingDirectory(self,
self.tr('Select directory'),
path,
QFileDialog.ShowDirsOnly)
if folder == '':
return
model = self.lstLayers.model()
item = QStandardItem(folder)
model.appendRow(item)
settings.setValue('/Processing/lastDirectory', os.path.dirname(folder))
def showSelectionDialog(self):
settings = QSettings()
text = str(self.cmbText.currentText())
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif settings.contains('/Processing/LastInputPath'):
path = str(settings.value('/Processing/LastInputPath'))
else:
path = ''
filename, selected_filter = QFileDialog.getOpenFileName(self, self.tr('Select file'),
path, self.tr('All files (*.*);;') + self.param.getFileFilter())
if filename:
settings.setValue('/Processing/LastInputPath',
os.path.dirname(str(filename)))
filename = dataobjects.getRasterSublayer(filename, self.param)
self.cmbText.addItem(filename, filename)
self.cmbText.setCurrentIndex(self.cmbText.count() - 1)
def addFile(self):
settings = QSettings()
if settings.contains('/Processing/LastInputPath'):
path = settings.value('/Processing/LastInputPath')
else:
path = ''
files, selected_filter = QFileDialog.getOpenFileNames(self,
self.tr('Select file(s)'), path, self.tr('All files (*.*)'))
if len(files) == 0:
return
model = self.lstLayers.model()
for filePath in files:
item = QStandardItem(filePath)
model.appendRow(item)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(files[0]))
def addFile(self):
settings = QSettings()
if settings.contains('/Processing/LastInputPath'):
path = settings.value('/Processing/LastInputPath')
else:
path = ''
files, selected_filter = QFileDialog.getOpenFileNames(
self, self.tr('Select file(s)'), path, self.tr('All files (*.*)'))
if len(files) == 0:
return
model = self.lstLayers.model()
for filePath in files:
item = QStandardItem(filePath)
model.appendRow(item)
settings.setValue('/Processing/LastInputPath',
os.path.dirname(files[0]))
def storeServerConfiguration(self,
name,
host,
port,
user,
password,
isDefault=False):
'''
Stores server configuration in QSettings
'''
if '_' in name:
QMessageBox.warning(
self, self.tr("Warning!"),
self.tr("Server name cannot contain the character \"_\"."))
self.servEdit.setStyleSheet('background-color: rgb(255, 150, 150)')
return 0
settings = QSettings()
if self.isEdit:
settings.beginGroup('PostgreSQL/servers/' + self.oldName)
settings.remove('')
settings.endGroup()
else:
if settings.contains('PostgreSQL/servers/' + name + '/host'):
QMessageBox.warning(
self, self.tr("Warning!"),
self.tr("Already has a server with this name."))
self.servEdit.setStyleSheet(
'background-color: rgb(255, 150, 150)')
return 0
settings.beginGroup('PostgreSQL/servers/' + name)
settings.setValue('host', host)
settings.setValue('port', port)
settings.setValue('username', user)
settings.setValue('password', password)
if isDefault:
settings.setValue('isDefault', True)
else:
settings.setValue('isDefault', False)
settings.endGroup()
return 1
def checkRIsInstalled(ignoreRegistrySettings=False):
if isWindows():
path = RUtils.RFolder()
if path == "":
return RUtils.tr("R folder is not configured.\nPlease configure " "it before running R scripts.")
R_INSTALLED = "R_INSTALLED"
settings = QSettings()
if not ignoreRegistrySettings:
if settings.contains(R_INSTALLED):
return
if isWindows():
if ProcessingConfig.getSetting(RUtils.R_USE64):
execDir = "x64"
else:
execDir = "i386"
command = [os.path.join(RUtils.RFolder(), "bin", execDir, "R.exe"), "--version"]
else:
command = ["R --version"]
proc = subprocess.Popen(
command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.DEVNULL,
stderr=subprocess.STDOUT,
universal_newlines=True,
).stdout
for line in iter(proc.readline, ""):
if "R version" in line:
settings.setValue(R_INSTALLED, True)
return
html = RUtils.tr(
"<p>This algorithm requires R to be run. Unfortunately, it "
"seems that R is not installed in your system, or it is not "
"correctly configured to be used from QGIS</p>"
'<p><a href="http://docs.qgis.org/testing/en/docs/user_manual/processing/3rdParty.html">Click here</a> '
"to know more about how to install and configure R to be used with QGIS</p>"
)
return html
def newProject(self):
"""Call QGIS actions to create and name a new project."""
settings = QSettings()
if settings.contains('/QSWATPlus/LastInputPath'):
path = settings.value('/QSWATPlus/LastInputPath')
else:
path = ''
title = 'Select parent directory'
parentDir = QFileDialog.getExistingDirectory(None, title, path)
if parentDir is not None and os.path.isdir(parentDir):
projName, ok = QInputDialog.getText(None, 'Project name', 'Please enter the project name, starting with a letter:')
if not ok:
return
if not projName[0].isalpha():
QSWATUtils.error('Project name must start with a letter', False)
return
projDir = QSWATUtils.join(parentDir, projName)
if os.path.exists(projDir):
response = QSWATUtils.question('Project directory {0} already exists. Do you wish to delete it?'.format(projDir), False, False)
if response != QMessageBox.Yes:
return
shutil.rmtree(projDir, True)
try:
os.mkdir(projDir)
except Exception:
QSWATUtils.exceptionError('Failed to create project directory {0}'.format(projDir), False)
return
self._iface.newProject()
projFile = QSWATUtils.join(projDir, projName + '.qgs')
proj = QgsProject.instance()
proj.setFileName(projFile)
QSWATUtils.loginfo('Project file is {0}'.format(projFile))
self._iface.actionSaveProject().trigger()
# allow time for project to be created
time.sleep(2)
self.initButtons()
settings.setValue('/QSWATPlus/LastInputPath', str(projDir))
self._odlg.raise_()
self.setupProject(proj, False)
self._gv.writeProjectConfig(0, 0)
def uri_from_name(conn_name):
settings = QSettings()
settings.beginGroup(u"/PostgreSQL/connections/%s" % conn_name)
if not settings.contains("database"): # non-existent entry?
raise DbError('There is no defined database connection "%s".' %
conn_name)
uri = QgsDataSourceUri()
settingsList = [
"service", "host", "port", "database", "username", "password",
"authcfg"
]
service, host, port, database, username, password, authcfg = [
settings.value(x, "", type=str) for x in settingsList
]
useEstimatedMetadata = settings.value("estimatedMetadata",
False,
type=bool)
sslmode = settings.value("sslmode", QgsDataSourceUri.SslPrefer, type=int)
settings.endGroup()
if hasattr(authcfg, 'isNull') and authcfg.isNull():
authcfg = ''
if service:
uri.setConnection(service, database, username, password, sslmode,
authcfg)
else:
uri.setConnection(host, port, database, username, password, sslmode,
authcfg)
uri.setUseEstimatedMetadata(useEstimatedMetadata)
return uri
def connect(self, selected, parent=None):
settings = QSettings()
settings.beginGroup(u"/%s/connections/%s" %
(self.getSettingsKey(), selected))
if not settings.contains("database"): # non-existent entry?
raise DbError('there is no defined database connection "%s".' %
selected)
get_value_str = lambda x: str(
settings.value(x)
if Utils.isSIPv2() else settings.value(x).toString())
service, host, port, database, username, password = list(
map(get_value_str, [
"service", "host", "port", "database", "username", "password"
]))
# qgis1.5 use 'savePassword' instead of 'save' setting
isSave = settings.value("save") if Utils.isSIPv2() else settings.value(
"save").toBool()
isSavePassword = settings.value("savePassword") if Utils.isSIPv2(
) else settings.value("savePassword").toBool()
if not (isSave or isSavePassword):
(password, ok) = QInputDialog.getText(
parent, "Enter password",
'Enter password for connection "%s":' % selected,
QLineEdit.Password)
if not ok: return
settings.endGroup()
uri = QgsDataSourceUri()
if service:
uri.setConnection(service, database, username, password)
else:
uri.setConnection(host, port, database, username, password)
return Connection(uri)
def saveToSpatialite(self):
fileFilter = self.output.tr('Spatialite files(*.sqlite)', 'OutputFile')
settings = QSettings()
if settings.contains('/Processing/LastOutputPath'):
path = settings.value('/Processing/LastOutputPath')
else:
path = ProcessingConfig.getSetting(ProcessingConfig.OUTPUT_FOLDER)
encoding = settings.value('/Processing/encoding', 'System')
fileDialog = QgsEncodingFileDialog(self, self.tr('Save Spatialite'),
path, fileFilter, encoding)
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setConfirmOverwrite(False)
if fileDialog.exec_() == QDialog.Accepted:
files = fileDialog.selectedFiles()
encoding = unicode(fileDialog.encoding())
self.output.encoding = encoding
fileName = unicode(files[0])
selectedFileFilter = unicode(fileDialog.selectedNameFilter())
if not fileName.lower().endswith(
tuple(re.findall("\*(\.[a-z]{1,10})", fileFilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
fileName += ext.group(1)
settings.setValue('/Processing/LastOutputPath',
os.path.dirname(fileName))
settings.setValue('/Processing/encoding', encoding)
uri = QgsDataSourceURI()
uri.setDatabase(fileName)
uri.setDataSource(
'', self.output.name.lower(),
'the_geom' if self.output.hasGeometry() else None)
self.leText.setText("spatialite:" + uri.uri())
# coding=utf-8
def loadP(self):
QSWATMOD_path_dict = self.dirs_and_paths()
settings = QSettings()
if settings.contains('/QSWATMOD2/LastInputPath'):
path = str(settings.value('/QSWATMOD2/LastInputPath'))
else:
path = ''
title = "Choose Initial P Rasterfile"
inFileName, __ = QFileDialog.getOpenFileName(
None, title, path, "Rasterfiles (*.tif);; All files (*.*)")
if inFileName:
settings.setValue('/QSWATMOD2/LastInputPath',
os.path.dirname(str(inFileName)))
Out_folder = QSWATMOD_path_dict['org_shps']
inInfo = QFileInfo(inFileName)
inFile = inInfo.fileName()
pattern = os.path.splitext(inFileName)[0] + '.*'
baseName = inInfo.baseName()
# inName = os.path.splitext(inFile)[0]
inName = 'p'
for f in glob.iglob(pattern):
suffix = os.path.splitext(f)[1]
if os.name == 'nt':
outfile = ntpath.join(Out_folder, inName + suffix)
else:
outfile = posixpath.join(Out_folder, inName + suffix)
shutil.copy(f, outfile)
if os.name == 'nt':
shp = ntpath.join(Out_folder, inName + ".tif")
else:
shp = posixpath.join(Out_folder, inName + ".tif")
# Delete existing "bot_elev (SMfolder)" raster file"
for lyr in list(QgsProject.instance().mapLayers().values()):
if lyr.name() == ("p (DATA)"):
QgsProject.instance().removeMapLayers([lyr.id()])
layer = QgsRasterLayer(shp, '{0} ({1})'.format("p", "DATA"))
# Put in the group
root = QgsProject.instance().layerTreeRoot()
mf_group = root.findGroup("RT3D")
QgsProject.instance().addMapLayer(layer, False)
mf_group.insertChildNode(0, QgsLayerTreeLayer(layer))
self.lineEdit_p_r.setText(shp)
des = 'Extracting P CONC from Raster'
self.time_stamp_start(des)
input1 = QgsProject.instance().mapLayersByName("rt3d_grid (RT3D)")[0]
input2 = QgsProject.instance().mapLayersByName("p (DATA)")[0]
provider1 = input1.dataProvider()
provider2 = input2.dataProvider()
rpath = provider2.dataSourceUri()
if provider1.fields().indexFromName("p_mean") != -1:
attrIdx = provider1.fields().indexFromName("p_mean")
provider1.deleteAttributes([attrIdx])
params = {
'INPUT_RASTER': input2,
'RASTER_BAND': 1,
'INPUT_VECTOR': input1,
'COLUMN_PREFIX': 'p_',
'STATS': [2]
}
processing.run("qgis:zonalstatistics", params)
self.time_stamp_end(des)
def connect(self, parent=None):
conn_name = self.connectionName()
settings = QSettings()
settings.beginGroup(u"/{0}/{1}".format(self.connectionSettingsKey(),
conn_name))
if not settings.contains("database"): # non-existent entry?
raise InvalidDataException(
self.tr('There is no defined database connection "{}".'.format(
conn_name)))
from qgis.core import QgsDataSourceURI
uri = QgsDataSourceURI()
settingsList = ["host", "port", "database", "username", "password"]
host, port, database, username, password = [
settings.value(x, "", type=str) for x in settingsList
]
# get all of the connexion options
useEstimatedMetadata = settings.value("estimatedMetadata",
False,
type=bool)
uri.setParam(
'userTablesOnly',
unicode(settings.value("userTablesOnly", False, type=bool)))
uri.setParam(
'geometryColumnsOnly',
unicode(settings.value("geometryColumnsOnly", False, type=bool)))
uri.setParam(
'allowGeometrylessTables',
unicode(settings.value("allowGeometrylessTables", False,
type=bool)))
uri.setParam(
'onlyExistingTypes',
unicode(settings.value("onlyExistingTypes", False, type=bool)))
uri.setParam(
'includeGeoAttributes',
unicode(settings.value("includeGeoAttributes", False, type=bool)))
settings.endGroup()
uri.setConnection(host, port, database, username, password)
uri.setUseEstimatedMetadata(useEstimatedMetadata)
err = u""
try:
return self.connectToUri(uri)
except ConnectionError as e:
err = unicode(e)
# ask for valid credentials
max_attempts = 3
for i in range(max_attempts):
(ok, username, password) = QgsCredentials.instance().get(
uri.connectionInfo(False), username, password, err)
if not ok:
return False
uri.setConnection(host, port, database, username, password)
try:
self.connectToUri(uri)
except ConnectionError as e:
if i == max_attempts - 1: # failed the last attempt
raise e
err = unicode(e)
continue
QgsCredentials.instance().put(uri.connectionInfo(False), username,
password)
return True
return False
class MorpheoPlugin:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'morpheo_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# settings
self.settings = QSettings()
# Create the dialog (after translation) and keep reference
self.dlg = MorpheoDialog()
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&Morpheo')
# TODO: We are going to let the user set this up in a future iteration
self.toolbar = self.iface.addToolBar(u'Morpheo')
self.toolbar.setObjectName(u'Morpheo')
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
return QCoreApplication.translate('morpheo', message)
def add_action(self,
icon_path,
text,
callback,
enabled_flag=True,
add_to_menu=True,
add_to_toolbar=True,
status_tip=None,
whats_this=None,
parent=None):
"""Add a toolbar icon to the toolbar.
:param icon_path: Path to the icon for this action. Can be a resource
path (e.g. ':/plugins/foo/bar.png') or a normal file system path.
:type icon_path: str
:param text: Text that should be shown in menu items for this action.
:type text: str
:param callback: Function to be called when the action is triggered.
:type callback: function
:param enabled_flag: A flag indicating if the action should be enabled
by default. Defaults to True.
:type enabled_flag: bool
:param add_to_menu: Flag indicating whether the action should also
be added to the menu. Defaults to True.
:type add_to_menu: bool
:param add_to_toolbar: Flag indicating whether the action should also
be added to the toolbar. Defaults to True.
:type add_to_toolbar: bool
:param status_tip: Optional text to show in a popup when mouse pointer
hovers over the action.
:type status_tip: str
:param parent: Parent widget for the new action. Defaults None.
:type parent: QWidget
:param whats_this: Optional text to show in the status bar when the
mouse pointer hovers over the action.
:returns: The action that was created. Note that the action is also
added to self.actions list.
:rtype: QAction
"""
icon = QIcon(icon_path)
action = QAction(icon, text, parent)
action.triggered.connect(callback)
action.setEnabled(enabled_flag)
if status_tip is not None:
action.setStatusTip(status_tip)
if whats_this is not None:
action.setWhatsThis(whats_this)
if add_to_toolbar:
self.toolbar.addAction(action)
if add_to_menu:
self.iface.addPluginToMenu(self.menu, action)
self.actions.append(action)
return action
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = os.path.join(os.path.dirname(__file__), "..",
"morpheo.png")
self.add_action(icon_path,
text=self.tr(u'Morpheo'),
callback=self.run,
parent=self.iface.mainWindow())
# Rename OK button to Run
self.dlg.buttonBox.button(QDialogButtonBox.Ok).setText(self.tr('Run'))
# connect group toggle
self.dlg.grpWaysBuilderStreetName.setChecked(False)
self.connectMutuallyExclusiveGroup(self.dlg.grpWaysBuilderGeomProps,
self.dlg.grpWaysBuilderStreetName)
self.dlg.grpHorizonGeo.setChecked(False)
self.connectMutuallyExclusiveGroup(self.dlg.grpHorizonAttribute,
self.dlg.grpHorizonGeo)
# Initialize field path selection
self.connectFileSelectionPanel(self.dlg.letWaysBuilderDirectoryPath,
self.dlg.pbnWaysBuilderDirectoryPath,
True)
self.connectFileSelectionPanel(self.dlg.letWayAttributesDBPath,
self.dlg.pbnWayAttributesDBPath, False,
'sqlite')
self.connectFileSelectionPanel(self.dlg.letPathDBPath,
self.dlg.pbnPathDBPath, False, 'sqlite')
self.connectFileSelectionPanel(self.dlg.letHorizonDBPath,
self.dlg.pbnHorizonDBPath, False,
'sqlite')
self.connectFileSelectionPanel(self.dlg.letStructuralDiffDBPath1,
self.dlg.pbnStructuralDiffDBPath1,
False, 'sqlite')
self.connectFileSelectionPanel(self.dlg.letStructuralDiffDBPath2,
self.dlg.pbnStructuralDiffDBPath2,
False, 'sqlite')
self.connectFileSelectionPanel(self.dlg.letStructuralDiffDirectoryPath,
self.dlg.pbnStructuralDiffDirectoryPath,
True)
# Initialize attribute list
self.connectComboboxLayerAttribute(self.dlg.cbxWaysBuilderWayAttribute,
self.dlg.cbxWaysBuilderInputLayer)
# connect layer name
self.dlg.cbxWaysBuilderInputLayer.currentIndexChanged.connect(
self.cbxWaysBuilderInputLayerCurrentIndexChanged)
# Connect db path and properties list
self.connectDBPathWithAttribute(self.dlg.letHorizonDBPath,
self.dlg.cbxHorizonWayAttribute)
self.connectDBPathWithAttribute(self.dlg.letPathDBPath,
self.dlg.cbxPathWayAttribute,
self.dlg.cbxPathComputeOn)
# Connect compute attributes on
self.dlg.cbxWayAttributesComputeOn.currentIndexChanged.connect(
self.cbxWayAttributesComputeOnCurrentIndexChanged)
# Connect select all attributes
self.dlg.pbnWayAttributeSelectAll.clicked.connect(
self.pbnWayAttributeSelectAllClicked)
# Deactivate path with attribute
self.dlg.grpPathAttribute.setChecked(False)
self.updatePathType()
self.dlg.grpPathAttribute.toggled.connect(self.updatePathType)
self.dlg.cbxPathComputeOn.currentIndexChanged.connect(
self.updatePathType)
# Set default value
if self.settings.contains('/Morpheo/LastInputPath'):
self.dlg.letWaysBuilderDirectoryPath.setText(
self.settings.value('/Morpheo/LastInputPath'))
self.dlg.letStructuralDiffDirectoryPath.setText(
self.settings.value('/Morpheo/LastInputPath'))
if self.settings.contains('/Morpheo/LastOutputPath'):
self.synchronizeAllDBPathOnChanged(
self.settings.value('/Morpheo/LastOutputPath'))
# Synchronize DBPath
self.dlg.letWayAttributesDBPath.textChanged.connect(
self.synchronizeAllDBPathOnChanged)
self.dlg.letPathDBPath.textChanged.connect(
self.synchronizeAllDBPathOnChanged)
self.dlg.letHorizonDBPath.textChanged.connect(
self.synchronizeAllDBPathOnChanged)
# Connect compute
self.computeRow = 0
self.dlg.mAlgosListWidget.setCurrentRow(self.computeRow)
self.dlg.buttonBox.accepted.connect(self.accept)
self.dlg.closed.connect(self.close)
# Add to processing
self.morpheoAlgoProvider = MorpheoAlgorithmProvider()
QgsApplication.processingRegistry().addProvider(
self.morpheoAlgoProvider)
def cbxWaysBuilderInputLayerCurrentIndexChanged(self, idx):
layerIdx = self.dlg.cbxWaysBuilderInputLayer.currentIndex()
layerId = self.dlg.cbxWaysBuilderInputLayer.itemData(layerIdx)
layer = QgsProject.instance().mapLayer(layerId)
if layer:
self.dlg.letWaysBuilderDBName.setText(
'morpheo_' + layer.name().replace(" ", "_"))
else:
self.dlg.letWaysBuilderDBName.setText('')
def cbxWayAttributesComputeOnCurrentIndexChanged(self, idx):
if self.dlg.cbxWayAttributesComputeOn.currentText() == self.tr(
'Edges'):
self.dlg.cbxWayAttributesRtopo.setChecked(False)
self.dlg.cbxWayAttributesRtopo.setEnabled(False)
else:
self.dlg.cbxWayAttributesRtopo.setEnabled(True)
def pbnWayAttributeSelectAllClicked(self):
self.dlg.cbxWayAttributesOrthogonality.setChecked(True)
if self.dlg.cbxWayAttributesComputeOn.currentText() != self.tr(
'Edges'):
self.dlg.cbxWayAttributesRtopo.setChecked(True)
self.dlg.cbxWayAttributesBetweenness.setChecked(True)
self.dlg.cbxWayAttributesCloseness.setChecked(True)
self.dlg.cbxWayAttributesStress.setChecked(True)
def connectMutuallyExclusiveGroup(self, grp1, grp2):
def grp1Toggled(toggle):
grp2.setChecked(not toggle)
def grp2Toggled(toggle):
grp1.setChecked(not toggle)
grp1.toggled.connect(grp1Toggled)
grp2.toggled.connect(grp2Toggled)
def connectFileSelectionPanel(self, leText, btnSelect, isFolder, ext=None):
def showSelectionDialog():
#QMessageBox.warning(self.dlg, 'showSelectionDialog', 'showSelectionDialog')
# Find the file dialog's working directory
text = leText.text()
if os.path.isdir(text):
path = text
elif os.path.isdir(os.path.dirname(text)):
path = os.path.dirname(text)
elif self.settings.contains('/Morpheo/LastInputPath'):
path = self.settings.value('/Morpheo/LastInputPath')
else:
path = ''
if isFolder:
folder = QFileDialog.getExistingDirectory(
self.dlg, self.tr('Select folder'), path)
if folder:
leText.setText(folder)
self.settings.setValue('/Morpheo/LastInputPath', folder)
else:
filenames = QFileDialog.getOpenFileNames(
self.dlg, self.tr('Select file'), path, '*.' + ext)
if filenames:
leText.setText(';'.join(filenames))
self.settings.setValue('/Morpheo/LastInputPath',
os.path.dirname(filenames[0]))
btnSelect.clicked.connect(showSelectionDialog)
def synchronizeAllDBPathOnChanged(self, txt):
if self.dlg.letWayAttributesDBPath.text() != txt:
self.dlg.letWayAttributesDBPath.setText(txt)
if self.dlg.letPathDBPath.text() != txt:
self.dlg.letPathDBPath.setText(txt)
if self.dlg.letHorizonDBPath.text() != txt:
self.dlg.letHorizonDBPath.setText(txt)
self.settings.setValue('/Morpheo/LastOutputPath', txt)
def connectDBPathWithAttribute(self,
dbpathLet,
attributeCbx,
waysCbx=None):
def updateAttributeCombobox(txt):
"""update"""
pass
attributeCbx.clear()
dbpath = dbpathLet.text()
try:
conn = connect_database(dbpath)
use_way = True
if waysCbx:
use_way = waysCbx.currentText() == self.tr('Ways')
for fieldName in computed_properties(conn, use_way):
attributeCbx.addItem(fieldName)
except Exception as e:
self.setWarningInfo(str(e))
dbpathLet.textChanged.connect(updateAttributeCombobox)
if waysCbx:
waysCbx.currentIndexChanged.connect(updateAttributeCombobox)
def connectComboboxLayerAttribute(self, attributeCbx, layerCbx):
def updateAttributeCombobox(idx):
"""update"""
attributeCbx.clear()
layerId = layerCbx.itemData(idx)
if layerId:
layer = QgsProject.instance().mapLayer(layerId)
if not layer or not layer.isValid():
self.setWarning("Cannot get fields: Invalid layer %s" %
layerId)
return
fields = sorted(field.name() for field in layer.fields()
if field.type() == QVariant.String)
for fieldName in fields:
attributeCbx.addItem(fieldName)
layerCbx.currentIndexChanged.connect(updateAttributeCombobox)
def updatePathType(self):
self.dlg.cbxPathType.clear()
use_attribute = self.dlg.grpPathAttribute.isChecked()
use_way = self.dlg.cbxPathComputeOn.currentText() == self.tr('Ways')
types = ['Simplest', 'Shortest', 'Azimuth']
for t in types:
self.dlg.cbxPathType.addItem(self.tr(t))
def populateLayerComboboxes(self):
"""Populate all layer comboboxes"""
# clear comboboxes
self.dlg.cbxWaysBuilderInputLayer.clear()
#self.dlg.cbxHorizonWayLayer.clear()
self.dlg.cbxWaysBuilderPlacesLayer.clear()
self.dlg.cbxWaysBuilderPlacesLayer.addItem(self.tr('No layer'), '')
# add items to comboboxes
layers = QgsProject.instance().layerTreeRoot().findLayers()
layers = [
lay.layer() for lay in layers
if lay.layer().type() == QgsMapLayer.VectorLayer
]
for l in layers:
if l.geometryType() == QgsWkbTypes.LineGeometry:
self.dlg.cbxWaysBuilderInputLayer.addItem(l.name(), l.id())
#self.dlg.cbxHorizonWayLayer.addItem(l.name(), l.id())
elif l.geometryType() == QgsWkbTypes.PolygonGeometry:
self.dlg.cbxWaysBuilderPlacesLayer.addItem(l.name(), l.id())
def computeWaysBuilder(self):
self.setText(self.tr('Compute ways builder'))
layerIdx = self.dlg.cbxWaysBuilderInputLayer.currentIndex()
layerId = self.dlg.cbxWaysBuilderInputLayer.itemData(layerIdx)
layer = QgsProject.instance().mapLayer(layerId)
if not layer:
self.setError(self.tr('No available layer!'))
return
output = self.dlg.letWaysBuilderDirectoryPath.text() or tempFolder()
dbname = self.dlg.letWaysBuilderDBName.text(
) or 'morpheo_' + layer.name().replace(" ", "_")
parameters = {
'INPUT_LAYER': layer,
'DIRECTORY': output,
'DBNAME': dbname,
'SNAP_DISTANCE': self.dlg.spxWaysBuilderSnapDist.value(),
'MIN_EDGE_LENGTH': self.dlg.spxWaysBuilderMinEdgeLength.value(),
'THRESHOLD': self.dlg.spxWaysBuilderThreshold.value() / 180.0 * pi
}
if self.dlg.grpWaysBuilderStreetName.isChecked():
parameters[
'WAY_ATTRIBUTE'] = self.dlg.cbxWaysBuilderWayAttribute.currentText(
)
# Compute places
placesIdx = self.dlg.cbxWaysBuilderPlacesLayer.currentIndex()
placesId = self.dlg.cbxWaysBuilderPlacesLayer.itemData(placesIdx)
places = None
if placesId:
places = QgsProject.instance().mapLayer(placesId)
parameters['INPUT_PLACES'] = places
parameters['BUFFER'] = self.dlg.spxWaysBuilderBuffer.value()
parameters.update(OUTPUT_PLACES="%s_%s" % ('places', dbname),
OUTPUT_PLACE_EDGES="%s_%s" % ('place_edges', dbname),
OUTPUT_WAYS="%s_%s" % ('ways', dbname))
self.remove_layer(parameters['OUTPUT_PLACES'])
self.remove_layer(parameters['OUTPUT_PLACE_EDGES'])
self.remove_layer(parameters['OUTPUT_WAYS'])
runAndLoadResults('morpheo:ways',
parameters,
feedback=ProcessingFeedBack(self),
context=None)
self.setText(self.tr('Compute ways builder finished'),
withMessageBar=True)
self.synchronizeAllDBPathOnChanged(
os.path.join(output, dbname) + '.sqlite')
def get_basename(self, dbpath):
""" Return a layer name for the table' table
"""
return os.path.basename(dbpath).replace('.sqlite', '')
def remove_layer(self, name):
"""
"""
project = QgsProject.instance()
layers = project.mapLayersByName(name)
if layers:
# XXX Problem with qgis list type conversion error
project.removeMapLayers([l.id() for l in layers])
def computeWayAttributes(self):
""" Compute attributes on ways or edges
"""
self.setText(self.tr('Compute attributes'))
dbpath = self.dlg.letWayAttributesDBPath.text()
if not os.path.isfile(dbpath):
self.setError(self.tr('DB Path does not exist!'))
return
basename = self.get_basename(dbpath)
parameters = {
'DBPATH': dbpath,
'ORTHOGONALITY':
self.dlg.cbxWayAttributesOrthogonality.isChecked(),
'BETWEENNESS': self.dlg.cbxWayAttributesBetweenness.isChecked(),
'CLOSENESS': self.dlg.cbxWayAttributesCloseness.isChecked(),
'STRESS': self.dlg.cbxWayAttributesStress.isChecked(),
'CLASSES': self.dlg.spxWayAttributesClasses.value(),
}
if self.dlg.cbxWayAttributesComputeOn.currentText() == self.tr(
'Edges'):
algorithm = 'morpheo:edge_attributes'
parameters['OUTPUT_PLACE_EDGES'] = "%s_%s" % ('place_edges',
basename)
else:
parameters['RTOPO'] = self.dlg.cbxWayAttributesRtopo.isChecked()
parameters['OUTPUT_WAYS'] = "%s_%s" % ('ways', basename)
algorithm = 'morpheo:way_attributes'
run(algorithm,
parameters,
feedback=ProcessingFeedBack(self),
context=None)
self.setText(self.tr('Compute attributes finished'),
withMessageBar=True)
def computePath(self):
""" Compute paths on morpheo graph
"""
self.setText(self.tr('Compute path'))
dbpath = self.dlg.letPathDBPath.text()
if not os.path.isfile(dbpath):
self.setError(self.tr('DB Path does not exist!'))
return
basename = self.get_basename(dbpath)
# Get the selection on the place layer
place_layer = QgsProject.instance().mapLayersByName('places_%s' %
basename)
if not place_layer:
self.setError("No 'places' layer found !")
return
place_layer = place_layer[0]
if place_layer.selectedFeatureCount() != 2:
QMessageBox.information(
self.dlg, self.tr("Message"),
self.tr(
"You must select exactly 2 places in the 'places' layer"))
return
fi = place_layer.getSelectedFeatures()
path_type = self.dlg.cbxPathType.currentText()
parameters = {
'DBPATH': dbpath,
'PLACE_START': next(fi).id(),
'PLACE_END': next(fi).id(),
'PATH_TYPE': str(path_type).lower(),
'OUTPUT_PATH': "path_%s_%s" % (path_type, basename)
}
if self.dlg.grpPathAttribute.isChecked():
use_way = self.dlg.cbxPathComputeOn.currentText() == self.tr(
'Ways')
attribute = self.dlg.cbxPathWayAttribute.currentText()
parameters.update(ATTRIBUTE=attribute,
PERCENTILE=self.dlg.spxPathPercentile.value(),
USE_WAY=use_way,
OUTPUT_PATH="path_{}_{}{}_{}".format(
path_type, attribute,
'_way' if use_way else '', basename))
runAndLoadResults('morpheo:path',
parameters,
feedback=ProcessingFeedBack(self),
context=None)
self.setText(self.tr('Compute path finished'), withMessageBar=True)
def computeHorizon(self):
self.setText(self.tr('Compute horizon'))
dbpath = self.dlg.letHorizonDBPath.text()
if not os.path.isfile(dbpath):
self.setError(self.tr('DB Path does not exist!'))
return
output = os.path.dirname(dbpath)
dbname = os.path.basename(dbpath).replace('.sqlite', '')
conn = connect_database(dbpath)
G = read_ways_graph(os.path.join(output, dbname))
if self.dlg.grpHorizonAttribute.isChecked():
attribute = self.dlg.cbxHorizonWayAttribute.currentText()
percentile = self.dlg.spxHorizonPercentile.value()
table = 'horizon_%s_%s' % (attribute, percentile)
hrz.horizon_from_attribute(conn, G, table, attribute, percentile)
else:
pt = self.dlg.letHorizonGeoPoint.text()
if len(pt.split(',')) != 2:
self.setError(self.tr('Invalid point!'))
return
pt = [float(n) for n in pt.split(',')]
radius = self.dlg.spxHorizonGeoRadius.value()
features = mesh.features_from_point_radius(conn.cursor(), 'ways',
pt[0], pt[1], radius,
'WAY_ID')
if len(features) == 0:
self.setError(self.tr('No ways found!'))
return
self.add_vector_layer(
dbpath, 'ways', "way_selection_%s" % dbname,
'WAY_ID IN (' + ','.join(str(i) for i in features) + ')')
table = "horizon_from_selection"
hrz.horizon_from_way_list(conn, G, table, features)
conn.commit()
conn.close()
self.add_vector_layer(dbpath, table, "%s_%s" % (table, dbname))
def computeStructuralDiff(self):
self.setText(self.tr('Compute structural differences'))
dbpath1 = self.dlg.letStructuralDiffDBPath1.text()
dbpath2 = self.dlg.letStructuralDiffDBPath2.text()
dbname1 = self.get_basename(dbpath1)
dbname2 = self.get_basename(dbpath2)
output = self.dlg.letStructuralDiffDirectoryPath.text() or tempFolder()
dbname = self.dlg.letStructuralDiffDBName.text(
) or 'morpheo_diff_{}_{}'.format(os.path.basename(dbname1),
os.path.basename(dbname2))
paired_edges = "%s_%s" % ('paired_edges', dbname)
removed_edges = "%s_%s" % ('removed_edges', dbname)
added_edges = "%s_%s" % ('added_edges', dbname)
# Remove already computed layers
for layer_name in (paired_edges, removed_edges, added_edges):
self.remove_layer(layer_name)
parameters = {
'DBPATH1': dbpath1,
'DBPATH2': dbpath2,
'DIRECTORY': output,
'DBNAME': dbname,
'TOLERANCE': self.dlg.spxStructuralDiffTolerance.value(),
'OUTPUT_PAIRED_EDGES': paired_edges,
'OUTPUT_ADDED_EDGES': added_edges,
'OUTPUT_REMOVED_EDGES': removed_edges
}
runAndLoadResults('morpheo:structural_diff',
parameters,
feedback=ProcessingFeedBack(self),
context=None)
self.setText(self.tr('Compute structural differences finished'),
withMessageBar=True)
def setInfo(self, msg, error=False):
if error:
self.dlg.bar.pushMessage(self.tr("Error"),
msg,
level=Qgis.Critical)
self.dlg.txtLog.append(
'<span style="color:red"><br>%s<br></span>' % msg)
else:
self.dlg.txtLog.append(msg)
QCoreApplication.processEvents()
def setWarningInfo(self, msg):
self.setInfo('<span style="color:orange">%s</span>' % msg)
QCoreApplication.processEvents()
def setDebugInfo(self, msg):
self.setInfo('<span style="color:blue">%s</span>' % msg)
QCoreApplication.processEvents()
def setConsoleInfo(self, msg):
self.setCommand('<span style="color:darkgray">%s</span>' % msg)
QCoreApplication.processEvents()
def setPercentage(self, value):
if self.dlg.progressBar.maximum() == 0:
self.dlg.progressBar.setMaximum(100)
self.dlg.progressBar.setValue(value)
QCoreApplication.processEvents()
def setText(self, text, withMessageBar=False):
self.dlg.lblProgress.setText(text)
self.setInfo(text, False)
if withMessageBar:
self.dlg.bar.pushMessage(self.tr("Info"), text, level=Qgis.Info)
QCoreApplication.processEvents()
def setWarning(self, text, withMessageBar=False):
self.dlg.lblProgress.setText(text)
self.setWarningInfo(text)
if withMessageBar:
self.dlg.bar.pushMessage(self.tr("Warning"),
text,
level=Qgis.Warning)
QCoreApplication.processEvents()
def setError(self, text):
self.dlg.lblProgress.setText(text)
self.setInfo(text, True)
QCoreApplication.processEvents()
def add_vector_layer(self, dbname, table_name, layer_name, clause=''):
add_vector_layer(dbname, table_name, layer_name, clause)
self.iface.actionDraw().trigger()
self.iface.mapCanvas().refresh()
def start(self):
self.dlg.mAlgosListWidget.setEnabled(False)
self.dlg.progressBar.setMaximum(0)
self.dlg.lblProgress.setText(self.tr('Start'))
self.dlg.txtLog.append('======== %s %s ========' %
(self.tr('Start'), datetime.now()))
def finish(self):
self.dlg.progressBar.setValue(0)
self.dlg.progressBar.setMaximum(100)
self.dlg.lblProgress.setText(self.tr(''))
self.dlg.txtLog.append('======== %s %s ========' %
(self.tr('Finish'), datetime.now()))
self.dlg.mAlgosListWidget.setEnabled(True)
self.dlg.mAlgosListWidget.setCurrentRow(self.computeRow)
def accept(self):
self.computeRow = self.dlg.mAlgosListWidget.currentRow()
self.dlg.mAlgosListWidget.setCurrentRow(5)
self.start()
if self.computeRow == 0:
self.computeWaysBuilder()
elif self.computeRow == 1:
self.computeWayAttributes()
elif self.computeRow == 2:
self.computePath()
elif self.computeRow == 3:
self.computeHorizon()
elif self.computeRow == 4:
self.computeStructuralDiff()
self.finish()
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
for action in self.actions:
self.iface.removePluginMenu(self.tr(u'&Morpheo'), action)
self.iface.removeToolBarIcon(action)
# remove the toolbar
del self.toolbar
# remove from processing
QgsApplication.processingRegistry().removeProvider(
self.morpheoAlgoProvider)
def close(self):
QgsProject.instance().layerWasAdded.disconnect(
self.populateLayerComboboxes)
QgsProject.instance().layersWillBeRemoved.disconnect(
self.populateLayerComboboxes)
def run(self):
"""Run method that performs all the real work"""
if not self.dlg.isVisible():
# populate layer comboboxes
self.populateLayerComboboxes()
# Rename OK button to Run
self.dlg.buttonBox.button(QDialogButtonBox.Ok).setText(
self.tr('Run'))
QgsProject.instance().layerWasAdded.connect(
self.populateLayerComboboxes)
QgsProject.instance().layersWillBeRemoved.connect(
self.populateLayerComboboxes)
# set the dialog
if self.settings.contains('/Morpheo/dialog'):
self.dlg.restoreGeometry(
self.settings.value("/Morpheo/dialog", QByteArray()))
# show the dialog
self.dlg.show()
else:
self.dlg.showNormal()
self.dlg.raise_()
self.dlg.activateWindow()
def installFromZipFile(self):
settings = QSettings()
lastDirectory = settings.value('/Qgis/plugin-installer/lastZipDirectory', '.')
filePath, _ = QFileDialog.getOpenFileName(iface.mainWindow(),
self.tr('Open file'),
lastDirectory,
self.tr('Plugin packages (*.zip *.ZIP)'))
if filePath == '':
return
settings.setValue('/Qgis/plugin-installer/lastZipDirectory',
QFileInfo(filePath).absoluteDir().absolutePath())
error = False
infoString = None
with zipfile.ZipFile(filePath, 'r') as zf:
pluginName = os.path.split(zf.namelist()[0])[0]
pluginFileName = os.path.splitext(os.path.basename(filePath))[0]
pluginsDirectory = qgis.utils.home_plugin_path
if not QDir(pluginsDirectory).exists():
QDir().mkpath(pluginsDirectory)
# If the target directory already exists as a link,
# remove the link without resolving
QFile(os.path.join(pluginsDirectory, pluginFileName)).remove()
try:
# Test extraction. If fails, then exception will be raised
# and no removing occurs
unzip(str(filePath), str(pluginsDirectory))
# Removing old plugin files if exist
removeDir(QDir.cleanPath(os.path.join(pluginsDirectory, pluginFileName)))
# Extract new files
unzip(str(filePath), str(pluginsDirectory))
except:
error = True
infoString = (self.tr("Plugin installation failed"),
self.tr("Failed to unzip the plugin package\n{}.\nProbably it is broken".format(zipFilePath)))
if infoString is None:
updateAvailablePlugins()
loadPlugin(pluginName)
plugins.getAllInstalled(testLoad=True)
plugins.rebuild()
plugin = plugins.all()[pluginName]
if settings.contains('/PythonPlugins/' + pluginName):
if settings.value('/PythonPlugins/' + pluginName, False, bool):
startPlugin(pluginName)
reloadPlugin(pluginName)
else:
unloadPlugin(pluginName)
loadPlugin(pluginName)
else:
if startPlugin(pluginName):
settings.setValue('/PythonPlugins/' + pluginName, True)
infoString = (self.tr("Plugin installed successfully"), "")
if infoString[0]:
level = error and QgsMessageBar.CRITICAL or QgsMessageBar.INFO
msg = "<b>%s:</b>%s" % (infoString[0], infoString[1])
iface.messageBar().pushMessage(msg, level)
def connect(self, parent=None):
conn_name = self.connectionName()
settings = QSettings()
settings.beginGroup(u"/{0}/{1}".format(
self.connectionSettingsKey(), conn_name))
if not settings.contains("database"): # non-existent entry?
raise InvalidDataException(
self.tr('There is no defined database connection "{}".'.format(
conn_name)))
from qgis.core import QgsDataSourceURI
uri = QgsDataSourceURI()
settingsList = ["host", "port", "database", "username", "password"]
host, port, database, username, password = [settings.value(x, "", type=str) for x in settingsList]
# get all of the connexion options
useEstimatedMetadata = settings.value(
"estimatedMetadata", False, type=bool)
uri.setParam('userTablesOnly', unicode(
settings.value("userTablesOnly", False, type=bool)))
uri.setParam('geometryColumnsOnly', unicode(
settings.value("geometryColumnsOnly", False, type=bool)))
uri.setParam('allowGeometrylessTables', unicode(
settings.value("allowGeometrylessTables", False, type=bool)))
uri.setParam('onlyExistingTypes', unicode(
settings.value("onlyExistingTypes", False, type=bool)))
settings.endGroup()
uri.setConnection(host, port, database, username, password)
uri.setUseEstimatedMetadata(useEstimatedMetadata)
err = u""
try:
return self.connectToUri(uri)
except ConnectionError as e:
err = unicode(e)
# ask for valid credentials
max_attempts = 3
for i in range(max_attempts):
(ok, username, password) = QgsCredentials.instance().get(
uri.connectionInfo(False), username, password, err)
if not ok:
return False
uri.setConnection(host, port, database, username, password)
try:
self.connectToUri(uri)
except ConnectionError as e:
if i == max_attempts - 1: # failed the last attempt
raise e
err = unicode(e)
continue
QgsCredentials.instance().put(
uri.connectionInfo(False), username, password)
return True
return False
def installFromZipFile(self):
settings = QSettings()
lastDirectory = settings.value(
'/Qgis/plugin-installer/lastZipDirectory', '.')
filePath, _ = QFileDialog.getOpenFileName(
iface.mainWindow(), self.tr('Open file'), lastDirectory,
self.tr('Plugin packages (*.zip *.ZIP)'))
if filePath == '':
return
settings.setValue('/Qgis/plugin-installer/lastZipDirectory',
QFileInfo(filePath).absoluteDir().absolutePath())
error = False
infoString = None
with zipfile.ZipFile(filePath, 'r') as zf:
pluginName = os.path.split(zf.namelist()[0])[0]
pluginFileName = os.path.splitext(os.path.basename(filePath))[0]
pluginsDirectory = qgis.utils.home_plugin_path
if not QDir(pluginsDirectory).exists():
QDir().mkpath(pluginsDirectory)
# If the target directory already exists as a link,
# remove the link without resolving
QFile(os.path.join(pluginsDirectory, pluginFileName)).remove()
try:
# Test extraction. If fails, then exception will be raised
# and no removing occurs
unzip(str(filePath), str(pluginsDirectory))
# Removing old plugin files if exist
removeDir(
QDir.cleanPath(os.path.join(pluginsDirectory, pluginFileName)))
# Extract new files
unzip(str(filePath), str(pluginsDirectory))
except:
error = True
infoString = (
self.tr("Plugin installation failed"),
self.
tr("Failed to unzip the plugin package\n{}.\nProbably it is broken"
.format(zipFilePath)))
if infoString is None:
updateAvailablePlugins()
loadPlugin(pluginName)
plugins.getAllInstalled(testLoad=True)
plugins.rebuild()
plugin = plugins.all()[pluginName]
if settings.contains('/PythonPlugins/' + pluginName):
if settings.value('/PythonPlugins/' + pluginName, False, bool):
startPlugin(pluginName)
reloadPlugin(pluginName)
else:
unloadPlugin(pluginName)
loadPlugin(pluginName)
else:
if startPlugin(pluginName):
settings.setValue('/PythonPlugins/' + pluginName, True)
infoString = (self.tr("Plugin installed successfully"), "")
if infoString[0]:
level = error and QgsMessageBar.CRITICAL or QgsMessageBar.INFO
msg = "<b>%s:</b>%s" % (infoString[0], infoString[1])
iface.messageBar().pushMessage(msg, level)
def showSelectionDialog(self):
if isinstance(self.output, OutputDirectory):
self.selectDirectory()
return
filefilter = self.output.getFileFilter(self.alg)
settings = QSettings()
if settings.contains('/Processing/LastBatchOutputPath'):
path = str(settings.value('/Processing/LastBatchOutputPath'))
else:
path = ''
filename, selectedFileFilter = QFileDialog.getSaveFileName(self,
self.tr('Save file'), path, filefilter)
if filename:
if not filename.lower().endswith(
tuple(re.findall("\*(\.[a-z]{1,10})", filefilter))):
ext = re.search("\*(\.[a-z]{1,10})", selectedFileFilter)
if ext:
filename += ext.group(1)
settings.setValue('/Processing/LastBatchOutputPath', os.path.dirname(filename))
dlg = AutofillDialog(self.alg)
dlg.exec_()
if dlg.mode is not None:
try:
if dlg.mode == AutofillDialog.DO_NOT_AUTOFILL:
self.table.cellWidget(self.row,
self.col).setValue(filename)
elif dlg.mode == AutofillDialog.FILL_WITH_NUMBERS:
n = self.table.rowCount() - self.row
for i in range(n):
name = filename[:filename.rfind('.')] \
+ str(i + 1) + filename[filename.rfind('.'):]
self.table.cellWidget(i + self.row,
self.col).setValue(name)
elif dlg.mode == AutofillDialog.FILL_WITH_PARAMETER:
n = self.table.rowCount() - self.row
for i in range(n):
widget = self.table.cellWidget(i + self.row,
dlg.param)
param = self.alg.parameters[dlg.param]
if isinstance(param, (ParameterRaster,
ParameterVector, ParameterTable,
ParameterMultipleInput)):
v = widget.value()
if isinstance(v, QgsMapLayer):
s = v.name()
else:
s = os.path.basename(v)
s = os.path.splitext(s)[0]
elif isinstance(param, ParameterBoolean):
s = str(widget.currentIndex() == 0)
elif isinstance(param, ParameterSelection):
s = str(widget.currentText())
elif isinstance(param, ParameterFixedTable):
s = str(widget.table)
else:
s = str(widget.text())
name = filename[:filename.rfind('.')] + s \
+ filename[filename.rfind('.'):]
self.table.cellWidget(i + self.row,
self.col).setValue(name)
except:
pass
import os
from qgis.PyQt.QtCore import QSettings
from gml_application_schema_toolbox import name as plugin_name
DEFAULT_GMLAS_CONFIG = os.path.realpath(
os.path.join(os.path.dirname(__file__), "..", "conf", "gmlasconf.xml"))
defaults = {
"default_maxfeatures": 100,
"wfs2_services": [],
"default_wfs2_service": None,
"default_import_method": "gmlas",
"default_gmlas_config": DEFAULT_GMLAS_CONFIG,
"default_language": "en",
"default_db_type": "SQLite",
"default_access_mode": None,
}
settings = QSettings()
settings.beginGroup(plugin_name())
for key, value in defaults.items():
if not settings.contains(key):
settings.setValue(key, value)
def import_mf_grid(self):
# Initiate function
APEXMOD_path_dict = self.dirs_and_paths()
settings = QSettings()
if settings.contains('/APEXMOD/LastInputPath'):
path = str(settings.value('/APEXMOD/LastInputPath'))
else:
path = ''
title = "Choose MODFLOW Grid Shapefile!"
inFileName, __ = QFileDialog.getOpenFileNames(
None, title, path,
"Shapefiles (*.shp);;All files (*.*)"
)
if inFileName:
settings.setValue('/APEXMOD/LastInputPath', os.path.dirname(str(inFileName)))
output_dir = APEXMOD_path_dict['org_shps']
inInfo = QFileInfo(inFileName[0])
inFile = inInfo.fileName()
pattern = os.path.splitext(inFileName[0])[0] + '.*'
time = datetime.now().strftime('[%m/%d/%y %H:%M:%S]')
self.dlg.textEdit_sm_link_log.append(time+' -> ' + "Importing MODFLOW object ... processing")
self.dlg.label_StepStatus.setText("Importing 'MODFLOW object' ... ")
self.dlg.progressBar_step.setValue(0)
QCoreApplication.processEvents()
# inName = os.path.splitext(inFile)[0]
inName = 'mf_grid_org'
for f in glob.iglob(pattern):
suffix = os.path.splitext(f)[1]
if os.name == 'nt':
outfile = ntpath.join(output_dir, inName + suffix)
else:
outfile = posixpath.join(output_dir, inName + suffix)
shutil.copy(f, outfile)
if os.name == 'nt':
mf_grid_obj = ntpath.join(output_dir, inName + ".shp")
else:
mf_grid_obj = posixpath.join(output_dir, inName + ".shp")
# fix geometries
mf_grid_shp_file = 'mf_grid.shp'
mf_grid_shp_f = os.path.join(output_dir, mf_grid_shp_file)
params = {
'INPUT': mf_grid_obj,
'OUTPUT': mf_grid_shp_f
}
processing.run('native:fixgeometries', params)
layer = QgsVectorLayer(mf_grid_shp_f, '{0} ({1})'.format("mf_grid","MODFLOW"), 'ogr')
# if there is an existing mf_grid shapefile, it will be removed
for lyr in list(QgsProject.instance().mapLayers().values()):
if lyr.name() == ("mf_grid (MODFLOW)"):
QgsProject.instance().removeMapLayers([lyr.id()])
# Put in the group
root = QgsProject.instance().layerTreeRoot()
swat_group = root.findGroup("MODFLOW")
QgsProject.instance().addMapLayer(layer, False)
swat_group.insertChildNode(0, QgsLayerTreeLayer(layer))
self.dlg.lineEdit_MODFLOW_grid_shapefile.setText(mf_grid_shp_f)
time = datetime.now().strftime('[%m/%d/%y %H:%M:%S]')
self.dlg.textEdit_sm_link_log.append(time+' -> ' + "Importing MODFLOW object ... passed")
self.dlg.label_StepStatus.setText("Step Status: ")
self.dlg.progressBar_step.setValue(100)
QCoreApplication.processEvents()
def __init__(self, iface: QgisInterface, version: str, plugin_dir: str, isBatch: bool, isHUC: bool=False, logFile: Optional[str]=None) -> None:
"""Initialise class variables."""
settings = QSettings()
if settings.contains('/QSWATPlus/SWATPlusDir'):
SWATPlusDir = settings.value('/QSWATPlus/SWATPlusDir')
if not os.path.isdir(SWATPlusDir):
SWATPlusDir = Parameters._SWATPLUSDEFAULTDIR
else:
SWATPlusDir = Parameters._SWATPLUSDEFAULTDIR
if not os.path.isdir(SWATPlusDir):
QSWATUtils.error('''Cannot find SWATPlus directory, expected to be {0}.
Please use the Parameters form to set its location.'''.format(SWATPlusDir), isBatch)
else:
settings.setValue('/QSWATPlus/SWATPlusDir', SWATPlusDir)
## SWATPlus directory
self.SWATPlusDir = SWATPlusDir
## Directory containing QSWAT plugin
self.plugin_dir = plugin_dir
## Databases directory: part of plugin
# containing template project and reference databases, plus soil database for STATSGO and SSURGO
self.dbPath = QSWATUtils.join(self.SWATPlusDir, Parameters._DBDIR)
## Path of template project database
self.dbProjTemplate = QSWATUtils.join(self.dbPath, Parameters._DBPROJ)
## Path of template reference database
self.dbRefTemplate = QSWATUtils.join(self.dbPath, Parameters._DBREF)
## Directory of TauDEM executables
self.TauDEMDir = TauDEMUtils.findTauDEMDir(settings, not isBatch)[0]
## Path of mpiexec
self.mpiexecPath = TauDEMUtils.findMPIExecPath(settings)
proj: QgsProject = QgsProject.instance()
title = proj.title()
## QGIS interface
self.iface = iface
## project projection (set from DEM)
self.crsProject: Optional[QgsCoordinateReferenceSystem] = None
## Stream burn-in depth
self.burninDepth: int = proj.readNumEntry(title, 'params/burninDepth', Parameters._BURNINDEPTH)[0]
## Channel width multiplier
self.channelWidthMultiplier: float = proj.readDoubleEntry(title, 'params/channelWidthMultiplier', Parameters._CHANNELWIDTHMULTIPLIER)[0]
## Channel width exponent
self.channelWidthExponent: float = proj.readDoubleEntry(title, 'params/channelWidthExponent', Parameters._CHANNELWIDTHEXPONENT)[0]
## Channel depth multiplier
self.channelDepthMultiplier: float = proj.readDoubleEntry(title, 'params/channelDepthMultiplier', Parameters._CHANNELDEPTHMULTIPLIER)[0]
## Channel depth exponent
self.channelDepthExponent: float = proj.readDoubleEntry(title, 'params/channelDepthExponent', Parameters._CHANNELDEPTHEXPONENT)[0]
## reach slope multiplier
self.reachSlopeMultiplier: float = proj.readDoubleEntry(title, 'params/reachSlopeMultiplier', Parameters._MULTIPLIER)[0]
## tributary slope multiplier
self.tributarySlopeMultiplier: float = proj.readDoubleEntry(title, 'params/tributarySlopeMultiplier', Parameters._MULTIPLIER)[0]
## mean slope multiplier
self.meanSlopeMultiplier: float = proj.readDoubleEntry(title, 'params/meanSlopeMultiplier', Parameters._MULTIPLIER)[0]
## main length multiplier
self.mainLengthMultiplier: float = proj.readDoubleEntry(title, 'params/mainLengthMultiplier', Parameters._MULTIPLIER)[0]
## tributary length multiplier
self.tributaryLengthMultiplier: float = proj.readDoubleEntry(title, 'params/tributaryLengthMultiplier', Parameters._MULTIPLIER)[0]
## upslope HRU drain percent
self.upslopeHRUDrain: int = proj.readNumEntry(title, 'params/upslopeHRUDrain', Parameters._UPSLOPEHRUDRAIN)[0]
## Index of slope group in Layers panel
self.slopeGroupIndex = -1
## Index of landuse group in Layers panel
self.landuseGroupIndex = -1
## Index of soil group in Layers panel
self.soilGroupIndex = -1
## Index of watershed group in Layers panel
self.watershedGroupIndex = -1
## Index of results group in Layers panel
self.resultsGroupIndex = -1
## Index of animation group in Layers panel
self.animationGroupIndex = -1
## Flag showing if using existing watershed
self.existingWshed = False
## Flag showing if using grid model
self.useGridModel = False
## flag to show if using landscape units
self.useLandscapes = False
## flag to show if dividing into left/right/headwater landscape units
self.useLeftRight = False
## Path of DEM raster
self.demFile = ''
## Path of filled DEM raster
self.felFile = ''
## Path of stream burn-in shapefile
self.burnFile = ''
## Path of DEM after burning-in
self.burnedDemFile = ''
## Path of D8 flow direction raster
self.pFile = ''
## Path of D8 flow accumulation raster
self.ad8File = ''
## Path of subbasins raster
self.basinFile = ''
## path of channel basins raster
self.channelBasinFile = ''
## path of channel basins file with lakes masked out
self.chBasinNoLakeFile = ''
## Path of channel raster
self.srcChannelFile = ''
## Path of valleyDepthsFile
# value at each point in this raster is the drop in metres
# from the point to where its D8 flow path meets a channel
# Channel elevations are measured at points adjacent to the channel
# to avoid problems caused by burning-in
self.valleyDepthsFile = ''
## Path of outlets shapefile
self.outletFile = ''
## path of snapped outlets file
self.snapFile = ''
## Path of outlets shapefile for extra reservoirs and point sources
self.extraOutletFile = ''
## Path of stream shapefile
self.streamFile = ''
## Path of stream shapefile calculated by delineation
# since streamFile is set to streams from grid when using a grid model
self.delinStreamFile = ''
## Path of channel shapefile
self.channelFile = ''
## Path of subbasins shapefile or grid file when using grids
self.subbasinsFile = ''
## Path of subbasins shapefile before lakes removed. Not used with grid models.
self.subsNoLakesFile = ''
## Path of watershed shapefile: shows channel basins. Not used with grid models.
self.wshedFile = ''
## Path of file like D8 contributing area but with heightened values at subbasin outlets
self.hd8File = ''
## Path of distance to stream outlets raster
self.distStFile = ''
## Path of distance to channel raster
self.distChFile = ''
## Path of slope raster
self.slopeFile = ''
## path of lakes shapefile
self.lakeFile = ''
## Path of slope bands raster
self.slopeBandsFile = ''
## Path of landuse raster
self.landuseFile = ''
## Path of soil raster
self.soilFile = ''
## path of floodplain raster
self.floodFile = ''
## path of raster generated from playa lakes
self.playaFile = ''
## Nodata value for DEM
self.elevationNoData = 0.0
## DEM horizontal block size
self.xBlockSize = 0
## DEM vertical block size
self.yBlockSize = 0
## Nodata value for basins raster
self.basinNoData = 0
## Nodata value for distance to outlets raster
self.distStNoData = 0.0
## Nodata value for distance to channel raster
self.distChNoData = 0.0
## Nodata value for slope raster
self.slopeNoData = 0
## Nodata value for landuse raster
self.cropNoData = 0
## Nodata value for soil raster
self.soilNoData = 0
## Nodata value for floodplain raster
self.floodNoData = -1
## Area of DEM cell in square metres
self.cellArea = 0.0
## channel threshold in square metres
self.channelThresholdArea = 10000000.0 # 1000 hectares default
## gridSize as count of DEM cells per side (grid model only)
self.gridSize = 0
## list of landuses exempt from HRU removal
self.exemptLanduses: List[str] = []
## table of landuses being split
self.splitLanduses: Dict[str, Dict[str, float]] = dict()
## Elevation bands threshold in metres
self.elevBandsThreshold = 0
## Number of elevation bands
self.numElevBands = 0
## Topology object
self.topo: QSWATTopology = QSWATTopology(isBatch, isHUC)
projFile: str = proj.fileName()
projPath: str = QFileInfo(projFile).canonicalFilePath()
pdir, base = os.path.split(projPath)
## Project name
self.projName = os.path.splitext(base)[0]
## Project directory
self.projDir = pdir
## QSWAT+ version
self.version = version
## DEM directory
self.demDir = ''
## Landuse directory
self.landuseDir = ''
## Soil directory
self.soilDir = ''
## Landscape directory
self.landscapeDir = ''
## Floodplain directory
self.floodDir = ''
## text directory
self.textDir = ''
## Rasters directory
self.rastersDir = ''
## Shapes directory
self.shapesDir = ''
## Scenarios directory
self.scenariosDir = ''
## Results directory
self.resultsDir = ''
## Plots directory
self.plotsDir = ''
## png directory for storing png images used to create animation videos
self.pngDir = ''
## animation directory for storing animation files
self.animationDir = ''
self.createSubDirectories()
## path of full lsus shapefile
self.fullLSUsFile = QSWATUtils.join(self.shapesDir, Parameters._LSUS1 + '.shp')
## path of actual lsus shapefile (after channel mergers
self.actLSUsFile = QSWATUtils.join(self.shapesDir, Parameters._LSUS2 + '.shp')
## Path of FullHRUs shapefile
self.fullHRUsFile = QSWATUtils.join(self.shapesDir, Parameters._HRUS1 + '.shp')
## Path of ActHRUs shapefile
self.actHRUsFile = QSWATUtils.join(self.shapesDir, Parameters._HRUS2 + '.shp')
## Flag to show if running in batch mode
self.isBatch = isBatch
## flag for HUC projects
self.isHUC = isHUC
## log file for message output for HUC projects
self.logFile = logFile
## Path of project database
self.db: DBUtils = DBUtils(self.projDir, self.projName, self.dbProjTemplate, self.dbRefTemplate, self.isHUC, self.logFile, self.isBatch)
## multiplier to turn DEM distances to metres
self.horizontalFactor = 1
## multiplier to turn elevations to metres
self.verticalFactor = 1
## vertical units
self.verticalUnits = Parameters._METRES
# positions of sub windows
## Position of delineation form
self.delineatePos = QPoint(0, 100)
## Position of HRUs form
self.hrusPos = QPoint(0, 100)
## Position of parameters form
self.parametersPos = QPoint(50, 100)
## Position of landscape form
self.landscapePos = QPoint(50, 80)
## Position of select subbasins form
self.selectSubsPos = QPoint(50, 100)
## Position of select reservoirs form
self.selectResPos = QPoint(50, 100)
## Position of about form
self.aboutPos = QPoint(50, 100)
## Position of elevation bands form
self.elevationBandsPos = QPoint(50, 100)
## Position of split landuses form
self.splitPos = QPoint(50, 100)
## Position of select landuses form
self.selectLuPos = QPoint(50, 100)
## Position of exempt landuses form
self.exemptPos = QPoint(50, 100)
## Position of outlets form
self.outletsPos = QPoint(50, 100)
## Position of select outlets file form
self.selectOutletFilePos = QPoint(50, 100)
## Position of select outlets form
self.selectOutletPos = QPoint(50, 100)
## Position of visualise form
self.visualisePos = QPoint(0, 100)
## rasters open that need to be closed if memory exception occurs
self.openRasters: Set[Raster] = set()
## options for creating shapefiles
self.vectorFileWriterOptions = QgsVectorFileWriter.SaveVectorOptions()
self.vectorFileWriterOptions.ActionOnExistingFile = QgsVectorFileWriter.CreateOrOverwriteFile
self.vectorFileWriterOptions.driverName = "ESRI Shapefile"
self.vectorFileWriterOptions.fileEncoding = "UTF-8"
## will set to choice made when converting from ArcSWAT, if that was how the project file was created
# 0: Full
# 1: Existing
# 2: No GIS
# NB These values are defined in convertFromArc.py
self.fromArcChoice = -1
def postgis_path_to_uri(path):
"""Convert layer path from QgsBrowserModel to full QgsDataSourceUri.
:param path: The layer path from QgsBrowserModel
:type path: string
:returns: layer uri.
:rtype: QgsDataSourceUri
"""
connection_name = path.split('/')[1]
schema = path.split('/')[2]
table_name = path.split('/')[3]
settings = QSettings()
key = "/PostgreSQL/connections/" + connection_name
service = settings.value(key + "/service")
host = settings.value(key + "/host")
port = settings.value(key + "/port")
if not port:
port = "5432"
db = settings.value(key + "/database")
use_estimated_metadata = settings.value(key + "/estimatedMetadata",
False,
type=bool)
sslmode = settings.value(key + "/sslmode",
QgsDataSourceUri.SSLprefer,
type=int)
username = ""
password = ""
if settings.value(key + "/saveUsername") == "true":
username = settings.value(key + "/username")
if settings.value(key + "/savePassword") == "true":
password = settings.value(key + "/password")
# Old save setting
if settings.contains(key + "/save"):
username = settings.value(key + "/username")
if settings.value(key + "/save") == "true":
password = settings.value(key + "/password")
uri = QgsDataSourceUri()
if service:
uri.setConnection(service, db, username, password, sslmode)
else:
uri.setConnection(host, port, db, username, password, sslmode)
uri.setUseEstimatedMetadata(use_estimated_metadata)
# Obtain the geometry column name
connector = PostGisDBConnector(uri)
tables = connector.getVectorTables(schema)
tables = [table for table in tables if table[1] == table_name]
if not tables:
return None
table = tables[0]
geom_col = table[8]
uri.setDataSource(schema, table_name, geom_col)
return uri
# -*- coding: utf-8 -*-
import os
from qgis.PyQt.QtCore import QSettings
from gml_application_schema_toolbox import name as plugin_name
DEFAULT_GMLAS_CONFIG = os.path.realpath(os.path.join(
os.path.dirname(__file__),
"..",
"conf",
"gmlasconf.xml"))
defaults = {
"default_maxfeatures": 100,
"wfs2_services": [],
"default_wfs2_service": None,
"default_import_method": "gmlas",
"default_gmlas_config": DEFAULT_GMLAS_CONFIG,
"default_language": "en",
"default_db_type": "SQLite",
"default_access_mode": None
}
settings = QSettings()
settings.beginGroup(plugin_name())
for key, value in defaults.items():
if not settings.contains(key):
settings.setValue(key, value)
