def testCalculateDateTimesFromISO8601(self):
# invalid duration string
vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601(
'x')
self.assertFalse(ok)
vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601(
'a-03-23T00:00:00Z/2021-03-24T12:00:00Z/PT12H')
self.assertFalse(ok)
vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601(
'2021-03-23T00:00:00Z/b-03-24T12:00:00Z/PT12H')
self.assertFalse(ok)
vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601(
'2021-03-23T00:00:00Z/2021-03-24T12:00:00Z/xc')
self.assertFalse(ok)
vals, ok, exceeded = QgsTemporalUtils.calculateDateTimesFromISO8601(
'2021-03-23T00:00:00Z/2021-03-24T12:00:00Z/PT12H')
self.assertEqual(vals, [
QDateTime(2021, 3, 23, 0, 0, 0, 0, Qt.TimeSpec(1)),
QDateTime(2021, 3, 23, 12, 0, 0, 0, Qt.TimeSpec(1)),
QDateTime(2021, 3, 24, 0, 0, 0, 0, Qt.TimeSpec(1)),
QDateTime(2021, 3, 24, 12, 0, 0, 0, Qt.TimeSpec(1))
])
self.assertTrue(ok)
self.assertFalse(exceeded)
def fetchAvailablePlugins(self, reloadMode):
""" Fetch plugins from all enabled repositories."""
""" reloadMode = true: Fully refresh data from QgsSettings to mRepositories """
""" reloadMode = false: Fetch unready repositories only """
QApplication.setOverrideCursor(Qt.WaitCursor)
if reloadMode:
repositories.load()
plugins.clearRepoCache()
plugins.getAllInstalled()
for key in repositories.allEnabled():
if reloadMode or repositories.all()[key]["state"] == 3: # if state = 3 (error or not fetched yet), try to fetch once again
repositories.requestFetching(key)
if repositories.fetchingInProgress():
fetchDlg = QgsPluginInstallerFetchingDialog(iface.mainWindow())
fetchDlg.exec_()
del fetchDlg
for key in repositories.all():
repositories.killConnection(key)
QApplication.restoreOverrideCursor()
# display error messages for every unavailable reposioty, unless Shift pressed nor all repositories are unavailable
keepQuiet = QgsApplication.keyboardModifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier)
if repositories.allUnavailable() and repositories.allUnavailable() != repositories.allEnabled():
for key in repositories.allUnavailable():
if not keepQuiet:
QMessageBox.warning(iface.mainWindow(), self.tr("QGIS Python Plugin Installer"), self.tr("Error reading repository:") + " " + key + "\n\n" + repositories.all()[key]["error"])
if QgsApplication.keyboardModifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier):
keepQuiet = True
# finally, rebuild plugins from the caches
plugins.rebuild()
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
#load the ui
uic.loadUi(UI_PATH, self)
self.iface = iface
self.HelpButton.clicked.connect(self.Help)
def paint_extent(self, rec):
self.roi_x_max = rec.xMaximum()
self.ui.XMaxLineEdit.setText(str(round(rec.xMaximum(), 3)))
self.roi_y_min = rec.yMinimum()
self.ui.YMinLineEdit.setText(str(round(rec.yMinimum(), 3)))
self.roi_x_min = rec.xMinimum()
self.ui.XMinLineEdit.setText(str(round(rec.xMinimum(), 3)))
self.roi_y_max = rec.yMaximum()
self.ui.YMaxLineEdit.setText(str(round(rec.yMaximum(), 3)))
if self.extent:
self.canvas.scene().removeItem(self.extent)
self.extent = None
self.extent = QgsRubberBand(self.canvas, True)
points = [
QgsPoint(self.roi_x_max, self.roi_y_min),
QgsPoint(self.roi_x_max, self.roi_y_max),
QgsPoint(self.roi_x_min, self.roi_y_max),
QgsPoint(self.roi_x_min, self.roi_y_min),
QgsPoint(self.roi_x_max, self.roi_y_min)
]
self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None)
self.extent.setColor(QColor(227, 26, 28, 255))
self.extent.setWidth(3)
self.extent.setLineStyle(Qt.PenStyle(Qt.DashLine))
self.canvas.refresh()
def flags(self, idx):
if idx.column() == self.LAYER_COL:
return Qt.ItemIsEnabled
layer = self.map_layer(idx)
if not layer:
return Qt.NoItemFlags
else:
enabled_flags = Qt.ItemIsEnabled | Qt.ItemIsEditable | Qt.ItemIsUserCheckable
if idx.column() == self.LAYER_COL:
return Qt.ItemIsEnabled
elif idx.column() == self.PACK_COL:
return enabled_flags if layer.id() in self.packable else Qt.ItemFlags()
elif idx.column() in (self.KEEP_COL, self.IGNORE_COL):
return enabled_flags
return Qt.ItemFlags()
def tableContentSet(self, file, rows):
"""Dodanie APP do tabeli zbioru"""
def path_leaf(file):
head, tail = ntpath.split(file)
return tail or ntpath.basename(head)
file2 = path_leaf(file)
flags = Qt.ItemFlags(32)
self.zbiorPrzygotowanieDialog.appTable_widget.setRowCount(rows + 1)
# pierwsza kolumna
idIIP = utils.getIPPapp(file)
itemIIP = QTableWidgetItem(idIIP)
itemIIP.setFlags(flags)
self.zbiorPrzygotowanieDialog.appTable_widget.setItem(
rows, 0, itemIIP)
# druga kolumna
self.zbiorPrzygotowanieDialog.appTable_widget.setItem(
rows, 1, QTableWidgetItem(file2))
test = self.zbiorPrzygotowanieDialog.appTable_widget.item(rows, 1)
test.setToolTip(file)
# trzecia kolumna
t = os.path.getmtime(file)
mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(t))
item = QTableWidgetItem(mtime)
item.setFlags(flags)
# dodanie do tabeli
self.zbiorPrzygotowanieDialog.appTable_widget.setItem(rows, 2, item)
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.input_layer = None
self.raster_layer = None
self.raster_layer_box.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.raster_layer_box.layerChanged.connect(self.setRasterLayer)
self.raster_band_box.setEnabled(False)
self.method_box.addItem('nearest neighbor (downscaling/upscaling)')
self.method_box.addItem('bi-linear (downscaling)')
self.method_box.addItem('bi-cubic (downscaling)')
#connect by signal and slot
self.browse_button.clicked.connect(self.onBrowseButtonClicked)
self.interpolation_group.clicked.connect(self.change_interpolation)
self.HelpButton.clicked.connect(self.Help)
self.iface.currentLayerChanged.connect(self.setInputLayer)
self.setInputLayer(self.iface.activeLayer())
self.setRasterLayer(self.raster_layer_box.currentLayer())
def fill_to_sld(symbolLayer, document, element, brushStyle, color):
patternName = ''
if brushStyle == Qt.NoBrush:
return
elif brushStyle == Qt.SolidPattern:
if color.isValid():
cssElement = createCssParameterElement(document, 'fill',
color.name())
element.appendChild(cssElement)
if color.alpha() < 255:
cssElement = createCssParameterElement(
document, 'fill-opacity',
QgsSymbolLayerV2Utils.encodeSldAlpha(color.alpha()))
element.appendChild()
return
elif brushStyle in (
Qt.CrossPattern,
Qt.CrossPattern,
Qt.DiagCrossPattern,
Qt.HorPattern,
Qt.VerPattern,
Qt.BDiagPattern,
Qt.FDiagPattern,
Qt.Dense1Pattern,
Qt.Dense2Pattern,
Qt.Dense3Pattern,
Qt.Dense4Pattern,
Qt.Dense5Pattern,
Qt.Dense6Pattern,
Qt.Dense7Pattern,
):
patternName = QgsSymbolLayerV2Utils.encodeSldBrushStyle(brushStyle)
return
else:
element.appendChild(document.createComment('Brush not supported'))
graphicFillElem = document.createElement('sld:GraphicFill')
element.appendChild(graphicFillElem)
graphicElem = document.createElement('sld:Graphic')
element.appendChild(graphicElem)
fillColor = color if patternName.startswith('brush://') else Qt.QColor()
borderColor = \
color if not patternName.startswith('brush://') else Qt.QColor()
# Use WellKnownName tag to handle QT brush styles.
QgsSymbolLayerV2Utils.wellKnownMarkerToSld(document, graphicElem,
patternName, fillColor,
borderColor, Qt.SolidLine, -1,
-1)
def flags(self, index):
column_def = self.columns[index.column()]
flags = Qt.ItemFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
if column_def['name'] != 'constraints':
flags = flags | Qt.ItemIsEditable
return flags
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.input_layer = None
self.browse_button.clicked.connect(self.onBrowseButtonClicked)
self.iface.currentLayerChanged.connect(self.setInputLayer)
self.setInputLayer(self.iface.activeLayer())
def __init__(self, canvas, callback):
self.canvas = canvas
QgsMapTool.__init__(self, self.canvas)
self.callback = callback
self.rubberBand = QgsRubberBand(self.canvas, True)
self.rubberBand.setColor(QColor(227, 26, 28, 255))
self.rubberBand.setWidth(3)
self.rubberBand.setLineStyle(Qt.PenStyle(Qt.DashLine))
self.reset()
def validateCurrentPage(self):
if self.currentId() == 0:
if self.importRadioButton.checkState() == Qt.Unchecked(
) and self.createNewRadioButton.checkState() == Qt.Unchecked(
) and self.installRadioButton.checkState() == Qt.Unchecked():
errorMsg = self.tr('An option must be chosen!\n')
QMessageBox.warning(self, self.tr('Error!'), errorMsg)
return False
if self.installRadioButton.checkState() == Qt.Checked():
if self.settingComboBox.currentIndex() == 0:
errorMsg = self.tr('A setting must be chosen!\n')
QMessageBox.warning(self, self.tr('Error!'), errorMsg)
return False
else:
return True
return True
else:
return True
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent=parent, flags=flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.db_host.editingFinished.connect(self.onConnectionSettingsEdited)
self.db_name.editingFinished.connect(self.onConnectionSettingsEdited)
self.db_user.editingFinished.connect(self.onConnectionSettingsEdited)
self.db_pass.editingFinished.connect(self.onConnectionSettingsEdited)
self.browse_button.clicked.connect(self.onBrowseButtonClicked)
self.connect_button.clicked.connect(self.onConnectClicked)
def paint_extent(self, rectParams):
width = rectParams["width"]
height = rectParams["height"]
points = getPointsFromRectangleParams(rectParams)
# 0 W 1
# +---------------+
# | |
# H | + AuxPto
# | |
# +---------------+ ----------> rotation
# 3 W 2
self.roi_x_max = points[1][0]
self.ui.XMaxLineEdit.setText(str(round(self.roi_x_max, 3)))
self.roi_y_min = points[3][1]
self.ui.YMinLineEdit.setText(str(round(self.roi_y_min, 3)))
self.roi_x_min = points[3][0]
self.ui.XMinLineEdit.setText(str(round(self.roi_x_min, 3)))
self.roi_y_max = points[1][1]
self.ui.YMaxLineEdit.setText(str(round(self.roi_y_max, 3)))
self.ui.WidthGeoLineEdit.setText(str(round(width, 3)))
self.ui.HeightGeoLineEdit.setText(str(round(height, 3)))
if self.extent:
self.canvas.scene().removeItem(self.extent)
self.extent = None
if self.divisions:
self.canvas.scene().removeItem(self.divisions)
self.divisions = []
self.extent = QgsRubberBand(self.canvas, True)
points = [
QgsPoint(points[0][0], points[0][1]),
QgsPoint(points[1][0], points[1][1]),
QgsPoint(points[2][0], points[2][1]),
QgsPoint(points[3][0], points[3][1]),
QgsPoint(points[0][0], points[0][1])
]
self.extent.setToGeometry(QgsGeometry.fromPolyline(points), None)
self.extent.setColor(QColor(227, 26, 28, 255))
self.extent.setWidth(3)
self.extent.setLineStyle(Qt.PenStyle(Qt.DashLine))
self.paint_model_division()
self.canvas.refresh()
def show_test_dialog(self):
test_dialog = QgsDialog(parent=self.iface.mainWindow(),
fl=Qt.WindowFlags(),
buttons=QDialogButtonBox.Close)
test_dialog.setWindowTitle("TEST DIALOG")
test_dialog.resize(300, 150)
date_time_edit = QgsDateTimeEdit(test_dialog)
date_time_edit.setMinimumSize(150, 30)
date_time_edit.move(20, 30)
btn_accept = QPushButton(test_dialog)
btn_accept.move(20, 80)
btn_accept.setText("Accept")
btn_accept.clicked.connect(self.test_dialog_signal)
test_dialog.open()
def tableContentGML(self, file, rows):
# data modyfikacji
def path_leaf(file):
head, tail = ntpath.split(file)
return tail or ntpath.basename(head)
file2 = path_leaf(file)
flags = Qt.ItemFlags(32)
self.generowanieGMLDialog.filesTable_widget.setRowCount(rows + 1)
self.generowanieGMLDialog.filesTable_widget.setItem(
rows, 0, QTableWidgetItem(file2))
test = self.generowanieGMLDialog.filesTable_widget.item(rows, 0)
test.setToolTip(file)
t = os.path.getmtime(file)
mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(t))
item = QTableWidgetItem(mtime)
item.setFlags(flags)
self.generowanieGMLDialog.filesTable_widget.setItem(rows, 2, item)
# Ustawianie rodzaju dokumentu
docNames = {
'AktPlanowaniaPrzestrzennego': 'APP',
'RysunekAktuPlanowaniaPrzestrzennego': 'Rysunek APP',
'DokumentFormalny': 'Dokument Formalny'
}
docName = docNames[utils.getDocType(file)]
rodzaj = ['Dokument Formalny', 'APP', 'Rysunek APP']
item2 = QTableWidgetItem(docName)
item2.setFlags(flags)
self.generowanieGMLDialog.filesTable_widget.setItem(rows, 1, item2)
# relacja z APP
if self.generowanieGMLDialog.filesTable_widget.item(rows, 1).text() == 'Dokument Formalny':
c = QComboBox()
c.addItems(dictionaries.relacjeDokumentu.keys())
i = self.generowanieGMLDialog.filesTable_widget.model().index(rows, 3)
self.generowanieGMLDialog.filesTable_widget.setCellWidget(
rows, 3, c)
else:
empty = QTableWidgetItem('')
empty.setFlags(flags)
self.generowanieGMLDialog.filesTable_widget.setItem(rows, 3, empty)
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.input_layer = None
self.iface.currentLayerChanged.connect(self.setInputLayer)
self.setInputLayer(self.iface.activeLayer())
# self.listWidget.currentRowChanged.connect(self.updateRasterPropertiesGroup)
self.addButton_2source.clicked.connect(self.add2sourcelist)
self.addButton_2sink.clicked.connect(self.add2sinklist)
self.addButton_2source_sink_pair.clicked.connect(self.merge2pair)
self.removeButton.clicked.connect(self.remove_pair)
self.browseButton.clicked.connect(self.onBrowseButtonClicked)
self.browseButton.setAutoDefault(False)
self.comboBox_conTypes.addItem('physical')
self.comboBox_conTypes.addItem('cyber')
self.comboBox_conTypes.addItem('geographic')
self.comboBox_conTypes.addItem('logical')
def tableContentAddSet(self, iip, file, rows):
"""Dodanie zbioru do tabeli zbioru"""
flags = Qt.ItemFlags(32)
self.zbiorPrzygotowanieDialog.appTable_widget.setRowCount(rows + 1)
# pierwsza kolumna
idIIP = iip
itemIIP = QTableWidgetItem(idIIP)
itemIIP.setFlags(flags)
self.zbiorPrzygotowanieDialog.appTable_widget.setItem(
rows, 0, itemIIP)
# druga kolumna
self.zbiorPrzygotowanieDialog.appTable_widget.setItem(
rows, 1, QTableWidgetItem(file))
# trzecia kolumna
t = os.path.getmtime(file)
mtime = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(t))
item = QTableWidgetItem(mtime)
item.setFlags(flags)
# dodanie do tabeli
self.zbiorPrzygotowanieDialog.appTable_widget.setItem(rows, 2, item)
def paint_model_division(self):
if self.rect_Params is None:
return
if self.divisions:
self.canvas.scene().removeItem(self.divisions)
self.divisions = []
x_models = int(self.ui.ColPartsSpinBox.value())
y_models = int(self.ui.RowPartsSpinBox.value())
points = getPointsFromRectangleParams(self.rect_Params)
lines = []
if y_models > 1:
model_height = self.rect_Params["height"] / y_models
custRot = self.rect_Params['rotation'] - math.pi * 0.5
for i in range(1, y_models):
p1 = getPolarPoint(points[0][0], points[0][1], custRot,
model_height * i)
p2 = getPolarPoint(points[1][0], points[1][1], custRot,
model_height * i)
lines.append(
[QgsPointXY(p1[0], p1[1]),
QgsPointXY(p2[0], p2[1])])
if x_models > 1:
model_width = self.rect_Params["width"] / x_models
for i in range(1, x_models):
p1 = getPolarPoint(points[3][0], points[3][1],
self.rect_Params['rotation'],
model_width * i)
p2 = getPolarPoint(points[0][0], points[0][1],
self.rect_Params['rotation'],
model_width * i)
lines.append(
[QgsPointXY(p1[0], p1[1]),
QgsPointXY(p2[0], p2[1])])
if lines:
self.divisions = QgsRubberBand(self.canvas, False)
self.divisions.setColor(QColor(227, 26, 28, 255))
self.divisions.setWidth(3)
self.divisions.setLineStyle(Qt.PenStyle(Qt.DashDotLine))
self.divisions.setToGeometry(
QgsGeometry.fromMultiPolylineXY(lines), None)
def __init__(self, model=None):
super().__init__(None)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi(self)
# LOTS of bug reports when we include the dock creation in the UI file
# see e.g. #16428, #19068
# So just roll it all by hand......!
self.propertiesDock = QgsDockWidget(self)
self.propertiesDock.setFeatures(
QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable)
self.propertiesDock.setObjectName("propertiesDock")
propertiesDockContents = QWidget()
self.verticalDockLayout_1 = QVBoxLayout(propertiesDockContents)
self.verticalDockLayout_1.setContentsMargins(0, 0, 0, 0)
self.verticalDockLayout_1.setSpacing(0)
self.scrollArea_1 = QgsScrollArea(propertiesDockContents)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.scrollArea_1.sizePolicy().hasHeightForWidth())
self.scrollArea_1.setSizePolicy(sizePolicy)
self.scrollArea_1.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_1.setFrameShape(QFrame.NoFrame)
self.scrollArea_1.setFrameShadow(QFrame.Plain)
self.scrollArea_1.setWidgetResizable(True)
self.scrollAreaWidgetContents_1 = QWidget()
self.gridLayout = QGridLayout(self.scrollAreaWidgetContents_1)
self.gridLayout.setContentsMargins(6, 6, 6, 6)
self.gridLayout.setSpacing(4)
self.label_1 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_1, 0, 0, 1, 1)
self.textName = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textName, 0, 1, 1, 1)
self.label_2 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
self.textGroup = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textGroup, 1, 1, 1, 1)
self.label_1.setText(self.tr("Name"))
self.textName.setToolTip(self.tr("Enter model name here"))
self.label_2.setText(self.tr("Group"))
self.textGroup.setToolTip(self.tr("Enter group name here"))
self.scrollArea_1.setWidget(self.scrollAreaWidgetContents_1)
self.verticalDockLayout_1.addWidget(self.scrollArea_1)
self.propertiesDock.setWidget(propertiesDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.propertiesDock)
self.propertiesDock.setWindowTitle(self.tr("Model properties"))
self.inputsDock = QgsDockWidget(self)
self.inputsDock.setFeatures(QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable)
self.inputsDock.setObjectName("inputsDock")
self.inputsDockContents = QWidget()
self.verticalLayout_3 = QVBoxLayout(self.inputsDockContents)
self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
self.scrollArea_2 = QgsScrollArea(self.inputsDockContents)
sizePolicy.setHeightForWidth(self.scrollArea_2.sizePolicy().hasHeightForWidth())
self.scrollArea_2.setSizePolicy(sizePolicy)
self.scrollArea_2.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_2.setFrameShape(QFrame.NoFrame)
self.scrollArea_2.setFrameShadow(QFrame.Plain)
self.scrollArea_2.setWidgetResizable(True)
self.scrollAreaWidgetContents_2 = QWidget()
self.verticalLayout = QVBoxLayout(self.scrollAreaWidgetContents_2)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(0)
self.inputsTree = QTreeWidget(self.scrollAreaWidgetContents_2)
self.inputsTree.setAlternatingRowColors(True)
self.inputsTree.header().setVisible(False)
self.verticalLayout.addWidget(self.inputsTree)
self.scrollArea_2.setWidget(self.scrollAreaWidgetContents_2)
self.verticalLayout_3.addWidget(self.scrollArea_2)
self.inputsDock.setWidget(self.inputsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.inputsDock)
self.inputsDock.setWindowTitle(self.tr("Inputs"))
self.algorithmsDock = QgsDockWidget(self)
self.algorithmsDock.setFeatures(QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable)
self.algorithmsDock.setObjectName("algorithmsDock")
self.algorithmsDockContents = QWidget()
self.verticalLayout_4 = QVBoxLayout(self.algorithmsDockContents)
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
self.scrollArea_3 = QgsScrollArea(self.algorithmsDockContents)
sizePolicy.setHeightForWidth(self.scrollArea_3.sizePolicy().hasHeightForWidth())
self.scrollArea_3.setSizePolicy(sizePolicy)
self.scrollArea_3.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_3.setFrameShape(QFrame.NoFrame)
self.scrollArea_3.setFrameShadow(QFrame.Plain)
self.scrollArea_3.setWidgetResizable(True)
self.scrollAreaWidgetContents_3 = QWidget()
self.verticalLayout_2 = QVBoxLayout(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setSpacing(4)
self.searchBox = QgsFilterLineEdit(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.addWidget(self.searchBox)
self.algorithmTree = QgsProcessingToolboxTreeView(None,
QgsApplication.processingRegistry())
self.algorithmTree.setAlternatingRowColors(True)
self.algorithmTree.header().setVisible(False)
self.verticalLayout_2.addWidget(self.algorithmTree)
self.scrollArea_3.setWidget(self.scrollAreaWidgetContents_3)
self.verticalLayout_4.addWidget(self.scrollArea_3)
self.algorithmsDock.setWidget(self.algorithmsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.algorithmsDock)
self.algorithmsDock.setWindowTitle(self.tr("Algorithms"))
self.searchBox.setToolTip(self.tr("Enter algorithm name to filter list"))
self.searchBox.setShowSearchIcon(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.centralWidget().layout().insertWidget(0, self.bar)
try:
self.setDockOptions(self.dockOptions() | QMainWindow.GroupedDragging)
except:
pass
if iface is not None:
self.mToolbar.setIconSize(iface.iconSize())
self.setStyleSheet(iface.mainWindow().styleSheet())
self.mActionOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.mActionSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.mActionSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.mActionSaveInProject.setIcon(
QgsApplication.getThemeIcon('/mAddToProject.svg'))
self.mActionZoomActual.setIcon(
QgsApplication.getThemeIcon('/mActionZoomActual.svg'))
self.mActionZoomIn.setIcon(
QgsApplication.getThemeIcon('/mActionZoomIn.svg'))
self.mActionZoomOut.setIcon(
QgsApplication.getThemeIcon('/mActionZoomOut.svg'))
self.mActionExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.mActionZoomToItems.setIcon(
QgsApplication.getThemeIcon('/mActionZoomFullExtent.svg'))
self.mActionExportPdf.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsPDF.svg'))
self.mActionExportSvg.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsSVG.svg'))
#self.mActionExportPython.setIcon(
# QgsApplication.getThemeIcon('/mActionSaveAsPython.svg'))
self.mActionEditHelp.setIcon(
QgsApplication.getThemeIcon('/mActionEditHelpContent.svg'))
self.mActionRun.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock)
self.tabifyDockWidget(self.inputsDock, self.algorithmsDock)
self.inputsDock.raise_()
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint |
Qt.WindowMaximizeButtonHint |
Qt.WindowCloseButtonHint)
settings = QgsSettings()
self.restoreState(settings.value("/Processing/stateModeler", QByteArray()))
self.restoreGeometry(settings.value("/Processing/geometryModeler", QByteArray()))
self.scene = ModelerScene(self, dialog=self)
self.scene.setSceneRect(QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'):
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'):
data = event.mimeData().data('application/x-vnd.qgis.qgis.algorithmid')
stream = QDataStream(data, QIODevice.ReadOnly)
algorithm_id = stream.readQString()
alg = QgsApplication.processingRegistry().createAlgorithmById(algorithm_id)
if alg is not None:
self._addAlgorithm(alg, event.pos())
else:
assert False, algorithm_id
elif event.mimeData().hasText():
itemId = event.mimeData().text()
if itemId in [param.id() for param in QgsApplication.instance().processingRegistry().parameterTypes()]:
self.addInputOfType(itemId, event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'):
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QgsSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
# "Normal" mouse has an angle delta of 120, precision mouses provide data
# faster, in smaller steps
factor = 1.0 + (factor - 1.0) / 120.0 * abs(event.angleDelta().y())
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].data(0, Qt.UserRole)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
self.algorithms_model = ModelerToolboxModel(self, QgsApplication.processingRegistry())
self.algorithmTree.setToolboxProxyModel(self.algorithms_model)
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
self.algorithmTree.setFilters(QgsProcessingToolboxProxyModel.FilterModeler)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(QCoreApplication.translate('ModelerDialog', 'Search…'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(self.tr('Enter model name here'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(self.tr('Enter group name here'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.algorithmTree.setFilterString)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
# Ctrl+= should also trigger a zoom in action
ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self)
ctrlEquals.activated.connect(self.zoomIn)
self.mActionOpen.triggered.connect(self.openModel)
self.mActionSave.triggered.connect(self.save)
self.mActionSaveAs.triggered.connect(self.saveAs)
self.mActionSaveInProject.triggered.connect(self.saveInProject)
self.mActionZoomIn.triggered.connect(self.zoomIn)
self.mActionZoomOut.triggered.connect(self.zoomOut)
self.mActionZoomActual.triggered.connect(self.zoomActual)
self.mActionZoomToItems.triggered.connect(self.zoomToItems)
self.mActionExportImage.triggered.connect(self.exportAsImage)
self.mActionExportPdf.triggered.connect(self.exportAsPdf)
self.mActionExportSvg.triggered.connect(self.exportAsSvg)
#self.mActionExportPython.triggered.connect(self.exportAsPython)
self.mActionEditHelp.triggered.connect(self.editHelp)
self.mActionRun.triggered.connect(self.runModel)
if model is not None:
self.model = model.create()
self.model.setSourceFilePath(model.sourceFilePath())
self.textGroup.setText(self.model.group())
self.textName.setText(self.model.displayName())
self.repaintModel()
else:
self.model = QgsProcessingModelAlgorithm()
self.model.setProvider(QgsApplication.processingRegistry().providerById('model'))
self.fillInputsTree()
self.view.centerOn(0, 0)
self.help = None
self.hasChanged = False
def flags(self, index):
flags = (Qt.ItemIsSelectable
+ Qt.ItemIsEditable
+ Qt.ItemIsEnabled)
return Qt.ItemFlags(flags)
def test_tool(self):
"""
Test some plot tool logic
"""
canvas = QgsElevationProfileCanvas()
canvas.setCrs(QgsCoordinateReferenceSystem('EPSG:4326'))
canvas.setFrameStyle(0)
canvas.resize(600, 400)
canvas.setProject(QgsProject.instance())
canvas.show()
self.assertEqual(canvas.width(), 600)
self.assertEqual(canvas.height(), 400)
ls = QgsLineString()
ls.fromWkt('LineString(0 2, 10 2, 10 4)')
canvas.setProfileCurve(ls)
canvas.setVisiblePlotRange(0, ls.length(), 0, 100)
self.assertFalse(canvas.tool())
tool = TestTool(canvas)
self.assertFalse(tool.isActive())
canvas.setTool(tool)
self.assertEqual(canvas.tool(), tool)
key_press_event = QKeyEvent(QEvent.KeyPress, 54, Qt.ShiftModifier)
canvas.keyPressEvent(key_press_event)
self.assertEqual(tool.events[-1].type(), QEvent.KeyPress)
key_release_event = QKeyEvent(QEvent.KeyRelease, 54, Qt.ShiftModifier)
canvas.keyReleaseEvent(key_release_event)
self.assertEqual(tool.events[-1].type(), QEvent.KeyRelease)
mouse_dbl_click_event = QMouseEvent(QEvent.MouseButtonDblClick, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier)
canvas.mouseDoubleClickEvent(mouse_dbl_click_event)
self.assertEqual(tool.events[-1].type(), QEvent.MouseButtonDblClick)
self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent)
self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.92, delta=0.6)
self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4)
self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5)
mouse_move_event = QMouseEvent(QEvent.MouseMove, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier)
canvas.mouseMoveEvent(mouse_move_event)
self.assertEqual(tool.events[-1].type(), QEvent.MouseMove)
self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent)
self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.92, delta=10)
self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4)
self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5)
mouse_press_event = QMouseEvent(QEvent.MouseButtonPress, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier)
canvas.mousePressEvent(mouse_press_event)
self.assertEqual(tool.events[-1].type(), QEvent.MouseButtonPress)
self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent)
self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.927, delta=1)
self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4)
self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5)
mouse_release_event = QMouseEvent(QEvent.MouseButtonRelease, QPointF(300, 200), Qt.LeftButton, Qt.MouseButtons(), Qt.ShiftModifier)
canvas.mouseReleaseEvent(mouse_release_event)
self.assertEqual(tool.events[-1].type(), QEvent.MouseButtonRelease)
self.assertIsInstance(tool.events[-1], QgsPlotMouseEvent)
self.assertAlmostEqual(tool.events[-1].mapPoint().x(), 5.927, delta=1)
self.assertAlmostEqual(tool.events[-1].mapPoint().y(), 2, 4)
self.assertAlmostEqual(tool.events[-1].mapPoint().z(), 49.165, delta=5)
wheel_event = QWheelEvent(QPointF(300, 200), QPointF(300, 200), QPoint(1, 2), QPoint(3, 4), Qt.NoButton, Qt.NoModifier, Qt.ScrollBegin, False)
canvas.wheelEvent(wheel_event)
self.assertEqual(tool.events[-1].type(), QEvent.Wheel)
def list_item_changed(self):
p_index = self.lst_list.currentRow()
flags = Qt.ItemFlags()
flags != Qt.ItemIsEnabled
# Clear table
self.clear_table()
self.need_to_update_graph = False
if p_index >= 0:
self.table.setRowCount(0)
if self.edit_type == self.edit_patterns:
self.current = self.params.patterns[
self.lst_list.currentItem().text()]
for v in range(len(self.current.values)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
item = QTableWidgetItem(str(v))
item.setFlags(flags)
self.table.setItem(v, 0, item)
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.values[v])))
elif self.edit_type == self.edit_curves:
self.current = self.params.curves[
self.lst_list.currentItem().text()]
for v in range(len(self.current.xs)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
self.table.setItem(
v, 0, QTableWidgetItem(str(self.current.xs[v])))
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.ys[v])))
curve_type = self.current.type
self.cbo_pump_type.setCurrentIndex(curve_type)
# Update GUI
self.txt_id.setText(self.current.id)
self.txt_desc.setText(self.current.desc)
self.update_table_headers()
# Update graph
self.need_to_update_graph = True
self.update_graph()
else:
# No curves
self.txt_id.setText('')
self.txt_desc.setText('')
# Update table and chart
self.need_to_update_graph = False
for v in range(self.table.columnCount()):
self.table.setItem(v, 1, QTableWidgetItem(''))
self.need_to_update_graph = True
self.update_graph()
def show_complete_md(self, md: dict, tags: dict):
"""Open the pop up window that shows the metadata sheet details.
:param md dict: Isogeo metadata dict
"""
logger.info("Displaying the whole metadata sheet.")
isogeo_tr = IsogeoTranslator(qsettings.value("locale/userLocale")[0:2])
# clean map canvas
vec_lyr = [
i.id() for i in self.complete_md.wid_bbox.layers() if i.type() == 0
]
QgsProject.instance().removeMapLayers(vec_lyr)
self.complete_md.wid_bbox.refresh()
# -- GENERAL ---------------------------------------------------------
if md.get("title"):
self.complete_md.lbl_title.setText(md.get("title"))
elif md.get("name"):
self.complete_md.lbl_title.setText(md.get("name"))
else:
self.complete_md.lbl_title.setTextFormat(Qt.TextFormat(1))
self.complete_md.lbl_title.setText("<i>{}</i>".format(
self.tr("Undefined", context=__class__.__name__)))
self.complete_md.val_owner.setText(
md.get("_creator").get("contact").get("name", "NR"))
# Keywords
kwords = tags.get("keywords", {"none": "NR"})
self.complete_md.val_keywords.setText(" ; ".join(kwords.keys()))
# INSPIRE themes and conformity
themes = tags.get("inspire", {"none": "NR"})
self.complete_md.val_inspire_themes.setText(" ; ".join(themes.keys()))
if tags.get("compliance"):
self.complete_md.ico_inspire_conformity.setEnabled(1)
self.complete_md.ico_inspire_conformity.setToolTip(
isogeo_tr.tr("quality", "isConform") + " INSPIRE")
else:
self.complete_md.ico_inspire_conformity.setDisabled(1)
self.complete_md.ico_inspire_conformity.setToolTip(
isogeo_tr.tr("quality", "isNotConform") + " INSPIRE")
# Abstract
self.complete_md.val_abstract.setText(md.get("abstract", "NR"))
# -- FEATURE ATTRIBUTES ----------------------------------------------
if md.get("type") == "vectorDataset":
# display
menu_list = self.complete_md.li_menu
item = menu_list.item(1)
item.setHidden(0)
# fillfull
tbl_attr = self.complete_md.tbl_attributes
fields = md.get("feature-attributes", dict())
tbl_attr.setRowCount(len(fields))
idx = 0
for i in fields:
tbl_attr.setItem(idx, 0, QTableWidgetItem(i.get("name", "NR")))
tbl_attr.setItem(idx, 1, QTableWidgetItem(i.get("alias", "")))
tbl_attr.setItem(idx, 2,
QTableWidgetItem(i.get("dataType", "")))
tbl_attr.setItem(idx, 3,
QTableWidgetItem(i.get("description", "")))
idx += 1
# adapt size
tbl_attr.horizontalHeader().setStretchLastSection(True)
tbl_attr.verticalHeader().setSectionResizeMode(3)
else:
menu_list = self.complete_md.li_menu
item = menu_list.item(1)
item.setHidden(1)
pass
# -- CONTACTS --------------------------------------------------------
contacts = md.get("contacts", dict())
contacts_pt_cct = []
contacts_other_cct = []
for ctact in sorted(contacts,
key=lambda i: i.get("contact").get("name")):
item = ctact.get("contact")
if ctact.get("role", "NR") == "pointOfContact":
content = "<b>{1}</b> ({2})<br><a href='mailto:{3}' target='_top'>{3}</a><br>{4}" "<br>{5} {6}<br>{7} {8}<br>{8}<br>{9}".format(
isogeo_tr.tr("roles", ctact.get("role")),
item.get("name", "NR"),
item.get("organization", "NR"),
item.get("email", "NR"),
item.get("phone", "NR"),
item.get("addressLine1", ""),
item.get("addressLine2", ""),
item.get("zipCode", ""),
item.get("city", ""),
item.get("country", ""),
)
contacts_pt_cct.append(content)
else:
content = (
"<b>{0} - {1}</b> ({2})<br><a href='mailto:{3}' target='_blank'>{3}"
"</a><br>{4}<br>{5} {6}<br>{7} {8}<br>{9}".format(
isogeo_tr.tr("roles", ctact.get("role")),
item.get("name", "NR"),
item.get("organization", "NR"),
item.get("email", "NR"),
item.get("phone", ""),
item.get("addressLine1", ""),
item.get("addressLine2", ""),
item.get("zipCode", ""),
item.get("city", ""),
item.get("country", ""),
))
contacts_other_cct.append(content)
# write
self.complete_md.val_ct_pointof.setText(
"<br><hr><br>".join(contacts_pt_cct))
self.complete_md.val_ct_other.setText(
"<br><hr><br>".join(contacts_other_cct))
# -- HISTORY ---------------------------------------------------------
# Data creation and last update dates
self.complete_md.val_data_crea.setText(
plg_tools.handle_date(md.get("_created", "NR")))
self.complete_md.val_data_update.setText(
plg_tools.handle_date(md.get("_modified", "NR")))
# Update frequency information
if md.get("updateFrequency", None):
freq = md.get("updateFrequency")
frequency_info = "{}{} {}".format(
isogeo_tr.tr("frequencyTypes", "frequencyUpdateHelp"),
"".join(i for i in freq if i.isdigit()),
isogeo_tr.tr("frequencyShortTypes", freq[-1]),
)
self.complete_md.val_frequency.setText(frequency_info)
else:
self.complete_md.val_frequency.setText("NR")
# Validity
self.complete_md.val_valid_start.setText(
plg_tools.handle_date(md.get("validFrom", "NR")))
self.complete_md.val_valid_end.setText(
plg_tools.handle_date(md.get("validTo", "NR")))
self.complete_md.val_valid_comment.setText(
md.get("validityComment", "NR"))
# Collect information
self.complete_md.val_method.setText(md.get("collectionMethod", "NR"))
self.complete_md.val_context.setText(md.get("collectionContext", "NR"))
# last modifications
events = md.get("events", dict())
tbl_events = self.complete_md.tbl_events
tbl_events.setRowCount(len(events))
idx = 0
for e in events:
if e.get("kind") == "update":
tbl_events.setItem(
idx, 0,
QTableWidgetItem(plg_tools.handle_date(e.get("date",
"NR"))))
tbl_events.setItem(idx, 1,
QTableWidgetItem(e.get("description", "")))
idx += 1
else:
pass
# adapt size
tbl_events.horizontalHeader().setStretchLastSection(True)
tbl_events.verticalHeader().setSectionResizeMode(3)
# -- TECHNICAL -------------------------------------------------------
# SRS
coord_sys = md.get("coordinate-system", {"None": "NR"})
self.complete_md.val_srs.setText("{} (EPSG:{})".format(
coord_sys.get("name", "NR"), coord_sys.get("code", "NR")))
# Set the data format
if tags.get("formats") != {}:
self.complete_md.val_format.setText(
list(tags.get("formats").keys())[0])
else:
self.complete_md.val_format.setText("NR")
# feature info
self.complete_md.val_feat_count.setText(str(md.get("features", "/")))
self.complete_md.val_geometry.setText(md.get("geometry", ""))
self.complete_md.val_resolution.setText(
str(md.get("distance", "")) + " m")
self.complete_md.val_scale.setText("1:" + str(md.get("scale", "")))
# Quality
self.complete_md.val_topology.setText(
md.get("topologicalConsistency", ""))
# Specifications
specs_in = md.get("specifications", dict())
specs_out = []
for s_in in specs_in:
# translate specification conformity
if s_in.get("conformant"):
s_conformity = isogeo_tr.tr("quality", "isConform")
else:
s_conformity = isogeo_tr.tr("quality", "isNotConform")
# make data human readable
if s_in.get("specification").get("published"):
s_date = datetime.strptime(
s_in.get("specification").get("published"),
"%Y-%m-%dT%H:%M:%S")
s_date = s_date.strftime("%Y-%m-%d")
else:
s_date = "<i>Date de publication non renseignée</i>"
# prepare text
spec_text = "<a href='{1}'><b>{0} ({2})</b></a>: {3}".format(
s_in.get("specification").get("name", "NR"),
s_in.get("specification").get("link", ""),
s_date,
s_conformity,
)
# store into the final list
specs_out.append(spec_text)
# write
self.complete_md.val_specifications.setText(
"<br><hr><br>".join(specs_out))
# Geography
if "envelope" in md:
qgs_prj = QgsProject.instance()
# display
self.complete_md.wid_bbox.setDisabled(0)
# get convex hull coordinates and create the polygon
md_lyr = self.envelope2layer(md.get("envelope"))
# add layers
qgs_prj.addMapLayers(
[md_lyr, li_lyrs_refs[0], li_lyrs_refs[1], li_lyrs_refs[2]], 0)
map_canvas_layer_list = [
qgs_prj.mapLayer(md_lyr.id()),
qgs_prj.mapLayer(li_lyrs_refs[0].id()),
qgs_prj.mapLayer(li_lyrs_refs[1].id()),
qgs_prj.mapLayer(li_lyrs_refs[2].id()),
]
self.complete_md.wid_bbox.setLayers(map_canvas_layer_list)
self.complete_md.wid_bbox.setExtent(md_lyr.extent())
self.complete_md.wid_bbox.zoomOut()
else:
self.complete_md.grp_bbox.setDisabled(1)
# -- CGUs ------------------------------------------------------------
# Licences
cgus_in = md.get("conditions", dict())
cgus_out = []
for c_in in cgus_in:
if "license" in c_in:
cgu_text = "<a href='{1}'><b>{0}</b></a><br>{2}<br>{3}".format(
c_in.get("license").get("name", "NR"),
c_in.get("license").get("link", ""),
c_in.get("description", ""),
c_in.get("license").get("content", ""),
)
else:
cgu_text = "<b>{0}</b><br>{1}".format(
isogeo_tr.tr("conditions", "noLicense"),
c_in.get("description", ""))
# store into the final list
cgus_out.append(cgu_text)
# write
self.complete_md.val_licenses.setText("<br><hr><br>".join(cgus_out))
# Limitations
lims_in = md.get("limitations", dict())
lims_out = []
for l_in in lims_in:
lim_text = "<b>{0}</b><br>{1}".format(
isogeo_tr.tr("limitations", l_in.get("type")),
l_in.get("description", ""),
)
# legal type
if l_in.get("type") == "legal":
lim_text += "<br>" + isogeo_tr.tr("restrictions",
l_in.get("restriction"))
else:
pass
# INSPIRE precision
if "directive" in l_in:
lim_text += (
"<br><u>INSPIRE</u><br><ul><li>{}</li><li>{}</li></ul>".
format(
l_in.get("directive").get("name"),
l_in.get("directive").get("description"),
))
else:
pass
# store into the final list
lims_out.append(lim_text)
# write
self.complete_md.val_limitations.setText("<br><hr><br>".join(lims_out))
# -- ADVANCED TAB ---------------------------------------------------
# Workgroup owner
wg_id = md.get("_creator").get("_id")
wg_contact = md.get("_creator").get("contact")
self.complete_md.val_owner_name.setText(wg_contact.get("name", ""))
self.complete_md.val_owner_email.setText(wg_contact.get("email", ""))
self.complete_md.val_owner_phone.setText(wg_contact.get("phone", ""))
self.complete_md.val_owner_address.setText("{}<br>{}".format(
wg_contact.get("addressLine1", "NR"),
wg_contact.get("addressLine2", "")))
self.complete_md.val_owner_city.setText(wg_contact.get("zipCode", ""))
self.complete_md.val_owner_country.setText(
wg_contact.get("countryCode", ""))
# Metadata
self.complete_md.val_md_lang.setText(md.get("language", "NR"))
self.complete_md.val_md_date_crea.setText(
plg_tools.handle_date(md.get("_modified")[:19]))
self.complete_md.val_md_date_update.setText(
plg_tools.handle_date(md.get("_created")[:19]))
# -- EDIT LINK -------------------------------------------------------
self.url_edition = plg_tools.get_edit_url(md_id=md.get("_id"),
md_type=md.get("type"),
owner_id=wg_id)
# only if user declared himself as Isogeo editor in authentication form
self.complete_md.btn_md_edit.setEnabled(
int(qsettings.value("isogeo/user/editor", 1)))
# -- ADD OPTIONS ------------------------------------------------------
self.complete_md.btn_addtomap.setHidden(1)
self.complete_md.btn_xml_dl.setHidden(1)
# -- DISPLAY ---------------------------------------------------------
self.fields_displayer(md.get("type"), md.get("series"))
# Finally open the damned window
self.complete_md.show()
try:
QgsMessageLog.logMessage(
message="Detailed metadata displayed: {}".format(
self.complete_md.lbl_title.text()),
tag="Isogeo",
level=0,
)
except UnicodeEncodeError:
QgsMessageLog.logMessage(
message="Detailed metadata displayed: {}".format(
self.complete_md.lbl_title.text()),
tag="Isogeo",
level=0,
)
def flags(self, index):
return Qt.ItemFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable
| Qt.ItemIsEnabled)
def style_maps(self, layer=None, style_by=None):
if layer is None:
layer = self.layer
if style_by is None:
style_by = self.default_field_name
symbol = QgsSymbolV2.defaultSymbol(layer.geometryType())
# see properties at:
# https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073
symbol.setAlpha(1) # opacity
if isinstance(symbol, QgsMarkerSymbolV2):
# do it only for the layer with points
self._set_symbol_size(symbol)
symbol.symbolLayer(0).setOutlineStyle(Qt.PenStyle(Qt.NoPen))
style = get_style(layer, self.iface.messageBar())
# this is the default, as specified in the user settings
ramp = QgsVectorGradientColorRampV2(style['color_from'],
style['color_to'])
mode = style['mode']
# in most cases, we override the user-specified setting, and use
# instead a setting that was required by scientists
if self.output_type in OQ_TO_LAYER_TYPES:
default_qgs_style = QgsStyleV2().defaultStyle()
default_color_ramp_names = default_qgs_style.colorRampNames()
if self.output_type in ('dmg_by_asset', 'losses_by_asset',
'avg_losses-stats'):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
mode = QgsGraduatedSymbolRendererV2.Jenks
ramp_type_idx = default_color_ramp_names.index('Reds')
inverted = False
elif self.output_type in ('hmaps', 'gmf_data', 'ruptures'):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
if self.output_type == 'ruptures':
mode = QgsGraduatedSymbolRendererV2.Pretty
else:
mode = QgsGraduatedSymbolRendererV2.EqualInterval
ramp_type_idx = default_color_ramp_names.index('Spectral')
inverted = True
ramp = default_qgs_style.colorRamp(
default_color_ramp_names[ramp_type_idx])
graduated_renderer = QgsGraduatedSymbolRendererV2.createRenderer(
layer,
style_by,
style['classes'],
mode,
symbol,
ramp,
inverted=inverted)
label_format = graduated_renderer.labelFormat()
# label_format.setTrimTrailingZeroes(True) # it might be useful
label_format.setPrecision(2)
graduated_renderer.setLabelFormat(label_format, updateRanges=True)
# add a class for 0 values, unless while styling ruptures
if self.output_type != 'ruptures':
VERY_SMALL_VALUE = 1e-20
graduated_renderer.updateRangeLowerValue(0, VERY_SMALL_VALUE)
symbol_zeros = QgsSymbolV2.defaultSymbol(layer.geometryType())
symbol_zeros.setColor(QColor(240, 240, 240)) # very light grey
if isinstance(symbol, QgsMarkerSymbolV2):
# do it only for the layer with points
self._set_symbol_size(symbol_zeros)
symbol_zeros.symbolLayer(0).setOutlineStyle(
Qt.PenStyle(Qt.NoPen))
zeros_min = 0.0
zeros_max = VERY_SMALL_VALUE
range_zeros = QgsRendererRangeV2(
zeros_min, zeros_max, symbol_zeros,
" %.2f - %.2f" % (zeros_min, zeros_max), True)
graduated_renderer.addClassRange(range_zeros)
graduated_renderer.moveClass(
len(graduated_renderer.ranges()) - 1, 0)
layer.setRendererV2(graduated_renderer)
layer.setLayerTransparency(30) # percent
layer.triggerRepaint()
self.iface.legendInterface().refreshLayerSymbology(layer)
self.iface.mapCanvas().refresh()
def setAvoidStyleSnapRubberBand(self):
self.rubberBand.setLineStyle(Qt.PenStyle(Qt.DashDotLine))
self.rubberBand.setSecondaryStrokeColor(QColor(255, 255, 0, 200))
self.rubberBand.setFillColor(QColor(255, 0, 0, 40))
def __init__(self, iface, parent=None, flags=Qt.WindowFlags()):
QDialog.__init__(self, parent, flags)
uic.loadUi(UI_PATH, self)
self.iface = iface
self.input_layer = None
self.raster_layer = None
self.roughness_layer = None
#add channel info
self.channel_info = None
# self.name_box.setExpression('')
# self.station_box.setExpression('')
self.delta_box.setExpression('0.1')
self.connection_box.setExpression("'standard'")
self.type_box.setExpression("'river'")
self.initial_box.setExpression('0.5')
self.point_bc_enabled_box.setExpression('False')
self.point_bc_stationary_box.setExpression('True')
self.point_bc_value_box.setExpression('0')
self.lateral_bc_enabled_box.setExpression('False')
self.lateral_bc_stationary_box.setExpression('True')
self.lateral_bc_value_box.setExpression('0')
self.overflow_left_enabled_box.setExpression('True')
self.overflow_left_poleni_box.setExpression('0.577')
self.overflow_right_enabled_box.setExpression('True')
self.overflow_right_poleni_box.setExpression('0.577')
self.localbridgeheight_box.setExpression('1.5')
self.bridgebodyheight_box.setExpression('4.0')
self.groupBox_bridge.setCollapsed(True)
self.mGroupBox_6.setCollapsed(True)
self.mGroupBox.setCollapsed(True)
self.mGroupBox_4.setCollapsed(True)
self.mGroupBox_3.setCollapsed(True)
self.mGroupBox_2.setCollapsed(True)
self.groupBox_main.setCollapsed(True)
self.mGroupBox_4.setCollapsed(False)
#set DGM layer
self.raster_layer_box.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.raster_layer_box.layerChanged.connect(self.setRasterLayer)
self.raster_band_box.setEnabled(False)
self.method_box.addItem('nearest neighbor (downscaling/upscaling)')
self.method_box.addItem('bi-linear (downscaling)')
self.method_box.addItem('bi-cubic (downscaling)')
#set roughness layer
self.roughness_layer_box.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.roughness_layer_box.layerChanged.connect(self.setRoughnessLayer)
self.roughness_layer_box.setLayer(None)
#set channel layer
self.comboBox_main.setFilters(QgsMapLayerProxyModel.PolygonLayer)
self.comboBox_main.layerChanged.connect(self.setChannelLayer)
self.comboBox_main.setLayer(None)
self.browse_button.clicked.connect(self.onBrowseButtonClicked)
self.HelpButton.clicked.connect(self.Help)
self.iface.currentLayerChanged.connect(self.setInputLayer)
#############################################
#autostationing button function
def autoclicked(state):
if state > 0:
self.profileid_box.setEnabled(True)
self.station_box.setEnabled(False)
self.preview_button.setDisabled(True)
else:
self.profileid_box.setEnabled(False)
self.station_box.setEnabled(True)
self.preview_button.setDisabled(False)
self.profileid_box.setEnabled(False)
self.autostation_box.stateChanged.connect(autoclicked)
#############################################
if PREVIEW_ENABLED:
self.figure = Figure(figsize=(10, 4), dpi=100)
self.axes = self.figure.add_subplot(111)
self.axes.set_xlabel('Stationing')
self.axes.set_ylabel('Elevation [m+NHN]')
self.figure.tight_layout()
self.canvas = Canvas(self.figure)
self.canvas.setParent(self)
self.canvas.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.layout().addWidget(self.canvas)
self.canvas.setVisible(False)
self.cursor = None
self.preview_button.toggled.connect(self.canvas.setVisible)
self.preview_button.toggled.connect(self.update_button.setEnabled)
self.update_button.clicked.connect(self.updateLongitudinalPreview)
else:
self.preview_button.setDisabled(True)
self.figure = None
self.axes = None
self.canvas = None
self.cursor = None
self.setInputLayer(self.iface.activeLayer())
self.setRasterLayer(self.raster_layer_box.currentLayer())
def setAllowedStyleSnapRubberBand(self):
self.rubberBand.setLineStyle(Qt.PenStyle(Qt.SolidLine))
self.rubberBand.setSecondaryStrokeColor(QColor(255, 0, 0, 200))
self.rubberBand.setFillColor(QColor(255, 0, 0, 40))
def style_maps(layer,
style_by,
iface,
output_type='damages-rlzs',
perils=None,
add_null_class=False,
render_higher_on_top=False,
repaint=True,
use_sgc_style=False):
symbol = QgsSymbol.defaultSymbol(layer.geometryType())
# see properties at:
# https://qgis.org/api/qgsmarkersymbollayerv2_8cpp_source.html#l01073
symbol.setOpacity(1)
if isinstance(symbol, QgsMarkerSymbol):
# do it only for the layer with points
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
style = get_style(layer, iface.messageBar())
# this is the default, as specified in the user settings
ramp = QgsGradientColorRamp(style['color_from'], style['color_to'])
style_mode = style['style_mode']
# in most cases, we override the user-specified setting, and use
# instead a setting that was required by scientists
if output_type in OQ_TO_LAYER_TYPES:
default_qgs_style = QgsStyle().defaultStyle()
default_color_ramp_names = default_qgs_style.colorRampNames()
if output_type in (
'damages-rlzs',
'avg_losses-rlzs',
'avg_losses-stats',
):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Jenks
else:
style_mode = 'Jenks'
ramp_type_idx = default_color_ramp_names.index('Reds')
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
inverted = False
elif (output_type in ('gmf_data', 'ruptures')
or (output_type == 'hmaps' and not use_sgc_style)):
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if output_type == 'ruptures':
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
else:
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
ramp_type_idx = default_color_ramp_names.index('Spectral')
inverted = True
symbol.setColor(QColor(RAMP_EXTREME_COLORS['Reds']['top']))
elif output_type == 'hmaps' and use_sgc_style:
# FIXME: for SGC they were using size 10000 map units
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.Pretty
else:
style_mode = 'PrettyBreaks'
try:
ramp_type_idx = default_color_ramp_names.index(
'SGC_Green2Red_Hmap_Color_Ramp')
except ValueError:
raise ValueError(
'Color ramp SGC_Green2Red_Hmap_Color_Ramp was '
'not found. Please import it from '
'Settings -> Style Manager, loading '
'svir/resources/sgc_green2red_hmap_color_ramp.xml')
inverted = False
registry = QgsApplication.symbolLayerRegistry()
symbol_props = {
'name': 'square',
'color': '0,0,0',
'color_border': '0,0,0',
'offset': '0,0',
'size': '1.5', # FIXME
'angle': '0',
}
square = registry.symbolLayerMetadata(
"SimpleMarker").createSymbolLayer(symbol_props)
symbol = QgsSymbol.defaultSymbol(layer.geometryType()).clone()
symbol.deleteSymbolLayer(0)
symbol.appendSymbolLayer(square)
symbol.symbolLayer(0).setStrokeStyle(Qt.PenStyle(Qt.NoPen))
elif output_type in ['asset_risk', 'input']:
# options are EqualInterval, Quantile, Jenks, StdDev, Pretty
# jenks = natural breaks
if Qgis.QGIS_VERSION_INT < 31000:
style_mode = QgsGraduatedSymbolRenderer.EqualInterval
else:
style_mode = 'EqualInterval'
# exposure_strings = ['number', 'occupants', 'value']
# setting exposure colors by default
colors = {
'single': RAMP_EXTREME_COLORS['Blues']['top'],
'ramp_name': 'Blues'
}
inverted = False
if output_type == 'asset_risk':
damage_strings = perils
for damage_string in damage_strings:
if damage_string in style_by:
colors = {
'single':
RAMP_EXTREME_COLORS['Spectral']['top'],
'ramp_name': 'Spectral'
}
inverted = True
break
else: # 'input'
colors = {
'single': RAMP_EXTREME_COLORS['Greens']['top'],
'ramp_name': 'Greens'
}
symbol.symbolLayer(0).setShape(
QgsSimpleMarkerSymbolLayerBase.Square)
single_color = colors['single']
ramp_name = colors['ramp_name']
ramp_type_idx = default_color_ramp_names.index(ramp_name)
symbol.setColor(QColor(single_color))
else:
raise NotImplementedError(
'Undefined color ramp for output type %s' % output_type)
ramp = default_qgs_style.colorRamp(
default_color_ramp_names[ramp_type_idx])
if inverted:
ramp.invert()
# get unique values
fni = layer.fields().indexOf(style_by)
unique_values = layer.dataProvider().uniqueValues(fni)
num_unique_values = len(unique_values - {NULL})
if num_unique_values > 2:
if Qgis.QGIS_VERSION_INT < 31000:
renderer = QgsGraduatedSymbolRenderer.createRenderer(
layer, style_by, min(num_unique_values, style['classes']),
style_mode, symbol.clone(), ramp)
else:
renderer = QgsGraduatedSymbolRenderer(style_by, [])
# NOTE: the following returns an instance of one of the
# subclasses of QgsClassificationMethod
classification_method = \
QgsApplication.classificationMethodRegistry().method(
style_mode)
renderer.setClassificationMethod(classification_method)
renderer.updateColorRamp(ramp)
renderer.updateSymbols(symbol.clone())
renderer.updateClasses(
layer, min(num_unique_values, style['classes']))
if not use_sgc_style:
if Qgis.QGIS_VERSION_INT < 31000:
label_format = renderer.labelFormat()
# NOTE: the following line might be useful
# label_format.setTrimTrailingZeroes(True)
label_format.setPrecision(2)
renderer.setLabelFormat(label_format, updateRanges=True)
else:
renderer.classificationMethod().setLabelPrecision(2)
renderer.calculateLabelPrecision()
elif num_unique_values == 2:
categories = []
for unique_value in unique_values:
symbol = symbol.clone()
try:
symbol.setColor(
QColor(RAMP_EXTREME_COLORS[ramp_name]
['bottom' if unique_value ==
min(unique_values) else 'top']))
except Exception:
symbol.setColor(
QColor(style['color_from'] if unique_value ==
min(unique_values) else style['color_to']))
category = QgsRendererCategory(unique_value, symbol,
str(unique_value))
# entry for the list of category items
categories.append(category)
renderer = QgsCategorizedSymbolRenderer(style_by, categories)
else:
renderer = QgsSingleSymbolRenderer(symbol.clone())
if add_null_class and NULL in unique_values:
# add a class for NULL values
rule_renderer = QgsRuleBasedRenderer(symbol.clone())
root_rule = rule_renderer.rootRule()
not_null_rule = root_rule.children()[0].clone()
# strip parentheses from stringified color HSL
not_null_rule.setFilterExpression(
'%s IS NOT NULL' % QgsExpression.quotedColumnRef(style_by))
not_null_rule.setLabel('%s:' % style_by)
root_rule.appendChild(not_null_rule)
null_rule = root_rule.children()[0].clone()
null_rule.setSymbol(
QgsFillSymbol.createSimple({
'color': '160,160,160',
'style': 'diagonal_x'
}))
null_rule.setFilterExpression(
'%s IS NULL' % QgsExpression.quotedColumnRef(style_by))
null_rule.setLabel(tr('No points'))
root_rule.appendChild(null_rule)
if isinstance(renderer, QgsGraduatedSymbolRenderer):
# create value ranges
rule_renderer.refineRuleRanges(not_null_rule, renderer)
# remove default rule
elif isinstance(renderer, QgsCategorizedSymbolRenderer):
rule_renderer.refineRuleCategoris(not_null_rule, renderer)
for rule in rule_renderer.rootRule().children()[1].children():
label = rule.label()
# by default, labels are like:
# ('"collapse-structural-ASH_DRY_sum" >= 0.0000 AND
# "collapse-structural-ASH_DRY_sum" <= 2.3949')
first, second = label.split(" AND ")
bottom = first.rsplit(" ", 1)[1]
top = second.rsplit(" ", 1)[1]
simplified = "%s - %s" % (bottom, top)
rule.setLabel(simplified)
root_rule.removeChildAt(0)
renderer = rule_renderer
if render_higher_on_top:
renderer.setUsingSymbolLevels(True)
symbol_items = [item for item in renderer.legendSymbolItems()]
for i in range(len(symbol_items)):
sym = symbol_items[i].symbol().clone()
key = symbol_items[i].ruleKey()
for lay in range(sym.symbolLayerCount()):
sym.symbolLayer(lay).setRenderingPass(i)
renderer.setLegendSymbolItem(key, sym)
layer.setRenderer(renderer)
if not use_sgc_style:
layer.setOpacity(0.7)
if repaint:
layer.triggerRepaint()
iface.setActiveLayer(layer)
iface.zoomToActiveLayer()
# NOTE QGIS3: probably not needed
# iface.layerTreeView().refreshLayerSymbology(layer.id())
iface.mapCanvas().refresh()
