def openModel(self):
filename = unicode(QFileDialog.getOpenFileName(self,
self.tr('Open Model'), ModelerUtils.modelsFolder(),
self.tr('Processing models (*.model *.MODEL)')))
if filename:
try:
alg = ModelerAlgorithm.fromFile(filename)
self.alg = alg
self.alg.setModelerView(self)
self.textGroup.setText(alg.group)
self.textName.setText(alg.name)
self.repaintModel()
self.view.centerOn(0, 0)
self.hasChanged = False
except WrongModelException as e:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('Could not load model %s\n%s') % (filename, e.msg))
QMessageBox.critical(self, self.tr('Could not open model'),
self.tr('The selected model could not be loaded.\n'
'See the log for more information.'))
except Exception as e:
ProcessingLog.addToLog(ProcessingLog.LOG_ERROR,
self.tr('Could not load model %s\n%s') % (filename, e.args[0]))
QMessageBox.critical(self, self.tr('Could not open model'),
self.tr('The selected model could not be loaded.\n'
'See the log for more information.'))
def openModel(self):
filename, selected_filter = QFileDialog.getOpenFileName(self,
self.tr('Open Model'),
ModelerUtils.modelsFolders()[0],
self.tr('Processing models (*.model3 *.MODEL3)'))
if filename:
self.loadModel(filename)
def execute(self):
settings = QSettings()
lastDir = settings.value('Processing/lastModelsDir', '')
filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
self.tr('Open model', 'AddModelFromFileAction'), lastDir,
self.tr('Processing model files (*.model *.MODEL)', 'AddModelFromFileAction'))
if filename:
try:
settings.setValue('Processing/lastModelsDir',
QFileInfo(filename).absoluteDir().absolutePath())
ModelerAlgorithm.fromFile(filename)
except WrongModelException:
QMessageBox.warning(
self.toolbox,
self.tr('Error reading model', 'AddModelFromFileAction'),
self.tr('The selected file does not contain a valid model', 'AddModelFromFileAction'))
return
except:
QMessageBox.warning(self.toolbox,
self.tr('Error reading model', 'AddModelFromFileAction'),
self.tr('Cannot read file', 'AddModelFromFileAction'))
return
destFilename = os.path.join(ModelerUtils.modelsFolders()[0], os.path.basename(filename))
shutil.copyfile(filename, destFilename)
algList.reloadProvider('model')
def on_btnLoad_clicked(self):
fileName, _ = QFileDialog.getOpenFileName(None,
self.tr('Import Colors and elevations from XML'),
QDir.homePath(),
self.tr('XML files (*.xml *.XML)'))
if fileName == '':
return
doc = QDomDocument()
with codecs.open(fileName, 'r', encoding='utf-8') as f:
content = f.read()
if not doc.setContent(content):
QMessageBox.critical(None,
self.tr('Error parsing XML'),
self.tr('The XML file could not be loaded'))
return
self.reliefClassTree.clear()
reliefColorList = doc.elementsByTagName('ReliefColor')
for i in range(reliefColorList.length()):
elem = reliefColorList.at(i).toElement()
item = QTreeWidgetItem()
item.setText(0, elem.attribute('MinElevation'))
item.setText(1, elem.attribute('MaxElevation'))
item.setBackground(2, QBrush(QColor(int(elem.attribute('red')),
int(elem.attribute('green')),
int(elem.attribute('blue')))))
self.reliefClassTree.addTopLevelItem(item)
def openModel(self):
filename, selected_filter = QFileDialog.getOpenFileName(self,
self.tr('Open Model'),
ModelerUtils.modelsFolders()[0],
self.tr('Processing models (*.model *.MODEL)'))
if filename:
try:
alg = ModelerAlgorithm.fromFile(filename)
self.alg = alg
self.alg.setModelerView(self)
self.textGroup.setText(alg._group)
self.textName.setText(alg._name)
self.repaintModel()
self.view.centerOn(0, 0)
self.hasChanged = False
except WrongModelException as e:
QgsMessageLog.logMessage(self.tr('Could not load model {0}\n{1}').format(filename, e.msg),
self.tr('Processing'),
QgsMessageLog.CRITICAL)
QMessageBox.critical(self, self.tr('Could not open model'),
self.tr('The selected model could not be loaded.\n'
'See the log for more information.'))
except Exception as e:
QgsMessageLog.logMessage(self.tr('Could not load model {0}\n{1}').format(filename, e.args[0]),
self.tr('Processing'), QgsMessageLog.CRITICAL)
QMessageBox.critical(self, self.tr('Could not open model'),
self.tr('The selected model could not be loaded.\n'
'See the log for more information.'))
def getOpenFileName(self, parent=None, caption='', filter='', selectedFilter=None, useEncoding=False):
if useEncoding:
return self.getDialog(parent, caption, QFileDialog.AcceptOpen, QFileDialog.ExistingFile, filter, selectedFilter, useEncoding)
res, selected_filter = QFileDialog.getOpenFileName(parent, caption, getLastUsedDir(), filter)
if res:
setLastUsedDir(res)
return res
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 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 selFile(self):
sf = QFileInfo(QFileDialog.getOpenFileName(self, 'Select SLD file', '', 'SLD files (*.sld)'))
f = sf.fileName()
if f!='':
df = os.path.join(os.path.join(self.plugin_dir, 'sld'), f)
shutil.copy(sf.absoluteFilePath(), df)
return f
def on_gmlasConfigButton_clicked(self):
path, filter = QFileDialog.getOpenFileName(self,
self.tr("Open GMLAS config file"),
self.gmlasConfigLineEdit.text(),
self.tr("XML Files (*.xml)"))
if path:
self.gmlasConfigLineEdit.setText(path)
def on_openArchiveButton_clicked(self):
"""opens directory search dialog and sets my attribute __dir"""
l_path = self._start_find_path()
#l_request = "Select zipfile which holds result request Dig ALert"
l_request = self.tr("Selecteer een zip bestand die een KLIC bericht bevat")
l_filter = self.tr("Zip bestanden (*.zip *.ZIP)")
l_fileName, __ = QFileDialog.getOpenFileName(self, l_request, l_path, l_filter)
if l_fileName=="":
return
#l_fileName = unicode(l_fileName)
#first find out if zipfile contains a named directory being
#ID of dig alert
l_dirName = self._dirNameInArchive(l_fileName)
l_dir = os.path.dirname(l_fileName)
l_zipDir = os.path.join(l_dir,l_dirName)
self.__dir = l_zipDir
l_unzipper = unzip.unzip()
l_unzipper.extract(l_fileName, l_zipDir)
#try to find out if after extract, folder holds another folder
#with message id
l_dir_maybe = os.path.join(l_zipDir, l_dirName)
if os.path.isdir(l_dir_maybe):
self.__dir = l_dir_maybe
self._loadMsg()
def selFile(self):
sf = QFileInfo(QFileDialog.getOpenFileName(self, 'Open logo file', QDir.homePath(), 'Image files (*.png)'))
f = sf.fileName()
if f!='':
self.logopath = sf.absoluteFilePath()
self.label.setPixmap(QPixmap(self.logopath))
return f
def select_file(self):
"""select file ops"""
label = self.tr('eXtensible Markup Language (*.xml *.XML)')
if self.mode == 0:
slabel = self.tr('Save connections')
self.filename, filter = QFileDialog.getSaveFileName(self, slabel,
'.', label)
else:
slabel = self.tr('Load connections')
self.filename, selected_filter = QFileDialog.getOpenFileName(self, slabel,
'.', label)
if not self.filename:
return
# ensure the user never omitted the extension from the file name
if not self.filename.lower().endswith('.xml'):
self.filename = '%s.xml' % self.filename
self.leFileName.setText(self.filename)
if self.mode == 1:
self.populate()
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(True)
def qmlOpenDialog(self):
filename = QFileDialog.getOpenFileName(None, "Input QML Style File",
self.qmlLineEdit.text(), "QGIS Layer Style File (*.qml)")[0]
if filename:
self.qmlStyle = filename
self.qmlLineEdit.setText(filename)
self.markerStyleComboBox.setCurrentIndex(2)
def on_open_place_tool_clicked(self):
input_place = self.input_place.text()
if not input_place:
input_place = os.path.expanduser('~')
filename, __ = QFileDialog.getOpenFileName(
self, tr('Input place layer'), input_place, tr('All Files (*.*)'))
if filename:
self.input_place.setText(filename)
def loadAPIFile(self):
settings = QgsSettings()
lastDirPath = settings.value("pythonConsole/lastDirAPIPath", "", type=str)
fileAPI, selected_filter = QFileDialog.getOpenFileName(
self, "Open API File", lastDirPath, "API file (*.api)")
if fileAPI:
self.addAPI(fileAPI)
settings.setValue("pythonConsole/lastDirAPIPath", fileAPI)
def onLoadProjects(self):
title = 'Projekt laden'
fFilter = 'Txt Dateien (*.txt)'
filename, __ = QFileDialog.getOpenFileName(self, title,
self.outputOpt['outputPath'], fFilter)
if filename:
self.loadProj(filename)
else:
return False
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 on_gmlPathButton_clicked(self):
gml_path = settings.value("last_path", settings.value("last_downloaded_path", ""))
path, filter = QFileDialog.getOpenFileName(self,
self.tr("Open GML file"),
gml_path,
self.tr("GML files or XSD (*.gml *.xml *.xsd)"))
if path:
settings.setValue("last_path", os.path.dirname(path))
settings.setValue("last_file", path)
self.gmlPathLineEdit.setText(path)
def on_open_input_tool_clicked(self):
"""Autoconnect slot activated when open input tool button is clicked.
"""
input_path = self.input_path.text()
if not input_path:
input_path = os.path.expanduser('~')
# noinspection PyCallByClass,PyTypeChecker
filename, __ = QFileDialog.getOpenFileName(
self, tr('Input file'), input_path, tr('Raw grid file (*.xml)'))
if filename:
self.input_path.setText(filename)
def select_file(self):
""" Open a dialog to locate the sqlite file and some more..."""
dbpath, __ = QFileDialog.getOpenFileName(None, str("Select database:"), "*.sqlite")
if dbpath: # Only get new db name if not cancelling the FileDialog
self.dbpath = dbpath
self.midvsettingsdialogdock.ms.settingsdict['database'] = utils.anything_to_string_representation({'spatialite': {'dbpath': dbpath}})
self.midvsettingsdialogdock.ms.save_settings('database')
self.midvsettingsdialogdock.load_plot_settings()
warn_about_old_database()
else: # debug
utils.MessagebarAndLog.info(log_msg=ru(QCoreApplication.translate('SpatialiteSettings', "DB selection cancelled and still using database path %s"))%utils.returnunicode(self.midvsettingsdialogdock.ms.settingsdict['database']))
def execute(self):
settings = QgsSettings()
lastDir = settings.value('Processing/lastScriptsDir', '')
filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
self.tr('Open Script', 'AddScriptFromFileAction'), lastDir,
self.tr('Script files (*.py)', 'AddScriptFromFileAction'))
if filename:
settings.setValue('Processing/lastScriptsDir',
QFileInfo(filename).absoluteDir().absolutePath())
dlg = ScriptEditorDialog(filePath=filename)
dlg.show()
def run(self):
filePath = QFileDialog.getOpenFileName(self.iface.mainWindow(), "Choose EPANET Input file",
os.path.join(os.path.join(os.path.expanduser('~')), 'Desktop'),
"Epanet Inp File (*.inp)")
if filePath[0] == "":
return
epa2gis(filePath[0])
self.iface.messageBar().clearWidgets()
msgBox = QMessageBox()
msgBox.setWindowTitle('ImportEpanetInpFiles')
msgBox.setText('Shapefiles have been created successfully in folder "_shapefiles_".')
msgBox.exec_()
def reload_saved_settings(self):
saved_settings, __ = QFileDialog.getOpenFileName(None,'Open file', on_Settings.getOneSetting('directory_last') , "Settings (*.xml);;All files (*)")
if saved_settings is None or saved_settings == "":
return
try:
on_Settings.copySavedSettingsToSettings(saved_settings)
self.reload_settings()
except:
QMessageBox.information(self, self.tr("opeNoise - Calculate Noise Levels"), self.tr("Sorry, but somethigs wrong in import saved settings."))
def execute(self):
settings = QgsSettings()
lastDir = settings.value('Processing/lastModelsDir', '')
filename, selected_filter = QFileDialog.getOpenFileName(self.toolbox,
self.tr('Open Model', 'AddModelFromFileAction'), lastDir,
self.tr('Processing models (*.model3 *.MODEL3)', 'AddModelFromFileAction'))
if filename:
settings.setValue('Processing/lastModelsDir',
QFileInfo(filename).absoluteDir().absolutePath())
dlg = ModelerDialog()
dlg.loadModel(filename)
dlg.show()
def open_north_arrow_path(self):
"""Open File dialog to choose the north arrow path."""
# noinspection PyCallByClass,PyTypeChecker
file_name, __ = QFileDialog.getOpenFileName(
self,
self.tr('Set north arrow image file'),
self.leNorthArrowPath.text(),
self.tr(
'Portable Network Graphics files (*.png *.PNG);;'
'JPEG Images (*.jpg *.jpeg);;'
'GIF Images (*.gif *.GIF);;'
'SVG Images (*.svg *.SVG);;'))
if file_name:
self.leNorthArrowPath.setText(file_name)
def open_organisation_logo_path(self):
"""Open File dialog to choose the organisation logo path."""
# noinspection PyCallByClass,PyTypeChecker
file_name, __ = QFileDialog.getOpenFileName(
self,
self.tr('Set organisation logo file'),
self.organisation_logo_path_line_edit.text(),
self.tr(
'Portable Network Graphics files (*.png *.PNG);;'
'JPEG Images (*.jpg *.jpeg);;'
'GIF Images (*.gif *.GIF);;'
'SVG Images (*.svg *.SVG);;'))
if file_name:
self.organisation_logo_path_line_edit.setText(file_name)
def addConnectionActionSlot(self, item, action, parent, index):
QApplication.restoreOverrideCursor()
try:
filename, selected_filter = QFileDialog.getOpenFileName(parent, "Choose SQLite/SpatiaLite file")
if not filename:
return
finally:
QApplication.setOverrideCursor(Qt.WaitCursor)
conn_name = QFileInfo(filename).fileName()
uri = QgsDataSourceUri()
uri.setDatabase(filename)
self.addConnection(conn_name, uri)
index.internalPointer().itemChanged()
def select(self):
lastDir = ''
if not self.selectFile:
selectedPath = QFileDialog.getExistingDirectory(None,
self.tr('Select directory'), lastDir,
QFileDialog.ShowDirsOnly)
else:
selectedPath, selected_filter = QFileDialog.getOpenFileName(None,
self.tr('Select file'), lastDir, self.tr('All files (*.*)')
)
if not selectedPath:
return
self.lineEdit.setText(selectedPath)
self.canFocusOut = True
def chooseInputFile(self):
vectorFormats = QgsProviderRegistry.instance().fileVectorFilters()
# get last used dir and format
settings = QSettings()
lastDir = settings.value("/db_manager/lastUsedDir", "")
lastVectorFormat = settings.value("/UI/lastVectorFileFilter", "")
# ask for a filename
filename, lastVectorFormat = QFileDialog.getOpenFileName(self, self.tr("Choose the file to import"),
lastDir, vectorFormats, lastVectorFormat)
if filename == "":
return
# store the last used dir and format
settings.setValue("/db_manager/lastUsedDir", QFileInfo(filename).filePath())
settings.setValue("/UI/lastVectorFileFilter", lastVectorFormat)
self.cboInputLayer.setEditText(filename)
def setCsvFilePath(self):
(csvPathNameText, fileTypeDetailsText) = QFileDialog.getOpenFileName(
self, 'Select CSV file', '*.csv')
check_AddCsvFilePath(self, csvPathNameText)
def setShapefilePath(self):
(shapefilePathNameText,
fileTypeDetailsText) = QFileDialog.getOpenFileName(
self, 'Select shapefile', '*.shp')
if shapefilePathNameText is not None:
self.puLineEdit.setText(shapefilePathNameText)
def showSelectionDialog(self):
filename, selected_filter = QFileDialog.getOpenFileName(
self, self.tr('Select Style File'), '',
self.tr('QGIS Layer Style File (*.qml *.QML)'))
if filename:
self.leText.setText(filename)
def onFileSelectClicked(self):
myfile, _ = QFileDialog.getOpenFileName(self, "Sélectionner un fichier",
filter="Fichiers 7zip (*.7z)")
if myfile:
self.lineEdit_file_path.setText(myfile)
def select_siteid_csv(self):
filename, _filter = QFileDialog.getOpenFileName(
self.dlg, "Select SITEID CSV... ", "", "*.csv")
self.dlg.siteidInput.setText(filename)
def select_input(self):
filename = QFileDialog.getOpenFileName(self.dlg, "select input file",
'', '*.shp')
pathname = filename[0]
layer = iface.addVectorLayer(pathname, "Shapefile", "ogr")
def on_gmlasConfigButton_clicked(self):
path, filter = QFileDialog.getOpenFileName(
self, self.tr("Open GMLAS config file"),
self.gmlasConfigLineEdit.text(), self.tr("XML Files (*.xml)"))
if path:
self.gmlasConfigLineEdit.setText(path)
def selectFileName(line_edit_widget, title, file_filter, parent):
filename, matched_filter = QFileDialog.getOpenFileName(
parent, title, line_edit_widget.text(), file_filter)
line_edit_widget.setText(filename)
def charge_individui_us(self, data):
# Clean Qgis Map Later Registry
# QgsMapLayerRegistry.instance().removeAllMapLayers()
# Get the user input, starting with the table name
# self.find_us_cutted(data)
cfg_rel_path = os.path.join(os.sep, 'pyarchinit_DB_folder',
'config.cfg')
file_path = '{}{}'.format(self.HOME, cfg_rel_path)
conf = open(file_path, "r")
con_sett = conf.read()
conf.close()
settings = Settings(con_sett)
settings.set_configuration()
if settings.SERVER == 'sqlite':
sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder',
'pyarchinit_db.sqlite')
db_file_path = '{}{}'.format(self.HOME, sqliteDB_path)
gidstr = id_us = "id_us = '" + str(data[0]) + "'"
if len(data) > 1:
for i in range(len(data)):
gidstr += " OR id_us = '" + str(data[i]) + "'"
uri = QgsDataSourceUri()
uri.setDatabase(db_file_path)
uri.setDataSource('', 'pyarchinit_us_view', 'Geometry', gidstr,
"gid")
layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view',
'spatialite')
###################################################################�
if layerUS.isValid():
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_caratterizzazioni.qml')
# layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
uri.setDataSource('', 'pyarchinit_quote_view', 'Geometry', gidstr,
"gid")
layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view',
'spatialite')
if layerQUOTE.isValid():
QgsProject.instance().addMapLayers([layerQUOTE], True)
elif settings.SERVER == 'postgres':
uri = QgsDataSourceUri()
# set host name, port, database name, username and password
uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE,
settings.USER, settings.PASSWORD)
gidstr = id_us = "id_archzoo = " + str(data[0])
if len(data) > 1:
for i in range(len(data)):
gidstr += " OR id_archzoo = " + str(data[i])
srs = QgsCoordinateReferenceSystem(
self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)
uri.setDataSource("public", "pyarchinit_archeozoo_view",
"the_geom", gidstr, "gid")
layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres")
if layerUS.isValid():
layerUS.setCrs(srs)
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml')
style_path = QFileDialog.getOpenFileName(
self, 'Open file', self.LAYER_STYLE_PATH)
layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
uri.setDataSource("public", "pyarchinit_quote_view", "the_geom",
gidstr, "gid")
layerQUOTE = QgsVectorLayer(uri.uri(),
"Quote Unita' Stratigrafiche",
"postgres")
if layerQUOTE.isValid():
layerQUOTE.setCrs(srs)
style_path = '{}{}'.format(self.LAYER_STYLE_PATH,
'stile_quote.qml')
layerQUOTE.loadNamedStyle(style_path)
try:
QgsProject.instance().addMapLayers([layerQUOTE], True)
except Exception as e:
pass
def charge_vector_layers_periodo(self, cont_per):
self.cont_per = str(cont_per)
# Clean Qgis Map Later Registry
# QgsMapLayerRegistry.instance().removeAllMapLayers()
# Get the user input, starting with the table name
# self.find_us_cutted(data)
cfg_rel_path = os.path.join(os.sep, 'pyarchinit_DB_folder',
'config.cfg')
file_path = '{}{}'.format(self.HOME, cfg_rel_path)
conf = open(file_path, "r")
con_sett = conf.read()
conf.close()
settings = Settings(con_sett)
settings.set_configuration()
if settings.SERVER == 'sqlite':
sqliteDB_path = os.path.join(os.sep, 'pyarchinit_DB_folder',
'pyarchinit_db.sqlite')
db_file_path = '{}{}'.format(self.HOME, sqliteDB_path)
uri = QgsDataSourceUri()
uri.setDatabase(db_file_path)
cont_per_string = "cont_per = '" + self.cont_per + "' OR cont_per LIKE '" + self.cont_per + "/%' OR cont_per LIKE '%/" + self.cont_per + "' OR cont_per LIKE '%/" + self.cont_per + "/%'"
uri.setDataSource('', 'pyarchinit_us_view', 'the_geom',
cont_per_string, "ROWID")
layerUS = QgsVectorLayer(uri.uri(), 'pyarchinit_us_view',
'spatialite')
srs = QgsCoordinateReferenceSystem(
self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)
if layerUS.isValid():
QMessageBox.warning(self, "TESTER", "OK Layer US valido",
QMessageBox.Ok)
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE, 'us_view.qml')
style_path = QFileDialog.getOpenFileName(
self, 'Open file', self.LAYER_STYLE_PATH)
layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
else:
QMessageBox.warning(self, "TESTER", "OK Layer US non valido",
QMessageBox.Ok)
uri.setDataSource('', 'pyarchinit_quote_view', 'the_geom',
cont_per_string, "ROWID")
layerQUOTE = QgsVectorLayer(uri.uri(), 'pyarchinit_quote_view',
'spatialite')
if layerQUOTE.isValid():
# self.USLayerId = layerUS.getLayerID()
style_path = '{}{}'.format(self.LAYER_STYLE_PATH_SPATIALITE,
'quote_us_view.qml')
layerQUOTE.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerQUOTE], True)
elif settings.SERVER == 'postgres':
uri = QgsDataSourceUri()
# set host name, port, database name, username and password
uri.setConnection(settings.HOST, settings.PORT, settings.DATABASE,
settings.USER, settings.PASSWORD)
# cont_per_string = "cont_per = '" + self.cont_per + "' OR cont_per LIKE '" + self.cont_per + "/%' OR cont_per LIKE '%/" + self.cont_per + "' OR cont_per LIKE '%/" + self.cont_per + "/%'"
srs = QgsCoordinateReferenceSystem(
self.SRS, QgsCoordinateReferenceSystem.PostgisCrsId)
uri.setDataSource("public", "pyarchinit_archeozoo_view",
"the_geom", cont_per_string, "id")
layerUS = QgsVectorLayer(uri.uri(), "Fauna", "postgres")
if layerUS.isValid():
layerUS.setCrs(srs)
# self.USLayerId = layerUS.getLayerID()
# style_path = '{}{}'.format(self.LAYER_STYLE_PATH, 'us_caratterizzazioni.qml')
style_path = QFileDialog.getOpenFileName(
self, 'Open file', self.LAYER_STYLE_PATH)
layerUS.loadNamedStyle(style_path)
QgsProject.instance().addMapLayers([layerUS], True)
uri.setDataSource("public", "pyarchinit_quote_view", "the_geom",
cont_per_string, "gid")
layerQUOTE = QgsVectorLayer(uri.uri(),
"Quote Unita' Stratigrafiche",
"postgres")
if layerQUOTE.isValid():
layerQUOTE.setCrs(srs)
style_path = '{}{}'.format(self.LAYER_STYLE_PATH,
'stile_quote.qml')
layerQUOTE.loadNamedStyle(style_path)
try:
QgsProject.instance().addMapLayers([layerQUOTE], True)
except Exception as e:
pass
def browse_datasets(self):
filename = QFileDialog.getOpenFileName()
fname = filename[0].split('/')[-1]
self.dlg.comboBox.addItem(fname)
self.dlg.comboBox.setCurrentText(fname)
def browse_projections(self):
filename = QFileDialog.getOpenFileName()
fname = filename[0].split('/')[-1]
self.dlg.projText.setText(fname)
def selectFile():
self.animationDialog.lineEdit.setText(
QFileDialog.getOpenFileName())
def on_upload_pressed(self):
self.percorso = QFileDialog.getOpenFileName(self,
'Open file', '/')
def select_input_shapefile(self):
filename, _filter = QFileDialog.getOpenFileName(
self.dlg, "Select input shapefile... ", "", "*.shp")
self.dlg.shapefileInput.setText(filename)
def cargacapadepuntos(self):
"""seleciono la capa de puntos con los datos de entrada"""
capaptos = QFileDialog.getOpenFileName( self.dlg , "Selecciona capa de puntos",filter = "shp(*.shp)")
self.dlg.rutaptos.setText(capaptos[0])
print (capaptos[0])
def setSourceFile(self):
# Set the file path to the source file
filters = "Comma Separated Value (*.csv);;ESRI Shapefile (*.shp);;AutoCAD DXF (*.dxf)"
sourceFile, _ = QFileDialog.getOpenFileName(self, "Select Source File", vectorFileDir(), filters)
if sourceFile:
self.txtDataSource.setText(sourceFile)
def select_ownership_csv(self):
filename, _filter = QFileDialog.getOpenFileName(
self.dlg, "Select owner type CSV... ", "", "*.csv")
self.dlg.ownerTypeInput.setText(filename)
def import_params(self):
setting_file = QFileDialog.getOpenFileName(
self, self.tr("Open settings file"), self.lastSavingPath, "*.txt")
if setting_file[0] != '':
with open(setting_file[0]) as json_file:
try:
parameters = json.load(json_file)
param_crs = QgsCoordinateReferenceSystem()
param_crs.createFromProj4(parameters["crs_map"])
if (self.map_crs != param_crs):
# do traslation
transform = QgsCoordinateTransform(
param_crs, self.map_crs, QgsProject.instance())
pointMin = transform.transform(parameters["roi_x_min"],
parameters["roi_y_min"])
pointMax = transform.transform(parameters["roi_x_max"],
parameters["roi_y_max"])
self.roi_x_max = pointMax.x()
self.roi_y_min = pointMin.y()
self.roi_x_min = pointMin.x()
self.roi_y_max = pointMax.y()
else:
self.roi_x_max = parameters["roi_x_max"]
self.roi_y_min = parameters["roi_y_min"]
self.roi_x_min = parameters["roi_x_min"]
self.roi_y_max = parameters["roi_y_max"]
self.ui.XMaxLineEdit.setText(str(round(self.roi_x_max, 3)))
self.ui.YMinLineEdit.setText(str(round(self.roi_y_min, 3)))
self.ui.XMinLineEdit.setText(str(round(self.roi_x_min, 3)))
self.ui.YMaxLineEdit.setText(str(round(self.roi_y_max, 3)))
if "roi_rect_Param" in parameters:
self.rect_Params = parameters["roi_rect_Param"]
else:
rec = QgsRectangle(self.roi_x_min, self.roi_y_min,
self.roi_x_max, self.roi_y_max)
self.rect_Params = {
'center': [rec.center().x(),
rec.center().y()],
'width': rec.width(),
'height': rec.height(),
'rotation': 0
}
self.ui.WidthGeoLineEdit.setText(
str(round(self.rect_Params["width"], 3)))
self.ui.HeightGeoLineEdit.setText(
str(round(self.rect_Params["height"], 3)))
self.ui.SpacingLineEdit.setText(
str(round(parameters["spacing_mm"], 2)))
self.scale = parameters['scale']
self.scale_h = parameters['scale_h']
self.scale_w = parameters['scale_w']
self.ui.ScaleLineEdit.setScale(int(parameters["scale"]))
self.upload_size_from_scale()
self.ui.ZScaleDoubleSpinBox.setValue(parameters["z_scale"])
self.get_z_max_z_min()
self.ui.BaseHeightLineEdit.setText(
str(round(parameters["z_base"], 3)))
self.ui.RevereseZCheckBox.setChecked(parameters["z_inv"])
self.get_height_model()
if "divideRow" in parameters:
self.ui.RowPartsSpinBox.setValue(
int(parameters["divideRow"]))
if "divideCols" in parameters:
self.ui.ColPartsSpinBox.setValue(
int(parameters["divideCols"]))
self.paint_extent(self.rect_Params)
except:
QMessageBox.warning(self, self.tr("Attention"),
self.tr("Wrong file"))
def select_meta_file(self):
filename, _filter = QFileDialog.getOpenFileName(
self.dockwidget, "Select WBNM _Meta.out file", "", "*_Meta.out")
return filename
def t1_Upload_Node_Layer(self):
proposed_nodes_file, _filter = QFileDialog.getOpenFileName(
self.dlg, "Select Nodelayer file ", "", '*.csv')
self.dlg.lineEdit_23.setText(proposed_nodes_file)
def getSQLFile(self):
fd = QFileDialog()
filename = fd.getOpenFileName(caption=self.tr('Select a SQL file'),
filter=self.tr('sql file (*.sql)'))
return filename
def select_input_file_landuse(self):
global filelanduse
filelanduse, _filter = QFileDialog.getOpenFileName(self.dlg, "Select land use map:")
self.dlg.TB_landuse.setText(filelanduse)
def select_input_file_temp(self):
filename, _filter = QFileDialog.getOpenFileName(self.dlg, "Select temperature map:")
self.dlg.TB_temp.setText(filename)
def select_ts_datasource(self):
"""
Open File dialog for selecting netCDF result files, triggered by button
:return: boolean, if file is selected
"""
settings = QSettings("3di", "qgisplugin")
try:
init_path = settings.value("last_used_datasource_path", type=str)
except TypeError:
logger.debug(
"Last used datasource path is no string, setting it to our home dir."
)
init_path = os.path.expanduser("~")
filename, __ = QFileDialog.getOpenFileName(
self,
"Open resultaten file",
init_path,
"NetCDF (subgrid_map.nc results_3di.nc)",
)
if filename:
# Little test for checking if there is an id mapping file available
# If not we check if an .h5 file is available
# If not we're not going to proceed
datasource_type = detect_netcdf_version(filename)
logger.info("Netcdf result file selected: %s, type is %s",
filename, datasource_type)
if datasource_type == "netcdf-groundwater":
try:
find_h5_file(filename)
except FileNotFoundError:
logger.warning(
"Groundwater h5 not found (%s), warning the user.",
filename)
pop_up_info(
"You selected a netcdf that was created "
"(after May 2018) with a 3Di calculation"
"core that is able to include groundwater"
" calculations. The ThreeDiToolbox reads "
"this netcdf together with an .h5 file, we "
"could however not find this .h5 file. Please "
"add this file next to the netcdf and try "
"again",
title="Error",
)
return False
elif datasource_type == "netcdf":
logger.warning(
"Result file (%s) version is too old. Warning the user.",
filename)
pop_up_info(
"The selected result data is too old and no longer "
"supported in this version of ThreediToolbox. Please "
"recalculate the results with a newer version of the "
"threedicore or use the ThreediToolbox plugin for QGIS 2",
title="Error",
)
# TODO: the below "return False" was previously missing. Check
# if Reinout was right in adding it :-)
return False
items = [{
"type": datasource_type,
"name": os.path.basename(filename).lower().rstrip(".nc"),
"file_path": filename,
}]
self.ts_datasources.insertRows(items)
settings.setValue("last_used_datasource_path",
os.path.dirname(filename))
return True
return False
