Beispiel #1
0
 def __init__(self):
     super(DataViewer, self).__init__()
     self.comboList = ComboList.ComboList()
     self.settings = SettingsWidget()
     self.calcPlot = CalculatorPlot(parent=self)
     self.setupGUI()
     # default plots will be drawn with multiple y and single x
     self.mainAxis = 'x'
     self.sliderParam = self.settings.config()['Main parameters']['slider']
     self.timeParam = self.settings.config()['Main parameters']['time']
     # no legend at first (there is no data)
     self.legend = None
     self.currentDataSetName = None
     # cursors are movable items to point the failure points
     self.cursors = []
     self.dataSetButtons = {} # list of items in the dataset section of the menu bar
     '''
     Note:
         indices = piece of all data indices, corresponding to the 
         values interval, contrained by the slider
         THE VIEWER PLOTTS DATA using indices!!!!
     '''
     self.data = None # dictionary with full current data set
     self.indices = None # array with indices for the current interval
     self.comments = {}
     self.allComments = {}
     self.allData = {} # here we keep data for different datasets
     self.allCursors = {} # cursors for different dataset
     self.allIndices = {} # contains all truncated indices
     self.allSampleLengths = {}
     self.allUnits = {}
     # self.settings.okButton.pressed.connect(self.settings.hide)
     self.exitButton.triggered.connect(sys.exit)
     self.settingsButton.triggered.connect(self.settings.show)
     self.loadButton.triggered.connect(self.requestLoad)
     self.addSceneButton.triggered.connect(self.addSceneToCombo)
     self.showComboDataButton.triggered.connect(self.comboList.show)
     self.calcPlotButton.triggered.connect(self.runCalcPlot)
     self.calcPlotButton.setDisabled(True)
     ####
     # connect cursors
     self.plt.sigRangeChanged.connect(self.scaleCursors)
     self.addPointButton.triggered.connect(self.addCursor)
     self.removePointButton.triggered.connect(self.removeCursor)
     self.drawCirclesButton.triggered.connect(self.plotMohrCircles)
     #  Finally enable the save button
     self.saveButton.triggered.connect(self.save)
     self.setStatus('Ready')
Beispiel #2
0
class DataViewer(QtGui.QWidget):
    def __init__(self):
        super(DataViewer, self).__init__()
        self.comboList = ComboList.ComboList()
        self.settings = SettingsWidget()
        self.calcPlot = CalculatorPlot(parent=self)
        self.setupGUI()
        # default plots will be drawn with multiple y and single x
        self.mainAxis = 'x'
        self.sliderParam = self.settings.config()['Main parameters']['slider']
        self.timeParam = self.settings.config()['Main parameters']['time']
        # no legend at first (there is no data)
        self.legend = None
        self.currentDataSetName = None
        # cursors are movable items to point the failure points
        self.cursors = []
        self.dataSetButtons = {} # list of items in the dataset section of the menu bar
        '''
        Note:
            indices = piece of all data indices, corresponding to the 
            values interval, contrained by the slider
            THE VIEWER PLOTTS DATA using indices!!!!
        '''
        self.data = None # dictionary with full current data set
        self.indices = None # array with indices for the current interval
        self.comments = {}
        self.allComments = {}
        self.allData = {} # here we keep data for different datasets
        self.allCursors = {} # cursors for different dataset
        self.allIndices = {} # contains all truncated indices
        self.allSampleLengths = {}
        self.allUnits = {}
        # self.settings.okButton.pressed.connect(self.settings.hide)
        self.exitButton.triggered.connect(sys.exit)
        self.settingsButton.triggered.connect(self.settings.show)
        self.loadButton.triggered.connect(self.requestLoad)
        self.addSceneButton.triggered.connect(self.addSceneToCombo)
        self.showComboDataButton.triggered.connect(self.comboList.show)
        self.calcPlotButton.triggered.connect(self.runCalcPlot)
        self.calcPlotButton.setDisabled(True)
        ####
        # connect cursors
        self.plt.sigRangeChanged.connect(self.scaleCursors)
        self.addPointButton.triggered.connect(self.addCursor)
        self.removePointButton.triggered.connect(self.removeCursor)
        self.drawCirclesButton.triggered.connect(self.plotMohrCircles)
        #  Finally enable the save button
        self.saveButton.triggered.connect(self.save)
        self.setStatus('Ready')
    def showComboList(self):
        self.comboList.show()
        self.comboList.activateWindow()
    def checkForLastDir(self):
        '''
        tries to open file 'lastdir'
        if it exists, returns the contents,
        else returns none
        '''
        try:
            with open('lastdir','r') as f:
                return f.read()
        except IOError:
            return ''
    def makeLastDir(self,filename):
        '''
        gets directory name from file absolute path
        create file 'lastdir' and writes 
        '''
        with open('lastdir','w') as f:
            f.write(os.path.dirname(filename))
    def requestLoad(self):
        '''
        opens file manager, gets filename,
        calls load
        '''
        self.lastdir = self.checkForLastDir()
        # second par - name of file dialog window
        # third parameter - default file name
        # forth parameter - file filter. types separated by ';;'
        filename = QtGui.QFileDialog.getOpenFileName(self, "",
         "%s"%(self.lastdir), "*.clf;;MAT files (*.mat)")
        self.load(filename)
    def load(self,filename):
        '''
        opens file manager, reads data from file,
        calls generateList to put into GUI
        '''
        headerexpr = self.settings.msWidget.getHeaderExpr()
        slengthexpr = self.settings.msWidget.getSampleLengthExpr()
        if filename[0] == '': return
        if filename[1] == 'MAT files (*.mat)':
            self.data = pymat.load(filename[0])
        elif filename[1] == u'*.clf':
            tup = readclf.readclf(filename[0],
                headerexpr=headerexpr,
                lengthexpr=slengthexpr)
            if tup==None:
                reply = QtGui.QMessageBox.warning(self,
                'Wrong header',
                BadHeaderMessage, QtGui.QMessageBox.Ok )
                IOError('Cannot read this file.')
            data,comments,length = tup
        else: raise IOError('Cannot read this file format.')
        # this is to remember this name when we wanna save file
        self.makeLastDir(filename[0]) # extract filename from absolute path
        self.filename = os.path.basename(filename[0])
        # remove extension from name
        self.filename = os.path.splitext(self.filename)[0]
        # Separate all digital data and units    
        units = data['Units']        
        del data['Units']
        self.data = data
        # self.setParameters()
        # self.connectParameters()
        isNew = True
        if self.filename in self.allData.keys():
            isNew = False
        self.allData[self.filename] = data
        # get one name from array to get length of the data
        key = data.keys()[0]
        l = self.data[key].shape[0]
        self.allSampleLengths[self.filename] = length
        self.allIndices[self.filename] = np.arange(l)
        self.allComments[self.filename] = comments
        self.allUnits[self.filename] = units
        self.addDataSet(self.filename,isNew)
    def addDataSet(self,name,isNew=True):
        print 'Modifying GUI: adding data set button'
        if isNew:
            dataSetButton = QtGui.QAction(name,self,checkable=True)
            dataSetButton.setActionGroup(self.dataSetGroup)
            dataSetButton.setChecked(True)
            self.dataSetMenu.addAction(dataSetButton)
            self.dataSetButtons[name] = dataSetButton
            dataSetButton.triggered.connect(lambda: self.setCurrentDataSet(name))
        self.allCursors[name] = []
        self.setCurrentDataSet(name)
    def setCurrentDataSet(self,name):
        print 'New data set is chosen'
        # if we switch to a different data set (if it's not the first),
        # remember cursors for the old one
        if self.currentDataSetName: 
            print 'Saving old data'
            self.allIndices[self.currentDataSetName] = self.indices
            self.allCursors[self.currentDataSetName] = self.cursors
            self.allComments[self.currentDataSetName] = self.comments
        print 'Setting new data'
        # set current data dictionaries to new values
        self.currentDataSetName = name
        self.data = self.allData[name]
        self.units = self.allUnits[name]
        self.sampleLength = self.allSampleLengths[name]
        self.indices = self.allIndices[name]
        self.dataSetMenu.setDefaultAction(self.dataSetButtons[name])
        self.cursors = self.allCursors[name]
        self.comments = self.allComments[name]
        self.setParameters()
        self.connectParameters()
        # self.mcSettings.setAvailableVariables(self.data.keys())
        self.settings.mcWidget.setAvailableVariables(self.data.keys())
        self.calcPlotButton.setDisabled(False)
        if self.calcPlot.active:
            print 'Calculator active'
            self.calcPlot.setData(self.data)
        self.updatePlot()
    def save(self):
        self.lastdir = self.checkForLastDir()
        # second par - name of file dialog window
        # third parameter - default file name
        # forth parameter - file filter. types separated by ';;'
        filename = pg.QtGui.QFileDialog.getSaveFileName(self, 
            "Save to MATLAB format", "%s%s"%(self.lastdir,self.currentDataSetName), "MAT files (*.mat)")
        if filename[0] == '': return
        pymat.save(filename[0],self.data)

    def connectParameters(self):
        '''
        Makes new connection of list entries with plot after
        loading a new dataset.
        'Parameter' with name Time is default if it's in the list
        Default Interval variable is set to Time
        '''
        # set default values for modifying parameters
        self.modparams.param('Parameter').setValue(self.timeParam)
        # self.modparams.param('Interval').setValue('Time')
        # connect signals to updating functions
        self.tree.sigStateChanged.connect(self.bindCursors)
        self.tree.sigStateChanged.connect(self.updatePlot)
        self.slider.sigRangeChanged.connect(self.truncate)
        # self.modparams.param('Interval').sigValueChanged.connect(self.updatePlot)
        self.modparams.param('min').sigValueChanged.connect(self.setTicks)
        self.modparams.param('max').sigValueChanged.connect(self.setTicks)
        self.modparams.param('Parameter').sigValueChanged.connect(self.updatePlot)
        self.modparams.param('Plot vs.').sigValueChanged.connect(self.setMainAxis)
        # connection with trend computations        
        self.tree.sigStateChanged.connect(self.setTrendParameter)
        self.modparams.param('Parameter').sigValueChanged.connect(self.checkTrendUpdates)
        self.modparams.param('Plot vs.').sigValueChanged.connect(self.setTrendParameter)
        self.computeTrendFlag.sigValueChanged.connect(self.checkTrendUpdates)
        self.trendParameter.sigValueChanged.connect(self.setTrendParameter)
        # connect Null parameter
        self.nullFlag.sigValueChanged.connect(self.updatePlot)

        ### enable cursors buttons
        self.addPointButton.setEnabled(True)
        self.removePointButton.setEnabled(True)
        self.drawCirclesButton.setEnabled(True)
        
    def addCursor(self):
        print 'adding a Cursor'
        viewrange = self.plt.viewRange()
        # print viewrange
        rangeX = [viewrange[0][0],viewrange[0][1]]
        rangeY = [viewrange[1][0],viewrange[1][1]]
        pos = [(rangeX[0] + rangeX[1])/2,(rangeY[0] + rangeY[1])/2]
        xSize = float(rangeX[1]-rangeX[0])/50*800/self.plt.width()
        ySize = float(rangeY[1]-rangeY[0])/50*800/self.plt.height()
        Cursor = CursorItem.CursorItem(pos,[xSize,ySize],pen=(4,9))
        self.cursors.append(Cursor)
        self.allCursors[self.currentDataSetName] = self.cursors
        # bind cursor if there is something to plot
        plotlist = self.activeEntries()
        if len(plotlist)>0: 
            self.bindCursors()
            self.updatePlot()

    def removeCursor(self):
        if len(self.cursors)>0:
            self.cursors.pop(-1)
            self.updatePlot()

    def plotMohrCircles(self):
        global CirclesWidget
        CirclesWidget = MohrCircles.MohrCircles()
        params = self.settings.mcWidget.parameters()
        b = params[3] # biot coef
        names = []
        PorePressure = []
        AxialStress = []
        ConfiningStress = []
        ncircles = 0
        for DataSet in self.allCursors.keys():
            cursors = self.allCursors[DataSet]
            data = self.allData[DataSet]
            if cursors == []: 
                continue
            else: 
                indices = []
                for cursor in cursors:
                    indices.append(cursor.index)
                    ncircles += 1
                    Sig1 = data[params[0]][cursor.index] #axial stress
                    if params[1]=='0':
                        Pc = 0
                    else:
                        Pc = data[params[1]][cursor.index] # confining press
                    if params[2]=='0':
                        Pu = 0
                    else:
                        Pu = data[params[2]][cursor.index] # pore pressure
                    sigma1 = Sig1 - b*Pu
                    sigma3 = Pc - b*Pu
                    CirclesWidget.addData(max(sigma1,sigma3),min(sigma1,sigma3),name=DataSet +'_'+ str(ncircles))
        if ncircles == 0: return 0
        CirclesWidget.start()
        CirclesWidget.show()
        CirclesWidget.activateWindow()

    def scaleCursors(self):
        '''
        make cursors circles of an appropriate size when scaling plot
        '''
        viewrange = self.plt.viewRange()
        rangeX = [viewrange[0][0],viewrange[0][1]]
        rangeY = [viewrange[1][0],viewrange[1][1]]
        xSize = float(rangeX[1]-rangeX[0])/50*800/self.plt.width()
        ySize = float(rangeY[1]-rangeY[0])/50*800/self.plt.height()
        size = np.array([xSize,ySize])
        for cursor in self.cursors:
            oldSize = cursor.getSize() # workaround to force the cursor stay on the same place
            cursor.translate(oldSize/2,snap=None)
            cursor.setSize(size)
            cursor.translate(-size/2,snap=None)
    def drawCursors(self):
        '''
        add cursors again after clearing the plot window
        '''
        for cursor in self.cursors:
            self.plt.addItem(cursor)
    def bindCursors(self):
        '''
        make cursor slide along data
        '''
        # print self.sender()
        try: 
            plotlist = self.activeEntries()
            if self.mainAxis == 'y':
                xlabel = plotlist[-1]
                ylabel = self.modparams.param('Parameter').value()
            elif self.mainAxis == 'x':
                ylabel = plotlist[-1]
                xlabel = self.modparams.param('Parameter').value()
            x = self.data[xlabel][self.indices]
            y = self.data[ylabel][self.indices]

            for cursor in self.cursors:
                cursor.setData(x,y)
        except: pass

    def checkTrendUpdates(self):
        if self.computeTrendFlag.value(): 
            self.computeTrend()
            self.updatePlot()
        
    def setTrendParameter(self):
        entries = self.activeEntries() 
        for i in entries: pass
        if entries != []: self.trendParameter.setValue(i)
        self.checkTrendUpdates()

    def truncate(self):
        interval = self.slider.interval()
        arr = self.data[self.sliderParam]
        self.indices = (arr>=interval[0]) & (arr <= interval[1])
        self.checkTrendUpdates() 
        self.updatePlot()

    def setMainAxis(self):
        self.mainAxis = self.modparams.param('Plot vs.').value()
        self.updatePlot()

    def updateLimits(self):
        interval = self.slider.interval()
        self.modparams.param('min').sigValueChanged.disconnect(self.setTicks)
        self.modparams.param('max').sigValueChanged.disconnect(self.setTicks)
        self.modparams.param('min').setValue(interval[0])
        self.modparams.param('max').setValue(interval[1])
        self.modparams.param('min').sigValueChanged.connect(self.setTicks)
        self.modparams.param('max').sigValueChanged.connect(self.setTicks)
    def setTicks(self):
        '''
        sets ticks to state coressponding to  Interval min/max
        values, when they are manually changed
        '''
        scale = self.data[self.sliderParam].max()
        values = [float(self.modparams.param('min').value())/scale,
                  float(self.modparams.param('max').value())/scale
                 ]
        self.slider.setInterval(values)
        self.updatePlot()

    def updatePlot(self):
        '''
        updates plot
        '''
        self.setAxisScale()
        self.updateLimits()
        ### Ready to update
        # self.setAutoFillBackground(True)
        self.clearPlotWindow()
        self.drawCursors()
        self.plt.showGrid(x=True, y=True)
        if self.mainAxis == 'x':
            self.plotVersusX()
        if self.mainAxis == 'y':
            self.plotVersusY()
        if self.computeTrendFlag.value():
            self.plotTrend()
        if self.calcPlot.active:
            self.calcPlot.indices = self.indices
            self.calcPlot.plot()

    def plotVersusX(self):
        '''
        plot when we have sevaral y's versus of x.
        '''
        # Get variables to plot
        data = self.data
        plotlist = self.activeEntries()
        xlabel = self.modparams.param('Parameter').value()
        null = self.nullFlag.value()
        for i in range(len(plotlist)):
            ylabel = plotlist[i]
            color = self.tree.colors[ylabel].getColor()
            linestyle = pg.mkPen(color=color, width=3)
            yunits = self.units[ylabel]
            xdata = data[xlabel][self.indices]
            ydata = data[ylabel][self.indices]
            if null: ydata -= ydata[0]
            self.plt.plot(xdata, ydata, 
                pen=linestyle, name=plotlist[i])
            self.plt.setLabel('left', plotlist[i],units=yunits,
                **AxisLabelStyle)
        xunits = self.units[xlabel]
        self.plt.setLabel('bottom', xlabel,units=xunits,**AxisLabelStyle)
        # if len(plotlist)>0: self.bindCursors(data[xlabel],data[ylabel])
    def plotVersusY(self):
        '''
        plot when we have sevaral y's versus of x.
        '''
        # Get variables to plot
        data = self.data
        plotlist = self.activeEntries()
        ylabel = self.modparams.param('Parameter').value()
        yunits = self.units[ylabel]
        null = self.nullFlag.value()
        for i in range(len(plotlist)):
            xlabel = plotlist[i]
            color = self.tree.colors[xlabel].getColor()
            linestyle = pg.mkPen(color=color, width=3)
            xunits = self.units[xlabel]
            xdata = data[xlabel][self.indices]
            ydata = data[ylabel][self.indices]
            if null: xdata -= xdata[0]
            self.plt.plot(xdata, ydata, 
                pen=linestyle, name=plotlist[i])
            self.plt.setLabel('bottom', xlabel,units=xunits,**AxisLabelStyle)
        self.plt.setLabel('left', ylabel,units=yunits,**AxisLabelStyle)

    def plotTrend(self):
        '''
        plots linear trend 
        '''
        if self.mainAxis == 'x':
            xpar = self.modparams.param('Parameter').value()
            ypar = self.trendParameter.value()
            self.plt.setLabel('bottom', xpar)
        if self.mainAxis == 'y':
            xpar = self.trendParameter.value()
            ypar = self.modparams.param('Parameter').value()
        x = self.data[xpar][self.indices]
        y = self.slope*x + self.intersection
        self.plt.plot(x,y,pen=TrendPen, name='%s Trend'%(self.trendParameter.value()))
        self.plt.setLabel('bottom', xpar)
        self.plt.setLabel('left', ypar)

    def clearPlotWindow(self):
        '''
        clears plot from data. clears legend.
        if there is no legend creates it
        '''
        # default legend position
        position = [30,30]
        # clear plot area
        self.plt.clear()
        # remove old legend
        if self.legend: 
            position = self.legend.pos()
            self.legend.scene().removeItem(self.legend)
        # creadte new legend
        self.plt.addLegend([90,20],offset=position)
        self.legend = self.plt.legend
    def setAxisScale(self):
        '''
        sets scale to the interval axis. if time, sets minimum value to 0,
        because it could have been cleared
        '''
        # interval_parameter = self.modparams.param('Interval').value()
        interval_parameter = self.sliderParam
        if interval_parameter == self.timeParam:
            self.slider.setRange(0,max(self.data[self.timeParam]))
        else:
            self.slider.setRange(min(self.data[interval_parameter]),max(self.data[interval_parameter]))

    def activeEntries(self):
        '''
        returns a list of active entries in the data bar
        '''
        plotlist = []
        # for i in self.data.keys():
        #     if self.params.param(i).value() == True:
        for item in self.data.keys():
            if self.tree.boxes[item].value() == True:
                plotlist.append(item)
        return plotlist
    def setParameters(self):
        print 'Modifying GUI: adding parameters to plot'
        # set modifying parameters
        self.modparamlist = ModifyingParameters
        self.modparamlist[1]['values'] = self.data.keys() # Parameter
        # self.modparamlist[2]['values'] = self.data.keys() # Interval
        self.modparamlist[5]['children'][1]['values'] = self.data.keys() # Trend parameter
        # create parameter class instances()
        # self.params = Parameter.create(name='Data', type='group',children=self.paramlist)
        self.modparams = Parameter.create(name='Options', type='group',children=self.modparamlist)
        self.tree.clear()
        self.tree.addItems(self.data.keys(),DataViewerTreeColors)
        # self.tree.setParameters(self.params, showTop=True)
        self.modtree.setParameters(self.modparams, showTop=True)
        self.assignAttributes() # to get shorter names
    def assignAttributes(self):
        '''
        assign parameters from modparams tree to class DataViewer
        attributes to shorten code
        '''
        self.nullFlag = self.modparams.param('Null')
        # assign chilren of 'Linear Trend' group to class attributes
        self.computeTrendFlag = self.modparams.param('Linear Trend').children()[0]
        self.trendParameter = self.modparams.param('Linear Trend').children()[1]
        self.trendSlope = self.modparams.param('Linear Trend').children()[2]
        self.trendIntersection = self.modparams.param('Linear Trend').children()[3]
    def setupGUI(self):
        pg.setConfigOption('background', (255,255,255))
        pg.setConfigOption('foreground',(0,0,0))
        self.setWindowIcon(QtGui.QIcon('images/Logo.png'))    
        # Global widget where we place our layout
        self.layout = QtGui.QVBoxLayout()
        self.layout.setContentsMargins(0,0,0,0)
        self.layout.setSpacing(0)
        self.setLayout(self.layout)
        # Create and add menu bar
        self.menuBar = QtGui.QMenuBar()
        self.fileMenu = self.menuBar.addMenu('File')
        self.viewMenu = self.menuBar.addMenu('View')
        self.dataSetMenu = self.menuBar.addMenu('Dataset')
        self.mohrMenu = self.menuBar.addMenu('Mohr\' Circles')
        self.comboPlotMenu = self.menuBar.addMenu('Combo plot')
        self.prefMenu = self.menuBar.addMenu('Preferences')
        self.dataSetGroup = QtGui.QActionGroup(self)
        # create status bar
        self.layout.addWidget(self.menuBar,0)
        self.layout.setMenuBar(self.menuBar)
        # create submenu items
        self.loadButton = QtGui.QAction('Load',self)
        self.saveButton = QtGui.QAction('Save',self)
        self.exitButton = QtGui.QAction('Exit',self,shortcut="Alt+F4")
        self.calcPlotButton = QtGui.QAction('Calculator',self)
        self.autoScaleButton = QtGui.QAction('Auto scale',self)
        self.addPointButton = QtGui.QAction('Add point',self,shortcut='Ctrl+Q')
        self.removePointButton = QtGui.QAction('Remove point',self,shortcut='Ctrl+R')
        self.drawCirclesButton = QtGui.QAction('Draw Mohr\'s Circles',self,shortcut='Alt+M')
        self.showComboDataButton = QtGui.QAction('Show',self,shortcut='Ctrl+Shift+C')
        self.addSceneButton = QtGui.QAction('Add scene',self,shortcut='Ctrl+C')
        self.settingsButton = QtGui.QAction('Settings',self)
        self.addPointButton.setEnabled(False)
        self.removePointButton.setEnabled(False)
        self.drawCirclesButton.setEnabled(False)
        # Add buttons to submenus
        self.fileMenu.addAction(self.loadButton)
        self.fileMenu.addAction(self.saveButton)
        self.fileMenu.addAction(self.exitButton)
        self.mohrMenu.addAction(self.addPointButton)
        self.mohrMenu.addAction(self.removePointButton)
        self.mohrMenu.addAction(self.drawCirclesButton)
        self.viewMenu.addAction(self.calcPlotButton)
        self.viewMenu.addAction(self.autoScaleButton)
        self.comboPlotMenu.addAction(self.showComboDataButton)
        self.comboPlotMenu.addAction(self.addSceneButton)
        self.prefMenu.addAction(self.settingsButton)
        # splitter is a widget, which handles the layout
        # it splits the main window into parameter window
        # and the plotting area
        self.splitter = QtGui.QSplitter()
        self.splitter.setOrientation(QtCore.Qt.Horizontal)
        self.layout.addWidget(self.splitter)

        # tree is a list of parameters to plot
        self.tree = CParameterTree.CParameterTree(name='Data')
        # modtree is a list of governing parameters to modify plot
        self.modtree = ParameterTree(showHeader=False)
        # sublayout is were we place our plot and slider
        self.sublayout = pg.GraphicsLayoutWidget()
        # treesplitter splits parameter window into 2 halfs
        self.treesplitter = QtGui.QSplitter()
        self.buttonsplitter = QtGui.QSplitter()
        self.treesplitter.setOrientation(QtCore.Qt.Vertical)
        self.treesplitter.addWidget(self.tree)
        self.treesplitter.addWidget(self.modtree)
        self.treesplitter.setSizes([int(self.height()*0.7),
                                    int(self.height()*0.3),
                                    20])
        self.treesplitter.setStretchFactor(0, 0)
        self.treesplitter.setStretchFactor(1, 0.9)

        self.splitter.addWidget(self.treesplitter)
        self.splitter.addWidget(self.sublayout)
        self.splitter.setSizes([int(self.width()*0.4), int(self.width()*0.6)])
        self.splitter.setStretchFactor(0, 0)
        self.splitter.setStretchFactor(1, 1)
        self.plt = self.sublayout.addPlot()
        setup_plot(self.plt)
        self.plt.setLabel('bottom', 'X Axis',**AxisLabelStyle)
        self.plt.setLabel('left', 'Y Axis',**AxisLabelStyle)
        self.plt.enableAutoRange(enable=True)
        self.autoScaleButton.triggered.connect(self.plt.enableAutoRange)
        # self.slider = self.createSlider()
        self.slider = SliderWidget()
        self.sublayout.nextRow()
        self.sublayout.addItem(self.slider)
        self.sublayout.nextRow()
        self.statusBar = QtGui.QStatusBar()
        self.treesplitter.addWidget(self.statusBar)
        self.setGeometry(80, 50, 800, 600)
        self.treesplitter.setStretchFactor(2, 0)
        self.treesplitter.setCollapsible(2, 0)
        self.statusBar.setSizePolicy(QtGui.QSizePolicy.Ignored,
            QtGui.QSizePolicy.Fixed)
        self.setGeometry(80, 30, 1000, 700)
    def setStatus(self,message):
        self.statusBar.showMessage(message)
        print message
    def computeTrend(self):
        '''
        computer linear trend a and b and 
        from truncated data. 
        '''
        if self.mainAxis == 'x': # if multiple plots vs x
            xpar = self.modparams.param('Parameter').value()
            ypar = self.trendParameter.value()
        if self.mainAxis == 'y': # if multiple plots vs y
            ypar = self.modparams.param('Parameter').value()
            xpar = self.trendParameter.value()
        
        x = self.data[xpar][self.indices]
        y = self.data[ypar][self.indices]
        A = np.array([x, np.ones(len(y))]).T
        ## Solves the equation a x = b by computing a vector x that 
        ## minimizes the Euclidean 2-norm || b - a x ||^2. 
        self.slope,self.intersection = np.linalg.lstsq(A,y)[0]
        self.trendSlope.setValue(self.slope)
        self.trendIntersection.setValue(self.intersection)

    def createSlider(self):
        slider = pg.GradientEditorItem(orientation='top', allowAdd=False)
        # print slider.__dict__
        # slider.tickPen = pg.mkPen(color=(255,255,255))
        slider.tickSize = 0
        # print slider.gradRect
        slider.rectSize = 0
        for i in slider.ticks:
            slider.setTickColor(i, QtGui.QColor(150,150,150))
        return slider
    def closeEvent(self,event):
        '''
        When pressing X button, show quit dialog.
        if yes, closes the window and ends the process
        '''
        # reply = QtGui.QMessageBox.question(self, 'Quit Dataviewer',
        #     "Are you sure to quit?", QtGui.QMessageBox.Yes | 
        #     QtGui.QMessageBox.No, QtGui.QMessageBox.No)

        # if reply == QtGui.QMessageBox.Yes:
        #     sys.exit()
        #     event.accept()
        # else:
        #     event.ignore()
        sys.exit()

    def addSceneToCombo(self):
        print 'adding scene to Combo plot'
        rootname = self.currentDataSetName
        for item in self.plt.listDataItems():
            name = rootname+'_'+item.name()
            x = item.xData
            y = item.yData
            self.comboList.addItem(name,x,y)
    def runCalcPlot(self):
        self.calcPlot.active = True
        self.calcPlot.setData(self.data)
        self.calcPlot.show()
        self.calcPlot.activateWindow()