KaptureControlGui/KCG/base/plotWidget.py

"""
This Module implements the Plot Windows used in KCG
"""
import pyqtgraph as pg
try:  # on some versions of pyqtgraph useOpenGl is no valid option
    pg.setConfigOption('useOpenGl', True)
except:
    pass
pg.setConfigOption('background', 'w')
pg.setConfigOption('foreground', 'k')
import numpy as np
from PyQt4 import QtCore, QtGui
from groupedelements import live_plot_windows
from backend import io
from backend import board
from backend.board import available_boards
import kcgwidget as kcgw

tr = kcgw.tr

LIVE = 1
FILE = 2
ERROR = 99
NO_DATA = 98


class Enum():
    """
    Simple Enum Class (as this is not supported by clean python)
    """
    def __init__(self, *args):
        self.idx = 0
        for i in args:
            setattr(self, i, self.idx)
            self.idx += 1

plotList = [tr("Label", "Heatmap"), tr("Label", "FFT"), tr("Label", "Trains"), tr("Label", "Combined"), tr("Label", "Compare")]
PlotType = Enum(*[str(i) for i in plotList])

# gradient = {'mode': 'rgb',
#             'ticks': [(0.0, (0.37281, 0.11883, 3.53583, 255)),
#                       (0.0390625, (4.9401150000000005, 3.858915, 22.635585, 255)),
#                       (0.078125, (15.6417, 9.330449999999999, 45.29871, 255)),
#                       (0.1171875, (29.74728, 12.13137, 69.44185499999999, 255)),
#                       (0.15625, (46.774395000000005, 10.283895, 90.51760499999999, 255)),
#                       (0.1953125, (64.1631, 9.614775, 102.86139, 255)),
#                       (0.234375, (80.65191, 13.63995, 108.40458, 255)),
#                       (0.2734375, (96.64525499999999, 19.444515, 110.343345, 255)),
#                       (0.3125, (112.507785, 25.33119, 110.05646999999999, 255)),
#                       (0.3515625, (128.390715, 31.001625, 107.95578, 255)),
#                       (0.390625, (144.29277, 36.609585, 104.10579, 255)),
#                       (0.4296875, (160.100985, 42.476625, 98.50038, 255)),
#                       (0.46875, (175.606515, 49.020945, 91.188765, 255)),
#                       (0.5078125, (190.517385, 56.70639, 82.32827999999999, 255)),
#                       (0.546875, (204.477105, 65.96187, 72.190245, 255)),
#                       (0.5859375, (217.10292, 77.07629999999999, 61.10718, 255)),
#                       (0.625, (228.047775, 90.11674500000001, 49.36392, 255)),
#                       (0.6640625, (237.05922, 104.927145, 37.068585, 255)),
#                       (0.703125, (243.99726, 121.21578, 24.147225, 255)),
#                       (0.7421875, (248.797635, 138.66849, 11.122589999999999, 255)),
#                       (0.78125, (251.41776000000002, 157.01625, 6.52596, 255)),
#                       (0.8203125, (251.80332, 176.04333, 20.397450000000003, 255)),
#                       (0.859375, (249.90816, 195.543435, 42.420015, 255)),
#                       (0.8984375, (245.92047, 215.18124, 69.714705, 255)),
#                       (0.9375, (241.63647, 233.936745, 104.719575, 255)),
#                       (0.9765625, (245.26206, 248.86062, 145.840875, 255)),
#                       (0.99609375, (252.03231, 254.58282, 164.45562, 255))]}

gradient = {'mode': 'rgb',
            'ticks': [(0.0, (0.37281, 0.11883, 3.53583, 255)),
                      (0.1171875, (29.74728, 12.13137, 69.44185499999999, 255)),
                      (0.234375, (80.65191, 13.63995, 108.40458, 255)),
                      (0.3515625, (128.390715, 31.001625, 107.95578, 255)),
                      (0.46875, (175.606515, 49.020945, 91.188765, 255)),
                      (0.5859375, (217.10292, 77.07629999999999, 61.10718, 255)),
                      (0.703125, (243.99726, 121.21578, 24.147225, 255)),
                      (0.8203125, (251.80332, 176.04333, 20.397450000000003, 255)),
                      (0.9375, (241.63647, 233.936745, 104.719575, 255)),
                      (0.99609375, (252.03231, 254.58282, 164.45562, 255))]}


class CustomGradientEditorItem(pg.GradientEditorItem):
    """
    A Gradient Editor Item to insert a perception linear gradient
    """
    def __init__(self, **kwargs):
        pg.GradientEditorItem.__init__(self, **kwargs)
        self.customGradients = {}

    def addGrad(self, name, grad_dic):
        """
        Add a gradient to the list of gradients in the gui
        :param name: the name of the gradient
        :param grad_dic: the dictionary containing the gradient data
        """
        if name not in self.customGradients:
            self.customGradients[name] = grad_dic
            px = QtGui.QPixmap(100, 15)
            p = QtGui.QPainter(px)
            self.restoreState(grad_dic)
            length_backup = self.length
            self.length = 100
            grad = self.getGradient()
            self.length = length_backup
            brush = QtGui.QBrush(grad)
            p.fillRect(QtCore.QRect(0, 0, 100, 15), brush)
            p.end()
            label = QtGui.QLabel()
            label.setPixmap(px)
            label.setContentsMargins(1, 1, 1, 1)
            act = QtGui.QWidgetAction(self)
            act.setDefaultWidget(label)
            act.triggered.connect(self.contextMenuClicked)
            act.name = name
            if len(self.customGradients) > 1:
                self.menu.insertAction(self.menu.actions()[0], act)
            else:
                sep = self.menu.insertSeparator(self.menu.actions()[0])
                self.menu.insertAction(sep, act)

        self.restoreState(grad_dic)

    def restoreState(self, state):
        """
        Reimplemented of pyqtgraph.GradientEditorItem.restoreState to work with our custom perception linear gradient.
        :param state: the state to restore to
        """
        self.setColorMode(state['mode'])
        for t in list(self.ticks.keys()):
            self.removeTick(t, finish=False)
        self.bottomTick = [None, 10]
        self.topmostTick = [None, -1]
        for t in state['ticks']:
            c = QtGui.QColor(*t[1])
            tick = self.addTick(t[0], c, finish=False)
            if t[0] < self.bottomTick[1]:
                self.bottomTick = [tick, t[0]]
            if t[0] > self.topmostTick[1]:
                self.topmostTick = [tick, t[0]]
        self.tickPosInPercent = self.ticks.copy()
        for t in self.ticks:
            if t is self.topmostTick[0] or t is self.bottomTick[0]:
                continue
            t.hide()
            t.movable = False
        # self.bottomTick[1] *= self.length
        # self.topmostTick[1] *= self.length
        self.updateGradient()
        self.sigGradientChangeFinished.emit(self)

    def loadPreset(self, name):
        """
        Reimplemented of pyqtgraph.GradientEditorItem.loadPreset to work with our custom perception linear gradient.
        :param name: the name of the preset to load
        """
        if name in self.customGradients:
            self.restoreState(self.customGradients[name])
        else:
            super(CustomGradientEditorItem, self).loadPreset(name)

    def tickMoved(self, tick, pos):
        """
        Reimplemented of pyqtgraph.GradientEditorItem.tickMoved to work with our custom perception linear gradient,
        which has a lot of steps which would create a lot of ticks in the gradient legend. This removes all but 2
        ticks and aligns all the internal ticks accordingly.
        :param tick: the tick to move
        :param pos: the position to move to
        """
        if tick is self.bottomTick[0]:
            # self.bottomTick[1] = pos.x()
            pg.TickSliderItem.tickMoved(self, tick, pos)
        elif tick is self.topmostTick[0]:
            # self.topmostTick[1] = pos.x()
            pg.TickSliderItem.tickMoved(self, tick, pos)
        if tick in [self.bottomTick[0], self.topmostTick[0]]:  # if bottom or topmost tick was moved
            if pos.x() < self.length and pos.x() > 0:  # if tick is not at top or bottom
                newUnit = (self.topmostTick[0].pos().x() - self.bottomTick[0].pos().x())  # create new virtual unit length
                for t in self.ticks:  # for every tick
                    if t not in [self.bottomTick[0], self.topmostTick[0]]:  # if tick is not bottom or topmost tick
                        pos = t.pos()
                        new_x = self.bottomTick[0].pos().x() + self.tickPosInPercent[t] * newUnit
                        pos.setX(new_x)
                        t.setPos(pos)
                        pg.TickSliderItem.tickMoved(self, t, pos)
        self.updateGradient()


class SpectrogramColorLegendItem(pg.GraphicsWidget):
    """
    The Item used as Legend for Heatmap and FFT Plot
    """
    gradientChanged = QtCore.pyqtSignal()
    def __init__(self, img=None):
        """
        Initialise the Legend
        :param img: (ImageItem) the image item this is the legend for
        :return: -
        """
        super(SpectrogramColorLegendItem, self).__init__()
        self.layout = QtGui.QGraphicsGridLayout()
        self.setLayout(self.layout)
        self.img = img
        # self.gei = pg.GradientEditorItem(orientation='right')
        self.gei = CustomGradientEditorItem(orientation='right', allowAdd=False)
        self.legend_axis = pg.AxisItem(orientation='left')
        # self.addItem(self.legend_axis)
        self.layout.addItem(self.legend_axis, 0, 0, alignment=QtCore.Qt.AlignVCenter)
        # self.addItem(self.gei)
        self.layout.addItem(self.gei, 0, 1)
        self.gei.sigGradientChanged.connect(self.gradient_changed)
        # self.gei.loadPreset('spectrum')
        self.gei.addGrad('inferno', gradient)
        # self.setFixedWidth(80)
        self.image_changed()

    def gradient_changed(self):
        """
        Proxy function for the gradient_cnahged event of the GradientEditorItem
        :return:
        """
        self.gradientChanged.emit()

    def set_image(self, img):
        """
        Set the Image this is the legend for (only needed if not already done upon initialisation)
        :param img: (ImageItem) The image item to use
        :return: -
        """
        self.img = img
        self.image_changed(True)

    def update_axis(self):
        """
        Update the axis of this legend
        :return: -
        """
        if self.img.getLevels():
            # min, max = self.img.getLevels()
            min, max = (np.min(self.img.image), np.max(self.img.image))
            self.legend_axis.setRange(min, max)

    def reset_gradient(self):
        """
        Reset the gradient to the preset "spectrum"
        :return: -
        """
        # self.gei.loadPreset('spectrum')
        self.gei.loadPreset('inferno')
        # self.gei.restoreState(gradient)

    def image_changed(self, reset_gradient=True):
        """
        Call this to adjust the legend when the image has changed
        :param reset_gradient: (bool) whether to reset the gradient or not
        :return:
        """
        if self.img:
            self.update_axis()
            if reset_gradient:
                self.reset_gradient()

    def getLookupTable(self, nPts, alpha=None):
        """
        Get the look up table of the imageitem
        :param nPts: (int) number of points the lookup table is defined on
        :param alpha: ??
        :return: -
        """
        return self.gei.getLookupTable(nPts, alpha=alpha)

    def resizeEvent(self, event):
        """
        Handle resizing of the window
        """
        self.legend_axis.setHeight(self.gei.length)


class SubPlotWidget(pg.GraphicsLayoutWidget):
    """
    The Widget actually containing the plots and images
    """
    def __init__(self, dType=FILE):
        super(SubPlotWidget, self).__init__()

        self.dType = dType

        self._type_changed = False
        # self.setStyleSheet("border: 5px solid black; margin: 10px;")
        self.plotType = 1
        self.plotItem = pg.PlotItem()
        self.img = pg.ImageItem()
        self.plotItem2 = pg.PlotItem()
        self.img2 = pg.ImageItem()
        self.plotItem2.addItem(self.img2)
        self.setFrameStyle(self.StyledPanel | self.Sunken)

        self.gradient_legend = SpectrogramColorLegendItem(self.img)
        def changelut():
            """
            Handle changing of the lookup table
            """
            self.img.setLookupTable(self.gradient_legend.getLookupTable(512))
            self.img2.setLookupTable(self.gradient_legend.getLookupTable(512))
        self.gradient_legend.gradientChanged.connect(changelut)

        self.addItem(self.plotItem)
        self.plotItem.addItem(self.img)
        self.plotItemPlotScatter = pg.PlotDataItem(pen=None, symbolPen=pg.mkPen(50, 50, 255), symbolSize=3, pxMode=True, symbolBrush=pg.mkBrush(50, 50, 255), downsample=200)
        self.plotItemPlotScatter1 = pg.PlotDataItem(pen=None, symbolPen=pg.mkPen(255, 50, 50), symbolSize=3, pxMode=True, symbolBrush=pg.mkBrush(255, 50, 50), downsample=200)
        # self.plotItemPlotScatter2 = pg.PlotDataItem(pen=None, symbolPen=pg.mkPen(50, 255, 50), symbolSize=3, pxMode=True, symbolBrush=pg.mkBrush(50, 255, 50), downsample=200)
        self.plotItemPlot = pg.PlotDataItem()  # pen="#000000")
        self.plotItem.addItem(self.plotItemPlot)
        self.plotItem.addItem(self.plotItemPlotScatter)
        self.plotItem.addItem(self.plotItemPlotScatter1)
        # self.plotItem.addItem(self.plotItemPlotScatter2)

        self.plotItem.vb.origAutoRange = self.plotItem.vb.autoRange

        self.error_label = pg.LabelItem("Error during plot.", color=(200, 50, 50))
        self.error_label.hide()
        self.error_label.scale(1, -0.6)
        self.error_label.translate(0, -30)
        self.plotItem.addItem(self.error_label)

        self.no_data_label = pg.LabelItem("No data to plot.", color=(200, 50, 50))
        self.no_data_label.hide()
        self.no_data_label.scale(1, -0.6)
        self.no_data_label.translate(0, -30)
        self.plotItem.addItem(self.no_data_label)

    def _enableCustomAutoRange(self, data):
        """
        Enable custom auto range in this plot
        :param data: the data to autorange
        :return:
        """
        def newAutoRange(*args, **kwargs):
            ''' function to handle the new autorange '''
            bounds = [np.min(data), np.max(data)]
            self.plotItem.vb.setRange(xRange=[0, len(data)],
                yRange=[bounds[0]-0.1*(bounds[1]-bounds[0])-1, bounds[1]+0.1*(bounds[1]-bounds[0])+1], update=True)
            self.plotItem.update()
        self.plotItem.vb.autoRange = newAutoRange
        self.plotItem.autoBtn.clicked.disconnect()
        self.plotItem.autoBtn.clicked.connect(newAutoRange)

    def _disableCustomAutoRange(self):
        """
        Disable the custom autorange and reset it to default
        :return: -
        """
        self.plotItem.vb.autoRange = self.plotItem.vb.origAutoRange
        self.plotItem.autoBtn.clicked.disconnect()
        self.plotItem.autoBtn.clicked.connect(self.plotItem.autoBtnClicked)

    @QtCore.pyqtSlot(np.ndarray, tuple, tuple)
    def plot(self, data, xvalueborders=None, yvalueborders=None, autorange=True):
        """
        Plot Data. The plot type depends on the type property
        :param data: (dataset.DataSet) data to plot
        :param xvalueborders: (touple) the borders for the xvalues
        :param yvalueborders: (touple) the borders for the yvalues
        :param autorange: (bool) whether to perform a autorange or not
        :return: -
        """
        self.error_label.hide()
        self.no_data_label.hide()
        self.plotItemPlot.clear()
        self.plotItemPlotScatter.clear()
        self.plotItemPlotScatter1.clear()
        # self.plotItemPlotScatter2.clear()
        self.plotItem.resetTransform()
        self.plotItem.getAxis('bottom').setScale()
        self.img.show()
        if self._type_changed:
            self.plotItem.autoBtnClicked()
        try:
            self.removeItem(self.plotItem2)
        except Exception as e:
            if "Could not determine index of item" in str(e):
                pass
            else:
                raise

        if self.plotType == PlotType.FFT or self.plotType == PlotType.Heatmap:
            self.addItem(self.gradient_legend)
            self.gradient_legend.show()

            self.img.setImage(data, scale=[1, 1/1000.])
            self.img.resetTransform()
            self.img.setAutoDownsample(True)
            if autorange:
                self.gradient_legend.image_changed()

            if xvalueborders:
                self.plotItem.getAxis('bottom').setScale((xvalueborders[1]-xvalueborders[0])/float(data.shape[0]))
                self.img.translate(xvalueborders[0]/self.plotItem.getAxis('bottom').scale, 0)

            else:
                self.plotItem.getAxis('bottom').setScale()

            if yvalueborders:
                self.img.translate(0, yvalueborders[0])
                self.plotItem.getAxis('left').setScale(yvalueborders[1]/float(data.shape[1]))

            self._disableCustomAutoRange()
            self.plotItem.setClipToView(True)

        if self.plotType == PlotType.Compare:
            self.addItem(self.plotItem2)
            self.plotItem2.vb.linkView(self.plotItem2.vb.XAxis, self.plotItem.vb)
            self.plotItem2.vb.linkView(self.plotItem2.vb.YAxis, self.plotItem.vb)
            self.addItem(self.gradient_legend)
            self.gradient_legend.show()

            self.img.setImage(data[0], scale=[1, 1/1000.])
            self.img.show()
            self.img.resetTransform()
            self.img2.setImage(data[1], scale=[1, 1/1000.])
            self.img2.show()
            self.img2.resetTransform()
            self.img.setAutoDownsample(True)
            self.img2.setAutoDownsample(True)
            if autorange:
                self.gradient_legend.image_changed()
                pass

            if xvalueborders:
                self.plotItem.getAxis('bottom').setScale((xvalueborders[1]-xvalueborders[0])/float(data[0].shape[0]))
                self.plotItem2.getAxis('bottom').setScale((xvalueborders[1]-xvalueborders[0])/float(data[1].shape[0]))
                self.img.translate(xvalueborders[0]/self.plotItem.getAxis('bottom').scale, 0)
                self.img2.translate(xvalueborders[0]/self.plotItem.getAxis('bottom').scale, 0)

            else:
                self.plotItem.getAxis('bottom').setScale()
                self.plotItem2.getAxis('bottom').setScale()

            if yvalueborders:
                self.img.translate(0, yvalueborders[0])
                self.img2.translate(0, yvalueborders[0])
                self.plotItem.getAxis('left').setScale(yvalueborders[1]/float(data[0].shape[1]))
                self.plotItem2.getAxis('left').setScale(yvalueborders[1]/float(data[1].shape[1]))

            self._disableCustomAutoRange()
            self.plotItem.setClipToView(True)

        if self.plotType == PlotType.Trains:
            self.img.clear()
            self.plotItemPlot.show()
            self.gradient_legend.hide()
            try:
                self.removeItem(self.gradient_legend)
                pass
            except Exception, e:
                if not "Could not determine index of item" in str(e):
                    raise
            self.plotItemPlotScatter.clear()
            self.plotItemPlotScatter1.clear()
            self.plotItemPlot.setData(data)

            self._enableCustomAutoRange(data)

        if self.plotType == PlotType.Combined:
            self.img.clear()
            self.plotItemPlotScatter.show()
            self.plotItemPlotScatter1.show()
            self.gradient_legend.hide()
            try:
                self.removeItem(self.gradient_legend)
                pass
            except Exception, e:
                if not "Could not determine index of item" in str(e):
                    raise
            self.plotItemPlot.clear()
            self.plotItemPlotScatter.setData(data[0].transpose())
            self.plotItemPlotScatter1.setData(data[1].transpose())

            self._enableCustomAutoRange(data[0][1])

            self.plotItem.setClipToView(False)  # NOTE: otherwise only a very small portion of data is visible :wonder:

        if self.plotType == ERROR or self.plotType == NO_DATA:
            self.img.hide()
            self.gradient_legend.hide()
            self.img2.hide()
            self.plotItemPlot.hide()
            self.plotItemPlotScatter.hide()
            self.plotItemPlotScatter1.hide()
            if self.plotType == ERROR:
                self.error_label.show()
            else:
                self.no_data_label.show()

        if autorange:
            self.plotItem.getViewBox().autoRange()
            self.plotItem.getViewBox().autoRange()

        self.labelAxes()
        if self.plotType in [PlotType.FFT, PlotType.Heatmap, PlotType.Compare]:
            self.gradient_legend.update_axis()

    def labelAxes(self):
        """
        Add Labels to the axis depending on the self.plotType property.
        :return: -
        """
        if self.plotType == PlotType.Heatmap:
            self.plotItem.setLabel('bottom', 'Turn', '')
            self.plotItem.setLabel('left', 'Bunch Position', '')
        elif self.plotType == PlotType.FFT:
            self.plotItem.setLabel('left', 'Bunch Position', '')
            self.plotItem.setLabel('bottom', 'Frequency', 'Hz')
        elif self.plotType == PlotType.Trains:
            self.plotItem.setLabel('left', '', '')
            self.plotItem.setLabel('bottom', 'Sample Point', '')
        elif self.plotType == PlotType.Combined:
            self.plotItem.setLabel('left', '', '')
            self.plotItem.setLabel('bottom', '', '')
        if self.plotType == PlotType.Compare:
            self.plotItem.setLabel('bottom', 'Turn', '')
            self.plotItem.setLabel('left', 'Bunch Position', '')
            self.plotItem2.setLabel('bottom', 'Turn', '')
            self.plotItem2.setLabel('left', 'Bunch Position', '')

    def changeType(self, type):
        """
        Change the plot Type
        :param type: (int) the new type
        :return: -
        """
        if type != self.plotType:
            self._type_changed = True
        self.plotType = type
        # if type in [PlotType.FFT, PlotType.Compare, PlotType.Heatmap]:  # this will generate an error
        #     self.gradient_legend.image_changed()

class PlotWidget(kcgw.KCGWidgets):
    """
    The container Class holding various buttons and controls and the actual plots as SubPlotWidgets instance
    """
    close_signal = QtCore.pyqtSignal()
    change_type_signal = QtCore.pyqtSignal(int, int, str)

    def __init__(self, board_id, parent=None, name=None, unique_id=None, type=None, datatype=None, prefix=None, fName=None, data=None):
        """
        Initialise the Plot Widgt
        :param parent: (QWidget) the parent widget
        :param name: (str) name of this widget
        :param unique_id: (int) unique id of this widget
        :param type: (int) type of this widget
        :param datatype: (int) datatype (LIVE or FILE)
        :param prefix: (str) prefix for text in the listview in LeftBar
        :param fName: (str) the filename (this is only used if datatype is FILE)
        :param data: (dataset.DataSet) the data to be plotted
        :return: -
        """
        super(PlotWidget, self).__init__()

        self.board_id = board_id

        if name != None:
            self.theName = name
        if unique_id != None:
            self.theId = unique_id
        if type != None:
            self.theType = type
            self._old_type = type
        if datatype != None:
            self.theDataType = datatype
        if prefix != None:
            self.thePrefix = prefix
        if self.theDataType == FILE:
            self.fName = fName
        if self.theDataType == FILE:
            self.data = data
        else:
            self.data = None

        self.close_silent = False
        self.parent = parent
        self.adc = 1
        self.secadc = 2
        self._single_adc_checked = False
        self.initUI()
        self.changePlotType(self.theType)  # initially mark the correct button
        self.setWindowTitle(self.theName + " - " + plotList[type] + " - " + str(self.thePrefix))
        if self.theDataType == FILE:
            self.plot(type)
        else:
            live_plot_windows.addWindow(board_id, self)
            if board.get_board_status(board_id).last_file is not None:
                self.data = io.read_from_file(board.get_board_status(board_id).last_file)
                self.plot(type)

    def initUI(self):
        """
        Initialise the UI
        :return: -
        """
        self.plot_widget = SubPlotWidget(dType=self.theDataType)
        self.layout = QtGui.QVBoxLayout()
        self.plot_buttons_layout = QtGui.QHBoxLayout()

        self.heatmap_button = self.createButton(text=tr("Button", "Heatmap"), connect=lambda: self.plot(type=PlotType.Heatmap))
        self.fft_button = self.createButton(text=tr("Button", "FFT"), connect=lambda: self.plot(type=PlotType.FFT))
        self.trains_button = self.createButton(text=tr("Button", "Trains"), connect=lambda: self.plot(type=PlotType.Trains))
        self.combined_button = self.createButton(text=tr("Button", "Combined"), connect=lambda: self.plot(type=PlotType.Combined))
        self.compare_button = self.createButton(text=tr("Button", "Compare"), connect=lambda: self.plot(type=PlotType.Compare))
        self.type_buttons = {PlotType.Heatmap:self.heatmap_button, PlotType.FFT:self.fft_button,
                             PlotType.Trains:self.trains_button, PlotType.Combined:self.combined_button,
                             PlotType.Compare:self.compare_button}
        self.defaultButtonStyleSheet = self.heatmap_button.styleSheet()

        self.adc1 = self.createCheckbox(text="ADC 1", connect=self.change_adc)
        self.adc1.setChecked(True)
        self.adc2 = self.createCheckbox(text="ADC 2", connect=self.change_adc)
        self.adc3 = self.createCheckbox(text="ADC 3", connect=self.change_adc)
        self.adc4 = self.createCheckbox(text="ADC 4", connect=self.change_adc)

        self.plot_buttons_layout.addWidget(self.heatmap_button)
        self.plot_buttons_layout.addWidget(self.fft_button)
        self.plot_buttons_layout.addWidget(self.trains_button)
        self.plot_buttons_layout.addWidget(self.combined_button)
        self.plot_buttons_layout.addWidget(self.compare_button)

        self.adc_checkbox_layout = QtGui.QHBoxLayout()
        self.adc_checkbox_layout.addWidget(self.adc1)
        self.adc_checkbox_layout.addWidget(self.adc2)
        self.adc_checkbox_layout.addWidget(self.adc3)
        self.adc_checkbox_layout.addWidget(self.adc4)

        self.groupWidget = QtGui.QWidget()
        self.groupWidget.setLayout(self.adc_checkbox_layout)
        self.group = QtGui.QButtonGroup()
        self.group.addButton(self.adc1, 1)
        self.group.addButton(self.adc2, 2)
        self.group.addButton(self.adc3, 3)
        self.group.addButton(self.adc4, 4)
        self.group.setExclusive(True)

        self.compare_heading_left = self.createLabel("ADC 1")
        self.compare_heading_left.setAlignment(QtCore.Qt.AlignCenter)
        self.compare_heading_right = self.createLabel("ADC 2")
        self.compare_heading_right.setAlignment(QtCore.Qt.AlignCenter)
        self.compare_heading = QtGui.QWidget()
        self.compare_heading_layout = QtGui.QHBoxLayout()
        self.compare_heading_layout.addWidget(self.compare_heading_left)
        self.compare_heading_layout.addWidget(self.compare_heading_right)
        self.compare_heading.setLayout(self.compare_heading_layout)
        self.compare_heading.hide()
        self.adc1Compare = self.createCheckbox(text="ADC 1", connect=lambda: self.change_adc_compare(who=1))
        self.adc2Compare = self.createCheckbox(text="ADC 2", connect=lambda: self.change_adc_compare(who=2))
        self.adc3Compare = self.createCheckbox(text="ADC 3", connect=lambda: self.change_adc_compare(who=3))
        self.adc4Compare = self.createCheckbox(text="ADC 4", connect=lambda: self.change_adc_compare(who=4))
        self.adc1Compare.setChecked(True)
        self.adc2Compare.setChecked(True)

        self.adc_checkbox_compare_layout = QtGui.QHBoxLayout()
        self.adc_checkbox_compare_layout.addWidget(self.adc1Compare)
        self.adc_checkbox_compare_layout.addWidget(self.adc2Compare)
        self.adc_checkbox_compare_layout.addWidget(self.adc3Compare)
        self.adc_checkbox_compare_layout.addWidget(self.adc4Compare)

        self.groupWidgetCompare = QtGui.QWidget()
        self.groupWidgetCompare.setLayout(self.adc_checkbox_compare_layout)
        self.groupCompare = QtGui.QButtonGroup()
        self.groupCompare.setExclusive(False)
        self.groupCompare.addButton(self.adc1Compare, 1)
        self.groupCompare.addButton(self.adc2Compare, 2)
        self.groupCompare.addButton(self.adc3Compare, 3)
        self.groupCompare.addButton(self.adc4Compare, 4)
        self.groupWidgetCompare.hide()

        self.from_to_layout = QtGui.QHBoxLayout()
        self.from_spinbox = self.createSpinbox(0, 100000000, interval=100, connect=lambda: self.plot(self.theType))
        self.to_spinbox = self.createSpinbox(0, 100000000, start_value=1000, interval=100, connect=lambda: self.plot(self.theType))
        self.from_to_layout.addStretch()
        self.from_to_layout.addWidget(self.createLabel(tr("Label", "From:")))
        self.from_to_layout.addWidget(self.from_spinbox)
        self.from_to_layout.addWidget(self.createLabel(tr("Label", "To:")))
        self.from_to_layout.addWidget(self.to_spinbox)

        self.layout.addLayout(self.plot_buttons_layout)
        self.layout.addWidget(self.compare_heading)
        self.layout.addWidget(self.plot_widget)
        self.layout.addWidget(self.groupWidget)
        self.layout.addWidget(self.groupWidgetCompare)
        self.layout.addLayout(self.from_to_layout)
        self.setLayout(self.layout)

    def change_adc(self):
        """
        Change the adc for which data is plotted
        :return: -
        """
        self.adc = self.group.checkedId()
        self.change_identifier_text()
        self.plot(self.theType)

    def change_adc_compare(self, who):
        """
        Change the adcs displayed in a compare plot
        :return:
        """
        if not self._single_adc_checked:
            self.adc1Compare.setChecked(False)
            self.adc2Compare.setChecked(False)
            self.adc3Compare.setChecked(False)
            self.adc4Compare.setChecked(False)
            getattr(self, 'adc'+str(who)+'Compare').setChecked(True)
            self._single_adc_checked = True
        else:
            checked = [i.isChecked() for i in self.groupCompare.buttons()]
            self._single_adc_checked = False
            self.adc = np.where(np.array(checked) == True)[0][0] + 1  # +1 because adcs are 1 based and indices 0
            self.secadc = np.where(np.array(checked) == True)[0][1] + 1  # +1 because adcs are 1 based and indices 0
            self.compare_heading_left.setText("ADC "+str(self.adc))
            self.compare_heading_right.setText("ADC "+str(self.secadc))
            self.change_identifier_text()
            if self.theType in [ERROR, NO_DATA]:
                self.plot(self._old_type)
            else:
                self.plot(self.theType)

    def disable_buttons(self, b_bool):
        """
        Disable the buttons on this widget
        This is not used at the moment
        :param b_bool: (bool) disable(False) or enable(True)
        :return: -
        """
        self.heatmap_button.setDisabled(b_bool)
        self.fft_button.setDisabled(b_bool)
        self.trains_button.setDisabled(b_bool)
        self.combined_button.setDisabled(b_bool)

    def changePlotType(self, type):
        """
        Change the plot type to the given type.
        :param type: the new type
        """
        if type not in [ERROR, NO_DATA]:
            self._old_type = type
        self.theType = type
        self.plot_widget.changeType(type)
        for btype, button in self.type_buttons.iteritems():
            style = ""
            if btype == type:
                style += "QPushButton {background-color:lightgreen;}"
            else:
                style += self.defaultButtonStyleSheet
            style += "QPushButton:focus{background-color: lightgrey!important; border-color: lightblue;}"  # Note: this does not work
            button.setStyleSheet(style)
    def plot(self, type=None):
        """
        Wrapper function to call the correct plot function depending on type
        :param type: (int) the plot type
        :return: -
        """
        try:
            if type == None:
                if self.theType in [ERROR, NO_DATA]:
                    type = self._old_type
                else:
                    type = self.theType
            self.do_plot(type)
        except Exception:
            if self.data is None or len(self.data.array) == 0:
                self.changePlotType(NO_DATA)
            else:
                self.changePlotType(ERROR)
            self.plot_widget.plot(None)

    def plot_live(self, type=None, data=None):
        """
        Function to call when livedata is to be plotted
        :param type: (int) plot type
        :param data: (dataset.DataSet) data to plot
        :return: -
        """
        self.data = data
        try:
            if type == None:
                if self.theType in [ERROR, NO_DATA]:
                    type = self._old_type
                else:
                    type = self.theType
            if type == PlotType.Trains or type == PlotType.Combined:
                self.do_plot(type, autorange=True)
            else:
                self.do_plot(type, autorange=False)
        except Exception:
            if len(self.data.array) == 0:
                self.changePlotType(NO_DATA)
            else:
                self.changePlotType(ERROR)
            self.plot_widget.plot(None)

    def do_plot(self, type, autorange=True):
        """
        Actually perform a plot (this calls SubPlotWidget.plot)
        :param type: (int) plot type
        :param autorange: (bool) whether to perform a autorange upon plot
        :return: -
        """
        if self.theType != type:
            if type == PlotType.Combined:
                self.groupWidget.hide()
            elif self.theType == PlotType.Combined:
                self.groupWidget.show()

            if type == PlotType.Compare:
                self.groupWidget.hide()
                self.groupWidgetCompare.show()
                self.compare_heading.show()
            else:
                self.groupWidget.show()
                self.groupWidgetCompare.hide()
                self.compare_heading.hide()

            self.changePlotType(type)
            self.setWindowTitle(self.theName + " - " + plotList[type] + " - " + str(self.thePrefix))
            self.change_identifier_text()
            if self.theType == PlotType.Compare:
                self.change_identifier_text()

        if self.theType == PlotType.Compare:
            self.groupWidget.hide()
            self.groupWidgetCompare.show()
            self.compare_heading.show()
        else:
            self.groupWidgetCompare.hide()
            self.compare_heading.hide()

        f = self.from_spinbox.value()
        t = self.to_spinbox.value() if self.to_spinbox.value() > f else f+1
        if type == PlotType.FFT:
            self.plot_widget.plot(np.abs(self.data.fft(adc=self.adc, frm=f, to=t+1, drop_first_bin=True)).transpose(),
                                  autorange=autorange,
                                  xvalueborders=[self.data.fft_freq_dist(), self.data.fft_max_freq()])
        if type == PlotType.Heatmap:
            self.plot_widget.plot(self.data.heatmap(adc=self.adc, frm=f, to=t).transpose(), autorange=autorange)
        if type == PlotType.Compare:
            self.plot_widget.plot([self.data.heatmap(adc=self.adc, frm=f, to=t).transpose(),self.data.heatmap(adc=self.secadc, frm=f, to=t).transpose()], autorange=autorange)
        if type == PlotType.Trains:
            self.plot_widget.plot(self.data.train(adc=self.adc, frm=f, to=t), autorange=autorange)
        if type == PlotType.Combined:
            self.plot_widget.plot(self.data.combined(frm=f, to=t), autorange=autorange)

    def change_identifier_text(self):
        """
        Change the text that identifies the plot in the left bar
        :return:
        """
        if self.theType is PlotType.Compare:
            the_text = str(self.adc)+"+"+str(self.secadc)
        else:
            the_text = str(self.adc)
        if self.theType in [ERROR, NO_DATA]:
            type = self._old_type
        else:
            type = self.theType
        if self.theDataType is LIVE:
            self.change_type_signal.emit(self.theId, type,
                                         the_text+" B: "+available_boards.get_board_name_from_id(self.board_id))
        else:
            self.change_type_signal.emit(self.theId, type, the_text)

    def closeEvent(self, event):
        """
        Event Handler to handle the event of closing this window
        :param event: QEvent
        :return: -
        """
        if not self.close_silent:
            if not self.parent.remove_plot(self.theId, silent=self.close_silent):
                event.ignore()
                return
        del self.data
        del self.plot_widget
        super(PlotWidget, self).closeEvent(event)
        if self.theDataType == LIVE:
            live_plot_windows.removeWindow(self.board_id, self)
        self.close_signal.emit()
        del self