GUI_main.py

            self.reader.SaveMask(self.Tindex, self.FOVindex, self.m.plotmask)
            
            self.Tindex = newtimeindex
            
            if self.Tindex == 0:
                self.button_nextframe.setEnabled(True)
                self.m.nextpicture = self.reader.LoadOneImage(self.Tindex+1,self.FOVindex)
                self.m.nextplotmask = self.reader.LoadMask(self.Tindex+1, self.FOVindex)
                
                self.m.currpicture = self.reader.LoadOneImage(self.Tindex, self.FOVindex)
                self.m.plotmask = self.reader.LoadMask(self.Tindex, self.FOVindex)
                
                self.m.prevpicture = np.zeros([self.reader.sizey, self.reader.sizex], 
                                              dtype = np.uint16)
                self.m.prevplotmask = np.zeros([self.reader.sizey, self.reader.sizex], 
                                               dtype = np.uint16)
    
                self.m.UpdatePlots()
                self.button_previousframe.setEnabled(False)
                
            elif self.Tindex == self.reader.sizet-1:
                self.button_previousframe.setEnabled(True)
                self.m.prevpicture = self.reader.LoadOneImage(self.Tindex-1, self.FOVindex)
                self.m.prevplotmask = self.reader.LoadMask(self.Tindex-1, self.FOVindex)
                   
                self.m.currpicture = self.reader.LoadOneImage(self.Tindex, self.FOVindex)
                self.m.plotmask = self.reader.LoadMask(self.Tindex, self.FOVindex)
                  
                self.m.nextpicture =  np.zeros([self.reader.sizey, self.reader.sizex], 
                                               dtype = np.uint16)
                self.m.nextplotmask =  np.zeros([self.reader.sizey, self.reader.sizex], 
                                                dtype = np.uint16)
                
                self.m.UpdatePlots()
                self.button_nextframe.setEnabled(False)
                
            else:
                self.button_nextframe.setEnabled(True)
                self.button_previousframe.setEnabled(True)
                self.m.prevpicture = self.reader.LoadOneImage(self.Tindex-1, self.FOVindex)
                self.m.prevplotmask = self.reader.LoadMask(self.Tindex-1, self.FOVindex)
                   
                self.m.currpicture = self.reader.LoadOneImage(self.Tindex, self.FOVindex)
                self.m.plotmask = self.reader.LoadMask(self.Tindex, self.FOVindex)              
                  
                self.m.nextpicture = self.reader.LoadOneImage(self.Tindex+1,self.FOVindex)
                self.m.nextplotmask = self.reader.LoadMask(self.Tindex+1, self.FOVindex)
                self.m.UpdatePlots()
            
            self.UpdateTitleSubplots()
            self.button_timeindex.clearFocus()
            self.button_timeindex.setText(str(self.Tindex)+'/'+str(self.reader.sizet-1))
            
            if self.button_hidemask.isChecked():
                self.m.HideMask()
            self.EnableCNNButtons()
        
        else:
            self.button_timeindex.clearFocus()
            return
        
     
    def CellCorrespActivation(self):
            self.Disable(self.button_cellcorespondance)
            self.WriteStatusBar('Doing the cell correspondance')

            if self.Tindex != 0:
                self.m.plotmask = self.reader.CellCorrespondance(self.Tindex, self.FOVindex)
                self.m.updatedata()
            else:
                self.m.plotmask = self.reader.LoadSeg(self.Tindex, self.FOVindex)
                self.m.updatedata()

            self.Enable(self.button_cellcorespondance)
            self.button_cellcorespondance.setChecked(False)
            self.ClearStatusBar()
        
        
    def SegmentBoxCheck(self):
        if self.button_segment.isChecked():
            self.Disable(self.button_segment)
            self.EnableCorrectionsButtons()
            self.m.SegmentedMask = self.reader.LoadSeg(self.Tindex, self.FOVindex)
            self.m.tempplotmask = self.m.plotmask.copy()
            self.m.plotmask = self.m.SegmentedMask.copy()
            self.m.currmask.set_data((self.m.SegmentedMask%10 + 1)*(self.m.SegmentedMask != 0))
            self.m.ax.draw_artist(self.m.currplot)
            self.m.ax.draw_artist(self.m.currmask)
            self.m.update()
            self.m.flush_events()
            
            # update the graph
            self.button_SetSegmentation.setEnabled(True)
            self.button_savesegmask.setEnabled(True)
            
        else:
            self.m.SegmentedMask = self.m.plotmask.copy()
            self.m.plotmask = self.m.tempplotmask.copy()
            self.m.updatedata()
            self.button_SetSegmentation.setEnabled(False)
            self.button_savesegmask.setEnabled(False)
            self.Enable(self.button_segment)
    
    
    def SegmentThresholdedPredMask(self):
        # update the plots to display the segmentation view
        segparamvalue = int(self.button_SetSegmentation.text())
        self.m.plotmask = self.reader.Segment(segparamvalue, self.Tindex,self.FOVindex)
        self.m.currmask.set_data((self.m.plotmask%10 + 1)*(self.m.plotmask != 0))
        self.m.ax.draw_artist(self.m.currplot)
        self.m.ax.draw_artist(self.m.currmask)
        self.m.update()
        self.m.flush_events()
    
    
    def ButtonSaveSegMask(self):
        """saves the segmented mask
        """
        self.reader.SaveSegMask(self.Tindex, self.FOVindex, self.m.plotmask)
    
        
    def ThresholdBoxCheck(self):
        """if the buttons is checked it shows the thresholded version of the 
        prediction, if it is not available it justs displays a null array.
        The buttons for the setting a threshold a value and to save it are then
        activated once this button is enabled.
        """
        if self.button_threshold.isChecked():
            self.Disable(self.button_threshold)
            self.m.ThresholdMask = self.reader.LoadThreshold(self.Tindex, self.FOVindex)
            
            self.m.currmask.set_data(self.m.ThresholdMask)
            self.m.ax.draw_artist(self.m.currplot)
            self.m.ax.draw_artist(self.m.currmask)
            self.m.update()
            self.m.flush_events()
            
            self.button_SetThreshold.setEnabled(True)
            self.button_savethresholdmask.setEnabled(True)
            
        else:
            self.m.updatedata()
            self.button_SetThreshold.setEnabled(False)
            self.button_savethresholdmask.setEnabled(False)
            self.Enable(self.button_threshold)


    def ThresholdPrediction(self):
        # update the plots to display the thresholded view
        thresholdvalue = float(self.button_SetThreshold.text())
        
        self.m.ThresholdMask = self.reader.ThresholdPred(
            thresholdvalue, 
            self.Tindex,self.FOVindex)
        
        self.m.currmask.set_data(self.m.ThresholdMask)
        self.m.ax.draw_artist(self.m.currplot)
        self.m.ax.draw_artist(self.m.currmask)
        self.m.update()
        self.m.flush_events()
      
        
    def ButtonSaveThresholdMask(self):
        """saves the thresholed mask
        """
        self.reader.SaveThresholdMask(self.Tindex, self.FOVindex, self.m.ThresholdMask)

        
    def ChangePreviousFrame(self):
         """This function is called when the previous frame buttons is pressed 
         and it tests if the buttons is enabled and if so it calls the
         BackwardTime() function. It should avoid the let the user do multiple 
         clicks and that the function is then called afterwards several times,
         once the frames and masks of the current time index have been loaded.
         """
         if self.button_previousframe.isEnabled():
            self.button_previousframe.setEnabled(False)
            self.BackwardTime()
            if self.Tindex >0:
                self.button_previousframe.setEnabled(True)
         else:
             return
             
             
    def ChangeNextFrame(self):
        """This function is called when the next frame buttons is pressed 
        and it tests if the buttons is enabled and if so it calls the
        ForwardTime() function. It should avoid the let the user do multiple 
        clicks and that the function is then called afterwards several times,
        once the frames and masks of the current time index have been loaded.
        """
        if self.button_nextframe.isEnabled():
            self.button_nextframe.setEnabled(False)
            self.ForwardTime()
            if self.Tindex + 1 < self.reader.sizet:
                self.button_nextframe.setEnabled(True)
                
        else:
            return

        
    def ForwardTime(self):
        """This function switches the frame in forward time index. And it tests
        several conditions if t == lastTimeIndex-1, because then the next frame
        button has to be disabled. It also tests if the show value of cells
        button and hidemask are active in order to hide/show the mask or to 
        show the cell values.
        """
        # the t frame is defined as the currently shown frame on the display.
        # If the button "Next time frame" is pressed, this function is called
        self.WriteStatusBar('Loading the next frame...')
        self.Disable(self.button_nextframe)

        if self.Tindex + 1 < self.reader.sizet - 1 :
            self.reader.SaveMask(self.Tindex, self.FOVindex, self.m.plotmask)
            
            self.m.prevpicture = self.m.currpicture.copy()
            self.m.prevplotmask = self.m.plotmask.copy()
            
            self.m.currpicture = self.m.nextpicture.copy()
            self.m.plotmask = self.m.nextplotmask.copy()
            
            self.m.nextpicture = self.reader.LoadOneImage(self.Tindex+2, self.FOVindex)
            self.m.nextplotmask = self.reader.LoadMask(self.Tindex+2, self.FOVindex)
            self.m.UpdatePlots()

            if self.Tindex + 1 == 1:
                self.button_previousframe.setEnabled(True)
                
        else:
            self.reader.SaveMask(self.Tindex, self.FOVindex, self.m.plotmask)
        
            self.m.prevpicture = self.m.currpicture.copy()
            self.m.prevplotmask = self.m.plotmask.copy()
            self.m.currpicture = self.m.nextpicture.copy()
            self.m.plotmask = self.m.nextplotmask.copy()
            self.m.nextpicture = np.zeros([self.reader.sizey, self.reader.sizex], 
                                          dtype = np.uint16)
            self.m.nextplotmask = np.zeros([self.reader.sizey,self.reader.sizex], 
                                           dtype = np.uint16)
            self.m.UpdatePlots()

            self.button_nextframe.setEnabled(False)

        self.Tindex = self.Tindex+1
        self.UpdateTitleSubplots()
        
        if self.button_hidemask.isChecked():
            self.m.HideMask()

        self.Enable(self.button_nextframe)
        self.ClearStatusBar()
        self.button_timeindex.setText(str(self.Tindex)+'/'+str(self.reader.sizet-1))

    
    def BackwardTime(self):
        """This function switches the frame in backward time index. And it 
        several conditions if t == 1, because then the button previous frame has to
        be disabled. It also tests if the show value of cells button and 
        hidemask are active in order to hide/show the mask or to show the cell
        values.
        """
        # the t frame is defined as the currently shown frame on the display.
        # If the button "Previous time frame" is pressed, this function is called
        self.WriteStatusBar('Loading the previous frame...')
        self.Disable(self.button_previousframe)
        
        self.reader.SaveMask(self.Tindex, self.FOVindex, self.m.plotmask)

        self.m.nextpicture = self.m.currpicture.copy()
        self.m.nextplotmask = self.m.plotmask.copy()
        self.m.currpicture = self.m.prevpicture.copy()
        self.m.plotmask = self.m.prevplotmask.copy()
            
        if self.Tindex == 1:
            self.m.prevpicture = np.zeros([self.reader.sizey, self.reader.sizex], dtype = np.uint16)
            self.m.prevplotmask = np.zeros([self.reader.sizey, self.reader.sizex], dtype = np.uint16)
            self.button_previousframe.setEnabled(False)
            
        else:
            self.m.prevpicture = self.reader.LoadOneImage(self.Tindex-2, self.FOVindex)
            self.m.prevplotmask = self.reader.LoadMask(self.Tindex-2, self.FOVindex)

        self.m.UpdatePlots()
        if self.Tindex-1 == self.reader.sizet-2:
            self.button_nextframe.setEnabled(True)            
        
        if self.button_hidemask.isChecked():
            self.m.HideMask()
        
        self.Tindex -= 1
        self.UpdateTitleSubplots()
            
        self.Enable(self.button_previousframe)
        
        if self.Tindex > 0:
            self.button_previousframe.setEnabled(True)          
            
        self.ClearStatusBar()
        self.button_timeindex.setText(str(self.Tindex)+'/' + str(self.reader.sizet-1))


# -----------------------------------------------------------------------------
# MANUAL MASK CORRECTIONS
            
    def ChangeOneValue(self):
        """This function is called when the button Change cell value is
        clicked. It displays the instructions on the status bar.
        And if the user clicks in the graph where the current mask is displayed
        it connects the event of the click (meaning that user has clicked on
        one cell) to the function self.DialogBoxChangeOneValue. 
        This function will then replaces the cell selected by the user with
        the click with a new value entered by the user.
        """
        
        # displaying the instructions on the statusbar
        self.WriteStatusBar((
            'Select one cell using the left click '
             'and then enter the desired value in the dialog box.'))

        # disables all the buttons
        self.Disable(self.button_changecellvalue)
        
        # connects the event "press mouse button" in the matplotlib plot 
        # (picture) to the function self.DialogBoxChangeOneValue
        self.id = self.m.mpl_connect('button_press_event', self.DialogBoxChangeOneValue)
        
        
    def DialogBoxChangeOneValue(self, event):
        """This function is called when the user after the user has selected
        the button Change cell value and clicked in the picture to select
        the desired cell to change.
        
        It first deconnects the mouse click event in matplotlib with this 
        function to not generate any other dialog window.
        
        It then tests if the click is inside the matplotlib plot (if it is
        outside it equals to None) and if it is the current and editable plot
        (the one in the middle of the gui, self.m.ax)
        
        If is true, then it sets the coordinates to int. and creates a dialog
        window where the user is asked to type a value to set it to the cell.
        
        If the user presses ok, it tests if the entry is valid (>0 and not 
        empty) and looks for the old cell value and replaces it. And then
        it updates the plot such that the result of the change can be seen.
        """
        # the function is disconnected from the matplotlib event.
        self.m.mpl_disconnect(self.id)
        
        # test if the button is a left click and if the coordinates
        # chosen by the user click is inside of the current matplotlib plot
        # which is given by self.m.ax
        if (event.button == 1 
            and (event.xdata != None and event.ydata != None) 
            and self.m.ax == event.inaxes):
            newx = int(event.xdata)
            newy = int(event.ydata)
            
            # creates a dialog window
            dlg = cocv.CustomDialog(self)
            
            #if the user presses 'ok' in the dialog window it executes the code
            #else it does nothing
            if dlg.exec_():
                #it tests that the user has entered some value, that it is not
                #empty and that it is equal or bigger to 0.
                if dlg.entry1.text() != '' and int(dlg.entry1.text()) >= 0:
                    #reads the new value to set and converts it from str to int
                    value = int(dlg.entry1.text())
                    
                    # self.m.plotmask[newy, newx] the value selected by the user
                    # self.m.plotmask == self.m.plotmask[newy, newx]
                    # gives the coordinates where it is equal to the value
                    # selected by the user. And it replaces it with the new
                    # value.
                    self.m.plotmask[self.m.plotmask == self.m.plotmask[newy,newx]] = value
                    
                    # updates the plot to see the modification.
                    self.m.updatedata()
                    
        self.Enable(self.button_changecellvalue)
        self.button_changecellvalue.setChecked(False)
        self.m.ShowCellNumbers()
        
        
    def DialogBoxECV(self, s):
        """This functions creates from the ExchangeCellValues.py file a 
        window which takes two integer entries and then swaps the cells having
        the given integer values.
        """
        # creates a dialog window from the ExchangeCellValues.py file
        dlg = ecv.CustomDialog(self)
        
        # if the user presses 'ok', it executes the code
        if dlg.exec_():

            # it tests if both value to be swapped are not empty.
            if dlg.entry1.text()!= '' and dlg.entry2.text() != '':
                
                # reads out the values and converts it into integers.
                value1 = int(dlg.entry1.text())
                value2 = int(dlg.entry2.text())
                
                # calls the function which does the swap
                self.m.ExchangeCellValue(value1,value2)
                self.m.ShowCellNumbers()
                
        else:
            return


    def MouseDraw(self):
        """
        This function is called whenever the brush or the eraser button is
        pressed. On the first press event it calls the self.m.OneClick, which
        tests whether it is a right click or a left click. If it a right click
        it assigns the value of the pixel which has been right clicked
        to self.cellval, meaning that the next drawn pixels will be set to this
        value.
        If it is left clicked, then it draws a 3x3 square with the current
        value of self.cellval.
        If after left clicking you drag the mouse, then you start drawing 
        using the mouse and it stops once you release the left click.
        
        Same for the eraser button, it sets directly the value of self.cellval
        to 0.
        """
        if self.button_drawmouse.isChecked():
            self.WriteStatusBar(('Draw using the brush, right click to select '
                                 'the cell to draw.'))
            self.Disable(self.button_drawmouse)
            
            self.m.tempmask = self.m.plotmask.copy()
            
            self.id2 = self.m.mpl_connect('button_press_event', self.m.OneClick)
            self.id = self.m.mpl_connect('motion_notify_event', self.m.PaintBrush)
            self.id3 = self.m.mpl_connect('button_release_event', self.m.ReleaseClick)

            pixmap = QtGui.QPixmap('./icons/brush2.png')
            cursor = QtGui.QCursor(pixmap, -1,-1)
            QApplication.setOverrideCursor(cursor)
        
        elif self.button_eraser.isChecked():
            self.WriteStatusBar('Erasing by setting the values to 0.')
            self.Disable(self.button_eraser)
            
            self.m.tempmask = self.m.plotmask.copy()
            
            self.m.cellval = 0
            self.id2 = self.m.mpl_connect('button_press_event', self.m.OneClick)
            self.id = self.m.mpl_connect('motion_notify_event', self.m.PaintBrush)
            self.id3 = self.m.mpl_connect('button_release_event', self.m.ReleaseClick)
            
            pixmap = QtGui.QPixmap('./icons/eraser.png')
            cursor = QtGui.QCursor(pixmap, -1, -1)
            QApplication.setOverrideCursor(cursor)
            
        else:
            self.m.mpl_disconnect(self.id3)
            self.m.mpl_disconnect(self.id2)
            self.m.mpl_disconnect(self.id)
            QApplication.restoreOverrideCursor()
            self.Enable(self.button_drawmouse)
            self.Enable(self.button_eraser)
            
            self.ClearStatusBar()
            
            
    def UpdateTitleSubplots(self):
        """This function updates the title of the plots according to the 
        current time index. So it called whenever a frame or a fov is changed.
        """
        if self.Tindex == 0:
            self.m.titlecurr.set_text('Time index {}'.format(self.Tindex))
            self.m.titleprev.set_text('No frame {}'.format(''))
            self.m.titlenext.set_text('Next time index {}'.format(self.Tindex+1))
            self.m.draw()
            
        elif self.Tindex == self.reader.sizet-1:
            self.m.titlecurr.set_text('Time index {}'.format(self.Tindex))
            self.m.titleprev.set_text('Previous time index {}'.format(self.Tindex-1))
            self.m.titlenext.set_text('No frame {}'.format(''))            
            self.m.draw()
            
        else:
            self.m.titlecurr.set_text('Time index {}'.format(self.Tindex))
            self.m.titleprev.set_text('Previous time index {}'.format(self.Tindex-1))
            self.m.titlenext.set_text('Next time index {}'.format(self.Tindex+1))
            self.m.draw()
        
        
    def ClickNewCell(self):
        """ 
        this method is called when the button New Cell is clicked. If the button
        state corresponds to True (if is activated) then it connects the mouse 
        clicks on the pyqt window to the canvas (so to the matplolib figure).
        The connection has an "id" which is given by the integer self.id
        After the connections is made, it calls the Disable function with argument 0
        which turns off the other button(s).
        
        If the button is clicked but it is deactivated then it disconnects the 
        connection between the canvas and the window (the user can not interact
        with the plot anymore). 
        Storemouseclicks is a list corresponding to the coordinates of all mouse
        clicks between the activation and the deactivation of the button.
        So if it is empty, it does not draw anything because no clicks
        were registered. 
        But if it has some coordinates, it will draw a polygon where the vertices
        are the coordinates of all the mouseclicks.
        Once the figure has been updated with a new polygon, the other button(s)
        are again enabled. 
        
        """
        if self.button_newcell.isChecked():
            self.WriteStatusBar(('Draw a new cell. Use the left click to '
                                 'produce a polygon with a new cell value. '
                                 'Click the button again to confirm.'))
            self.m.tempmask = self.m.plotmask.copy()
            self.id = self.m.mpl_connect('button_press_event', self.m.MouseClick)
            self.Disable(self.button_newcell)
            
        else:
            self.m.mpl_disconnect(self.id)
            if  self.m.storemouseclicks and self.TestSelectedPoints():
                self.m.DrawRegion(True)
            else:
                self.m.updatedata()
            self.Enable(self.button_newcell)
            self.m.ShowCellNumbers()
            self.ClearStatusBar()
            
            
    def TestSelectedPoints(self):
        """This function is just used to catch an exception, when the new cell
        or the add region function is called. If all the dots drawn by the user
        are located on one line (horizontal or vertical) the DrawRegion 
        function calls a method to create a polygon and 
        it can not make a polygon out of straight line so it gives an error.
        In order to prevent this error, this function avoids to attempt to draw
        by returning False if the square are all on one line.
        """
                
        allx = list(np.array(self.m.storemouseclicks)[:,0])
        ally = list(np.array(self.m.storemouseclicks)[:,1])
        
        resultx = all(elem == allx[0] for elem in allx)
        resulty = all(elem == ally[0] for elem in ally)
        
        if resultx or resulty:
            return False
        else:
            return True
                    
        
    def clickmethod(self):
        """ 
        this method is called when the button Add region is clicked. If the button
        state corresponds to True (if is activated) then it connects the mouse 
        clicks on the pyqt window to the canvas (so to the matplolib figure).
        The connection has an "id" which is given by the integer self.id
        After the connections is made, it calls the Disable function with argument 1
        which turns off the other button(s).
        
        If the button is clicked and it is deactivated then it disconnects the 
        connection between the canvas and the window (the user can not interact
        with the plot anymore). 
        Storemouseclicks is a list corresponding to the coordinates of all mouse
        clicks between the activation and the deactivation of the button.
        So if it is empty, it does not draw anything because no clicks
        were registered. 
        But if it has some coordinates, it will draw a polygon where the vertices
        are the coordinates of all the mouseclicks.
        Once the figure has been updated with a new polygon, the other button(s)
        are again enabled. 
        
        """
        if self.button_add_region.isChecked():
            self.WriteStatusBar(('Select the cell with the first click, '
                                 'then draw polygon with subsequent '
                                 'clicks. Reclick the button to confirm.'))
            self.m.tempmask = self.m.plotmask.copy()
            self.id = self.m.mpl_connect('button_press_event', self.m.MouseClick)           
            self.Disable(self.button_add_region) 
            
        else:
            self.m.mpl_disconnect(self.id)
            
            # test if the list is not empty and if the dots are not all in the same line
            if self.m.storemouseclicks and self.TestSelectedPoints():
                self.m.DrawRegion(False)

            else:
                self.m.updatedata()
                
            self.Enable(self.button_add_region)
            self.m.ShowCellNumbers()
            self.ClearStatusBar()
            
            
# -----------------------------------------------------------------------------
# BUTTON ENABLE / DISABLE
    
    def Enable(self, button):
         """
         this functions turns on buttons all the buttons, depending on the time
         index. (next and previous buttons should not be turned on if t = 0 
         or t = lasttimeindex)
         """
         if self.button_segment.isChecked():
             self.EnableCorrectionsButtons()
             self.button_home.setEnabled(True)
             self.button_zoom.setEnabled(True)
             self.button_pan.setEnabled(True)
             self.button_back.setEnabled(True)
             self.button_forward.setEnabled(True)
         else:
             for k in range(0, len(self.buttonlist)):
                 if button != self.buttonlist[k]:
                     self.buttonlist[k].setEnabled(True)
                 
         if self.Tindex == 0:
             self.button_previousframe.setEnabled(False)
             
         if self.Tindex == self.reader.sizet-1:
             self.button_nextframe.setEnabled(False)
             
         self.EnableCNNButtons()
         
     
    def Disable(self, button):
         """
         this functions turns off all the buttons except the one given in 
         argument.
         """
         flag = False
         if (button == self.button_add_region 
             or button == self.button_newcell 
             or button == self.button_exval 
             or button == self.button_changecellvalue 
             or button == self.button_drawmouse 
             or button == self.button_eraser):
             if self.button_segment.isChecked():
                 flag = True

         for k in range(0,len(self.buttonlist)):
             if button != self.buttonlist[k]:
                 self.buttonlist[k].setEnabled(False)
         if flag:
             self.button_segment.setEnabled(True)
        
         if button == self.button_segment or button == self.button_threshold:
             self.button_home.setEnabled(True)
             self.button_zoom.setEnabled(True)
             self.button_pan.setEnabled(True)
             self.button_back.setEnabled(True)
             self.button_forward.setEnabled(True)


    def EnableCNNButtons(self):
        if self.reader.TestPredExisting(self.Tindex, self.FOVindex):
            self.button_threshold.setEnabled(True)
            self.button_segment.setEnabled(True)
            self.button_cellcorespondance.setEnabled(True)
            self.button_extractfluorescence.setEnabled(True)
        else:
            self.button_threshold.setEnabled(False)
            self.button_segment.setEnabled(False)
            self.button_cellcorespondance.setEnabled(False)
            self.button_extractfluorescence.setEnabled(False)
    
    
    def EnableCorrectionsButtons(self):
        self.button_newcell.setEnabled(True)
        self.button_add_region.setEnabled(True)
        self.button_drawmouse.setEnabled(True)
        self.button_eraser.setEnabled(True)
        self.button_exval.setEnabled(True)
        self.button_changecellvalue.setEnabled(True)
        self.button_showval.setEnabled(True)
        
        
    def DisableCorrectionsButtons(self):
        self.button_newcell.setEnabled(False)
        self.button_add_region.setEnabled(False)
        self.button_drawmouse.setEnabled(False)
        self.button_eraser.setEnabled(False)
        self.button_exval.setEnabled(False)
        self.button_changecellvalue.setEnabled(False)
        self.button_showval.setEnabled(False)

    
    def ButtonSaveMask(self):
        """
        When this function is called, it saves the current mask
        (self.m.plotmask)
        """
        self.reader.SaveMask(self.Tindex, self.FOVindex, self.m.plotmask)
        
        
    def WriteStatusBar(self, text):
        """Writes text to status bar"""
        self.statusBarText.setText(text)
        
        
    def ClearStatusBar(self):
        """Removes text from status bar"""
        self.statusBarText.setText('')


if __name__ == '__main__':
    app = QApplication(sys.argv)
    
    # If two arguments are given, make them nd2name and hdfname
    if len(sys.argv)==3:
        nd2name1 = sys.argv[1]
        hdfname1 = sys.argv[2]
        ex = App(nd2name1, hdfname1, '')
        sys.exit(app.exec_())
    
    # Launch file browser otherwise
    else:
        wind = dfb.FileBrowser()
        if wind.exec_():
            nd2name1 = wind.nd2name
            hdfname1 = wind.hdfname
            hdfnewname = wind.newhdfentry.text()
            ex = App(nd2name1, hdfname1, hdfnewname)
            sys.exit(app.exec_())
        else:
            app.exit()