def setData(self, index, data, role):
if index.column() == SourceModel.Columns.IS_CATALOGUE:
return QStandardItemModel.setData(
self, index, data, int(SourceModel.Roles.IS_CATALOGUE))
if index.column() == SourceModel.Columns.DATASET:
return QStandardItemModel.setData(
self, index, data, int(SourceModel.Roles.DATASET_NAME))
return QStandardItemModel.setData(self, index, data, role)
def set_data(self, data):
"""Update the table data"""
model = QStandardItemModel(len(data), 3)
model.setHorizontalHeaderItem(0, QStandardItem("Duplicate Id"))
model.setHorizontalHeaderItem(1, QStandardItem("Table"))
model.setHorizontalHeaderItem(2, QStandardItem("Table"))
row = 0
for (feat_id, rel1, rel2) in data:
model.setData(model.index(row, 0), str(feat_id))
model.setData(model.index(row, 1), rel1)
model.setData(model.index(row, 2), rel2)
row += 1
self.tbl_dup_ids.setModel(model)
self.tbl_dup_ids.setEditTriggers(QAbstractItemView.NoEditTriggers)
class DoProfile(QWidget):
def __init__(self, iface, dockwidget1 , tool1 , plugin, parent = None):
QWidget.__init__(self, parent)
self.profiles = None #dictionary where is saved the plotting data {"l":[l],"z":[z], "layer":layer1, "curve":curve1}
self.xAxisSteps = None
self.xAxisStepType = "numeric"
self.iface = iface
self.tool = tool1
self.dockwidget = dockwidget1
self.pointstoDraw = None
self.plugin = plugin
#init scale widgets
self.dockwidget.sbMaxVal.setValue(0)
self.dockwidget.sbMinVal.setValue(0)
self.dockwidget.sbMaxVal.setEnabled(False)
self.dockwidget.sbMinVal.setEnabled(False)
self.dockwidget.sbMinVal.valueChanged.connect(self.reScalePlot)
self.dockwidget.sbMaxVal.valueChanged.connect(self.reScalePlot)
#**************************** function part *************************************************
# remove layers which were removed from QGIS
def removeClosedLayers(self, model1):
qgisLayerNames = []
for i in range(0, self.iface.mapCanvas().layerCount()):
qgisLayerNames.append(self.iface.mapCanvas().layer(i).name())
for i in range(0 , model1.rowCount()):
layerName = model1.item(i,2).data(Qt.EditRole)
if not layerName in qgisLayerNames:
self.plugin.removeLayer(i)
self.removeClosedLayers(model1)
break
def calculatePointProfile(self, point, model, library):
self.model = model
self.library = library
statName = self.getPointProfileStatNames()[0]
self.removeClosedLayers(model)
if point == None:
return
PlottingTool().clearData(self.dockwidget, model, library)
self.profiles = []
#creating the plots of profiles
for i in range(0 , model.rowCount()):
self.profiles.append( {"layer": model.item(i,3).data(Qt.EditRole) } )
self.profiles[i][statName] = []
self.profiles[i]["l"] = []
layer = self.profiles[i]["layer"]
if layer:
try:
ident = layer.dataProvider().identify(point, QgsRaster.IdentifyFormatValue )
except:
ident = None
else:
ident = None
if ident is not None:
self.profiles[i][statName] = list(ident.results().values())
self.profiles[i]["l"] = list(ident.results().keys())
self.setXAxisSteps()
PlottingTool().attachCurves(self.dockwidget, self.profiles, model, library)
if self.dockwidget.cboAutoScale.isChecked():
PlottingTool().reScalePlot(self.dockwidget, self.profiles, model, library)
self.setupTableTab(model)
def getPointProfileStatNames(self):
return ["value"]
# The code is based on the approach of ZonalStatistics from Processing toolbox
def calculatePolygonProfile(self, geometry, crs, model, library):
self.model = model
self.library = library
self.removeClosedLayers(model)
if geometry is None or geometry.isEmpty():
return
PlottingTool().clearData(self.dockwidget, model, library)
self.profiles = []
#creating the plots of profiles
for i in range(0 , model.rowCount()):
self.profiles.append( {"layer": model.item(i,3).data(Qt.EditRole) } )
self.profiles[i]["l"] = []
for statistic in self.getPolygonProfileStatNames():
self.profiles[i][statistic] = []
# Get intersection between polygon geometry and raster following ZonalStatistics code
rasterDS = gdal.Open(self.profiles[i]["layer"].source(), gdal.GA_ReadOnly)
geoTransform = rasterDS.GetGeoTransform()
cellXSize = abs(geoTransform[1])
cellYSize = abs(geoTransform[5])
rasterXSize = rasterDS.RasterXSize
rasterYSize = rasterDS.RasterYSize
rasterBBox = QgsRectangle(geoTransform[0], geoTransform[3] - cellYSize
* rasterYSize, geoTransform[0] + cellXSize
* rasterXSize, geoTransform[3])
rasterGeom = QgsGeometry.fromRect(rasterBBox)
memVectorDriver = ogr.GetDriverByName('Memory')
memRasterDriver = gdal.GetDriverByName('MEM')
intersectedGeom = rasterGeom.intersection(geometry)
ogrGeom = ogr.CreateGeometryFromWkt(intersectedGeom.asWkt())
bbox = intersectedGeom.boundingBox()
xMin = bbox.xMinimum()
xMax = bbox.xMaximum()
yMin = bbox.yMinimum()
yMax = bbox.yMaximum()
(startColumn, startRow) = self.mapToPixel(xMin, yMax, geoTransform)
(endColumn, endRow) = self.mapToPixel(xMax, yMin, geoTransform)
width = endColumn - startColumn
height = endRow - startRow
if width == 0 or height == 0:
return
srcOffset = (startColumn, startRow, width, height)
newGeoTransform = (
geoTransform[0] + srcOffset[0] * geoTransform[1],
geoTransform[1],
0.0,
geoTransform[3] + srcOffset[1] * geoTransform[5],
0.0,
geoTransform[5],
)
# Create a temporary vector layer in memory
memVDS = memVectorDriver.CreateDataSource('out')
memLayer = memVDS.CreateLayer('poly', crs, ogr.wkbPolygon)
ft = ogr.Feature(memLayer.GetLayerDefn())
ft.SetGeometry(ogrGeom)
memLayer.CreateFeature(ft)
ft.Destroy()
# Rasterize it
rasterizedDS = memRasterDriver.Create('', srcOffset[2],
srcOffset[3], 1, gdal.GDT_Byte)
rasterizedDS.SetGeoTransform(newGeoTransform)
gdal.RasterizeLayer(rasterizedDS, [1], memLayer, burn_values=[1])
rasterizedArray = rasterizedDS.ReadAsArray()
for bandNumber in range(1, rasterDS.RasterCount+1):
rasterBand = rasterDS.GetRasterBand(bandNumber)
noData = rasterBand.GetNoDataValue()
if noData is None:
noData = np.nan
scale = rasterBand.GetScale()
if scale is None:
scale = 1.0
offset = rasterBand.GetOffset()
if offset is None:
offset = 0.0
srcArray = rasterBand.ReadAsArray(*srcOffset)
srcArray = srcArray*scale+offset
masked = np.ma.MaskedArray(srcArray,
mask=np.logical_or.reduce((
srcArray == noData,
np.logical_not(rasterizedArray),
np.isnan(srcArray))))
self.profiles[i]["l"].append(bandNumber)
self.profiles[i]["count"].append(float(masked.count()))
self.profiles[i]["max"].append(float(masked.max()))
self.profiles[i]["mean"].append(float(masked.mean()))
self.profiles[i]["median"].append(float(np.ma.median(masked)))
self.profiles[i]["min"].append(float(masked.min()))
self.profiles[i]["range"].append(float(masked.max()) - float(masked.min()))
self.profiles[i]["std"].append(float(masked.std()))
self.profiles[i]["sum"].append(float(masked.sum()))
self.profiles[i]["unique"].append(np.unique(masked.compressed()).size)
self.profiles[i]["var"].append(float(masked.var()))
memVDS = None
rasterizedDS = None
rasterDS = None
self.setXAxisSteps()
PlottingTool().attachCurves(self.dockwidget, self.profiles, model, library)
if self.dockwidget.cboAutoScale.isChecked():
PlottingTool().reScalePlot(self.dockwidget, self.profiles, model, library)
self.setupTableTab(model)
def getPolygonProfileStatNames(self):
return ["count", "max", "mean", "median", "min", "range", "std", "sum", "unique", "var"]
def setXAxisSteps(self):
if self.xAxisSteps == None:
self.changeXAxisStepType("numeric")
return
elif self.xAxisSteps[0] == "Timesteps":
for profile in self.profiles:
stepsNum = len(profile["l"])
startTime = self.xAxisSteps[1]
step = self.xAxisSteps[2]
stepType = self.xAxisSteps[3]
useNetcdfTime = self.xAxisSteps[4]
if stepType == "years":
stepType = "days"
step = step * 365
elif stepType == "months":
stepType = "days"
step = step * 365/12
profile["l"] = []
if useNetcdfTime and (profile["layer"].source().startswith("NETCDF:") or
profile["layer"].source().endswith(".nc")):
try:
import netCDF4
if profile["layer"].source().startswith("NETCDF:"):
filename = re.match('NETCDF:\"(.*)\":.*$', profile["layer"].source()).group(1)
else:
filename = profile["layer"].source()
nc = netCDF4.Dataset(filename, mode='r')
profile["l"] = netCDF4.num2date(nc.variables["time"][:],
units = nc.variables["time"].units,
calendar = nc.variables["time"].calendar)
nc.close()
except ImportError:
text = "Temporal/Spectral Profile Tool: netCDF4 module is required to read NetCDF " + \
"time dimension. Please use pip install netCDF4"
self.iface.messageBar().pushWidget(self.iface.messageBar().createMessage(text),
QgsMessageBar.WARNING, 5)
profile["l"] = []
except KeyError:
text = "Temporal/Spectral Profile Tool: NetCDF file does not have " + \
"time dimension."
self.iface.messageBar().pushWidget(self.iface.messageBar().createMessage(text),
QgsMessageBar.WARNING, 5)
nc.close()
profile["l"] = []
if profile["l"] == []:
for i in range(stepsNum):
timedeltaParams = {stepType: step*i}
profile["l"].append(startTime + timedelta(**timedeltaParams))
self.changeXAxisStepType("timedate")
else:
for profile in self.profiles:
# Truncate the profiles to the minimum of the length of each profile
# or length of provided x-axis steps
stepsNum = min(len(self.xAxisSteps), len(profile["l"]))
profile["l"] = self.xAxisSteps[:stepsNum]
for stat in list(profile.keys()):
if stat == "l" or stat == "layer":
continue
profile[stat] = profile[stat][:stepsNum]
# If any x-axis step is a NaN then remove the corresponding
# value from profile
nans = [i for i, x in enumerate(profile["l"]) if math.isnan(x)]
for stat in list(profile.keys()):
if stat == "layer":
continue
profile[stat] = [x for i, x in enumerate(profile[stat]) if i not in nans]
self.changeXAxisStepType("numeric")
def changeXAxisStepType(self, newType):
if self.xAxisStepType == newType:
return
else:
self.xAxisStepType = newType
PlottingTool().resetAxis(self.dockwidget, self.library)
def mapToPixel(self, mX, mY, geoTransform):
(pX, pY) = gdal.ApplyGeoTransform(
gdal.InvGeoTransform(geoTransform), mX, mY)
return (int(pX), int(pY))
def setupTableTab(self, model1):
#*********************** TAble tab *************************************************
try: #Reinitializing the table tab
self.VLayout = self.dockwidget.scrollAreaWidgetContents.layout()
while 1:
child = self.VLayout.takeAt(0)
if not child:
break
child.widget().deleteLater()
except:
self.VLayout = QVBoxLayout(self.dockwidget.scrollAreaWidgetContents)
self.VLayout.setContentsMargins(9, -1, -1, -1)
#Setup the table tab
self.groupBox = []
self.profilePushButton = []
self.tableView = []
self.verticalLayout = []
for i in range(0 , model1.rowCount()):
self.groupBox.append( QGroupBox(self.dockwidget.scrollAreaWidgetContents) )
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.groupBox[i].sizePolicy().hasHeightForWidth())
self.groupBox[i].setSizePolicy(sizePolicy)
self.groupBox[i].setMinimumSize(QSize(0, 150))
self.groupBox[i].setMaximumSize(QSize(16777215, 350))
self.groupBox[i].setTitle(QApplication.translate("GroupBox" + str(i), self.profiles[i]["layer"].name(), None))
self.groupBox[i].setObjectName("groupBox" + str(i))
self.verticalLayout.append( QVBoxLayout(self.groupBox[i]) )
self.verticalLayout[i].setObjectName("verticalLayout")
#The table
self.tableView.append( QTableView(self.groupBox[i]) )
self.tableView[i].setObjectName("tableView" + str(i))
font = QFont("Arial", 8)
columns = len(self.profiles[i]["l"])
rowNames = list(self.profiles[i].keys())
rowNames.remove("layer") # holds the QgsMapLayer instance
rowNames.remove("l") # holds the band number
rows = len(rowNames)
self.mdl = QStandardItemModel(rows+1, columns)
self.mdl.setVerticalHeaderLabels(["band"] + rowNames)
for j in range(columns):
self.mdl.setData(self.mdl.index(0, j, QModelIndex()), str(self.profiles[i]["l"][j]))
self.mdl.setData(self.mdl.index(0, j, QModelIndex()), font ,Qt.FontRole)
for k in range(rows):
self.mdl.setData(self.mdl.index(k+1, j, QModelIndex()), str(self.profiles[i][rowNames[k]][j]))
self.mdl.setData(self.mdl.index(k+1, j, QModelIndex()), font ,Qt.FontRole)
#self.tableView[i].setVerticalHeaderLabels(rowNames)
self.tableView[i].verticalHeader().setDefaultSectionSize(18)
self.tableView[i].horizontalHeader().setDefaultSectionSize(60)
self.tableView[i].setModel(self.mdl)
self.verticalLayout[i].addWidget(self.tableView[i])
self.horizontalLayout = QHBoxLayout()
#the copy to clipboard button
self.profilePushButton.append( QPushButton(self.groupBox[i]) )
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.profilePushButton[i].sizePolicy().hasHeightForWidth())
self.profilePushButton[i].setSizePolicy(sizePolicy)
self.profilePushButton[i].setText(QApplication.translate("GroupBox", "Copy to clipboard", None))
self.profilePushButton[i].setObjectName(str(i))
self.horizontalLayout.addWidget(self.profilePushButton[i])
self.horizontalLayout.addStretch(0)
self.verticalLayout[i].addLayout(self.horizontalLayout)
self.VLayout.addWidget(self.groupBox[i])
self.profilePushButton[i].clicked.connect(self.copyTable)
def copyTable(self): #Writing the table to clipboard in excel form
nr = int( self.sender().objectName() )
self.clipboard = QApplication.clipboard()
text = "band"
rowNames = list(self.profiles[nr].keys())
rowNames.remove("layer")
rowNames.remove("l")
for name in rowNames:
text += "\t"+name
text += "\n"
for i in range( len(self.profiles[nr]["l"]) ):
text += str(self.profiles[nr]["l"][i])
for j in range(len(rowNames)):
text += "\t" + str(self.profiles[nr][rowNames[j]][i])
text += "\n"
self.clipboard.setText(text)
def reScalePlot(self, param): # called when a spinbox value changed
if type(param) != float:
# don't execute it twice, for both valueChanged(int) and valueChanged(str) signals
return
if self.dockwidget.sbMinVal.value() == self.dockwidget.sbMaxVal.value() == 0:
# don't execute it on init
return
PlottingTool().reScalePlot(self.dockwidget, self.profiles, self.model, self.library, autoMode = False)
class Dialog(QDialog, Ui_nbEditor_dialog):
def __init__(self, iface, ml, mc):
"""Constructor for the dialog.
Args:
iface: QgsInterface instance.
"""
QDialog.__init__(self, iface.mainWindow())
self.setupUi(self)
self.ml = ml
self.mCanvas = mc
self.mRubberBand = QgsRubberBand(self.mCanvas, True)
self.mRubberBand.reset(QgsWkbTypes.PolygonGeometry)
self.mRubberBand.setColor(Qt.red)
self.mRubberBand.setWidth(2)
self.ids = []
self.ini(0)
self.pushCancel.clicked.connect(self.close)
self.pushOK.clicked.connect(self.convert)
self.comboBox.addItems(
['', 'Intersections', 'Touches', 'Within distance'])
self.comboBox.currentIndexChanged.connect(self.nbMethod)
self.ml.selectionChanged.connect(self.map2tab)
def ini(self, n):
self.model = QStandardItemModel(n, 1)
self.tableView.setModel(self.model)
self.model.setHeaderData(0, Qt.Horizontal, 'Neighbouring IDs')
self.tableView.setSelectionMode(QAbstractItemView.SingleSelection)
self.selectionModel = QItemSelectionModel(self.model)
self.tableView.setSelectionModel(self.selectionModel)
self.tableView.horizontalHeader().setStretchLastSection(True)
self.tableView.selectionModel().selectionChanged.connect(self.tab2map)
self.progressBar.setValue(0)
def settings(self):
self.mod = min(self.ids)
self.p = 1
if self.mod == 1:
self.p = 0
def map2tab(self):
s = ''
idx = self.tableView.selectionModel().selectedIndexes()[0]
ts = str(self.model.itemData(idx)[0])
for fid in sorted(self.ml.selectedFeatureIds()):
s += '%s,' % str(int(fid) + self.p)
s = s[:-1]
if s != ts:
self.model.setData(idx, s)
# in order to handle the symmetry
if len(s) > len(ts):
iLst = s.strip().replace(' ', '').split(',')
jLst = ts.strip().replace(' ', '').split(',')
else:
iLst = ts.strip().replace(' ', '').split(',')
jLst = s.strip().replace(' ', '').split(',')
cent = str(idx.row() + self.p)
dLst = list(set(iLst) - set(jLst))
for d in dLst:
row = int(d) - self.p
sor = str(self.model.itemData(self.model.index(row, 0))[0])
eLst = sor.strip().replace(' ', '').split(',')
res = ''
if cent in set(eLst):
ii = eLst.index(cent)
del eLst[ii]
eLst = sorted(map(int, eLst))
for e in eLst:
res += '%s,' % e
res = res[:-1]
else:
u = sor + ',%s' % cent
eLst = sorted(map(int, u.strip().replace(' ', '').split(',')))
for e in eLst:
res += '%s,' % e
res = res[:-1]
self.model.setData(self.model.index(row, 0, QModelIndex()), res)
def nbWithinDist(self):
dlg = xdist.Dialog()
dlg.setModal(True)
dlg.setWindowTitle("Between two objects")
if dlg.exec_() == QDialog.Accepted:
lDist = float(dlg.lineEdit.text())
if lDist == 0:
return
feat = QgsFeature()
provider = self.ml.dataProvider()
e = provider.featureCount()
self.settings()
for ne in range(self.mod, e + self.mod):
feat = QgsFeature()
geom = QgsGeometry()
fiter = self.ml.getFeatures(QgsFeatureRequest(ne))
if fiter.nextFeature(feat):
geom = QgsGeometry(feat.geometry())
neighbours = self.hdist(feat, lDist)
row = feat.id() - self.mod
self.model.setData(self.model.index(row, 0, QModelIndex()),
neighbours)
self.progressBar.setValue(100 * ne / e)
def hdist(self, feata, lDist):
geoma = QgsGeometry(feata.geometry())
feat = QgsFeature()
provider = self.ml.dataProvider()
feats = provider.getFeatures()
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0)
#self.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, provider.featureCount()))
ne = 0
neighbours = ""
while feats.nextFeature(feat):
ne += 1
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne)
geomb = QgsGeometry(feat.geometry())
if feata.id() != feat.id():
if geoma.distance(geomb) <= lDist:
neighbours = neighbours + '%s,' % (feat.id() + self.p)
return neighbours[:-1]
def tab2map(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
self.ml.selectionChanged.disconnect(self.map2tab)
idx = self.tableView.selectionModel().selectedIndexes()[0]
featureId = idx.row() + self.p
s = self.model.itemData(idx)
lst = s[0].strip().replace(' ', '').split(',')
self.ml.removeSelection()
for sid in lst:
self.ml.select(int(sid) - self.p)
provider = self.ml.dataProvider()
feat = QgsFeature()
layer = QgsVectorLayerCache(self.ml, provider.featureCount())
layer.featureAtId(idx.row() + self.mod, feat)
geom = QgsGeometry(feat.geometry())
self.mRubberBand.setToGeometry(geom, self.ml)
self.mRubberBand.show()
self.ml.selectionChanged.connect(self.map2tab)
QApplication.restoreOverrideCursor()
def closeEvent(self, event):
QApplication.setOverrideCursor(Qt.WaitCursor)
self.ml.selectionChanged.disconnect(self.map2tab)
self.ml.removeSelection()
self.mRubberBand.hide()
self.close()
QApplication.restoreOverrideCursor()
def convert(self):
dlg = editordlg()
dlg.setModal(True)
dlg.setWindowTitle("Neighbour list in BUGS format")
num = ""
adj = ""
sumNumNeigh = 0
for row in range(0, self.model.rowCount()):
ts = self.model.itemData(self.model.index(row, 0))
lst = ts[0].strip().replace(' ', '').split(',')
num += '%s, ' % len(lst)
sumNumNeigh += len(lst)
lst.reverse()
sor = ', '.join(lst) + ','
adj = adj + str(sor) + '\n'
num = num[:-2]
adj = adj[:-2]
nblist = 'list(\nnum = c(%s),\nadj = c(%s),\nsumNumNeigh=%s)' % (
num, adj, sumNumNeigh)
dlg.plainTextEdit.appendPlainText(nblist)
dlg.exec_()
def nbMethod(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
self.ml.selectionChanged.disconnect(self.map2tab)
self.model.removeRows(0, self.model.rowCount(QModelIndex()),
QModelIndex())
n = self.ml.dataProvider().featureCount()
self.ini(n)
self.ids = []
provider = self.ml.dataProvider()
feats = provider.getFeatures()
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0)
#self.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, n))
ne = 0
feat = QgsFeature()
while feats.nextFeature(feat):
ne += 1
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne)
self.ids.append(feat.id())
if self.comboBox.currentText() == "Touches":
if self.ml.geometryType() == 0:
return
else:
self.nbTouches()
if self.comboBox.currentText() == "Intersections":
if self.ml.geometryType() == 0:
return
else:
self.nbIntersects()
if self.comboBox.currentText() == "Within distance":
self.nbWithinDist()
self.ml.selectionChanged.connect(self.map2tab)
QApplication.restoreOverrideCursor()
def nbTouches(self):
feat = QgsFeature()
provider = self.ml.dataProvider()
e = provider.featureCount()
self.settings()
for ne in range(self.mod, e + self.mod):
feat = QgsFeature()
geom = QgsGeometry()
fiter = self.ml.getFeatures(QgsFeatureRequest(ne))
if fiter.nextFeature(feat):
geom = QgsGeometry(feat.geometry())
neighbours = self.htouch(feat)
row = feat.id() - self.mod
self.model.setData(self.model.index(row, 0, QModelIndex()),
neighbours)
self.progressBar.setValue(100 * ne / e)
def htouch(self, feata):
geoma = QgsGeometry(feata.geometry())
feat = QgsFeature()
provider = self.ml.dataProvider()
feats = provider.getFeatures()
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0)
#self.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, provider.featureCount()))
ne = 0
neighbours = ""
while feats.nextFeature(feat):
ne += 1
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne)
geomb = QgsGeometry(feat.geometry())
if feata.id() != feat.id():
if geoma.touches(geomb) == True:
neighbours = neighbours + '%s,' % (feat.id() + self.p)
return neighbours[:-1]
def nbIntersects(self):
feat = QgsFeature()
provider = self.ml.dataProvider()
e = provider.featureCount()
self.settings()
for ne in range(self.mod, e + self.mod):
feat = QgsFeature()
geom = QgsGeometry()
fiter = self.ml.getFeatures(QgsFeatureRequest(ne))
if fiter.nextFeature(feat):
geom = QgsGeometry(feat.geometry())
neighbours = self.hintersect(feat)
row = feat.id() - self.mod
self.model.setData(self.model.index(row, 0, QModelIndex()),
neighbours)
self.progressBar.setValue(100 * ne / e)
def hintersect(self, feata):
geoma = QgsGeometry(feata.geometry())
feat = QgsFeature()
provider = self.ml.dataProvider()
feats = provider.getFeatures()
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), 0)
#self.emit(SIGNAL("runRange(PyQt_PyObject)"), (0, provider.featureCount()))
ne = 0
neighbours = ""
while feats.nextFeature(feat):
ne += 1
#self.emit(SIGNAL("runStatus(PyQt_PyObject)"), ne)
geomb = QgsGeometry(feat.geometry())
if feata.id() != feat.id():
if geoma.intersects(geomb) == True:
neighbours = neighbours + '%s,' % (feat.id() + self.p)
return neighbours[:-1]
class AdjustmentDialogThresholds(QObject):
COLOR_ERROR = QColor(224, 103, 103)
COLOR_ATTENTION = QColor(237, 148, 76)
COLOR_NEUTRAL = QColor(255, 255, 255)
COLOR = {1: COLOR_NEUTRAL, 2: COLOR_ATTENTION, 3: COLOR_ERROR}
sig_clickedRow = pyqtSignal(int)
def __init__(self, parent, datasetSize):
"""
:type parent: gui.adjustmentDialog.AdjustmentDialog
"""
super().__init__()
self.parent = parent
self.tbl = self.parent.tableThresholds
self.model = QStandardItemModel(datasetSize[0], datasetSize[1],
self.tbl)
self.initState = True
self.thresholdExeeded = False
self.tbl.setModel(self.model)
self.tbl.resizeColumnsToContents()
self.tbl.resizeRowsToContents()
# Icons
self.iconOk = QIcon()
self.iconOk.addPixmap(
QPixmap(":/plugins/SeilaplanPlugin/gui/icons/icon_green.png"),
QIcon.Normal, QIcon.Off)
self.iconErr = QIcon()
self.iconErr.addPixmap(
QPixmap(
":/plugins/SeilaplanPlugin/gui/icons/icon_exclamation.png"),
QIcon.Normal, QIcon.Off)
self.tbl.clicked.connect(self.onClick)
def populate(self, header, dataset, valueColumn):
self.model.setHorizontalHeaderLabels(header)
self.tbl.hideColumn(5)
# Insert data into cells
for i, rowData in enumerate(dataset):
for j, cellData in enumerate(rowData):
if j == 0:
# Create clickable info button in first column
btnWidget = self.createInfoBtn(cellData)
self.tbl.setIndexWidget(self.model.index(i, j), btnWidget)
continue
if j == 5 and isinstance(cellData, dict):
loclen = len(cellData['loc'])
if loclen > 0:
# Set background color for cells where threshold is
# exceeded
color = self.COLOR[max(cellData['color'] or [1])]
self.colorBackground(i, valueColumn, color)
cellData = loclen
item = QStandardItem(cellData)
self.model.setItem(i, j, item)
self.model.setData(self.model.index(i, j), cellData)
# Adjust column widths
self.tbl.resizeColumnsToContents()
for idx in range(2, self.model.columnCount()):
currSize = self.tbl.sizeHintForColumn(idx)
self.tbl.setColumnWidth(idx, max(currSize, 100))
self.tbl.setFocusPolicy(Qt.NoFocus)
self.updateTabIcon()
def updateData(self, row, col, newVal):
# Update background color of new values
if col == 5 and isinstance(newVal, dict):
locLen = len(newVal['loc'])
color = self.COLOR[max(newVal['color'] or [1])]
self.colorBackground(row, 4, color)
newVal = locLen
# Update value itself
self.model.setData(self.model.index(row, col), newVal)
self.updateTabIcon()
# Remove the background color from initially calculated
# cable line data
if self.initState:
self.initState = False
for row in range(self.model.rowCount()):
self.colorBackground(row, 3, self.COLOR_NEUTRAL)
def colorBackground(self, row, col, color):
self.model.setData(self.model.index(row, col), QBrush(color),
Qt.BackgroundRole)
def updateTabIcon(self):
""" Updates icon of QTabWidget with an exclamation mark or check
mark depending on presents of exceeded thresholds."""
thresholdExceeded = False
for i in range(0, self.model.rowCount()):
if i == 2:
# Dont check thresholds for 'Sattelkraft'
continue
data = self.model.data(self.model.index(i, 5))
if data and data > 0:
thresholdExceeded = True
break
if thresholdExceeded:
self.parent.tabWidget.setTabIcon(2, self.iconErr)
else:
self.parent.tabWidget.setTabIcon(2, self.iconOk)
def onClick(self, item):
# Row is already selected
if self.parent.selectedThdRow == item.row():
# Deselect
self.tbl.clearSelection()
# Emit select signal
self.sig_clickedRow.emit(item.row())
def createInfoBtn(self, cellData):
button = QPushButton('?')
button.setMaximumSize(QSize(22, 22))
# Fill info text into message box
button.clicked.connect(
lambda: QMessageBox.information(self.parent, cellData[
'title'], cellData['message'], QMessageBox.Ok))
cellWidget = QWidget()
# Add layout to center button in cell
layout = QHBoxLayout(cellWidget)
layout.addWidget(button, 0, Qt.AlignCenter)
layout.setAlignment(Qt.AlignCenter)
cellWidget.setLayout(layout)
return cellWidget
