def fill_table(self, dict_parcels, types_change_detection):
num_rows = 0
for type in types_change_detection:
# We didn't use COUNT_KEY because for duplicate parcels the count (t_ids) differs from number of parcels
num_rows += len(
dict_parcels[type][DICT_KEY_PARCEL_T_PARCEL_NUMBER_F])
self.tbl_changes_all_parcels.clearContents()
self.tbl_changes_all_parcels.setRowCount(num_rows)
self.tbl_changes_all_parcels.setSortingEnabled(False)
row = 0
filter_parcels = None
for type in types_change_detection:
filter_parcels = dict_parcels[type]
if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE:
inverse = False
else:
inverse = True # Take the supplies db as base db
base_db = self.utils._supplies_db if inverse else self.utils._db
self.compared_parcels_data = self.utils.get_compared_parcels_data(
inverse)
for parcel_number, parcel_attrs in self.compared_parcels_data.items(
):
if filter_parcels and parcel_number in filter_parcels[
DICT_KEY_PARCEL_T_PARCEL_NUMBER_F]:
item = QTableWidgetItem(
parcel_number) if parcel_number else QTableWidgetItem(
QgsApplication.nullRepresentation())
item.setData(
Qt.UserRole, {
base_db.names.T_ID_F:
parcel_attrs[base_db.names.T_ID_F],
'inverse':
inverse
})
self.tbl_changes_all_parcels.setItem(row, 0, item)
status = parcel_attrs[PARCEL_STATUS]
status_display = parcel_attrs[PARCEL_STATUS_DISPLAY]
if filter_parcels:
# If we are on the supplies DB, "new" parcels are "missing" parcels from the collected db perspective
if filter_parcels[
SOURCE_DB] == SUPPLIES_DB_SOURCE and parcel_attrs[
PARCEL_STATUS_DISPLAY] == CHANGE_DETECTION_NEW_PARCEL:
status_display = CHANGE_DETECTION_MISSING_PARCEL
status = CHANGE_DETECTION_MISSING_PARCEL
item = QTableWidgetItem(status_display)
item.setData(
Qt.UserRole, {
base_db.names.T_ID_F:
parcel_attrs[base_db.names.T_ID_F],
'inverse':
inverse
})
self.tbl_changes_all_parcels.setItem(row, 1, item)
color = STATUS_COLORS[status]
self.tbl_changes_all_parcels.item(row,
1).setBackground(color)
row += 1
self.tbl_changes_all_parcels.setSortingEnabled(True)
# Go for parcel ids and then for plot ids
parcel_ids_collected = list()
parcel_ids_supplies = list()
for type in types_change_detection:
filter_parcels = dict_parcels[type]
if filter_parcels:
if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE:
parcel_ids_collected.extend(
filter_parcels[self.utils._db.names.T_ID_F])
else:
parcel_ids_supplies.extend(
filter_parcels[self.utils._supplies_db.names.T_ID_F])
plot_ids_collected = list()
if parcel_ids_collected:
plot_ids_collected = self.utils.ladm_data.get_plots_related_to_parcels(
self.utils._db,
parcel_ids_collected,
None, # Get QGIS plot ids
self.utils._layers[self.utils._db.names.OP_PLOT_T][LAYER],
self.utils._layers[self.utils._db.names.COL_UE_BAUNIT_T]
[LAYER])
plot_ids_supplies = list()
if parcel_ids_supplies:
plot_ids_supplies = self.utils.ladm_data.get_plots_related_to_parcels_supplies(
self.utils._supplies_db,
parcel_ids_supplies,
None, # Get QGIS plot ids
self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T][LAYER])
# Now that we've got plot ids, select them and zoom to them (combining the extent from both plot layers)
if plot_ids_collected:
self.utils._layers[self.utils._db.names.OP_PLOT_T][
LAYER].selectByIds(plot_ids_collected)
if plot_ids_supplies:
self.utils._supplies_layers[
self.utils._supplies_db.names.GC_PLOT_T][LAYER].selectByIds(
plot_ids_supplies)
self.zoom_to_selected_plots()
def __init__(self, iface, parent=None):
super(PersistorDialog, self).__init__(parent)
# Set up the user interface from Designer.
self.setupUi(self)
self.iface = iface
self.DISP_TEMP_LAYERS = read_setting(PLUGIN_NAME + '/DISP_TEMP_LAYERS',
bool)
self.DEBUG = config.get_debug_mode()
self.pixel_size = ['0', 'm', '']
self.layers_df = None
# Catch and redirect python errors directed at the log messages python error tab.
QgsApplication.messageLog().messageReceived.connect(errorCatcher)
if not os.path.exists(TEMPDIR):
os.mkdir(TEMPDIR)
# Setup for validation messagebar on gui-----------------------------
# leave this message bar for bailouts
self.messageBar = QgsMessageBar(self)
self.validationLayout = QtWidgets.QFormLayout(
self) # new layout to gui
if isinstance(self.layout(), QtWidgets.QFormLayout):
# create a validation layout so multiple messages can be added and
# cleaned up.
self.layout().insertRow(0, self.validationLayout)
self.layout().insertRow(0, self.messageBar)
else:
# for use with Vertical/horizontal layout box
self.layout().insertWidget(0, self.messageBar)
# GUI Runtime Customisation -------------------------------------------
self.setWindowIcon(
QtGui.QIcon(':/plugins/pat/icons/icon_persistor.svg'))
self.mcboRasterLayer.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.mcboRasterLayer.setExcludedProviders(['wms'])
#self.setMapLayers()
self.cboMethod.addItems(
['Target Probability', 'Target Over All Years'])
self.cboMethod.setCurrentIndex(1)
for ea_cbo in [
self.cboAllYearTargetPerc, self.cboUpperPerc, self.cboLowerPerc
]:
ea_cbo.addItems(['{}%'.format(ea) for ea in range(50, -55, -5)])
ea_cbo.setCurrentIndex(
ea_cbo.findText('10%', QtCore.Qt.MatchFixedString))
self.cboLowerPerc.setCurrentIndex(
self.cboLowerPerc.findText('-10%', QtCore.Qt.MatchFixedString))
for ea_tab in [self.tabUpper, self.tabLower]:
ea_tab.setColumnCount(2)
ea_tab.hideColumn(0) # don't need to display the unique layer ID
ea_tab.setHorizontalHeaderItem(0, QTableWidgetItem("ID"))
ea_tab.setHorizontalHeaderItem(1, QTableWidgetItem("0 Raster(s)"))
ea_tab.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.Stretch)
ea_tab.hideColumn(0) # don't need to display the unique layer ID
def AddFileRowToManager(self,
name,
filename,
load_id=None,
islocal=False,
klv_folder=None):
''' Add file Video to new Row '''
# We limit the number of videos due to the buffer
if self.VManager.rowCount() > 5:
qgsu.showUserAndLogMessage(
QCoreApplication.translate(
"ManagerDock",
"You must delete some video from the list before adding a new one"
))
return
self.islocal = islocal
self.klv_folder = klv_folder
self.isStreaming = False
w = QWidget()
layout = QVBoxLayout()
pbar = QProgressBar()
layout.addWidget(pbar)
w.setLayout(layout)
rowPosition = self.VManager.rowCount()
pbar.setGeometry(0, 0, 300, 30)
pbar.setValue(0)
pbar.setMaximumHeight(30)
if load_id is None:
row_id = 0
if rowPosition != 0:
row_id = int(self.VManager.item(rowPosition - 1, 0).text()) + 1
else:
row_id = load_id
self.VManager.insertRow(rowPosition)
self.VManager.setItem(rowPosition, 0, QTableWidgetItem(str(row_id)))
self.VManager.setItem(rowPosition, 1, QTableWidgetItem(name))
self.VManager.setItem(
rowPosition, 2,
QTableWidgetItem(
QCoreApplication.translate("ManagerDock", "Loading")))
self.VManager.setItem(rowPosition, 3, QTableWidgetItem(filename))
self.VManager.setItem(rowPosition, 4, QTableWidgetItem("-"))
self.VManager.setCellWidget(rowPosition, 5, w)
self.VManager.setVisible(False)
self.VManager.horizontalHeader().setStretchLastSection(True)
self.VManager.setVisible(True)
# resolve if it is a stream
if "://" in filename:
self.isStreaming = True
if not self.isStreaming:
# Disable row if not exist video file
if not os.path.exists(filename):
self.ToggleActiveRow(rowPosition, value="Missing source file")
for j in range(self.VManager.columnCount()):
try:
self.VManager.item(rowPosition,
j).setFlags(Qt.NoItemFlags
| Qt.ItemIsEnabled)
self.VManager.item(rowPosition, j).setBackground(
QColor(211, 211, 211))
except Exception:
self.VManager.cellWidget(rowPosition, j).setStyleSheet(
"background-color:rgb(211,211,211);")
pass
return
pbar.setValue(30)
info = FFMpeg().probe(filename)
if info is None:
qgsu.showUserAndLogMessage(
QCoreApplication.translate("ManagerDock",
"Failed loading FFMPEG ! "))
return
info.format.duration
# init non-blocking metadata buffered reader
self.meta_reader[str(rowPosition)] = BufferedMetaReader(
filename, pass_time=self.pass_time)
qgsu.showUserAndLogMessage(
"",
"buffered non-blocking metadata reader initialized.",
onlyLog=True)
pbar.setValue(60)
try:
# init point we can center the video on
self.initialPt[str(rowPosition)] = getVideoLocationInfo(
filename, islocal, klv_folder)
if not self.initialPt[str(rowPosition)]:
self.VManager.setItem(
rowPosition, 4,
QTableWidgetItem(
QCoreApplication.translate(
"ManagerDock",
"Start location not available.")))
self.ToggleActiveRow(rowPosition, value="Not MISB")
pbar.setValue(99)
return
else:
self.VManager.setItem(
rowPosition, 4,
QTableWidgetItem(self.initialPt[str(rowPosition)][2]))
except Exception:
qgsu.showUserAndLogMessage(
QCoreApplication.translate(
"ManagerDock", "This video don't have Metadata ! "))
pbar.setValue(99)
self.ToggleActiveRow(rowPosition, value="Not MISB")
return
pbar.setValue(90)
dtm_path = parser['GENERAL']['DTM_file']
if self.initialPt[str(rowPosition)] and dtm_path != '':
try:
initElevationModel(self.initialPt[str(rowPosition)][0],
self.initialPt[str(rowPosition)][1],
dtm_path)
qgsu.showUserAndLogMessage("",
"Elevation model initialized.",
onlyLog=True)
except Exception:
None
else:
self.meta_reader[str(rowPosition)] = StreamMetaReader(filename)
qgsu.showUserAndLogMessage("",
"StreamMetaReader initialized.",
onlyLog=True)
self.initialPt[str(rowPosition)] = None
pbar.setValue(100)
if islocal:
self.ToggleActiveRow(rowPosition, value="Ready Local")
else:
self.ToggleActiveRow(rowPosition, value="Ready")
# Add video to settings list
AddVideoToSettings(str(row_id), filename)
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = NewRaptorDialog()
self.dlg.cmbSpecies.currentTextChanged.connect(
self.evt_cmbSpecies_changed)
mc = self.iface.mapCanvas()
self.dlg.spbLatitude.setValue(mc.center().y())
self.dlg.spbLongitude.setValue(mc.center().x())
self.dlg.dteLast.setDate(QDate.currentDate())
map_layers = []
for lyr in mc.layers():
map_layers.append(lyr.name())
missing_layers = []
if not "Raptor Nests" in map_layers:
missing_layers.append("Raptor Nests")
if not "Raptor Buffer" in map_layers:
missing_layers.append("Raptor Buffer")
if not "Linear Buffer" in map_layers:
missing_layers.append("Linear Buffer")
if missing_layers:
msg = "The following layers are misisng from this project\n"
for lyr in missing_layers:
msg += "\n{}".format(lyr)
QMessageBox.critical(self.dlg, "Missing layers", msg)
return
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
lyrNests = QgsProject.instance().mapLayersByName("Raptor Nests")[0]
lyrBuffer = QgsProject.instance().mapLayersByName(
"Raptor Buffer")[0]
lyrLinear = QgsProject.instance().mapLayersByName(
"Linear Buffer")[0]
idxNestID = lyrNests.fields().indexOf("Nest_ID")
valNestID = lyrNests.maximumValue(idxNestID) + 1
valLat = self.dlg.spbLatitude.value()
valLng = self.dlg.spbLongitude.value()
valSpecies = self.dlg.cmbSpecies.currentText()
valBuffer = self.dlg.spbBuffer.value()
valStatus = self.dlg.cmbStatus.currentText()
valLast = self.dlg.dteLast.date()
QMessageBox.information(
self.dlg, "Message",
"New Nest ID: {}\n\nLatitude: {}\nLongitude: {}\nSpecies: {}\nBuffer: {}\nStatus: {}\nLast Survey: {}"
.format(valNestID, valLat, valLng, valSpecies, valBuffer,
valStatus, valLast))
ftrNest = QgsFeature(lyrNests.fields())
ftrNest.setAttribute("lat_y_dd", valLat)
ftrNest.setAttribute("long_x_dd", valLng)
ftrNest.setAttribute("recentspec", valSpecies)
ftrNest.setAttribute("buf_dist", valBuffer)
ftrNest.setAttribute("recentstat", valStatus)
ftrNest.setAttribute("lastsurvey", valLast)
ftrNest.setAttribute("Nest_ID", valNestID)
geom = QgsGeometry(QgsPoint(valLng, valLat))
ftrNest.setGeometry(geom)
pr = lyrNests.dataProvider()
pr.addFeatures([ftrNest])
lyrNests.reload()
pr = lyrBuffer.dataProvider()
buffer = geom.buffer(valBuffer, 10)
ftrNest.setGeometry(buffer)
pr.addFeatures([ftrNest])
lyrBuffer.reload()
dlgTable = DlgTable()
dlgTable.setWindowTitle(
"Impacts Table for Nest {}".format(valNestID))
# Find linear projects that will be impacted and report them in the table
bb = buffer.boundingBox()
linears = lyrLinear.getFeatures(bb)
for linear in linears:
valID = linear.attribute("Project")
valType = linear.attribute("type")
valDistance = linear.geometry().distance(geom)
if valDistance < valBuffer:
# Populate table with linear data
row = dlgTable.tblImpacts.rowCount()
dlgTable.tblImpacts.insertRow(row)
dlgTable.tblImpacts.setItem(row, 0,
QTableWidgetItem(str(valID)))
dlgTable.tblImpacts.setItem(row, 1,
QTableWidgetItem(valType))
twi = QTableWidgetItem("{:4.5f}".format(valDistance))
twi.setTextAlignment(QtCore.Qt.AlignRight)
dlgTable.tblImpacts.setItem(row, 2, twi)
dlgTable.tblImpacts.sortItems(2)
dlgTable.show()
dlgTable.exec_()
else:
QMessageBox.information(self.dlg, "Message",
"Should only run if cancelled")
def restoreSettings(self):
settings = QgsSettings()
font = QFontDatabase.systemFont(QFontDatabase.FixedFont)
self.spinBox.setValue(settings.value("pythonConsole/fontsize", font.pointSize(), type=int))
self.spinBoxEditor.setValue(settings.value("pythonConsole/fontsizeEditor", font.pointSize(), type=int))
self.fontComboBox.setCurrentFont(QFont(settings.value("pythonConsole/fontfamilytext",
font.family())))
self.fontComboBoxEditor.setCurrentFont(QFont(settings.value("pythonConsole/fontfamilytextEditor",
font.family())))
self.preloadAPI.setChecked(settings.value("pythonConsole/preloadAPI", True, type=bool))
self.lineEdit.setText(settings.value("pythonConsole/preparedAPIFile", "", type=str))
itemTable = settings.value("pythonConsole/userAPI", [])
if itemTable:
self.tableWidget.setRowCount(0)
for i in range(len(itemTable)):
self.tableWidget.insertRow(i)
self.tableWidget.setColumnCount(2)
pathSplit = itemTable[i].split("/")
apiName = pathSplit[-1][0:-4]
self.tableWidget.setItem(i, 0, QTableWidgetItem(apiName))
self.tableWidget.setItem(i, 1, QTableWidgetItem(itemTable[i]))
self.autoSaveScript.setChecked(settings.value("pythonConsole/autoSaveScript", False, type=bool))
self.autoCompThreshold.setValue(settings.value("pythonConsole/autoCompThreshold", 2, type=int))
self.autoCompThresholdEditor.setValue(settings.value("pythonConsole/autoCompThresholdEditor", 2, type=int))
self.groupBoxAutoCompletionEditor.setChecked(
settings.value("pythonConsole/autoCompleteEnabledEditor", True, type=bool))
self.groupBoxAutoCompletion.setChecked(settings.value("pythonConsole/autoCompleteEnabled", True, type=bool))
self.enableObjectInspector.setChecked(settings.value("pythonConsole/enableObjectInsp", False, type=bool))
self.autoCloseBracketEditor.setChecked(settings.value("pythonConsole/autoCloseBracketEditor", False, type=bool))
self.autoCloseBracket.setChecked(settings.value("pythonConsole/autoCloseBracket", False, type=bool))
self.autoInsertionImportEditor.setChecked(
settings.value("pythonConsole/autoInsertionImportEditor", True, type=bool))
self.autoInsertionImport.setChecked(settings.value("pythonConsole/autoInsertionImport", True, type=bool))
if settings.value("pythonConsole/autoCompleteSource") == 'fromDoc':
self.autoCompFromDoc.setChecked(True)
elif settings.value("pythonConsole/autoCompleteSource") == 'fromAPI':
self.autoCompFromAPI.setChecked(True)
elif settings.value("pythonConsole/autoCompleteSource") == 'fromDocAPI':
self.autoCompFromDocAPI.setChecked(True)
if settings.value("pythonConsole/autoCompleteSourceEditor") == 'fromDoc':
self.autoCompFromDocEditor.setChecked(True)
elif settings.value("pythonConsole/autoCompleteSourceEditor") == 'fromAPI':
self.autoCompFromAPIEditor.setChecked(True)
elif settings.value("pythonConsole/autoCompleteSourceEditor") == 'fromDocAPI':
self.autoCompFromDocAPIEditor.setChecked(True)
# Setting font lexer color
self.defaultFontColor.setColor(QColor(settings.value("pythonConsole/defaultFontColor", QColor(Qt.black))))
self.defaultFontColorEditor.setColor(
QColor(settings.value("pythonConsole/defaultFontColorEditor", QColor(Qt.black))))
self.keywordFontColor.setColor(QColor(settings.value("pythonConsole/keywordFontColor", QColor(Qt.darkGreen))))
self.keywordFontColorEditor.setColor(
QColor(settings.value("pythonConsole/keywordFontColorEditor", QColor(Qt.darkGreen))))
self.classFontColor.setColor(QColor(settings.value("pythonConsole/classFontColor", QColor(Qt.blue))))
self.classFontColorEditor.setColor(
QColor(settings.value("pythonConsole/classFontColorEditor", QColor(Qt.blue))))
self.methodFontColor.setColor(QColor(settings.value("pythonConsole/methodFontColor", QColor(Qt.darkGray))))
self.methodFontColorEditor.setColor(
QColor(settings.value("pythonConsole/methodFontColorEditor", QColor(Qt.darkGray))))
self.decorFontColor.setColor(QColor(settings.value("pythonConsole/decorFontColor", QColor(Qt.darkBlue))))
self.decorFontColorEditor.setColor(
QColor(settings.value("pythonConsole/decorFontColorEditor", QColor(Qt.darkBlue))))
self.commentFontColor.setColor(QColor(settings.value("pythonConsole/commentFontColor", QColor(Qt.gray))))
self.commentFontColorEditor.setColor(
QColor(settings.value("pythonConsole/commentFontColorEditor", QColor(Qt.gray))))
self.commentBlockFontColor.setColor(
QColor(settings.value("pythonConsole/commentBlockFontColor", QColor(Qt.gray))))
self.commentBlockFontColorEditor.setColor(
QColor(settings.value("pythonConsole/commentBlockFontColorEditor", QColor(Qt.gray))))
self.paperBackgroundColor.setColor(
QColor(settings.value("pythonConsole/paperBackgroundColor", QColor(Qt.white))))
self.paperBackgroundColorEditor.setColor(
QColor(settings.value("pythonConsole/paperBackgroundColorEditor", QColor(Qt.white))))
self.caretLineColor.setColor(QColor(settings.value("pythonConsole/caretLineColor", QColor("#fcf3ed"))))
self.caretLineColorEditor.setColor(
QColor(settings.value("pythonConsole/caretLineColorEditor", QColor("#fcf3ed"))))
self.cursorColor.setColor(QColor(settings.value("pythonConsole/cursorColor", QColor(Qt.black))))
self.cursorColorEditor.setColor(QColor(settings.value("pythonConsole/cursorColorEditor", QColor(Qt.black))))
self.stderrFontColor.setColor(QColor(settings.value("pythonConsole/stderrFontColor", QColor(Qt.red))))
self.singleQuoteFontColor.setColor(settings.value("pythonConsole/singleQuoteFontColor", QColor(Qt.blue)))
self.singleQuoteFontColorEditor.setColor(
settings.value("pythonConsole/singleQuoteFontColorEditor", QColor(Qt.blue)))
self.doubleQuoteFontColor.setColor(settings.value("pythonConsole/doubleQuoteFontColor", QColor(Qt.blue)))
self.doubleQuoteFontColorEditor.setColor(
settings.value("pythonConsole/doubleQuoteFontColorEditor", QColor(Qt.blue)))
self.tripleSingleQuoteFontColor.setColor(
settings.value("pythonConsole/tripleSingleQuoteFontColor", QColor(Qt.blue)))
self.tripleSingleQuoteFontColorEditor.setColor(
settings.value("pythonConsole/tripleSingleQuoteFontColorEditor", QColor(Qt.blue)))
self.tripleDoubleQuoteFontColor.setColor(
settings.value("pythonConsole/tripleDoubleQuoteFontColor", QColor(Qt.blue)))
self.tripleDoubleQuoteFontColorEditor.setColor(
settings.value("pythonConsole/tripleDoubleQuoteFontColorEditor", QColor(Qt.blue)))
def update_local_data_sources(self, local_layers, local_raster_layers):
# update table names lookup
local_layers += local_raster_layers
self.update_data_sources_table_names()
self.local_data_sources.update_local_data_sources(local_layers)
# update GUI
self.ui.tblLocalLayers.setRowCount(0)
for data_source, layers in list(self.local_data_sources.iteritems()):
layer_names = []
for layer in layers:
layer_names.append(str(layer.name()))
layers_item = QTableWidgetItem(", ".join(layer_names))
layers_item.setToolTip("\n".join(layer_names))
data_source_item = QTableWidgetItem(data_source)
data_source_item.setToolTip(data_source)
# find a better table name if there are multiple layers with same
# data source?
table_name = layers[0].name()
if data_source in self.data_sources_table_names:
# use current table name if available to keep changes by user
table_name = self.data_sources_table_names[data_source]
table_name_item = QTableWidgetItem(self.launder_pg_name(table_name))
if layers[0].providerType() == 'gdal':
geometry_type_item = QTableWidgetItem('Raster')
else:
wkbType = layers[0].wkbType()
if wkbType not in self.GEOMETRY_TYPES:
QMessageBox.warning(self.iface.mainWindow(), self.tr("Unsupported geometry type"), self.tr(
"Unsupported geometry type '{type}' in layer '{layer}'").format(type=self.__wkbTypeString(wkbType), layer=layers[0].name()))
continue
geometry_type_item = QTableWidgetItem(self.GEOMETRY_TYPES[wkbType])
if layers[0].providerType() == "ogr":
geometry_type_item.setToolTip(
self.tr("Note: OGR features will be converted to MULTI-type"))
srid_item = QTableWidgetItem(layers[0].crs().authid())
row = self.ui.tblLocalLayers.rowCount()
self.ui.tblLocalLayers.insertRow(row)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_LAYERS, layers_item)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_DATA_SOURCE, data_source_item)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_TABLE_NAME, table_name_item)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_GEOMETRY_TYPE, geometry_type_item)
self.ui.tblLocalLayers.setItem(row, self.COLUMN_SRID, srid_item)
if self.local_data_sources.count() > 0:
self.ui.tblLocalLayers.resizeColumnsToContents()
self.ui.tblLocalLayers.setColumnWidth(self.COLUMN_LAYERS, 100)
self.ui.tblLocalLayers.setColumnWidth(self.COLUMN_DATA_SOURCE, 100)
self.ui.tblLocalLayers.sortItems(self.COLUMN_DATA_SOURCE)
self.ui.tblLocalLayers.setSortingEnabled(False)
else:
self.ui.btnUploadData.setEnabled(False)
self.statusBar().showMessage(self.tr("Updated local data sources"))
def showFeatureAttributes(self):
conflictItem = self.lastSelectedItem
self.oursgeom = None
self.theirsgeom = None
geoms = (self.oursgeom, self.theirsgeom)
self.currentConflictedAttributes = []
attribs = list(conflictItem.origin.keys())
self.attributesTable.setRowCount(len(attribs))
self.conflicted = []
for idx, name in enumerate(attribs):
font = QFont()
font.setBold(True)
font.setWeight(75)
item = QTableWidgetItem(name)
item.setFont(font)
self.attributesTable.setItem(idx, 3, item)
self.attributesTable.setItem(idx, 4, ValueItem(None, False))
try:
values = (conflictItem.origin[name], conflictItem.local[name],
conflictItem.remote[name])
except Exception: #Local has been deleted
self._afterSolve(False)
self.solveModifyAndDelete(conflictItem.conflict.path,
self.REMOTE)
return
except TypeError: #Remote has been deleted
self._afterSolve(False)
self.solveModifyAndDelete(conflictItem.conflict.path,
self.LOCAL)
return
try:
geom = QgsGeometry.fromWkt(values[0])
except:
geom = None
if geom is not None:
self.theirsgeom = QgsGeometry().fromWkt(values[1])
self.oursgeom = QgsGeometry.fromWkt(values[2])
geoms = (self.oursgeom, self.theirsgeom)
ok = values[0] == values[1] or values[1] == values[2] or values[
0] == values[2]
for i, v in enumerate(values):
self.attributesTable.setItem(idx, i,
ValueItem(v, not ok, geoms))
if not ok:
self.conflicted.append(name)
else:
if values[0] == values[1]:
newvalue = values[2]
else:
newvalue = values[1]
self.attributesTable.setItem(idx, 4,
ValueItem(newvalue, False, geoms))
self.attributesTable.resizeRowsToContents()
self.attributesTable.horizontalHeader().setMinimumSectionSize(150)
self.attributesTable.horizontalHeader().setStretchLastSection(True)
def reloadProject(self):
"""
Load all layers from the map layer registry into the table.
"""
self.unsupportedLayersList = list()
self.photoNamingTable.setRowCount(0)
self.layersTable.setRowCount(0)
self.layersTable.setSortingEnabled(False)
for layer in self.project.mapLayers().values():
layer_source = LayerSource(layer)
count = self.layersTable.rowCount()
self.layersTable.insertRow(count)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer_source)
item.setData(Qt.EditRole, layer.name())
self.layersTable.setItem(count, 0, item)
cmb = QComboBox()
set_available_actions(cmb, layer_source)
cbx = QCheckBox()
cbx.setEnabled(layer_source.can_lock_geometry)
cbx.setChecked(layer_source.is_geometry_locked)
# it's more UI friendly when the checkbox is centered, an ugly workaround to achieve it
cbx_widget = QWidget()
cbx_layout = QHBoxLayout()
cbx_layout.setAlignment(Qt.AlignCenter)
cbx_layout.setContentsMargins(0, 0, 0, 0)
cbx_layout.addWidget(cbx)
cbx_widget.setLayout(cbx_layout)
# NOTE the margin is not updated when the table column is resized, so better rely on the code above
# cbx.setStyleSheet("margin-left:50%; margin-right:50%;")
self.layersTable.setCellWidget(count, 1, cbx_widget)
self.layersTable.setCellWidget(count, 2, cmb)
if not layer_source.is_supported:
self.unsupportedLayersList.append(layer_source)
self.layersTable.item(count, 0).setFlags(Qt.NoItemFlags)
self.layersTable.cellWidget(count, 1).setEnabled(False)
self.layersTable.cellWidget(count, 2).setEnabled(False)
cmb.setCurrentIndex(cmb.findData(SyncAction.REMOVE))
# make sure layer_source is the same instance everywhere
self.photoNamingTable.addLayerFields(layer_source)
self.layersTable.resizeColumnsToContents()
self.layersTable.sortByColumn(0, Qt.AscendingOrder)
self.layersTable.setSortingEnabled(True)
# Remove the tab when not yet suported in QGIS
if Qgis.QGIS_VERSION_INT < 31300:
self.tabWidget.removeTab(self.tabWidget.count() - 1)
# Load Map Themes
for theme in self.project.mapThemeCollection().mapThemes():
self.mapThemeComboBox.addItem(theme)
self.layerComboBox.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.__project_configuration = ProjectConfiguration(self.project)
self.createBaseMapGroupBox.setChecked(
self.__project_configuration.create_base_map)
if self.__project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER:
self.singleLayerRadioButton.setChecked(True)
else:
self.mapThemeRadioButton.setChecked(True)
self.mapThemeComboBox.setCurrentIndex(
self.mapThemeComboBox.findText(
self.__project_configuration.base_map_theme))
layer = QgsProject.instance().mapLayer(
self.__project_configuration.base_map_layer)
self.layerComboBox.setLayer(layer)
self.mapUnitsPerPixel.setText(
str(self.__project_configuration.base_map_mupp))
self.tileSize.setText(
str(self.__project_configuration.base_map_tile_size))
self.onlyOfflineCopyFeaturesInAoi.setChecked(
self.__project_configuration.offline_copy_only_aoi)
if self.unsupportedLayersList:
self.unsupportedLayersLabel.setVisible(True)
unsupported_layers_text = '<b>{}: </b>'.format(self.tr('Warning'))
unsupported_layers_text += self.tr(
"There are unsupported layers in your project which will not be available in QField."
)
unsupported_layers_text += self.tr(
" If needed, you can create a Base Map to include those layers in your packaged project."
)
self.unsupportedLayersLabel.setText(unsupported_layers_text)
def run_stats(self):
self.progressBar_stats.setValue(0)
self.label_progressStats.setText('')
# noinspection PyArgumentList
QApplication.processEvents()
blurred_layer = self.comboBox_blurredLayer.currentLayer()
stats_layer = self.comboBox_statsLayer.currentLayer()
try:
if not blurred_layer or not stats_layer:
raise NoLayerProvidedException
crs_blurred_layer = blurred_layer.crs()
crs_stats_layer = stats_layer.crs()
if crs_blurred_layer != crs_stats_layer:
raise DifferentCrsException(
epsg1=crs_blurred_layer.authid(),
epsg2=crs_stats_layer.authid())
if blurred_layer == stats_layer:
raise NoLayerProvidedException
if not blurred_layer or not stats_layer:
raise NoLayerProvidedException
nb_feature_stats = stats_layer.featureCount()
nb_feature_blurred = blurred_layer.featureCount()
features_stats = {}
label_preparing = tr('Preparing index on the stats layer')
label_creating = tr('Creating index on the stats layer')
label_calculating = tr('Calculating')
if Qgis.QGIS_VERSION_INT < 20700:
self.label_progressStats.setText('%s 1/3' % label_preparing)
for i, feature in enumerate(stats_layer.getFeatures()):
features_stats[feature.id()] = feature
percent = int((i + 1) * 100 / nb_feature_stats)
self.progressBar_stats.setValue(percent)
# noinspection PyArgumentList
QApplication.processEvents()
self.label_progressStats.setText('%s 2/3' % label_creating)
# noinspection PyArgumentList
QApplication.processEvents()
index = QgsSpatialIndex()
for i, f in enumerate(stats_layer.getFeatures()):
index.insertFeature(f)
percent = int((i + 1) * 100 / nb_feature_stats)
self.progressBar_stats.setValue(percent)
# noinspection PyArgumentList
QApplication.processEvents()
self.label_progressStats.setText('%s 3/3' % label_calculating)
else:
# If QGIS >= 2.7, we can speed up the spatial index.
# From 1 min 15 to 7 seconds on my PC.
self.label_progressStats.setText('%s 1/2' % label_creating)
# noinspection PyArgumentList
QApplication.processEvents()
index = QgsSpatialIndex(stats_layer.getFeatures())
self.label_progressStats.setText('%s 2/2' % label_calculating)
# noinspection PyArgumentList
QApplication.processEvents()
self.tab = []
for i, feature in enumerate(blurred_layer.getFeatures()):
count = 0
ids = index.intersects(feature.geometry().boundingBox())
for unique_id in ids:
request = QgsFeatureRequest().setFilterFid(unique_id)
f = next(stats_layer.getFeatures(request))
if f.geometry().intersects(feature.geometry()):
count += 1
self.tab.append(count)
percent = int((i + 1) * 100 / nb_feature_blurred)
self.progressBar_stats.setValue(percent)
# noinspection PyArgumentList
QApplication.processEvents()
stats = Stats(self.tab)
items_stats = [
'Count(blurred),%d' % nb_feature_blurred,
'Count(stats),%d' % nb_feature_stats,
'Min,%d' % stats.min(),
'Average,%f' % stats.average(),
'Max,%d' % stats.max(), 'Median,%f' % stats.median(),
'Range,%d' % stats.range(),
'Variance,%f' % stats.variance(),
'Standard deviation,%f' % stats.standard_deviation()
]
self.tableWidget.clear()
self.tableWidget.setColumnCount(2)
labels = ['Parameters', 'Values']
self.tableWidget.setHorizontalHeaderLabels(labels)
self.tableWidget.setRowCount(len(items_stats))
for i, item in enumerate(items_stats):
s = item.split(',')
self.tableWidget.setItem(i, 0, QTableWidgetItem(s[0]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(s[1]))
self.tableWidget.resizeRowsToContents()
self.draw_plot(self.tab)
except GeoPublicHealthException as e:
self.label_progressStats.setText('')
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
def buscar(self):
self.datos = self.dlg.leBusqueda_4.text()
envio = {}
envio['folio'] = self.datos
envio['solicitante'] = self.datos
resp = self.guardarOperacion(nuevo=self.nuevo,
url=(self.CFG.urlOptenerTramites),
envio=envio)
#print(resp)
self.dlg.twOperaciones_9.clearContents()
self.dlg.twOperaciones_9.setRowCount(0)
if resp == []:
self.createAlert('Ingrese un Folio correcta o un nombre correcto',
QMessageBox().Critical, "Solicitud")
# mostrar usuarios en tabla
self.dlg.twOperaciones_9.setRowCount(len(resp))
for x in range(0, len(resp)):
item2 = QTableWidgetItem(str(resp[x]['fecha_solcitud']))
item3 = QTableWidgetItem(str(resp[x]['clave_catastral']))
item4 = QTableWidgetItem(str(resp[x]['solicita_localidad']))
item5 = QTableWidgetItem(str(resp[x]['folio_inicio']))
item6 = QTableWidgetItem(str(resp[x]['propietario']))
item7 = QTableWidgetItem(str(resp[x]['solicita_nombre']))
item8 = QTableWidgetItem(str(resp[x]['idTramite']))
item9 = QTableWidgetItem(str(resp[x]['solicita_tel']))
item10 = QTableWidgetItem(str(resp[x]['solicita_municipio']))
item11 = QTableWidgetItem(str(resp[x]['id']))
item12 = QTableWidgetItem(str(resp[x]['solicita_colonia']))
item13 = QTableWidgetItem(str(resp[x]['solicita_fraccionamiento']))
item14 = QTableWidgetItem(str(resp[x]['solicita_correo']))
item15 = QTableWidgetItem(str(resp[x]['solicita_calle']))
self.dlg.twOperaciones_9.setItem(x, 0, item2)
self.dlg.twOperaciones_9.setItem(x, 1, item3)
self.dlg.twOperaciones_9.setItem(x, 2, item4)
self.dlg.twOperaciones_9.setItem(x, 3, item5)
self.dlg.twOperaciones_9.setItem(x, 4, item6)
self.dlg.twOperaciones_9.setItem(x, 5, item7)
self.dlg.twOperaciones_9.setItem(x, 6, item8)
self.dlg.twOperaciones_9.setItem(x, 7, item9)
self.dlg.twOperaciones_9.setItem(x, 8, item10)
self.dlg.twOperaciones_9.setItem(x, 9, item11)
self.dlg.twOperaciones_9.setItem(x, 10, item12)
self.dlg.twOperaciones_9.setItem(x, 11, item13)
self.dlg.twOperaciones_9.setItem(x, 12, item14)
self.dlg.twOperaciones_9.setItem(x, 13, item15)
def readMapping(self,filename):
if self.dlg.interlinkTable.rowCount()!=0:
tree = ET.parse(filename)
root = tree.getroot()
filedata=root.find('file')[0]
self.dlg.interlinkNameSpace.setText(filedata.get("namespace"))
self.dlg.interlinkOwlClassInput.setText(filedata.get("class"))
for neighbor in root.iter('column'):
name=neighbor.get("name")
proptype=neighbor.get("prop")
propiri=neighbor.get("propiri")
concept=neighbor.get("concept")
query=neighbor.get("query")
triplestoreurl=neighbor.get("triplestoreurl")
valuemappings={}
for vmap in neighbor.findall("valuemapping"):
valuemappings[vmap.get("from")]=vmap.get("to")
for row in range(self.dlg.interlinkTable.rowCount()):
columnname=self.dlg.interlinkTable.item(row,3).text()
if columnname==name:
if propiri!=None:
item=QTableWidgetItem(propiri)
item.setText(propiri)
item.setData(1,propiri)
self.dlg.interlinkTable.setItem(row,4,item)
if proptype!=None:
comboboxx=self.dlg.interlinkTable.cellWidget(row,5)
if proptype=="annotation":
comboboxx.setCurrentIndex(comboboxx.findText("AnnotationProperty", QtCore.Qt.MatchFixedString))
elif proptype=="obj":
comboboxx.setCurrentIndex(comboboxx.findText("ObjectProperty", QtCore.Qt.MatchFixedString))
elif proptype=="data":
comboboxx.setCurrentIndex(comboboxx.findText("DataProperty", QtCore.Qt.MatchFixedString))
elif proptype=="subclass":
comboboxx.setCurrentIndex(comboboxx.findText("SubClass", QtCore.Qt.MatchFixedString))
else:
comboboxx.setCurrentIndex(comboboxx.findText("Automatic", QtCore.Qt.MatchFixedString))
if concept!=None:
item=QTableWidgetItem(concept)
item.setText(concept)
item.setData(1,concept)
self.dlg.interlinkTable.setItem(row,6,item)
if valuemappings!={} and valuemappings!=None:
item=QTableWidgetItem("ValueMap{}")
item.setText("ValueMap{}")
item.setData(1,valuemappings)
if query!=None:
item.setData(2,query)
item.setData(3,triplestoreurl)
self.dlg.interlinkTable.setItem(row,7,item)
elif query!=None:
item=QTableWidgetItem("ValueMap{}")
item.setText("ValueMap{}")
item.setData(2,query)
item.setData(3,triplestoreurl)
if valuemappings!={} and valuemappings!=None:
item.setData(1,valuemappings)
self.dlg.interlinkTable.setItem(row,7,item)
else:
msgBox=QMessageBox()
msgBox.setText("Please first load a dataset to enrich before loading a mapping file")
msgBox.exec()
def loadLayerForEnrichment(self):
layers = QgsProject.instance().layerTreeRoot().children()
selectedLayerIndex = self.chooseLayerEnrich.currentIndex()
if len(layers) == 0:
return
layer = layers[selectedLayerIndex].layer()
self.enrichTableResult.hide()
while self.enrichTableResult.rowCount() > 0:
self.enrichTableResult.removeRow(0)
self.enrichTable.show()
self.addEnrichedLayerRowButton.setEnabled(True)
fieldnames = [field.name() for field in layer.fields()]
while self.enrichTable.rowCount() > 0:
self.enrichTable.removeRow(0)
row = 0
self.enrichTable.setColumnCount(9)
self.enrichTable.setHorizontalHeaderLabels([
"Column", "EnrichmentConcept", "TripleStore", "Strategy",
"content", "ID Column", "ID Property", "ID Domain", "Language"
])
for field in fieldnames:
item = QTableWidgetItem(field)
item.setFlags(QtCore.Qt.ItemIsEnabled)
currentRowCount = self.enrichTable.rowCount()
self.enrichTable.insertRow(row)
self.enrichTable.setItem(row, 0, item)
cbox = QComboBox()
cbox.addItem("No Enrichment")
cbox.addItem("Keep Local")
cbox.addItem("Keep Remote")
cbox.addItem("Replace Local")
cbox.addItem("Merge")
cbox.addItem("Ask User")
cbox.addItem("Exclude")
self.enrichTable.setCellWidget(row, 3, cbox)
cbox = QComboBox()
cbox.addItem("Enrich Value")
cbox.addItem("Enrich URI")
cbox.addItem("Enrich Both")
self.enrichTable.setCellWidget(row, 4, cbox)
cbox = QComboBox()
for fieldd in fieldnames:
cbox.addItem(fieldd)
self.enrichTable.setCellWidget(row, 5, cbox)
itemm = QTableWidgetItem(
"http://www.w3.org/2000/01/rdf-schema#label")
self.enrichTable.setItem(row, 6, itemm)
itemm = QTableWidgetItem("")
self.enrichTable.setItem(row, 7, itemm)
itemm = QTableWidgetItem("")
self.enrichTable.setItem(row, 8, itemm)
celllayout = QHBoxLayout()
upbutton = QPushButton("Up")
removebutton = QPushButton("Remove", self)
removebutton.clicked.connect(self.deleteEnrichRow)
downbutton = QPushButton("Down")
celllayout.addWidget(upbutton)
celllayout.addWidget(downbutton)
celllayout.addWidget(removebutton)
w = QWidget()
w.setLayout(celllayout)
optitem = QTableWidgetItem()
#self.enrichTable.setCellWidget(row,4,w)
#self.enrichTable.setItem(row,3,cbox)
row += 1
self.originalRowCount = row
def applyFilter(self, table, index, filter_value, filter_operation):
if filter_value == None:
table.filters[index] = None
else:
if isinstance(filter_value, QDateEdit):
table.filters[index] = filter_value.date()
elif isinstance(filter_value, QTimeEdit):
table.filters[index] = filter_value.time()
elif isinstance(filter_value, QDateTimeEdit):
table.filters[index] = filter_value.dateTime()
else:
table.filters[index] = filter_value.text()
table.filter_op[index] = filter_operation.currentIndex()
nb_elts = 0
for i in range(0, table.rowCount()):
table.setRowHidden(i, False)
nb_elts += 1
hidden_rows = []
for nb_col in range(0, table.columnCount()):
filtered = False
header = table.horizontalHeaderItem(nb_col).text()
valid = False
if table.filters[nb_col] is not None:
if type(table.filters[nb_col]) in [QDate, QTime, QDateTime]:
valid = True
else:
if table.filters[nb_col].strip():
valid = True
if valid:
filtered = True
items = None
if table.types[nb_col] in [10]:# If it's a string
filter_type = None
if table.filter_op[nb_col] == 0: # Contain
filter_type = Qt.MatchContains
if table.filter_op[nb_col] == 1: # Equal
filter_type = Qt.MatchFixedString
items = table.findItems(table.filters[nb_col], filter_type)
elif table.types[nb_col] in [14, 15, 16]: # If it's a date/time
items = []
for nb_row in range(0, table.rowCount()):
item = table.item(nb_row, nb_col)
if table.filter_op[nb_col] == 0: # =
if item.data(QTableWidgetItem.Type) == table.filters[nb_col]:
items.append(item)
if table.filter_op[nb_col] == 1: # >
if item.data(QTableWidgetItem.Type) > table.filters[nb_col]:
items.append(item)
if table.filter_op[nb_col] == 2: # <
if item.data(QTableWidgetItem.Type) < table.filters[nb_col]:
items.append(item)
else: # If it's a number
items = []
for nb_row in range(0, table.rowCount()):
item = table.item(nb_row, nb_col)
if item.text().strip():
if table.filter_op[nb_col] == 0: # =
if float(item.text()) == float(table.filters[nb_col]):
items.append(item)
if table.filter_op[nb_col] == 1: # >
if float(item.text()) > float(table.filters[nb_col]):
items.append(item)
if table.filter_op[nb_col] == 2: # <
if float(item.text()) < float(table.filters[nb_col]):
items.append(item)
rows = []
for item in items:
if item.column() == nb_col:
rows.append(item.row())
for i in range(0, table.rowCount()):
if i not in rows:
if i not in hidden_rows:
nb_elts -= 1
table.setRowHidden(i, True)
hidden_rows.append(i)
if filtered:
if header[len(header)-1] != '*':
table.setHorizontalHeaderItem(nb_col, QTableWidgetItem(header+'*'))
else:
if header[len(header)-1] == '*':
header = header[:-1]
table.setHorizontalHeaderItem(nb_col, QTableWidgetItem(header))
title = self.tabWidget.tabText(self.tabWidget.currentIndex())
for i in reversed(range(len(title))):
if title[i] == ' ':
break
title = title[:-1]
title += '('+str(nb_elts)+')'
self.tabWidget.setTabText(self.tabWidget.currentIndex(), title)
def addLayer(self, layer, headers, types, features):
tab = QWidget()
tab.layer = layer
p1_vertical = QVBoxLayout(tab)
p1_vertical.setContentsMargins(0,0,0,0)
table = QTableWidget()
table.itemSelectionChanged.connect(self.highlight_features)
table.title = layer.name()
table.crs = layer.crs()
table.setColumnCount(len(headers))
if len(features) > 0:
table.setRowCount(len(features))
nbrow = len(features)
self.loadingWindow.show()
self.loadingWindow.setLabelText(table.title)
self.loadingWindow.activateWindow()
self.loadingWindow.showNormal()
# Table population
m = 0
for feature in features:
n = 0
for cell in feature.attributes():
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, cell)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item.feature = feature
table.setItem(m, n, item)
n += 1
m += 1
self.loadingWindow.setValue(int((float(m)/nbrow)*100))
QApplication.processEvents()
else:
table.setRowCount(0)
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setSectionsMovable(True)
table.types = types
table.filter_op = []
table.filters = []
for i in range(0, len(headers)):
table.filters.append('')
table.filter_op.append(0)
header = table.horizontalHeader()
header.setContextMenuPolicy(Qt.CustomContextMenu)
header.customContextMenuRequested.connect(partial(self.filterMenu, table))
table.setSortingEnabled(True)
p1_vertical.addWidget(table)
# Status bar to display informations (ie: area)
tab.sb = QStatusBar()
p1_vertical.addWidget(tab.sb)
title = table.title
# We reduce the title's length to 20 characters
if len(title)>20:
title = title[:20]+'...'
# We add the number of elements to the tab's title.
title += ' ('+str(len(features))+')'
self.tabWidget.addTab(tab, title) # Add the tab to the conatiner
self.tabWidget.setTabToolTip(self.tabWidget.indexOf(tab), table.title) # Display a tooltip with the layer's full name
def update_srs_table_content(dockwidget, srs_table):
with block_signals_to(dockwidget.QTableW_StraRS):
# init table
dockwidget.QTableW_StraRS.setRowCount(srs_table["row_count"])
dockwidget.QTableW_StraRS.setColumnCount(srs_table["column_count"])
# enter data onto Table
for n, key in enumerate(srs_table["header"]):
if key == "Pix Val":
for m, item in enumerate(
srs_table["color_table"]["Pixel Value"]):
item_table = QTableWidgetItem(str(item))
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "Color":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem()
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setBackground(
QColor(srs_table["color_table"]["Red"][m],
srs_table["color_table"]["Green"][m],
srs_table["color_table"]["Blue"][m],
srs_table["color_table"]["Alpha"][m]))
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "Num Samples":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem(srs_table["num_samples"][m])
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip(
"Total number of samples for this class, this is generated\n"
"automatically based on the area proportion by the activated\n"
"classes, overall standard error and its standard deviation."
)
if not srs_table["On"][m]:
item_table.setForeground(QColor("lightGrey"))
item_table.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "Std Dev":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem(srs_table["std_dev"][m])
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip(
"Set the standard deviation for this class")
if not srs_table["On"][m]:
item_table.setForeground(QColor("lightGrey"))
item_table.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "On":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem()
item_table.setFlags(Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip("Enable/disable this class")
if srs_table["On"][m]:
item_table.setCheckState(Qt.Checked)
else:
item_table.setCheckState(Qt.Unchecked)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
# hidden row labels
dockwidget.QTableW_StraRS.verticalHeader().setVisible(False)
# add Header
dockwidget.QTableW_StraRS.setHorizontalHeaderLabels(
srs_table["header"])
# adjust size of Table
dockwidget.QTableW_StraRS.resizeColumnsToContents()
dockwidget.QTableW_StraRS.resizeRowsToContents()
# set label total samples
total_num_samples = sum(
[int(x) for x in mask(srs_table["num_samples"], srs_table["On"])])
dockwidget.TotalNumSamples.setText(str(total_num_samples))
# set maximum and reset the value in progress bar status
dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setValue(0)
dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setMaximum(
total_num_samples)
def run_stats(self):
"""Main function which do the process."""
# Get the common fields.
self.admin_layer = self.cbx_aggregation_layer.currentLayer()
if self.use_point_layer:
# If we use a point layer.
point_layer = self.cbx_case_layer.currentLayer()
else:
# If we use a column with number of case.
case_column = self.cbx_case_field.currentField()
index_case = self.admin_layer.fields().indexFromName(case_column)
#Replace laer.fieldNameIndex(name) to layer.fields().lookup\Field(name)
#http://learn.openwaterfoundation.org/owf-app-geoprocessor-python-doc-dev/resources/migrate-qgis2-qgis3/
if not self.use_area:
# If we don't use density.
population = self.cbx_population_field.currentField()
index_population = self.admin_layer.fields().indexFromName(population)
self.name_field=self.le_new_column.text()
if not self.name_field:
self.name_field = self.le_new_column.placeholderText()
# Add new column.
add_nb_intersections = self.checkBox_addNbIntersections.isChecked()
# Ratio
ratio = self.cbx_ratio.currentText()
ratio = ratio.replace(' ', '')
# Output.
self.output_file_path = self.le_output_filepath.text()
try:
self.button_box_ok.setDisabled(True)
# noinspection PyArgumentList
QApplication.setOverrideCursor(Qt.WaitCursor)
# noinspection PyArgumentList
QApplication.processEvents()
if not self.admin_layer:
QMessageBox.information(None, "DEBUG:", str("There is no layer"))
raise NoLayerProvidedException
if not self.admin_layer and self.use_point_layer:
QMessageBox.information(None, "DEBUG:", str("There is no layer"))
raise NoLayerProvidedException
crs_admin_layer = self.admin_layer.crs()
if self.use_point_layer:
crs_point_layer = point_layer.crs()
if crs_admin_layer != crs_point_layer:
QMessageBox.information(None, "DEBUG:", str("CRS of two layers are not the same. Please set CRS."))
raise DifferentCrsException(
epsg1=crs_point_layer.authid(),
epsg2=crs_admin_layer.authid())
if not self.use_point_layer and not self.use_area:
if index_population == index_case:
QMessageBox.information(None, "DEBUG:", str("You are using the same variable for case and population. Please change."))
raise FieldException(field_1='Population', field_2='Case')
try:
ratio = float(ratio)
except ValueError:
QMessageBox.information(None, "DEBUG:", str("The variable is not number."))
raise NotANumberException(suffix=ratio)
# Output
if not self.output_file_path:
temp_file = NamedTemporaryFile(
delete=False,
suffix='-geohealth.shp')
self.output_file_path = temp_file.name
temp_file.flush()
temp_file.close()
else:
with open(self.output_file_path, 'w') as document: pass
admin_layer_provider = self.admin_layer.dataProvider()
fields = self.admin_layer.fields()
if admin_layer_provider.fields().indexFromName(self.name_field) != -1:
QMessageBox.information(None, "DEBUG:", str("The field name already exist."))
raise FieldExistingException(field=self.name_field)
fields.append(QgsField(self.name_field, QVariant.Double))
if add_nb_intersections:
fields.append(QgsField('nb_of_intersections', QVariant.Int))
data = []
file_writer = QgsVectorFileWriter(
self.output_file_path,
'utf-8',
fields,
QgsWkbTypes.Polygon,
self.admin_layer.crs(),
'ESRI Shapefile')
if self.use_point_layer:
total_case = point_layer.featureCount()
else:
total_case = 0
for i, feature in enumerate(self.admin_layer.getFeatures()):
attributes = feature.attributes()
if self.use_point_layer:
count = 0
for f in point_layer.getFeatures():
if f.geometry().intersects(feature.geometry()):
count += 1
else:
count = int(attributes[index_case])
total_case += count
try:
if self.use_area:
area = feature.geometry().area()
value = float(count) / area * ratio
else:
try:
population = float(attributes[index_population])
except ValueError:
QMessageBox.information(None, "DEBUG:", str("This is not a number."))
raise NotANumberException(
suffix=attributes[index_population])
value = float(count) / population * ratio
except ZeroDivisionError:
value = None
except TypeError:
value = None
data.append(value)
attributes.append(value)
if add_nb_intersections:
attributes.append(count)
new_feature = QgsFeature()
new_geom = QgsGeometry(feature.geometry())
new_feature.setAttributes(attributes)
new_feature.setGeometry(new_geom)
file_writer.addFeature(new_feature)
del file_writer
self.output_layer = QgsVectorLayer(
self.output_file_path,
self.name_field,
'ogr')
QgsProject.instance().addMapLayer(self.output_layer)
if self.checkBox_incidence_runStats.isChecked():
stats = Stats(data)
items_stats = [
'Incidence null,%d' % stats.null_values(),
'Count(point),%d' % total_case,
'Count(polygon),%d' % self.admin_layer.featureCount(),
'Min,%d' % stats.min(),
'Average,%f' % stats.average(),
'Max,%d' % stats.max(),
'Median,%f' % stats.median(),
'Range,%d' % stats.range(),
'Variance,%f' % stats.variance(),
'Standard deviation,%f' % stats.standard_deviation()
]
self.tableWidget.clear()
self.tableWidget.setColumnCount(2)
labels = ['Parameters', 'Values']
self.tableWidget.setHorizontalHeaderLabels(labels)
self.tableWidget.setRowCount(len(items_stats))
for i, item in enumerate(items_stats):
s = item.split(',')
self.tableWidget.setItem(i, 0, QTableWidgetItem(s[0]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(s[1]))
self.tableWidget.resizeRowsToContents()
self.draw_plot(data)
else:
self.hide()
if self.symbology.isChecked():
self.add_symbology()
self.signalStatus.emit(3, tr('Successful process'))
except GeoPublicHealthException as e:
display_message_bar(msg=e.msg, level=e.level, duration=e.duration)
finally:
self.button_box_ok.setDisabled(False)
# noinspection PyArgumentList
QApplication.restoreOverrideCursor()
# noinspection PyArgumentList
QApplication.processEvents()
def configureDialog(self,
p_layertype,
p_wkbtype,
p_Multitype=False,
p_Z=False,
p_M=False,
p_EditMode=False,
p_Canvas=None):
""" Init dialog controls """
self.layertype = p_layertype
self.wkbtype = p_wkbtype
self.has_Z = p_Z
self.has_M = p_M
self.isMultiType = p_Multitype
self.isEditMode = p_EditMode
self.mapCanvas = p_Canvas
self.projectCrsId = self.mapCanvas.mapSettings().destinationCrs(
).srsid()
self.highLighter = HighlightFeature(
self.mapCanvas, self.layertype == QgsWkbTypes.PointGeometry,
self.layertype == QgsWkbTypes.PolygonGeometry, self.projectCrsId)
self.valueChecker = ValueChecker(self.twPoints, self.layertype)
# Hide working with parts for any point geometry and simple line geometry
if self.layertype == QgsWkbTypes.PointGeometry or \
(self.layertype == QgsWkbTypes.LineGeometry and not self.isMultiType):
self.partButtonsFrame.hide()
self.partsFrame.hide()
self.gridMainLayout.setHorizontalSpacing(0)
# Else activate multipart controls
else:
self.partButtonsFrame.show()
self.partsFrame.show()
self.gridMainLayout.setHorizontalSpacing(3)
# Set enabled state Add ring button only for polygons
self.toolButtonAddRing.setEnabled(
self.layertype == QgsWkbTypes.PolygonGeometry)
# Disable add parts buttons for not multipolygone (only add ring enabled)
self.toolButtonAddPart.setEnabled(self.isMultiType)
model = self.listParts.model()
model.blockSignals(True)
model.insertRows(0, 1)
model.setData(model.index(0), '1', QtCore.Qt.EditRole)
model.blockSignals(False)
self.__contursCount = 1
self.prev_row = 0
if self.has_Z and self.has_M:
tableColumns = 4
headerLabels = ['X', 'Y', 'Z', 'M']
elif self.has_Z != self.has_M:
tableColumns = 3
if self.has_Z:
headerLabels = ['X', 'Y', 'Z']
else:
headerLabels = ['X', 'Y', 'M']
else:
tableColumns = 2
headerLabels = ['X', 'Y']
modelColumns = self.twPoints.model().columnCount()
if tableColumns > modelColumns:
self.twPoints.model().insertColumns(2, tableColumns - modelColumns)
elif tableColumns < modelColumns:
self.twPoints.model().removeColumns(2, modelColumns - tableColumns)
for i in range(len(headerLabels)):
if self.twPoints.horizontalHeaderItem(i) is not None:
self.twPoints.horizontalHeaderItem(i).setText(headerLabels[i])
else:
item = QTableWidgetItem()
item.setText(headerLabels[i])
self.twPoints.setHorizontalHeaderItem(i, item)
# Resize grid. Set column's width equal. Resize the section to fill the available space.
for i in range(self.twPoints.columnCount()):
self.twPoints.setColumnWidth(
i,
self.twPoints.width() / self.twPoints.columnCount())
self.twPoints.horizontalHeader().setSectionResizeMode(
i, QHeaderView.Stretch)
# Disable OK button. Wait for entering valid coordinates
self.buttonBox.button(QDialogButtonBox.Ok).setEnabled(False)
# Disable choose CRS button while not selected rb_ChooseCrs
self.l_OtherCrsName.setEnabled(self.rb_OtherCrs.isChecked())
self.pb_OtherCrs.setEnabled(self.rb_OtherCrs.isChecked())
settings = QSettings()
rb_checked = settings.value("/Plugin-NumericalDigitize/Projection",
"LayerCrs",
type=str)
if rb_checked == "ProjectCrs":
self.featureCrsId = self.projectCrsId
self.rb_ProjectCrs.setChecked(True)
elif rb_checked == "OtherCrs":
self.otherCrsId = settings.value(
"/Plugin-NumericalDigitize/OtherCrsId", -1, type=int)
self.featureCrsId = self.otherCrsId
self.__displayAuthid()
self.rb_OtherCrs.setChecked(True)
else:
self.featureCrsId = self.mapCanvas.currentLayer().crs().srsid()
self.rb_LayerCrs.setChecked(True)
self.selectedCRS.emit(self.featureCrsId)
def treeItemChanged(self, current, previous):
qgsgeom1 = None
qgsgeom2 = None
crs = "EPSG:4326"
if not isinstance(current, FeatureItem):
self.attributesTable.clear()
self.attributesTable.setRowCount(0)
return
color = {
"MODIFIED": QColor(255, 170, 0),
"ADDED": Qt.green,
"REMOVED": Qt.red,
"NO_CHANGE": Qt.white
}
path = current.layername + "/" + current.featureid
featurediff = self.changes[path].featurediff()
self.attributesTable.clear()
self.attributesTable.verticalHeader().show()
self.attributesTable.horizontalHeader().show()
self.attributesTable.setRowCount(len(featurediff))
self.attributesTable.setVerticalHeaderLabels(
[a["attributename"] for a in featurediff])
self.attributesTable.setHorizontalHeaderLabels(
["Old value", "New value", "Change type"])
for i, attrib in enumerate(featurediff):
try:
if attrib["changetype"] == "MODIFIED":
oldvalue = attrib["oldvalue"]
newvalue = attrib["newvalue"]
elif attrib["changetype"] == "ADDED":
newvalue = attrib["newvalue"]
oldvalue = ""
elif attrib["changetype"] == "REMOVED":
oldvalue = attrib["oldvalue"]
newvalue = ""
else:
oldvalue = newvalue = attrib["oldvalue"]
except:
oldvalue = newvalue = ""
self.attributesTable.setItem(i, 0, DiffItem(oldvalue))
self.attributesTable.setItem(i, 1, DiffItem(newvalue))
try:
self.attributesTable.setItem(i, 2, QTableWidgetItem(""))
if qgsgeom1 is None or qgsgeom2 is None:
if "crs" in attrib:
crs = attrib["crs"]
qgsgeom1 = QgsGeometry.fromWkt(oldvalue)
qgsgeom2 = QgsGeometry.fromWkt(newvalue)
if qgsgeom1 is not None and qgsgeom2 is not None:
widget = QWidget()
btn = QPushButton()
btn.setText("View detail")
btn.clicked.connect(lambda: self.viewGeometryChanges(
qgsgeom1, qgsgeom2, crs))
label = QLabel()
label.setText(attrib["changetype"])
layout = QHBoxLayout(widget)
layout.addWidget(label)
layout.addWidget(btn)
layout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
self.attributesTable.setCellWidget(i, 2, widget)
else:
self.attributesTable.setItem(
i, 2, QTableWidgetItem(attrib["changetype"]))
else:
self.attributesTable.setItem(
i, 2, QTableWidgetItem(attrib["changetype"]))
except:
self.attributesTable.setItem(
i, 2, QTableWidgetItem(attrib["changetype"]))
for col in range(3):
self.attributesTable.item(i, col).setBackgroundColor(
color[attrib["changetype"]])
self.attributesTable.resizeColumnsToContents()
self.attributesTable.horizontalHeader().setResizeMode(
QHeaderView.Stretch)
def loadStats(self):
names = self.getLayerNames()
data = getLastSearch()
valueList, itemList, amountList, lenghtList, areaList, areaTotalList = [], [], [], [], [], []
valueList, itemList, amountList, lenghtList, areaList, areaTotalList = [], [], [], [], [], []
for i in names:
item_id = getID(i)
item = nvdbFagdata(item_id)
if data[1] == "kommune":
kommuneID = getKommuneID(data[0])
item.filter({'kommune': kommuneID})
elif data[1] == "kontraktsomrade":
item.filter({'kontraktsomrade': data[0]})
else:
fylkeID = getFylkeID(data[0])
item.filter({'fylke': fylkeID})
if data[2] != "Alle":
item.filter({'vegsystemreferanse': [data[2][0]]})
for v in item.statistikk().items():
valueList.append(v)
itemList.append(item)
for itemobj in itemList:
while itemobj is not None:
area = itemobj.nesteNvdbFagObjekt()
if area is None:
break
else:
areaList.append(area.egenskapverdi('Areal'))
continue
else:
print("TEST")
break
for i in range(len(valueList)):
v = valueList[i]
if v[0] == "antall":
amountList.append(v[1])
else:
lenghtList.append(v[1])
for i in range(len(amountList)):
areaTotal = 0
for u in range(amountList[i]):
if areaList[u] is not None:
if isinstance(areaList[u], str):
pass
else:
areaTotal += areaList[u]
else:
pass
areaTotalList.append(areaTotal)
areaList = areaList[amountList[i]:]
# Row count
self.dlg.statsTable.setRowCount(len(names) + 1)
# Column count
self.dlg.statsTable.setColumnCount(4)
self.dlg.statsTable.setItem(0, 0, QTableWidgetItem("Navn"))
self.dlg.statsTable.setItem(0, 1, QTableWidgetItem("Mengde"))
self.dlg.statsTable.setItem(0, 2, QTableWidgetItem("Lengde"))
self.dlg.statsTable.setItem(0, 3, QTableWidgetItem("Areal"))
for i in range(len(names) + 1):
if i == len(names):
break
self.dlg.statsTable.setItem(i + 1, 0, QTableWidgetItem(names[i]))
self.dlg.statsTable.setItem(i + 1, 1,
QTableWidgetItem(str(amountList[i])))
self.dlg.statsTable.setItem(
i + 1, 2, QTableWidgetItem(str(round(int(lenghtList[i])))))
self.dlg.statsTable.setItem(
i + 1, 3, QTableWidgetItem(str(round(int(areaTotalList[i])))))
# Table will fit the screen horizontally
self.dlg.statsTable.horizontalHeader().setStretchLastSection(True)
self.dlg.statsTable.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.successMessage("Viser statistikk for layers innenfor " + data[1] +
":")
self.successMessage(data[0])
self.successMessage("Vegsystemreferanse:")
self.successMessage(data[2])
def fill_table(self, filter_parcels=dict()):
if not filter_parcels or (filter_parcels and filter_parcels[SOURCE_DB]
== COLLECTED_DB_SOURCE):
inverse = False
else:
inverse = True # Take the official db as base db
self.compared_parcels_data = self.utils.get_compared_parcels_data(
inverse)
self.tbl_changes_all_parcels.clearContents()
self.tbl_changes_all_parcels.setRowCount(
len(filter_parcels[PARCEL_NUMBER_FIELD]
) if filter_parcels else len(self.compared_parcels_data))
self.tbl_changes_all_parcels.setSortingEnabled(False)
row = 0
for parcel_number, parcel_attrs in self.compared_parcels_data.items():
if not filter_parcels or (filter_parcels and parcel_number
in filter_parcels[PARCEL_NUMBER_FIELD]):
item = QTableWidgetItem(
parcel_number) if parcel_number else QTableWidgetItem(
QgsApplication.nullRepresentation())
item.setData(Qt.UserRole, {
ID_FIELD: parcel_attrs[ID_FIELD],
'inverse': inverse
})
self.tbl_changes_all_parcels.setItem(row, 0, item)
status = parcel_attrs[PARCEL_STATUS]
status_display = parcel_attrs[PARCEL_STATUS_DISPLAY]
if filter_parcels:
# If we are on the official DB, "new" parcels are "missing" parcels from the collected db perspective
if filter_parcels[
SOURCE_DB] == OFFICIAL_DB_SOURCE and parcel_attrs[
PARCEL_STATUS_DISPLAY] == CHANGE_DETECTION_NEW_PARCEL:
status_display = CHANGE_DETECTION_MISSING_PARCEL
status = CHANGE_DETECTION_MISSING_PARCEL
item = QTableWidgetItem(status_display)
item.setData(Qt.UserRole, {
ID_FIELD: parcel_attrs[ID_FIELD],
'inverse': inverse
})
self.tbl_changes_all_parcels.setItem(row, 1, item)
color = STATUS_COLORS[status]
self.tbl_changes_all_parcels.item(row, 1).setBackground(color)
row += 1
self.tbl_changes_all_parcels.setSortingEnabled(True)
# Zoom and flash features
if filter_parcels:
plot_layer = None
if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE:
plot_layer = self.utils._layers[PLOT_TABLE][LAYER]
else:
plot_layer = self.utils._official_layers[PLOT_TABLE][LAYER]
plot_ids = self.utils.ladm_data.get_plots_related_to_parcels(
self.utils._db if filter_parcels[SOURCE_DB]
== COLLECTED_DB_SOURCE else self.utils._official_db,
filter_parcels[ID_FIELD],
None, # Get QGIS plot ids
plot_layer,
self.utils._layers[UEBAUNIT_TABLE][LAYER]
if filter_parcels[SOURCE_DB] == COLLECTED_DB_SOURCE else
self.utils._official_layers[UEBAUNIT_TABLE][LAYER])
self.parent.request_zoom_to_features(plot_layer,
ids=plot_ids,
duration=3000)
# plot_layer.select(plot_ids)
else:
self.utils.qgis_utils.activate_layer_requested.emit(
self.utils._layers[PLOT_TABLE][LAYER])
self.utils.iface.zoomToActiveLayer()
self.select_related_plots_listed(False)
def show_results(self, api_results, pg_connections=dict()):
"""Display the results in a table."""
logger.info("Results manager called. Displaying the results")
tbl_result = self.tbl_result
# Get the name (and other informations) of all databases whose
# connection is set up in QGIS
if pg_connections == {}:
pg_connections = self.pg_connections
else:
pass
# Set table rows
if api_results.get("total") >= 10:
tbl_result.setRowCount(10)
else:
tbl_result.setRowCount(api_results.get("total"))
# dimensions (see https://github.com/isogeo/isogeo-plugin-qgis/issues/276)
hheader = tbl_result.horizontalHeader()
# make the entire width of the table is occupied
hheader.setSectionResizeMode(1)
# make date and icone columns width adapted to their content
# so title and adding columns occupy the rest of the available width
hheader.setSectionResizeMode(1, 3)
hheader.setSectionResizeMode(2, 3)
vheader = tbl_result.verticalHeader()
# Looping inside the table lines. For each of them, showing the title,
# abstract, geometry type, and a button that allow to add the data
# to the canvas.
count = 0
for i in api_results.get("results"):
md = Metadata.clean_attributes(i)
# get metadata's keywords from tags, they will be displayed in QGIS
# 'layer properties' if the layer is added to the canvas
md.keywords = [
md.tags.get(kw) for kw in md.tags
if kw.startswith("keyword:isogeo")
]
# COLUMN 1 - Title and abstract
# Displaying the metadata title inside a button
title = md.title_or_name()
if title:
btn_md_title = QPushButton(
plg_tools.format_button_title(title))
else:
btn_md_title = QPushButton(
self.tr("Undefined", context=__class__.__name__))
btn_md_title.setStyleSheet("font: italic")
# Connecting the button to the full metadata popup
btn_md_title.pressed.connect(partial(self.md_asked.emit, md._id))
# Putting the abstract as a tooltip on this button
if md.abstract:
btn_md_title.setToolTip(md.abstract[:300])
else:
pass
# Insert it in column 1
tbl_result.setCellWidget(count, 0, btn_md_title)
# COLUMN 2 - Data last update
lbl_date = QLabel(tbl_result)
lbl_date.setText(plg_tools.handle_date(md._modified))
lbl_date.setMargin(5)
lbl_date.setAlignment(Qt.AlignCenter)
tbl_result.setCellWidget(count, 1, lbl_date)
# COLUMN 3 - Geometry type
lbl_geom = QLabel(tbl_result)
if md.geometry:
if md.geometry == "TIN":
tbl_result.setItem(count, 2, QTableWidgetItem("TIN"))
elif md.geometry in known_geom_list:
for geom_type in self.pix_geom_dict:
if md.geometry in geom_type:
geom_item = self.pix_geom_dict.get(geom_type)
lbl_geom.setPixmap(geom_item.get("pix"))
lbl_geom.setToolTip(
self.tr(geom_item.get("tooltip"),
context=__class__.__name__))
else:
continue
else:
tbl_result.setItem(
count,
2,
QTableWidgetItem(
self.tr("Unknown geometry",
context=__class__.__name__)),
)
else:
if "rasterDataset" in md.type:
lbl_geom.setPixmap(pix_rastr)
lbl_geom.setToolTip(
self.tr("Raster", context=__class__.__name__))
elif "service" in md.type:
lbl_geom.setPixmap(pix_serv)
lbl_geom.setToolTip(
self.tr("Service", context=__class__.__name__))
else:
lbl_geom.setPixmap(pix_nogeo)
lbl_geom.setToolTip(
self.tr("Unknown geometry",
context=__class__.__name__))
lbl_geom.setAlignment(Qt.AlignCenter)
tbl_result.setCellWidget(count, 2, lbl_geom)
# COLUMN 4 - Add options
add_options_dict = {}
# Build metadata portal URL if the setting is checked in "Settings" tab
add_portal_md_url = int(
qsettings.value("isogeo/settings/add_metadata_url_portal", 0))
portal_base_url = self.form_mng.input_portal_url.text()
portal_md_url = ""
if add_portal_md_url and portal_base_url != "":
portal_md_url = portal_base_url + md._id
else:
pass
# Files and PostGIS direct access
if md.format:
# If the data is a vector and the path is available, store
# useful information in the dict
if md.format in li_formats_vect and md.path:
add_path = self._filepath_builder(md.path)
if add_path:
params = [
"vector",
add_path,
md.title,
md.abstract,
md.keywords,
portal_md_url,
]
add_options_dict[self.tr(
"Data file", context=__class__.__name__)] = params
else:
pass
# Same if the data is a raster
elif md.format in li_formats_rastr and md.path:
add_path = self._filepath_builder(md.path)
if add_path:
params = [
"raster",
add_path,
md.title,
md.abstract,
md.keywords,
portal_md_url,
]
add_options_dict[self.tr(
"Data file", context=__class__.__name__)] = params
else:
pass
# If the data is a postGIS table and the connexion has
# been saved in QGIS.
elif md.format == "postgis":
if md.path:
base_name = md.path
else:
base_name = "No path"
if base_name in pg_connections.keys():
params = {}
params["base_name"] = base_name
schema_table = md.name
if schema_table is not None and "." in schema_table:
params["schema"] = schema_table.split(".")[0]
params["table"] = schema_table.split(".")[1]
params["abstract"] = md.abstract
params["title"] = md.title
params["keywords"] = md.keywords
params["md_portal_url"] = portal_md_url
add_options_dict[self.tr(
"PostGIS table",
context=__class__.__name__)] = params
else:
pass
else:
pass
else:
logger.debug(
"Metadata {} has a format ({}) but it's not handled hear or path is"
"missing".format(md._id, md.format))
pass
# Associated service layers
if md.type == "vectorDataset" or md.type == "rasterDataset":
for layer in md.serviceLayers:
service = layer.get("service")
if service is not None:
srv_details = {
"path": service.get("path", "NR"),
"formatVersion": service.get("formatVersion"),
}
# WMTS
if service.get("format") == "wmts":
params = self.layer_adder.build_wmts_url(
layer, srv_details, rsc_type="ds_dyn_lyr_srv")
# EFS, EMS, WMS or WFS
elif service.get("format") in list(
self.service_dict.keys()):
url_builder = self.service_dict.get(
service.get("format")).get("url_builder")
params = url_builder(
layer,
srv_details,
rsc_type="ds_dyn_lyr_srv",
mode="quicky",
)
else:
params = [0]
logger.debug(
"Service with no format detected for '{}' metadata : {}"
.format(md._id, service))
pass
if params[0] != 0:
basic_md = [
md.title,
md.abstract,
md.keywords,
portal_md_url,
]
params.append(basic_md)
add_options_dict["{} : {}".format(
params[0], params[1])] = params
else:
pass
# New association mode. For services metadata sheet, the layers
# are stored in the purposely named include: "layers".
elif md.type == "service":
if md.layers is not None:
srv_details = {
"path": md.path,
"formatVersion": md.formatVersion,
}
# WMTS
if md.format == "wmts":
for layer in md.layers:
name_url = self.layer_adder.build_wmts_url(
layer, srv_details, rsc_type="service")
if name_url[0] != 0:
btn_label = "WMTS : {}".format(name_url[1])
add_options_dict[btn_label] = name_url
else:
continue
# EFS, EMS, WMS or WFS
elif md.format in list(self.service_dict.keys()):
url_builder = self.service_dict.get(
md.format).get("url_builder")
for layer in md.layers:
name_url = url_builder(layer,
srv_details,
rsc_type="service",
mode="quicky")
if name_url[0] != 0:
add_options_dict[name_url[5]] = name_url
else:
continue
else:
pass
else:
pass
# Now the plugin has tested every possibility for the layer to be
# added. The "Add" column has to be filled accordingly.
# If the data can't be added, just insert "can't" text.
if add_options_dict == {}:
text = self.tr("Can't be added", context=__class__.__name__)
fake_button = QPushButton(text)
fake_button.setStyleSheet("text-align: left")
fake_button.setEnabled(False)
tbl_result.setCellWidget(count, 3, fake_button)
# If the data can be added
else:
data_info = {"limitations": None, "layer": None}
# retrieves data limitations
data_info["limitations"] = md.limitations
# If there is only one way for the data to be added, insert a button.
if len(add_options_dict) == 1:
text = list(add_options_dict.keys())[0]
params = add_options_dict.get(text)
option_type = text.split(" : ")[0]
# services
if option_type.lower() in list(self.service_dict.keys()):
icon = self.service_dict.get(
option_type.lower()).get("ico")
# PostGIS table
elif option_type.startswith(
self.tr("PostGIS table",
context=__class__.__name__)):
icon = ico_pgis
# Data file
elif option_type.startswith(
self.tr("Data file", context=__class__.__name__)):
icon = ico_file
# Unkown option
else:
logger.debug(
"Undefined add option type : {}/{} --> {}".format(
option_type, text, params))
# create the add button with the icon corresponding to the add option
add_button = QPushButton(icon, option_type)
add_button.setStyleSheet("text-align: left")
# connect the widget to the adding method from LayerAdder class
data_info["layer"] = ("info", params, count)
add_button.pressed.connect(
partial(self.lim_checker.check, data_info))
tbl_result.setCellWidget(count, 3, add_button)
# Else, add a combobox, storing all possibilities.
else:
combo = QComboBox()
for option in add_options_dict:
option_type = option.split(" : ")[0]
# services
if option_type.lower() in list(
self.service_dict.keys()):
icon = self.service_dict.get(
option_type.lower()).get("ico")
# PostGIS table
elif option.startswith(
self.tr("PostGIS table",
context=__class__.__name__)):
icon = ico_pgis
# Data file
elif option.startswith(
self.tr("Data file",
context=__class__.__name__)):
icon = ico_file
# Unkown option
else:
logger.debug(
"Undefined add option type : {}/{} --> {}".
format(option_type, text, params))
# add a combobox item with the icon corresponding to the add option
combo.addItem(icon, option,
add_options_dict.get(option))
# connect the widget to the adding method from LayerAdder class
data_info["layer"] = ("index", count)
combo.activated.connect(
partial(self.lim_checker.check, data_info))
combo.model().sort(
0) # sort alphabetically on option prefix. see: #113
tbl_result.setCellWidget(count, 3, combo)
# make the widget (button or combobox) width the same as the column width
tbl_result.cellWidget(count,
3).setFixedWidth(hheader.sectionSize(3))
count += 1
# dimensions bis (see https://github.com/isogeo/isogeo-plugin-qgis/issues/276)
# last column take the width of his content
hheader.setSectionResizeMode(3, 3)
# the height of the row adapts to the content without falling below 30px
vheader.setMinimumSectionSize(30)
vheader.setSectionResizeMode(3)
# method ending
return None
def getTableItem(content, editingDisabled=True):
item = QTableWidgetItem(content)
if editingDisabled:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
return item
def evaluatePipeline(self, point, button):
if button == Qt.LeftButton:
self.rbPipeline.addPoint(point)
self.rbPipeline.show()
elif button == Qt.RightButton:
pipeline = self.rbPipeline.asGeometry()
self.dlg.tblImpacts.setRowCount(0)
lyrRaptor = QgsProject.instance().mapLayersByName(
"Raptor Buffer")[0]
raptors = lyrRaptor.getFeatures(pipeline.boundingBox())
for raptor in raptors:
valConstraint = raptor.attribute("recentspec")
valID = raptor.attribute("Nest_ID")
valStatus = raptor.attribute("recentstat")
valDistance = pipeline.distance(raptor.geometry().centroid())
if raptor.geometry().intersects(pipeline):
row = self.dlg.tblImpacts.rowCount()
self.dlg.tblImpacts.insertRow(row)
self.dlg.tblImpacts.setItem(
row, 0, QTableWidgetItem(valConstraint))
self.dlg.tblImpacts.setItem(row, 1,
QTableWidgetItem(str(valID)))
self.dlg.tblImpacts.setItem(row, 2,
QTableWidgetItem(valStatus))
self.dlg.tblImpacts.setItem(
row, 3,
QTableWidgetItem("{:4.5f}".format(valDistance)))
lyrEagle = QgsProject.instance().mapLayersByName("BAEA Buffer")[0]
eagles = lyrEagle.getFeatures(pipeline.boundingBox())
for eagle in eagles:
valConstraint = "BAEA Nest"
valID = eagle.attribute("nest_id")
valStatus = eagle.attribute("status")
valDistance = pipeline.distance(eagle.geometry().centroid())
if eagle.geometry().intersects(pipeline):
row = self.dlg.tblImpacts.rowCount()
self.dlg.tblImpacts.insertRow(row)
self.dlg.tblImpacts.setItem(
row, 0, QTableWidgetItem(valConstraint))
self.dlg.tblImpacts.setItem(row, 1,
QTableWidgetItem(str(valID)))
self.dlg.tblImpacts.setItem(row, 2,
QTableWidgetItem(valStatus))
self.dlg.tblImpacts.setItem(
row, 3,
QTableWidgetItem("{:4.5f}".format(valDistance)))
lyrBUOWL = QgsProject.instance().mapLayersByName("BUOWL Buffer")[0]
buowls = lyrBUOWL.getFeatures(pipeline.boundingBox())
for buowl in buowls:
valConstraint = "BUOWL Habitat"
valID = buowl.attribute("habitat_id")
valStatus = buowl.attribute("recentstat")
valDistance = pipeline.distance(buowl.geometry().buffer(
-0.001, 5))
if buowl.geometry().intersects(pipeline):
row = self.dlg.tblImpacts.rowCount()
self.dlg.tblImpacts.insertRow(row)
self.dlg.tblImpacts.setItem(
row, 0, QTableWidgetItem(valConstraint))
self.dlg.tblImpacts.setItem(row, 1,
QTableWidgetItem(str(valID)))
self.dlg.tblImpacts.setItem(row, 2,
QTableWidgetItem(valStatus))
self.dlg.tblImpacts.setItem(
row, 3,
QTableWidgetItem("{:4.5f}".format(valDistance)))
self.dlg.show()
self.rbPipeline.reset()
def _open_function(self, index):
# this '0' refers to the index of the item in the selected row
self.function_selected = index.sibling(index.row(), 0).data()
# Control no clickable items
if self.function_selected in self.no_clickable_items:
return
if 'reports' in index.parent().data().lower():
# this '1' refers to the index of the item in the selected row
function_name = index.sibling(index.row(), 0).data()
self.function_selected = index.sibling(index.row(), 1).data()
self.dlg_reports = GwToolboxReportsUi()
tools_gw.load_settings(self.dlg_reports)
# Set listeners
self.dlg_reports.btn_export_path.clicked.connect(self._select_file_report)
self.dlg_reports.btn_export.clicked.connect(partial(self._export_reports, self.dlg_reports, self.dlg_reports.tbl_reports, self.dlg_reports.txt_export_path))
self.dlg_reports.rejected.connect(partial(tools_gw.close_dialog, self.dlg_reports))
self.dlg_reports.btn_close.clicked.connect(self.dlg_reports.reject)
extras = f'"filterText":null, "listId":"{self.function_selected}"'
body = tools_gw.create_body(extras=extras)
json_result = tools_gw.execute_procedure('gw_fct_getreport', body)
if not json_result or json_result['status'] == 'Failed':
return False
layout = self.dlg_reports.findChild(QGridLayout, 'lyt_filters')
order = 0
for field in json_result['body']['data']['fields']:
label = None
widget = None
if 'label' in field and field['label']:
label = QLabel()
label.setObjectName('lbl_' + field['widgetname'])
label.setText(field['label'].capitalize())
if 'stylesheet' in field and field['stylesheet'] is not None and 'label' in field['stylesheet']:
label = tools_gw.set_stylesheet(field, label)
if 'tooltip' in field:
label.setToolTip(field['tooltip'])
else:
label.setToolTip(field['label'].capitalize())
if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead':
completer = QCompleter()
widget = tools_gw.add_lineedit(field)
widget = tools_gw.set_widget_size(widget, field)
widget = tools_gw.set_data_type(field, widget)
widget.textChanged.connect(partial(self._update_tbl_reports))
if field['widgettype'] == 'typeahead':
widget = tools_gw.set_typeahead(field, self.dlg_reports, widget, completer)
elif field['widgettype'] == 'combo':
widget = tools_gw.add_combo(field)
widget = tools_gw.set_widget_size(widget, field)
widget.currentIndexChanged.connect(partial(self._update_tbl_reports))
elif field['widgettype'] == 'check':
widget = tools_gw.add_checkbox(field)
widget.stateChanged.connect(partial(self._update_tbl_reports))
elif field['widgettype'] == 'datetime':
widget = tools_gw.add_calendar(self.dlg_reports, field)
widget.valueChanged.connect(partial(self._update_tbl_reports))
elif field['widgettype'] == 'list':
numrows = len(field['value'])
numcols = len(field['value'][0])
self.dlg_reports.tbl_reports.setColumnCount(numcols)
self.dlg_reports.tbl_reports.setRowCount(numrows)
i = 0
dict_keys = {}
for key in field['value'][0].keys():
dict_keys[i] = f"{key}"
self.dlg_reports.tbl_reports.setHorizontalHeaderItem(i, QTableWidgetItem(f"{key}"))
i = i + 1
for row in range(numrows):
for column in range(numcols):
column_name = dict_keys[column]
self.dlg_reports.tbl_reports.setItem(row, column, QTableWidgetItem(f"{field['value'][row][column_name]}"))
continue
order = order + 1
if label:
layout.addWidget(label, 0, order)
if widget:
layout.addWidget(widget, 1, order)
self.dlg_reports.setWindowTitle(f"{function_name}")
tools_gw.open_dialog(self.dlg_reports, dlg_name='reports')
elif 'giswater' in index.parent().data().lower():
self.dlg_functions = GwToolboxManagerUi()
tools_gw.load_settings(self.dlg_functions)
self.dlg_functions.progressBar.setVisible(False)
self.dlg_functions.btn_cancel.hide()
self.dlg_functions.btn_close.show()
self.dlg_functions.btn_cancel.clicked.connect(self._cancel_task)
self.dlg_functions.cmb_layers.currentIndexChanged.connect(partial(self.set_selected_layer, self.dlg_functions,
self.dlg_functions.cmb_layers))
self.dlg_functions.rbt_previous.toggled.connect(partial(self._rbt_state, self.dlg_functions.rbt_previous))
self.dlg_functions.rbt_layer.toggled.connect(partial(self._rbt_state, self.dlg_functions.rbt_layer))
self.dlg_functions.rbt_layer.setChecked(True)
extras = f'"filterText":"{self.function_selected}"'
extras += ', "isToolbox":true'
body = tools_gw.create_body(extras=extras)
json_result = tools_gw.execute_procedure('gw_fct_gettoolbox', body)
if not json_result or json_result['status'] == 'Failed':
return False
status = self._populate_functions_dlg(self.dlg_functions, json_result['body']['data']['processes'])
if not status:
self.function_selected = index.sibling(index.row(), 1).data()
message = "Function not found"
tools_qgis.show_message(message, parameter=self.function_selected)
return
# Disable tab log
tools_gw.disable_tab_log(self.dlg_functions)
# Connect signals
self.dlg_functions.mainTab.currentChanged.connect(partial(self._manage_btn_run))
self.dlg_functions.btn_run.clicked.connect(partial(self._execute_function, self.function_selected,
self.dlg_functions, self.dlg_functions.cmb_layers, json_result['body']['data']['processes']))
self.dlg_functions.btn_close.clicked.connect(partial(tools_gw.close_dialog, self.dlg_functions))
self.dlg_functions.rejected.connect(partial(tools_gw.close_dialog, self.dlg_functions))
self.dlg_functions.btn_cancel.clicked.connect(partial(self.remove_layers))
# Open form and set title
self.dlg_functions.setWindowTitle(f"{self.function_selected}")
tools_gw.open_dialog(self.dlg_functions, dlg_name='toolbox')
def setMapLayers(self):
""" Run through all loaded layers to find ones which should be excluded."""
if self.tabUpper.rowCount() == 0 and self.tabLower.rowCount() == 0:
# reset to show all pixel sizes.
self.mcboRasterLayer.setExceptedLayerList([])
self.pixel_size = ['0', 'm', '']
else:
# the layers already in the list
used_up_layers = [
self.tabUpper.item(row, 0).text()
for row in range(0, self.tabUpper.rowCount())
]
used_low_layers = [
self.tabLower.item(row, 0).text()
for row in range(0, self.tabLower.rowCount())
]
# loop through the pick list
if self.cboMethod.currentText() == 'Target Over All Years':
tab_obj_list = [self.tabUpper]
used_layers = used_up_layers
else:
tab_obj_list = [self.tabUpper, self.tabLower]
# get layers common to both lists.
used_layers = list(set(used_up_layers) & set(used_low_layers))
if self.layers_df is None:
self.layers_df = build_layer_table()
# get the used layers dataframe containing geometry
df_used = self.layers_df[self.layers_df['layer_id'].isin(
used_up_layers + used_low_layers)]
df_sub = self.layers_df[(self.layers_df['provider'] == 'gdal') & (
self.layers_df['layer_type'] == 'RasterLayer')]
# Find layers that don't overlap, have a different pixel size or have already been added (via list of layer id's).
df_sub = df_sub[((df_sub['layer_id'].isin(used_layers)) |
(df_sub['pixel_size'] != self.pixel_size[0])) |
(~df_sub.intersects(df_used.unary_union))]
if len(df_sub['layer'].tolist()) > 0:
self.mcboRasterLayer.setExceptedLayerList(
df_sub['layer'].tolist())
self.tabUpper.horizontalHeader().setStyleSheet('color:black')
if self.tabUpper.rowCount() == 0:
self.tabUpper.setHorizontalHeaderItem(
1,
QTableWidgetItem("{} Raster(s)".format(
self.tabUpper.rowCount())))
else:
self.tabUpper.setHorizontalHeaderItem(
1,
QTableWidgetItem("{} Raster(s) with {}{} pixels".format(
self.tabUpper.rowCount(), *self.pixel_size[:2])))
self.tabLower.horizontalHeader().setStyleSheet('color:black')
self.tabLower.setHorizontalHeaderItem(
1,
QTableWidgetItem("{} Raster(s)".format(self.tabLower.rowCount())))
self.cmdAdd.setEnabled(len(self.mcboRasterLayer) > 0)
self.cmdDel.setEnabled(self.tabUpper.rowCount() > 0)
self.cmdAddLower.setEnabled(len(self.mcboRasterLayer) > 0)
self.cmdDelLower.setEnabled(self.tabLower.rowCount() > 0)
def create_table(self):
from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa
header = ["Classification Name", "Color", "Thematic Class", ""]
# clear table
self.tableBtnsConfig.clear()
# init table
self.tableBtnsConfig.setRowCount(len(self.table_buttons))
self.tableBtnsConfig.setColumnCount(4)
# hidden row labels
self.tableBtnsConfig.verticalHeader().setVisible(False)
# add Header
self.tableBtnsConfig.setHorizontalHeaderLabels(header)
# insert items
for n, h in enumerate(header):
if h == "Classification Name":
for m, (key, item) in enumerate(self.table_buttons.items()):
if m + 1 in self.buttons_config:
item_table = QTableWidgetItem(
self.buttons_config[m + 1]["name"])
else:
item_table = QTableWidgetItem(str(item))
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip(
"Classification button ID: {}".format(key))
self.tableBtnsConfig.setItem(m, n, item_table)
if h == "Color":
for m, item in enumerate(self.table_buttons.values()):
item_table = QTableWidgetItem()
if m + 1 in self.buttons_config:
item_table.setBackground(
QColor(self.buttons_config[m + 1]["color"]))
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tableBtnsConfig.setItem(m, n, item_table)
if h == "Thematic Class":
for m, item in enumerate(self.table_buttons.values()):
if valid_file_selected_in(
AcATaMa.dockwidget.QCBox_ThematicRaster):
if m + 1 in self.buttons_config and self.buttons_config[
m + 1]["thematic_class"] is not None:
item_table = QTableWidgetItem(
self.buttons_config[m + 1]["thematic_class"])
else:
item_table = QTableWidgetItem(str(item))
item_table.setToolTip(
"Click to open the pixel value/color table of the thematic classes"
)
else:
item_table = QTableWidgetItem("none")
item_table.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
item_table.setForeground(QColor("lightGrey"))
item_table.setToolTip(
"No thematic layer, if you want enable the thematic classes,\n"
"select first a valid thematic layer in thematic tab"
)
item_h = QTableWidgetItem(h)
item_h.setForeground(QColor("lightGrey"))
self.tableBtnsConfig.setHorizontalHeaderItem(2, item_h)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tableBtnsConfig.setItem(m, n, item_table)
if h == "":
for m, item in enumerate(self.table_buttons.values()):
item_table = QTableWidgetItem()
path = ':/plugins/AcATaMa/icons/trash.svg'
icon = QIcon(path)
item_table.setIcon(icon)
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip("Clean this row")
self.tableBtnsConfig.setItem(m, n, item_table)
# set the minimum width to 0 for headers
self.tableBtnsConfig.horizontalHeader().setMinimumSectionSize(0)
# adjust size of Table
self.tableBtnsConfig.resizeColumnsToContents()
self.tableBtnsConfig.resizeRowsToContents()
# adjust the dialog based on table content
dialog_width = self.tableBtnsConfig.horizontalHeader().length() + 50
self.resize(dialog_width, self.height())
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = NewRaptorDialog()
#
self.dlg.cmbSpecies.currentTextChanged.connect(
self.evt_cmbSpecies_changed)
mc = self.iface.mapCanvas()
self.dlg.spbLatitude.setValue(mc.center().y())
self.dlg.spbLongitude.setValue(mc.center().x())
self.dlg.dteLast.setDate(QDate.currentDate())
# Lista de camada do mapa
map_layers = []
for lyr in mc.layers():
map_layers.append(lyr.name())
# Coloca o nome dos layrs em uma caixa de mensagem, com o titulo camadas
#QMessageBox.information(self.dlg, "Layers", str(map_layers))
# cria uma caixa de mensagem caso não achar alguams das layrs descritas abaixo
missing_layers = []
if not 'Raptor Nests' in map_layers:
missing_layers.append('Raptor Nests')
if not 'Raptor Buffer' in map_layers:
missing_layers.append('Raptor Buffer')
if not 'Linear Buffer' in map_layers:
missing_layers.append('Linear Buffer')
if missing_layers:
msg = 'The following layres are missing from ths project\n'
for lyr in missing_layers:
msg += f'\n {lyr}'
QMessageBox.critical(self.dlg, 'Missing layers', msg)
# o return barra a execução das demais linhas de códigos
return
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
# irá retornar uma lista com o as camdas com nome Raptor Nests, mas iremos pegar apenas a primeira camadd
lyrNests = QgsProject.instance().mapLayersByName('Raptor Nests')[0]
lyrBuffer = QgsProject.instance().mapLayersByName(
'Raptor Buffer')[0]
lyrLinear = QgsProject.instance().mapLayersByName(
'Linear Buffer')[0]
# Irá pegar o ultimo valor de índice
idxNestID = lyrNests.fields().indexOf('Nest_ID')
valNestID = lyrNests.maximumValue(idxNestID) + 1
# Irá pegar os valores que foram digitados na caixa de texto
valLat = self.dlg.spbLatitude.value()
valLng = self.dlg.spbLongitude.value()
valSpecies = self.dlg.cmbSpecies.currentText()
valBuffer = self.dlg.spbBuffer.value()
valStatus = self.dlg.cmbStatus.currentText()
valLast = self.dlg.dteLast.date()
QMessageBox.information(
self.dlg, 'Message',
f'New Nest ID: {valNestID}\n \nLatitude: {valLat} '
f'\nLongitude: {valLng} \nSpecies: {valSpecies} '
f'\nBuffer: {valBuffer} \nStatus: {valStatus} \nLast: {valLast}'
)
# cria um novo objeto da classe QgsFeature, no qual a classe terá os mesmoa campos do lyrnet.fildes
# (objeto da Layer Raptor Nests)
ftrNest = QgsFeature(lyrNests.fields())
# Irá começar a adicoanr atributos de acordo com o nome dos campos da layer Raptor Nests
ftrNest.setAttribute('lat_y_dd', valLat)
ftrNest.setAttribute('long_x_dd', valLng)
ftrNest.setAttribute('recentspec', valSpecies)
ftrNest.setAttribute('buf_dist', valBuffer)
ftrNest.setAttribute('recentstat', valStatus)
ftrNest.setAttribute('lastsurvey', valLast)
ftrNest.setAttribute('Nest_ID', valNestID)
# colcoando o tipo de geometria
geom = QgsGeometry(QgsPoint(valLng, valLat))
ftrNest.setGeometry(geom)
# Cada tipo de dados pode ter um provedor diferente, o qgis tem extensões para varios tipos de provedor,
# a função abaixo pega o provedor e inclui os dados de acordo com o proveor
pr = lyrNests.dataProvider()
pr.addFeatures([ftrNest])
lyrNests.reload()
# Adiconando a camada de buffer
pr = lyrBuffer.dataProvider()
buffer = geom.buffer(valBuffer, 10)
ftrNest.setGeometry(buffer)
pr.addFeatures([ftrNest])
lyrBuffer.reload()
dlgTable = DlgTable()
dlgTable.setWindowTitle(f"Impacts Table for Nest {valNestID}")
# Find linear projects that will impacted and report then in the table
bb = buffer.boundingBox()
linears = lyrLinear.getFeatures(bb)
for linear in linears:
valID = linear.attribute('Project')
valType = linear.attribute('type')
valDistance = linear.geometry().distance(geom)
if valDistance < valBuffer:
#populate table with Linear data
row = dlgTable.tblImpacts.rowCount()
dlgTable.tblImpacts.insertRow(row)
dlgTable.tblImpacts.setItem(row, 0,
QTableWidgetItem(str(valID)))
dlgTable.tblImpacts.setItem(row, 1,
QTableWidgetItem(valType))
twi = QTableWidgetItem(f"{valDistance:4.5f}")
twi.setTextAlignment(QtCore.Qt.AlignRight)
dlgTable.tblImpacts.setItem(row, 2, twi)
dlgTable.tblImpacts.sortItems(2)
dlgTable.show()
dlgTable.exec_()
else:
QMessageBox.information(self.dlg, "Message",
"Should only run if cancelled")
def create_table(self):
from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa
header = ["Pix Val", "Color", "Select"]
# get color table from raster
thematic_table = {
"color_table":
get_color_table(
AcATaMa.dockwidget.QCBox_ThematicRaster.currentLayer(),
band=int(AcATaMa.dockwidget.QCBox_band_ThematicRaster.
currentText()),
nodata=int(AcATaMa.dockwidget.nodata_ThematicRaster.value()))
}
if not thematic_table["color_table"]:
# clear table
self.tableOfClasses.setRowCount(0)
self.tableOfClasses.setColumnCount(0)
return
thematic_table["row_count"] = len(
list(thematic_table["color_table"].values())[0])
# init table
self.tableOfClasses.setRowCount(thematic_table["row_count"])
self.tableOfClasses.setColumnCount(3)
# hidden row labels
self.tableOfClasses.verticalHeader().setVisible(False)
# add Header
self.tableOfClasses.setHorizontalHeaderLabels(header)
# insert items
for n, h in enumerate(header):
if h == "Pix Val":
for m, item in enumerate(
thematic_table["color_table"]["Pixel Value"]):
item_table = QTableWidgetItem(str(item))
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tableOfClasses.setItem(m, n, item_table)
if h == "Color":
for m in range(thematic_table["row_count"]):
item_table = QTableWidgetItem()
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setBackground(
QColor(thematic_table["color_table"]["Red"][m],
thematic_table["color_table"]["Green"][m],
thematic_table["color_table"]["Blue"][m],
thematic_table["color_table"]["Alpha"][m]))
self.tableOfClasses.setItem(m, n, item_table)
if h == "Select":
for m in range(thematic_table["row_count"]):
item_table = QPushButton("Select this")
item_table.clicked.connect(self.select_clicked)
self.tableOfClasses.setCellWidget(m, n, item_table)
# adjust size of Table
self.tableOfClasses.resizeColumnsToContents()
self.tableOfClasses.resizeRowsToContents()
# adjust the dialog based on table content
dialog_width = self.tableOfClasses.horizontalHeader().length() + 50
self.resize(dialog_width, self.height())
def ToggleActiveRow(self, row, value="Playing"):
''' Toggle Active row manager video status '''
self.VManager.setItem(
row, 2,
QTableWidgetItem(QCoreApplication.translate("ManagerDock", value)))
return
def run(self):
"""Run method that performs all the real work"""
# Create the dialog with elements (after translation) and keep reference
# Only create GUI ONCE in callback, so that it will only load when the plugin is started
if self.first_start == True:
self.first_start = False
self.dlg = NuevoNidoDialog()
#QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr una vez" )
self.dlg.Cb_Estado.currentTextChanged.connect(
self.evt_Cb_Estado_change)
#Codigo que siempre se ejecuta la primera vez que se ejecuta
#QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr siempre" )
#Crear conexion al Map Canvas
mc = self.iface.mapCanvas()
self.dlg.SpbD_Coord_X.setValue(mc.center().x())
self.dlg.SpbD_Coord_Y.setValue(mc.center().y())
self.dlg.DtE_Fecha.setDate(QDate.currentDate())
#Revisar capas cargadas
map_layers = []
for lyr in mc.layers():
map_layers.append(lyr.name())
missing_layers = []
if not "Avistamientos" in map_layers:
missing_layers.append("Avistamientos")
if not "Buffer Nidos" in map_layers:
missing_layers.append("Buffer Nidos")
if not "Buffer Lineal" in map_layers:
missing_layers.append("Buffer Lineal")
if missing_layers:
mag = "Las siguientes capas falta en este proyecto"
for lyr in missing_layers:
mag += f"\n{lyr}"
QMessageBox.critical(self.dlg, "Capas Faltantes", mag)
return
# show the dialog
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Do something useful here - delete the line containing pass and
# substitute with your code.
#QMessageBox.information(self.dlg, "Mensaje", "Esto solo debe correr si presiona Ok" )
lyrNido = QgsProject.instance().mapLayersByName("Avistamientos")[0]
lyrBuffer = QgsProject.instance().mapLayersByName(
"Buffer Nidos")[0]
idxNidoId = lyrNido.fields().indexOf("nidoID")
valNidoId = lyrNido.maximumValue(idxNidoId) + 1
lyrLineal = QgsProject.instance().mapLayersByName(
"Buffer Lineal")[0]
#QMessageBox.information(self.dlg, "Mensaje", f"Nuevo Nido Id = {valNidoId}")
valX = self.dlg.SpbD_Coord_X.value()
valY = self.dlg.SpbD_Coord_Y.value()
valEsp = self.dlg.Cb_Especie.currentText()
valEst = self.dlg.Cb_Estado.currentText()
valBuff = self.dlg.Spb_BuffDist.value()
valFecha = self.dlg.DtE_Fecha.date()
#QMessageBox.information(self.dlg, "Mensaje", f"Nuevo Nido Id = {valNidoId}\nCoord X = {valX}\nCoord Y = {valY}\nEspecie = {valEsp}\nEstado = {valEst}\nBuffer = {valBuff}\nFecha = {valFecha}")
ftrNido = QgsFeature(lyrNido.fields())
ftrNido.setAttribute("id", valNidoId)
ftrNido.setAttribute("coord_x", valX)
ftrNido.setAttribute("coord_y", valY)
ftrNido.setAttribute("fecha", valFecha)
ftrNido.setAttribute("especie", valEsp)
ftrNido.setAttribute("estado", valEst)
ftrNido.setAttribute("nidoID", valNidoId)
ftrNido.setAttribute("dist_buf", valBuff)
geom = QgsGeometry(QgsPoint(valX, valY))
ftrNido.setGeometry(geom)
pr = lyrNido.dataProvider()
pr.addFeatures([ftrNido])
lyrNido.reload()
#Agregar el buffer
pr = lyrBuffer.dataProvider()
buffer = geom.buffer(valBuff, 10)
ftrNido.setGeometry(buffer)
pr.addFeatures([ftrNido])
lyrBuffer.reload()
dlgTabla = DlgTabla()
dlgTabla.setWindowTitle(f"Tabla de Impactos para Nido {valNidoId}")
bb = buffer.boundingBox()
lineales = lyrLineal.getFeatures(bb)
for lineal in lineales:
valID = lineal.attribute("Proyecto")
valTipo = lineal.attribute("Tipo")
valDistancia = lineal.geometry().distance(geom)
if valDistancia < valBuff:
fila = dlgTabla.Tbw_Impactos.rowCount()
dlgTabla.Tbw_Impactos.insertRow(fila)
dlgTabla.Tbw_Impactos.setItem(fila, 0,
QTableWidgetItem(str(valID)))
dlgTabla.Tbw_Impactos.setItem(fila, 1,
QTableWidgetItem(valTipo))
#dlgTabla.Tbw_Impactos.setItem(fila, 2, QTableWidgetItem(f"{valDistancia:.2f}")) #"{:.2f}".format(valDistancia)
twi = QTableWidgetItem(f"{valDistancia:.2f}")
twi.setTextAlignment(QtCore.Qt.AlignRight)
dlgTabla.Tbw_Impactos.setItem(fila, 2, twi)
dlgTabla.Tbw_Impactos.sortItems(2)
dlgTabla.show()
dlgTabla.exec_()
else:
QMessageBox.information(
self.dlg, "Mensaje",
"Esto solo debe correr si presiona Cancel")
