systeminfo.py

# -*- coding: utf-8 -*-
"""
/***************************************************************************
                              HUB TimeSeriesViewer
                              -------------------
        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
from __future__ import absolute_import
import sys, os, re
from qgis.core import *
from collections import OrderedDict
from qgis.gui import QgsDockWidget
from PyQt4.QtCore import *
from PyQt4.QtGui import *
import numpy as np
from timeseriesviewer import jp, SETTINGS
from timeseriesviewer.utils import loadUi, SpatialExtent

PSUTIL_AVAILABLE = False
try:
    import psutil
    PSUTIL_AVAILABLE = True
except:
    pass


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 = QgsMapLayerRegistry.instance()
            self.REG.layersAdded.connect(self.addLayers)
            self.REG.layersWillBeRemoved .connect(self.removeLayers)
            self.addLayers(self.REG.mapLayers().values())


            s = ""

        def addLayers(self, lyrs):
            self.mLayers.extend(lyrs)
            self.layoutChanged.emit()

        @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(self.createIndex(0,0),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 = 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(name, str)
            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 columnNames(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.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
            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.columnNames())

        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 self.mLoadingTimes.keys()[index.row()]

        def data(self, index, role=Qt.DisplayRole):
            if role is None or not index.isValid():
                return None

            columnName = self.columnNames()[index.column()]
            name = self.idx2type(index)
            lTimes = self.mLoadingTimes[name]
            value = None
            if role == Qt.DisplayRole:
                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.columnNames()[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.dataLoadingModel = DataLoadingModel()
        def resetModel():
            self.dataLoadingModel.mLoadingTimes.clear()
            self.dataLoadingModel.layoutChanged.emit()

        self.tableViewDataLoading.setModel(self.dataLoadingModel)
        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)


if __name__ == '__main__':
    import site, sys
    from timeseriesviewer import utils
    from timeseriesviewer.mapcanvas import MapCanvas
    from example.Images import Img_2014_01_15_LC82270652014015LGN00_BOA
    qgsApp = utils.initQgisApplication()

    d = SystemInfoDock()
    d.show()
    c = MapCanvas()
    c.sigDataLoadingFinished.connect(lambda p : d.addTimeDelta('MAPCANVAS', p))
    c.show()
    lyr = QgsRasterLayer(Img_2014_01_15_LC82270652014015LGN00_BOA)
    c.setDestinationCrs(lyr.crs())
    c.setExtent(lyr.extent())
    c.setLayers([lyr])
    qgsApp.exec_()