-
Benjamin Jakimow authoredfixed bug in vector layer visualization pulled qps updates
Benjamin Jakimow authoredfixed bug in vector layer visualization pulled qps updates
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
systeminfo.py 15.35 KiB
# -*- coding: utf-8 -*-
"""
/***************************************************************************
EO Time Series Viewer
-------------------
begin : 2017-08-04
git sha : $Format:%H$
copyright : (C) 2017 by HU-Berlin
email : benjamin.jakimow@geo.hu-berlin.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
"""
# noinspection PyPep8Naming
import sys, os, re
from qgis.core import *
from collections import OrderedDict
from qgis.gui import QgsDockWidget
from qgis.PyQt.QtCore import *
from qgis.PyQt.QtGui import *
from qgis.PyQt.QtWidgets import *
import numpy as np
from eotimeseriesviewer.utils import loadUI, SpatialExtent
PSUTIL_AVAILABLE = False
try:
import psutil
PSUTIL_AVAILABLE = True
except:
pass
def value2str(args, separator = ''):
return str(args)
class MapLayerRegistryModel(QAbstractTableModel):
class LayerWrapper(object):
def __init__(self, lyr):
assert isinstance(lyr, QgsMapLayer)
self.lyr = lyr
def __init__(self, parent=None):
super(MapLayerRegistryModel, self).__init__(parent)
self.cID = '#'
self.cPID = 'PID'
self.cName = 'Name'
self.cSrc = 'Uri'
self.cType= 'Type'
self.mLayers = list()
self.REG = QgsProject.instance()
self.REG.layersAdded.connect(self.addLayers)
self.REG.layersWillBeRemoved.connect(self.removeLayers)
self.addLayers(self.REG.mapLayers().values())
s = ""
def addLayers(self, lyrs):
lyrs = [l for l in lyrs if isinstance(l, QgsMapLayer)]
l = len(lyrs)
if l > 0:
i = len(self.mLayers)
self.beginInsertRows(QModelIndex(),i, i+l)
self.mLayers.extend(lyrs)
self.endInsertRows()
#@pyqtSlot(list)
def removeLayers(self, lyrNames):
to_remove = [self.REG.mapLayer(name) for name in lyrNames]
for l in to_remove:
if l in self.mLayers:
i = self.mLayers.index(l)
self.beginRemoveRows(QModelIndex(),i,i)
self.mLayers.remove(l)
self.endRemoveRows()
#self.reset()
def columnNames(self):
return [self.cID, self.cPID, self.cName, self.cType, self.cSrc]
def headerData(self, col, orientation, role):
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
return self.columnNames()[col]
elif orientation == Qt.Vertical and role == Qt.DisplayRole:
return col
return None
def sort(self, col, order):
"""Sort table by given column number.
"""
self.layoutAboutToBeChanged.emit()
columnName = self.columnNames()[col]
rev = order == Qt.DescendingOrder
sortedLyers = None
if columnName == self.cName:
sortedLyers = sorted(self.mLayers, key=lambda l: l.name(), reverse=rev)
elif columnName == self.cSrc:
sortedLyers = sorted(self.mLayers, key=lambda l: l.source(), reverse=rev)
elif columnName == self.cID:
lyrs = self.REG.mapLayers().values()
sortedLyers = sorted(self.mLayers, key=lambda l: lyrs.index(l), reverse=rev)
elif columnName == self.cPID:
sortedLyers = sorted(self.mLayers, key=lambda l: id(l), reverse=rev)
elif columnName == self.cType:
types = [QgsVectorLayer, QgsRasterLayer]
sortedLyers = sorted(self.mLayers, key=lambda l: types.index(type(l)), reverse=rev)
del self.mLayers[:]
self.mLayers.extend(sortedLyers)
self.layoutChanged.emit()
def rowCount(self, parentIdx=None, *args, **kwargs):
return len(self.mLayers)
def columnCount(self, QModelIndex_parent=None, *args, **kwargs):
return len(self.columnNames())
def lyr2idx(self, lyr):
assert isinstance(lyr, QgsMapLayer)
# return self.createIndex(self.mSpecLib.index(profile), 0)
# pw = self.mProfileWrappers[profile]
if not lyr in self.mLayers:
return None
return self.createIndex(self.mLayers.index(lyr), 0)
def idx2lyr(self, index):
assert isinstance(index, QModelIndex)
if not index.isValid():
return None
return self.mLayers[index.row()]
def idx2lyrs(self, indices):
lyrs = [self.idx2lyr(i) for i in indices]
return [l for l in lyrs if isinstance(l, QgsMapLayer)]
def data(self, index, role=Qt.DisplayRole):
if role is None or not index.isValid():
return None
columnName = self.columnNames()[index.column()]
lyr = self.idx2lyr(index)
value = None
assert isinstance(lyr, QgsMapLayer)
if role == Qt.DisplayRole:
if columnName == self.cPID:
value = id(lyr)
elif columnName == self.cID:
value = list(self.REG.mapLayers().values()).index(lyr)
elif columnName == self.cName:
value = lyr.name()
elif columnName == self.cSrc:
value = lyr.source()
elif columnName in self.cType:
value = re.sub('[\'<>]','',str(type(lyr))).split('.')[-1]
if role == Qt.UserRole:
value = lyr
return value
def flags(self, index):
if index.isValid():
columnName = self.columnNames()[index.column()]
flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable
return flags
return None
class DataLoadingModel(QAbstractTableModel):
def __init__(self, parent=None):
super(DataLoadingModel, self).__init__(parent)
self.cName = 'Type'
self.cSamples = 'n'
self.cAvgAll = u'mean \u0394t(all) [ms]'
self.cMaxAll = u'max \u0394t(all) [ms]'
self.cAvg10 = u'mean \u0394t(10) [ms]'
self.cMax10 = u'max \u0394t(10) [ms]'
self.cLast = u'last \u0394t [ms]'
self.mCacheSize = 500
self.mLoadingTimes = OrderedDict()
def addTimeDelta(self, name, timedelta):
assert isinstance(timedelta, np.timedelta64)
#if timedelta.astype(float) > 0:
#print(timedelta)
if name not in self.mLoadingTimes.keys():
self.mLoadingTimes[name] = []
to_remove = max(0,len(self.mLoadingTimes[name]) + 1 - self.mCacheSize)
if to_remove > 0:
del self.mLoadingTimes[name][0:to_remove]
self.mLoadingTimes[name].append(timedelta)
self.layoutChanged.emit()
def variableNames(self):
return [self.cName, self.cSamples, self.cLast, self.cMaxAll, self.cAvgAll, self.cMax10, self.cAvg10]
def headerData(self, col, orientation, role):
if orientation == Qt.Horizontal and role == Qt.DisplayRole:
return self.variableNames()[col]
elif orientation == Qt.Vertical and role == Qt.DisplayRole:
return col
return None
def sort(self, col, order):
"""Sort table by given column number.
"""
self.layoutAboutToBeChanged.emit()
columnName = self.variableNames()[col]
rev = order == Qt.DescendingOrder
sortedNames = None
if columnName == self.cName:
sortedNames = sorted(self.mLoadingTimes.keys(), reverse=rev)
elif columnName == self.cSamples:
sortedNames = sorted(self.mLoadingTimes.keys(), key=lambda n: len(self.mLoadingTimes[n]), reverse=rev)
elif columnName == self.cAvgAll:
sortedNames = sorted(self.mLoadingTimes.keys(), key=lambda name:
np.asarray(self.mLoadingTimes[name]).mean(), reverse=rev)
elif columnName == self.cAvg10:
sortedNames = sorted(self.mLoadingTimes.keys(), key=lambda name:
np.asarray(self.mLoadingTimes[name][-10:]).mean(), reverse=rev)
if sortedNames is not None:
tmp = OrderedDict([(name, self.mLoadingTimes[name]) for name in sortedNames])
self.mLoadingTimes.clear()
self.mLoadingTimes.update(tmp)
self.layoutChanged.emit()
def rowCount(self, parentIdx=None, *args, **kwargs):
return len(self.mLoadingTimes)
def columnCount(self, QModelIndex_parent=None, *args, **kwargs):
return len(self.variableNames())
def type2idx(self, type):
assert isinstance(type, str)
if type not in self.mLoadingTimes.keys():
return None
return self.createIndex(self.mLoadingTimes.keys().index(type), 0)
def idx2type(self, index):
assert isinstance(index, QModelIndex)
if not index.isValid():
return None
return list(self.mLoadingTimes.keys())[index.row()]
def data(self, index, role=Qt.DisplayRole):
if role is None or not index.isValid():
return None
columnName = self.variableNames()[index.column()]
name = self.idx2type(index)
lTimes = self.mLoadingTimes[name]
value = None
if role in [Qt.DisplayRole, Qt.EditRole]:
if columnName == self.cName:
value = name
elif columnName == self.cSamples:
value = len(lTimes)
if len(lTimes) > 0:
if columnName == self.cAvg10:
value = float(np.asarray(lTimes[-10:]).mean().astype(float))
elif columnName == self.cAvgAll:
value = float(np.asarray(lTimes[:]).mean().astype(float))
elif columnName == self.cMax10:
value = float(np.asarray(lTimes[-10:]).max().astype(float))
elif columnName == self.cMaxAll:
value = float(np.asarray(lTimes[:]).max().astype(float))
elif columnName == self.cLast:
value = float(lTimes[-1].astype(float))
if role == Qt.UserRole:
value = lTimes
return value
def flags(self, index):
if index.isValid():
columnName = self.variableNames()[index.column()]
flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable
return flags
return None
class SystemInfoDock(QgsDockWidget, loadUI('systeminfo.ui')):
def __init__(self, parent=None):
super(SystemInfoDock, self).__init__(parent)
self.setupUi(self)
self.lyrModel = MapLayerRegistryModel()
self.tableViewMapLayerRegistry.setModel(self.lyrModel)
self.tableViewMapLayerRegistry.contextMenuEvent = \
lambda event: self.contextMenuEvent(self.tableViewMapLayerRegistry, event)
self.dataLoadingModel = DataLoadingModel()
def resetModel():
self.dataLoadingModel.mLoadingTimes.clear()
self.dataLoadingModel.layoutChanged.emit()
self.tableViewDataLoading.setModel(self.dataLoadingModel)
self.tableViewDataLoading.contextMenuEvent = \
lambda event: self.contextMenuEvent(self.tableViewDataLoading, event)
self.btnResetDataLoadingModel.clicked.connect(resetModel)
self.labelPSUTIL.setVisible(PSUTIL_AVAILABLE == False)
if PSUTIL_AVAILABLE:
self.tableViewSystemParameters.setVisible(True)
#self.systemInfoModel = SystemInfoModel()
#self.tableViewSystemParameters.setModel(self.systemInfoModel)
else:
self.systemInfoModel = None
def addTimeDelta(self, type, timedelta):
self.dataLoadingModel.addTimeDelta(type, timedelta)
def contextMenuEvent(self, tableView, event):
assert isinstance(tableView, QTableView)
menu = QMenu(self)
a = menu.addAction("Copy selected")
a.triggered.connect(lambda :self.onCopy2Clipboard(tableView, 'SELECTED', separator=';'))
a = menu.addAction("Copy table")
a.triggered.connect(lambda: self.onCopy2Clipboard(tableView, 'TABLE', separator=';'))
a = menu.addAction('Save to file')
a.triggered.connect(lambda : self.onSaveToFile(tableView, 'TABLE'))
menu.popup(QCursor.pos())
def onCopy2Clipboard(self, tableView, key, separator='\t'):
lines = self.readTableValues(key, tableView)
if len(lines) > 0:
lines = [value2str(l, sep=separator) for l in lines]
QApplication.clipboard().setText('\n'.join(lines))
def readTableValues(self, key, tableView):
assert key in ['SELECTED', 'TABLE']
txt = None
model = tableView.model()
assert isinstance(model, QAbstractTableModel)
lines = []
if key == 'SELECTED':
line = []
row = None
for idx in tableView.selectionModel().selectedIndexes():
if row is None:
row = idx.row()
elif row != idx.row():
lines.append(line)
line = []
line.append(model.data(idx, role=Qt.DisplayRole))
lines.append(line)
elif key == 'TABLE':
for row in range(model.rowCount()):
line = []
for col in range(model.columnCount()):
idx = model.createIndex(row, col)
line.append(model.data(idx, role=Qt.DisplayRole))
lines.append(line)
return lines
def onSaveToFile(self, tableView, key):
lines = self.readTableValues(key, tableView)
if len(lines) > 0:
filters = 'Textfile (*.txt);;CSV Table (*.csv)'
path = QFileDialog.getSaveFileName(parent=None, caption="Save Table to file",
directory='', filter=filters)
if len(path) > 0:
ext = os.path.splitext(path)[-1].lower()
if ext in ['.txt']:
lines = [value2str(l, sep=';') for l in lines]
else:
lines = [value2str(l, sep='\t') for l in lines]
file = open(path, 'w')
for line in lines:
file.write(line + '\n')
file.flush()
file.close()