GUI_main.py

        """
        
        # it reads out the text in the button and converts it to an int.
        newtimeindex = int(self.button_timeindex.text())
        if newtimeindex >= 0 and newtimeindex <= self.reader.sizet-1:
            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.statusBar.showMessage('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.statusBar.clearMessage()
        
        
    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.statusBar.showMessage('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.statusBar.clearMessage()
        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.statusBar.showMessage('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.statusBar.clearMessage()
        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.statusBar.showMessage(
            '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.statusBar.clearMessage()
        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.statusBar.showMessage('Drawing using the brush, right click to set a value...')
            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.statusBar.showMessage('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.statusBar.clearMessage()
            
            
    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.statusBar.showMessage('Draw a new cell...')
            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.statusBar.clearMessage()
            
            
    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.statusBar.showMessage('Adding a region to an existing cell...')
            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.statusBar.clearMessage()
            
            
# -----------------------------------------------------------------------------
# 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)
        

class PlotCanvas(FigureCanvas):
    def __init__(self, parent=None):
        """this class defines the canvas. It initializes a figure, which is then
        used to plot our data using imshow.
        """
        # define three subplots corresponding to the previous, current and next
        # time index.
        fig, (self.ax2, self.ax, self.ax3) = plt.subplots(1,3, sharex = True, sharey = True)
        
        # self.ax2.axis('tight')
        # self.ax.axis('tight')
        # self.ax3.axis('tight')
        
        # plt.gca().xaxis.set_major_locator(plt.NullLocator())
        # plt.gca().yaxis.set_major_locator(plt.NullLocator())
        fig.subplots_adjust(bottom=0, top=1, left=0, right=1, wspace = 0.05, hspace = 0.05)
        FigureCanvas.__init__(self, fig)
        self.setParent(parent)
        
        # this is some mambo jambo.
        FigureCanvas.setSizePolicy(self,
                QSizePolicy.Expanding,
                QSizePolicy.Expanding)
        FigureCanvas.updateGeometry(self)
        
        # the self.currpicture attribute takes the original data and will then 
        # contain the updates drawn by the user.
        
        self.currpicture = parent.currentframe
        self.prevpicture = parent.previousframe
        self.nextpicture = parent.nextframe
        self.plotmask = parent.mask_curr
        self.prevplotmask = parent.mask_previous
        self.nextplotmask = parent.mask_next
        self.tempmask = self.plotmask.copy()
        self.tempplotmask = self.plotmask.copy()
        
        self.ThresholdMask = np.zeros([parent.reader.sizey, parent.reader.sizex], dtype = np.uint16)
        self.SegmentedMask = np.zeros([parent.reader.sizey, parent.reader.sizex], dtype = np.uint16)
        
        # this line is just here to not attribute a zero value to the plot
        # because if so, then it does not update the plot and it stays blank.
        # (it is unclear why..if someone finds a better solution)
        self.prevpicture = self.currpicture.copy()
        
        self.currplot, self.currmask = self.plot(self.currpicture, self.plotmask, self.ax)
        
        self.previousplot, self.previousmask = self.plot(self.prevpicture, self.prevplotmask, self.ax2)
        self.prevpicture = np.zeros([parent.reader.sizey, parent.reader.sizex], dtype = np.uint16)
        self.prevplotmask = np.zeros([parent.reader.sizey, parent.reader.sizex], dtype =np.uint16)
        
        self.nextplot, self.nextmask = self.plot(self.nextpicture, self.nextplotmask, self.ax3)
        
        self.previousplot.set_data(self.prevpicture)
        self.previousmask.set_data((self.prevplotmask%10+1)*(self.prevplotmask != 0))

        self.ax2.draw_artist(self.previousplot)
        self.ax2.draw_artist(self.previousmask)
        self.update()
        self.flush_events()
        
        self.titlecurr = self.ax.set_title('Time index {}'.format(parent.Tindex))
        self.titleprev = self.ax2.set_title('No frame {}'.format(''))
        self.titlenext = self.ax3.set_title('Next time index {}'.format(parent.Tindex+1))
        
        # these variables are just set to test the states of the buttons
        # (button turned on or  off, etc..) of the buttons in the methods 
        # used in this class.
        self.button_showval_check = parent.button_showval
        self.button_newcell_check = parent.button_newcell
        self.button_add_region_check = parent.button_add_region
        self.button_drawmouse_check = parent.button_drawmouse
        self.button_eraser_check = parent.button_eraser
        self.button_hidemask_check = parent.button_hidemask
        
        # It will plot for the first time and return the imshow function
        self.currmask.set_clim(0, 10)
        self.previousmask.set_clim(0,10)
        self.nextmask.set_clim(0,10)
        
        # This attribute is a list which stores all the clicks of the mouse.
        self.storemouseclicks = []
        
        # This attribute is used to store the square where the mouse has been
        # in order than to draw lines (Paintbrush function)
        self.storebrushclicks = [[False,False]]
        
        # self.cellval is the variable which sets the value to the pixel
        # whenever something is drawn.
        self.cellval = 0
        
        # These are the codes used to create a polygon in the new cell/addregion
        # functions, which should be fed into the Path function
        self.codes_drawoneline = [Path.MOVETO, Path.LINETO]
        
        # These are lists storing all the annotations which are used to
        # show the values of the cells on the plots.
        self.ann_list = []
        self.ann_list_prev = []
        self.ann_list_next = []

        
    def ExchangeCellValue(self, val1, val2):
        """Swaps the values of the cell between two clusters each representing
        one cell. This method is called after the user has entered 
        values in the ExchangeCellValues window.
        """
        if (val1 in self.plotmask) and (val2 in self.plotmask):
            indices = np.where(self.plotmask == val1)
            self.plotmask[self.plotmask == val2] = val1
            for i in range(0,len(indices[0])):
                self.plotmask[indices[0][i], indices[1][i]] = val2
            self.updatedata()
        
        else:
            return
        
        
    def ReleaseClick(self, event):
        """This method is called from the brush button when the mouse is 
        released such that the last coordinate saved when something is drawn
        is set to zero. Because otherwise, if the user starts drawing somewhere
        else, than a straight line is draw between the last point of the
        previous mouse drawing/dragging and the new one which then starts.
        """
        if self.ax == event.inaxes:
            self.storebrushclicks[0] = [False, False]
            self.ShowCellNumbers()
        
        
    def OneClick(self, event):
        """This method is called when the Brush button is activated. And
        sets the value of self.cellval if the click is a right click, or draws
        a square if the click is a left click. (so if the user does just left
        click but does not drag, there will be only a square which is drawn )
        """
        if (event.button == 3 
            and (event.xdata != None and event.ydata != None) 
            and (not self.button_eraser_check.isChecked()) 
            and self.ax == event.inaxes):
            tempx = int(event.xdata)
            tempy = int(event.ydata)
            self.cellval = self.plotmask[tempy, tempx]
            self.storebrushclicks[0] = [False, False]
            
        elif (event.button == 1 and 
              (event.xdata != None and event.ydata != None) 
              and self.ax == event.inaxes):
            tempx = int(event.xdata)
            tempy = int(event.ydata)
            self.plotmask[tempy:tempy+3, tempx:tempx+3] = self.cellval
            self.storebrushclicks[0] = [tempx,tempy]
            self.updatedata()
            
        else:
            return
            
    
    def PaintBrush(self, event):
        """PantBrush is the method to paint using a "brush" and it is based
        on the mouse event in matplotlib "motion notify event". However it can 
        not record every pixel that the mouse has hovered over (it is too fast).
        So, in order to not only draw points (happens when the mouse is dragged
        too quickly), these points are interpolated here with lines.
        """
        if (event.button == 1 
            and (event.xdata != None and event.ydata != None) 
            and self.ax == event.inaxes):
            newx = int(event.xdata)
            newy = int(event.ydata)
            # when a new cell value is set, there is no point to interpolate, to
            # draw a line between the points. 
            if self.storebrushclicks[0][0] == False :
                self.plotmask[newy:newy+3,newx:newx+3] = self.cellval
                self.storebrushclicks[0] = [newx,newy]
                
            else:
                oldx = self.storebrushclicks[0][0]
                oldy = self.storebrushclicks[0][1]
                
                if newx != oldx:
                    slope = (oldy-newy)/(oldx-newx)
                    offset = (newy*oldx-newx*oldy)/(oldx-newx)
                    
                    if newx > oldx:
                        for xtemp in range(oldx+1, newx+1):
                            ytemp = int(slope*xtemp + offset)
                            self.plotmask[ytemp:ytemp + 3, xtemp:xtemp+3] = self.cellval
                            
                    else:
                        for xtemp in range(oldx-1,newx-1,-1):
                            ytemp = int(slope*xtemp + offset)
                            self.plotmask[ytemp:ytemp+3, xtemp:xtemp+3] = self.cellval
                            
                else:
                    if newy > oldy:
                        for ytemp in range(oldy+1,newy+1):
                            self.plotmask[ytemp:ytemp+3, newx:newx+3] = self.cellval
                            
                    else:
                        for ytemp in range(oldy-1,newy-1,-1):
                            self.plotmask[ytemp:ytemp+3, newx:newx+3] = self.cellval

            self.storebrushclicks[0][0] = newx
            self.storebrushclicks[0][1] = newy
            self.updatedata()
            
            
    def MouseClick(self,event):
        """This function is called whenever, the add region or the new cell
        buttons are active and the user clicks on the plot. For each 
        click on the plot, it records the coordinate of the click and stores
        it. When the user deactivate the new cell or add region button, 
        all the coordinates are given to the DrawRegion function (if they 
        do not all lie on the same line) and out of the coordinates, it makes
        a polygon. And then draws inside of this polygon by setting the pixels
        to the self.cellval value.
        """
        # button == 1 corresponds to the left click. 
        if (event.button == 1 
            and (event.xdata != None and event.ydata != None) 
            and self.ax == event.inaxes):
            
            # extract the coordinate of the click inside of the matplotlib figure
            # and then takes the integer part
            newx = int(event.xdata)
            newy = int(event.ydata)
            
            # stores the coordinates of the click
            self.storemouseclicks.append([newx, newy])
            
            # draws in the figure a small square (4x4 pixels) to
            # visualize where the user has clicked
            self.updateplot(newx, newy)
                

    def DefineColormap(self, Ncolors):
       """Define a new colormap by assigning 10 values of the jet colormap
        such that there are only colors for the values 0-10 and the values >10
        will be treated with a modulo operation (updatedata function)
       """
       jet = cm.get_cmap('jet', Ncolors)
       colors = []
       for i in range(0,Ncolors):
           if i==0 : 
               # set background transparency to 0
               temp = list(jet(i))
               temp[3]= 0.0
               colors.append(tuple(temp))
               
           else:
               colors.append(jet(i))
               
       colormap = ListedColormap(colors)
       return colormap
           
    
    def plot(self, picture, mask, ax):
       """this function is called for the first time when all the subplots
       are drawn.
       """
       # Define a new colormap with 20 colors.
       newcmp = self.DefineColormap(21)
       ax.axis("off")

       self.draw()
       return (ax.imshow(picture, interpolation= 'None', 
                         origin = 'upper', cmap = 'gray_r'), 
               ax.imshow((mask%10+1)*(mask != 0), origin = 'upper', 
                         interpolation = 'None', alpha = 0.2, cmap = newcmp))
   
    
    def UpdatePlots(self):
        """
        Updates plots, handles mask and cell numbers.
        """
        
        # Plot images
        self.currplot.set_data(self.currpicture)
        self.currplot.set_clim(np.amin(self.currpicture), np.amax(self.currpicture))
        self.ax.draw_artist(self.currplot)
        
        self.previousplot.set_data(self.prevpicture)
        self.previousplot.set_clim(np.amin(self.prevpicture), np.amax(self.prevpicture))
        self.ax2.draw_artist(self.previousplot)
            
        self.nextplot.set_data(self.nextpicture)
        self.nextplot.set_clim(np.amin(self.nextpicture), np.amax(self.nextpicture))
        self.ax3.draw_artist(self.nextplot)
        
        # Plot masks
        if not self.button_hidemask_check.isChecked():
            self.currmask.set_data((self.plotmask%10+1)*(self.plotmask!=0))
            self.ax.draw_artist(self.currmask)
        
            self.previousmask.set_data((self.prevplotmask%10+1)*(self.prevplotmask != 0))
            self.ax2.draw_artist(self.previousmask)