home/diploma/lws_root/utils/qt.py

# -*- coding: utf-8 -*-
import logging
import math
from PyQt4 import QtGui, QtCore
import numpy as np

class QTLoggingHandler(logging.Handler):
    def __init__(self, signal):
        logging.Handler.__init__(self)
        self.level = logging.DEBUG
        formatter = logging.Formatter("%(asctime)s.%(msecs)03d "
                                      "%(name)s %(levelname)s %(message)s",
                                      "%H:%M:%S")
        self.setFormatter(formatter)
        self.signal = signal
        
    def emit(self, record):
        msg = self.format(record)
        self.signal.emit(msg)
        

class MaterialModel(QtCore.QAbstractTableModel):
    def __init__(self, materials, parent=None):
        QtCore.QAbstractTableModel.__init__(self, parent)
        self.materials = materials.values()
        self.matnames = materials.keys()
        self.onChange = None
        
    def rowCount(self, parent=None):
        return len(self.materials)

    def columnCount(self, parent=None):
        return 4
    
    def flags(self, idx): 
        baseflags = QtCore.QAbstractTableModel.flags(self, idx) 
        if idx.column() in (1, 2): 
            return baseflags | QtCore.Qt.ItemIsEditable 
        else: 
            return baseflags
             
    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
        if role == QtCore.Qt.DisplayRole:
            if orientation == QtCore.Qt.Horizontal:
                if section == 0:
                    return 'name'
                elif section == 1:
                    return 'reflection'
                elif section == 2:
                    return 'refraction'
                elif section == 3:
                    return 'ior'
    
    def data(self, index, role=QtCore.Qt.DisplayRole):
        if index.isValid() and role == QtCore.Qt.DisplayRole:
            row = index.row()
            col = index.column()
            v = None
            
            if col == 0:
                v = self.matnames[row]
            elif col == 1:
                v = self.materials[row].reflect
            elif col == 2:
                v = self.materials[row].alpha
            elif col == 3:
                v = self.materials[row].ior
            
            if v is not None:    
                return QtCore.QVariant(v)
                
        return QtCore.QVariant()
    
    def setData(self, index, value, role=QtCore.Qt.DisplayRole):
        
        if index.isValid():
            row = index.row()
            col = index.column()
            value = float(value.toString())
            
            if col == 1:
                self.materials[row].reflect = value
            elif col == 2:
                self.materials[row].alpha = value
                
            self.onChange()
        return True
        
                
class NumpyModel(QtCore.QAbstractTableModel):
    def __init__(self, narray, offset, mode, parent=None):
        QtCore.QAbstractTableModel.__init__(self, parent)
        self._array = narray
        self._offset = offset
        
        # either 'raw' for raw data in milliwatt? (very small doubles, unsmothed
        # or 'descibel' for 
        self.mode = mode 
        
        self.SOURCE_POWER = 1.0

    def rowCount(self, parent=None):
        return self._array.shape[0]

    def columnCount(self, parent=None):
        return self._array.shape[1]
    
    def headerData(self, section, orientation, role=QtCore.Qt.DisplayRole):
        if role == QtCore.Qt.DisplayRole:
            if orientation == QtCore.Qt.Horizontal:
                s = "%d" % (self._offset[0] + section)
            else:
                s = "%d" % (self._offset[1] + section)
            return QtCore.QVariant(s)
        else:
            return QtCore.QVariant()
    
    def _format(self, v):
        if np.isnan(v):
            return ''
        elif v == 0:
            return '0'
            
        if self.mode == 'decibel_from_raw':
            return '%.1f' % v
        elif self.mode == 'raw':
            return '%.1e' % v
        elif self.mode == 'smoothed':
            return str(v)
        else:
            return self.mode
        
    def data(self, index, role=QtCore.Qt.DisplayRole):
        if index.isValid():
            if role == QtCore.Qt.DisplayRole:
                row = index.row()
                col = index.column()
                v = self._array[row, col]
                #~ return QtCore.QVariant("%.5f" %self._array[row, col])
                if self.mode == 'decibel_from_raw':
                    if v > 0:
                        v = 10 * math.log10(v / self.SOURCE_POWER)
                    else:
                        v = -200
                return QtCore.QVariant(self._format(v))
        return QtCore.QVariant()