diff --git a/DialogDataBrowser.py b/DialogDataBrowser.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe6c8fe6b6d1a70ed2a950205ab55459eb6f14e5
--- /dev/null
+++ b/DialogDataBrowser.py
@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Nov 19 17:38:58 2019
+"""
+
+from PyQt5.QtWidgets import QApplication, QMainWindow, QMenu, QVBoxLayout, QSizePolicy, QMessageBox, QWidget, QPushButton, QShortcut, QComboBox, QDialog, QDialogButtonBox, QInputDialog, QLineEdit, QFormLayout, QFileDialog, QLabel
+from PyQt5 import QtGui
+#from PyQt5.QtGui import QIcon, QKeySequence
+from PyQt5.QtCore import pyqtSignal, QObject, Qt
+#import PyQt package, allows for GUI interactions
+
+class FileBrowser(QDialog):
+
+ def __init__(self, *args, **kwargs):
+ super(FileBrowser, self).__init__(*args, **kwargs)
+
+ self.setWindowTitle("Data file")
+ self.setGeometry(100,100, 800,200)
+
+
+ self.button_openxls = QPushButton('Open excel file')
+ self.button_openxls.setEnabled(True)
+ self.button_openxls.clicked.connect(self.getxlspath)
+ self.button_openxls.setToolTip("Browse for an xls file")
+ self.button_openxls.setMaximumWidth(150)
+
+
+
+ self.newxlsentry = QLineEdit()
+
+ self.xlsname = ''
+#
+ flo = QFormLayout()
+# flo.addRow('Enter Cell value 1 (integer):', self.entry1)
+
+
+ QBtn = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
+
+ self.buttonBox = QDialogButtonBox(QBtn)
+ self.buttonBox.accepted.connect(self.accept)
+ self.buttonBox.rejected.connect(self.reject)
+
+
+ self.labelxls = QLabel()
+ self.labelxls.setText('No xls file selected')
+
+ flo.addRow(self.labelxls, self.button_openxls)
+
+# flo.addWidget(self.button_openhdf)
+ flo.addRow('If no xls data file already exists, give a name to create a new file', self.newxlsentry)
+
+ flo.addWidget(self.buttonBox)
+
+ self.setLayout(flo)
+
+
+
+
+ def getxlspath(self):
+ self.xlsname,_ = QFileDialog.getOpenFileName(self, 'Open .xls File','', 'xls Files (*.xls)')
+# print(self.nd2name)
+# print(self.nd2name)
+ self.labelxls.setText(self.xlsname)
+
+
\ No newline at end of file
diff --git a/DialogFileBrowser.py b/DialogFileBrowser.py
new file mode 100644
index 0000000000000000000000000000000000000000..8be3a282898591356a90a5d3f48a91a28ca09336
--- /dev/null
+++ b/DialogFileBrowser.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Nov 19 17:38:58 2019
+"""
+
+from PyQt5.QtWidgets import QApplication, QMainWindow, QMenu, QVBoxLayout, QSizePolicy, QMessageBox, QWidget, QPushButton, QShortcut, QComboBox, QDialog, QDialogButtonBox, QInputDialog, QLineEdit, QFormLayout, QFileDialog, QLabel
+from PyQt5 import QtGui
+#from PyQt5.QtGui import QIcon, QKeySequence
+from PyQt5.QtCore import pyqtSignal, QObject, Qt
+#import PyQt package, allows for GUI interactions
+
+class FileBrowser(QDialog):
+
+ def __init__(self, *args, **kwargs):
+ super(FileBrowser, self).__init__(*args, **kwargs)
+
+ self.setWindowTitle("Open Files")
+ self.setGeometry(100,100, 800,200)
+
+
+ self.button_opennd2 = QPushButton('Open nd2 file')
+ self.button_opennd2.setEnabled(True)
+ self.button_opennd2.clicked.connect(self.getnd2path)
+ self.button_opennd2.setToolTip("Browse for an nd2 file")
+ self.button_opennd2.setMaximumWidth(150)
+
+ self.button_openhdf = QPushButton('Open hdf file')
+ self.button_openhdf.setEnabled(True)
+ self.button_openhdf.clicked.connect(self.gethdfpath)
+ self.button_openhdf.setToolTip("Browse for an hdf file containing the masks")
+ self.button_openhdf.setMaximumWidth(150)
+
+ self.newhdfentry = QLineEdit()
+# self.newhdfentry(Qt.AlignLeft)
+
+
+
+ self.nd2name = ''
+ self.hdfname = ''
+#
+ flo = QFormLayout()
+# flo.addRow('Enter Cell value 1 (integer):', self.entry1)
+
+
+ QBtn = QDialogButtonBox.Ok | QDialogButtonBox.Cancel
+
+ self.buttonBox = QDialogButtonBox(QBtn)
+ self.buttonBox.accepted.connect(self.accept)
+ self.buttonBox.rejected.connect(self.reject)
+
+
+ self.labelnd2 = QLabel()
+ self.labelnd2.setText('No nd2 file selected')
+
+ self.labelhdf = QLabel()
+ self.labelhdf.setText('No hdf file selected')
+ flo.addRow(self.labelnd2, self.button_opennd2)
+ flo.addRow(self.labelhdf, self.button_openhdf)
+# flo.addWidget(self.button_openhdf)
+ flo.addRow('If no hdf file already exists, give a name to create a new file', self.newhdfentry)
+
+ flo.addWidget(self.buttonBox)
+
+ self.setLayout(flo)
+
+
+
+
+ def getnd2path(self):
+ self.nd2name,_ = QFileDialog.getOpenFileName(self, 'Open .nd2 File','', 'nd2 Files (*.nd2)')
+# print(self.nd2name)
+# print(self.nd2name)
+ self.labelnd2.setText(self.nd2name)
+
+ def gethdfpath(self):
+ self.hdfname,_ = QFileDialog.getOpenFileName(self,'Open .hdf File','', 'hdf Files (*.h5)')
+ self.labelhdf.setText(self.hdfname)
+
\ No newline at end of file
diff --git a/GUI_main.py b/GUI_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..3765ac322e566c412fb72dd1fa25aa36876ae9d0
--- /dev/null
+++ b/GUI_main.py
@@ -0,0 +1,2601 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+This script is the main script used to produce a GUI which should help for
+cell segmentation. This script can only read .nd2 files containing the
+images of cells, especially it displays for each recorded positions (field
+of view) the pictures in the time axis.
+
+The script opens first a window which allows you to load an nd2 file and
+to load or create an hdf file. The hdf file contains all the masks, so if
+it is the first the user segments an nd2 file, a new one should be created.
+And it can be then loaded for later use. Along with new hdf file, created
+by the name entered by the user (say filename), it creates three other hdf
+files (filename_predicted.h5, filename_thresholded.h5 and
+filename_segmented.h5) these contain all the steps of the NN to get to the
+segmented picture.
+
+After the first window is finished a second one opens, where at each time
+index, three pictures
+are displayed the t-1 picture, the t picture (current frame which can be
+edited) and the t+1 picture. Using the arrows one can navigate through time.
+On top of the picture, there is always a mask which is displayed, if no cells
+are present in the mask then the mask is blank and the user does not see it.
+If one wants to hand anmotate the pictures, one can just start to draw on the
+picture using the different functions (New Cell, Add Region, Brush, Eraser,
+Save Mask,...) and the informations will be saved in the mask overlayed on
+top of the pictures.
+
+If one wants to segment using a neural network, one can press the
+corresponding button (Launch CNN) and select the time range and
+the field of views on which the neural network is applied.
+
+Once the neural network has finished predicting, there are still no visible
+masks, but on the field of views and time indices where the NN has been
+applied, the threshold and segment buttons are enabled. By checking these
+two buttons one can either display the thresholded image of the prediction or
+display the segmentation of the thresholded prediction.
+
+At this stage, one can correct the segmentation of the prediction using
+the functions (New Cell, Add Region, etc..) by selecting the Segment
+checkbox and then save them using the Save Seg button.
+If the user is happy with the segmentation, the Cell Correspondance button
+can be clicked. Until then, the cells get random numbers attributed by
+the segmentation algorithm. In order to keep track of the cell through time,
+the same cells should have the same number between two different time pictures.
+This can be (with some errors) achieved by the Cell Correspondance button,
+which tries to attribute the same number to corresponding cells in time.
+After that, the final mask is saved and it is always visible when you go on
+the corresponding picture. This mask can also be corrected using the
+usual buttons (because the Cell Correspondance makes also mistakes).
+
+"""
+
+import sys
+#append all the paths where the modules are stored. Such that this script
+#looks into all of these folders when importing modules.
+sys.path.append("./unet")
+sys.path.append("./disk")
+sys.path.append("./icons")
+sys.path.append("./init")
+sys.path.append("./misc")
+import time
+import os
+import numpy as np
+
+
+# Import everything for the Graphical User Interface from the PyQt5 library.
+from PyQt5.QtWidgets import QApplication, QMainWindow, QMenu, QVBoxLayout, QSizePolicy, QMessageBox, QWidget, QPushButton, QShortcut, QComboBox, QCheckBox, QLineEdit, QMenu, QAction, QStatusBar
+from PyQt5 import QtGui
+from PyQt5.QtCore import pyqtSignal, QObject, Qt
+
+#Import from matplotlib to use it to display the pictures and masks.
+from matplotlib.backends.qt_compat import QtCore, QtWidgets, is_pyqt5
+from matplotlib.backends.backend_qt5agg import (FigureCanvasQTAgg as FigureCanvas, NavigationToolbar2QT as NavigationToolbar)
+from matplotlib.figure import Figure
+import matplotlib.pyplot as plt
+#import the colormaps function to create a customed colormap scale with 10
+#colors only
+from matplotlib import cm
+from matplotlib.colors import ListedColormap, LinearSegmentedColormap
+#import Path functions to handle the regions drawn by the user. ("add region
+#and new cell")
+from matplotlib.path import Path
+
+
+#Import all the other python files
+#this file handles the interaction with the disk, so loading/saving images
+#and masks and it also runs the neural network.
+import InteractionDisk_temp as nd
+#this file contains a dialog window that takes two integers as entry to swap
+#two cell values
+import ExchangeCellValues as ecv
+#this file contains a dialog window which is opened before the main program
+#and allows to load the nd2 and hdf files by browsing through the computer.
+import DialogFileBrowser as dfb
+#this file contains a window that opens to change the value of one cell. It
+#is opened as soon as the user presses with the left click on a specific cell.
+import ChangeOneCellValue as cocv
+#this file contains a dialog window to browse for the excel file where
+#all the extracted information on the fluoerscence is written. Or to create a
+#new excel file by typing a name in the text box. It is thought to have one
+#excel file per field of view.
+import DialogDataBrowser as ddb
+#this file contains a dialog window where a time range and the field of views
+#can be selected to then launch a prediction of the neural network on
+#a specific range of pictures.
+import LaunchBatchPrediction as lbp
+
+#this file initializes all the buttons present in the gui, sets the shortcuts
+#to these buttons and also connect the buttons to the function that are
+#triggered when the buttons are pressed.
+import InitButtons
+
+#this file contains the layout of the main window so it justs puts the buttons
+#and the pictures at the desired position in the main window.
+import InitLayout
+
+
+import random
+
+#import everything needed to write and read excel files.
+from openpyxl import load_workbook
+from openpyxl import Workbook
+
+
+
+
+class NavigationToolbar(NavigationToolbar):
+ """This is the standard matplotlib toolbar but only the buttons
+ that are of interest for this gui are loaded. These buttons allow
+ to zoom into the pictures/masks and to navigate in the zoomed picture.
+ A Home button can be used to set the view back to the original view.
+ """
+ toolitems = [t for t in NavigationToolbar.toolitems if
+ t[0] in ('Home', 'Pan', 'Zoom','Back', 'Forward')]
+
+class App(QMainWindow):
+ """This class creates the main window.
+
+ """
+
+ def __init__(self, nd2pathstr, hdfpathstr, newhdfstr):
+ super().__init__()
+# initializes the window
+
+
+# id is an integer that gives the id of the connection between the mouseclick method
+# and the activation of the button.
+
+# all these ids are integers which are used to set a connection between
+# the button and the function that this button calls.
+# There are three of them because it happens that one can trigger three
+# different functions with one button.
+ self.id = 0
+ self.id2 = 0
+ self.id3 = 0
+
+
+
+# it calls an object of the class Load Image from the InteractionDisk
+# file which is used to load images and masks from the nd2 file. To
+# initialize this object it needs the path of the nd2 file, of an
+# existing hdf file and the name of a new hdf file. If the user has no
+# hdf file yet the hdfpathstr will be empty and vice versa if the user
+# selects an already existing hdf file.
+# It takes all the strings given by the first window
+# (called before the main window opens) from the DialogFileBrowser.py
+# file. (see at the end of this code)
+
+ self.reader = nd.Reader(hdfpathstr, newhdfstr, nd2pathstr)
+
+
+# these variables are used to create/read/load the excel file used
+# to write the fluorescence values extracted. For each field of view,
+# the user will be asked each time to create a new xls file for the
+# field of view or to load an existing field of view (this is the role
+# of the boolean variable)
+ self.xlsfilename = ''
+ self.nd2path = nd2pathstr
+ self.FlagFluoExtraction = False
+
+
+
+
+# Set the indices for the time axis and the field of view index. These
+# indices represent everywhere the current picture (the one that can be
+# edited, i.e. the time t frame)
+ self.Tindex = 0
+ self.FOVindex = 0
+
+# loading the first images of the cells from the nd2 file
+ self.currentframe = self.reader.LoadOneImage(self.Tindex,self.FOVindex)
+ self.nextframe = self.reader.LoadOneImage(self.Tindex+1, self.FOVindex)
+ self.previousframe = np.zeros([self.reader.sizey, self.reader.sizex])
+
+
+
+# loading the first masks from the hdf5 file
+ self.mask_curr = self.reader.LoadMask(self.Tindex, self.FOVindex)
+ self.mask_previous = np.zeros([self.reader.sizey, self.reader.sizex])
+ self.mask_next = self.reader.LoadMask(self.Tindex+1, self.FOVindex)
+
+
+# creates a list of all the buttons, which will then be used in order
+# to disable all the other buttons at once when one button/function
+# is pressed/used in the gui.
+ self.buttonlist = []
+
+
+# setting buttons as attributes
+# the shortcuts for the buttons, the functions to which they are
+# connected to,... are all set up in the ButtonInit file which is called
+# in the self.initUI() method below.
+
+ self.button_newcell = QPushButton("New cell")
+ self.buttonlist.append(self.button_newcell)
+
+ self.button_add_region = QPushButton("Add region")
+ self.buttonlist.append(self.button_add_region)
+
+ self.button_savemask = QPushButton("Save Mask")
+ self.buttonlist.append(self.button_savemask)
+
+ self.button_drawmouse = QPushButton('Brush')
+ self.buttonlist.append(self.button_drawmouse)
+
+ self.button_eraser = QPushButton('Eraser')
+ self.buttonlist.append(self.button_eraser)
+
+ self.button_exval = QPushButton('Exchange Cell Values')
+ self.buttonlist.append(self.button_exval)
+
+ self.button_showval = QCheckBox('Show Cell Values')
+ self.buttonlist.append(self.button_showval)
+
+ self.button_hidemask = QCheckBox('Hide Mask')
+ self.buttonlist.append(self.button_hidemask)
+
+ self.button_nextframe = QPushButton("Next Time Frame")
+ self.buttonlist.append(self.button_nextframe)
+
+ self.button_previousframe = QPushButton("Previous Time Frame")
+ self.buttonlist.append(self.button_previousframe)
+
+ self.button_cnn = QPushButton('Launch CNN')
+ self.buttonlist.append(self.button_cnn)
+
+ self.button_threshold = QCheckBox('Threshold prediction')
+ self.buttonlist.append(self.button_threshold)
+
+ self.button_segment = QCheckBox('Segment')
+ self.buttonlist.append(self.button_segment)
+
+ self.button_cellcorespondance = QPushButton('Cell Correspondance')
+ self.buttonlist.append(self.button_cellcorespondance)
+
+ self.button_changecellvalue = QPushButton('Change cell value')
+ self.buttonlist.append(self.button_changecellvalue)
+
+ self.button_extractfluorescence = QPushButton('Extract Fluorescence')
+ self.buttonlist.append(self.button_extractfluorescence)
+
+
+ self.initUI()
+
+
+
+
+ def initUI(self):
+ """Initializing the widgets contained in the window.
+ Especially, it creates the widget to plot the
+ pictures/masks by creating an object of the PlotCanvas class self.m.
+ Every interaction with the masks or the pictures (loading new
+ frames/editing the frames/masks) occurs through this class.
+
+ This method initializes all the buttons with the InitButtons file.
+ It connects the buttons to the functions that they should trigger,
+ it sets the shortcuts to the buttons, a tool tip,
+ eventually a message on the status bar when the user hovers
+ over the button, etc..
+
+ This function also sets all the layout in the InitLayout file. It
+ takes and places the widgets (buttons, canvas, toolbar).
+
+ The function initializes a Menu Bar to have a menu which can be
+ improved later on.
+ It sets a toolbar of the matplotlib library and hides it. But it allows
+ to connect to the functions of this toolbar through "homemade"
+ QPushButtons instead of the ones provided by matplotlib.
+ Finally, it sets a StatusBar which displays some text to describe
+ the use of some buttons, or to show that the program is working on
+ something (running the neural network, loading frames, etc...)
+
+ After all this has been initialized, the program is ready to be used.
+
+ """
+ self._main = QtWidgets.QWidget()
+ self.setCentralWidget(self._main)
+
+# Here our canvas is created where using matplotlib,
+# one can plot data to display the pictures and masks.
+ self.m = PlotCanvas(self)
+
+# Initialize all the buttons that are needed and the functions that are
+# connected when the buttons are triggered.
+ InitButtons.Init(self)
+ InitLayout.Init(self)
+
+# MENU, TOOLBAR AND STATUS BAR
+# creates a menu just in case, some other functions can be added later
+# in this menu.
+ menubar = self.menuBar()
+ self.fileMenu = menubar.addMenu('File')
+ self.saveactionmenu = QAction('Save')
+ self.fileMenu.addAction(self.saveactionmenu)
+ self.saveactionmenu.triggered.connect(self.ButtonSaveMask)
+
+
+# hide the toolbar and instead of the original buttons of matplotlib,
+# QPushbuttons are used and are connected to the functions of the toolbar
+# it is than easier to interact with these buttons (for example to
+# to disable them and so on..)
+ self.Nvgtlbar = NavigationToolbar(self.m, self)
+ self.addToolBar(self.Nvgtlbar)
+ self.Nvgtlbar.hide()
+
+# creates a status bar, which displays (or should display) some text
+# whenever a function is used.
+ self.statusBar = QStatusBar()
+ self.setStatusBar(self.statusBar)
+
+ self.show()
+
+
+ def mousePressEvent(self, QMouseEvent):
+ """this function is implemented just to have the QLineButtons of the
+ change time index button, setthreshold button and the setsegmentation
+ button out of focus when the user clicks somewhere
+ on the gui. (to unfocus the buttons)
+ """
+ self.button_timeindex.clearFocus()
+ if self.button_SetThreshold.isEnabled():
+ self.button_SetThreshold.clearFocus()
+
+ if self.button_SetSegmentation.isEnabled():
+ self.button_SetSegmentation.clearFocus()
+
+
+
+# CONNECT the functions of the toolbar to our custom QPushbuttons.
+ def ZoomTlbar(self):
+ """The button_zoom is connected to the zoom function of the toolbar
+ already present in the matplotlib library.
+
+ Depending on the buttons that are active or checked, when the zoom
+ function is used, it does not disable all the buttons.
+
+ If the segment and threshold button are not checked or used
+ when the zoom button is clicked, it disables all the button
+ using self.Disable which disables everything except the button passed
+ in argument (in this case button_zoom).
+
+
+ If the zoom button is used while the segment button is checked,
+ it disables all the buttons (1st elif) except the segment button
+ but once it is finished (so the zoom button becomes unchecked)
+ then it enables only the editing buttons (as long as the segment
+ button is still checked) such as New Cell, Add Region, Eraser,
+ Brush,etc.. and the other toolbar buttons (3rd elif)
+
+
+ If the zoom button is clicked while the threshold button is checked,
+ it disables all the button except the threshold button (2nd elif).
+ Once the zoom button is unchecked, it enables the toolbar buttons
+ (4th elif)
+ In any other case, it just enables all the buttons again.
+
+
+ """
+ self.Nvgtlbar.zoom()
+
+ if self.button_zoom.isChecked() and not(self.button_segment.isChecked() or self.button_threshold.isChecked()):
+ self.Disable(self.button_zoom)
+
+ elif self.button_zoom.isChecked() and self.button_segment.isChecked():
+ self.Disable(self.button_zoom)
+ self.button_segment.setEnabled(True)
+
+ elif self.button_zoom.isChecked() and self.button_threshold.isChecked():
+ self.Disable(self.button_zoom)
+ self.button_threshold.setEnabled(True)
+
+ elif self.button_zoom.isChecked() == False and self.button_segment.isChecked():
+
+ self.button_pan.setEnabled(True)
+ self.button_home.setEnabled(True)
+ self.button_back.setEnabled(True)
+ self.button_forward.setEnabled(True)
+
+ self.EnableCorrectionsButtons()
+
+ elif self.button_zoom.isChecked() == False and self.button_threshold.isChecked():
+
+ self.button_pan.setEnabled(True)
+ self.button_home.setEnabled(True)
+ self.button_back.setEnabled(True)
+ self.button_forward.setEnabled(True)
+
+ else:
+ self.Enable(self.button_zoom)
+
+ def HomeTlbar(self):
+# connects the home button to the home function of the matplotlib
+# toolbar. It sets the view to the original view (no zoom)
+ self.Nvgtlbar.home()
+
+
+ def BackTlbar(self):
+# It calls the back function of the matplotlib toolbar which sets the
+# view to the previous one (if the user does several zooms/pans,
+# this button allows to go back in the "history of views")
+ self.Nvgtlbar.back()
+
+
+
+ def ForwardTlbar(self):
+# It calls the forward function of the matplotlib toolbar which sets the
+# view to the next one (if the user does several zooms/pans,
+# this button allows to go forward in the "history of views"
+
+ self.Nvgtlbar.forward()
+
+
+
+ def PanTlbar(self):
+ """The button_pan is connected to the pan function of the toolbar
+ already present in the matplotlib library.
+
+ Depending on the buttons that are active or checked, when the pan
+ function is used, it does not disable all the buttons.
+
+ If the segment and threshold button are not checked or used
+ when the pan button is clicked, it disables all the button
+ using self.Disable which disables everything except the button passed
+ in argument (in this case button_pan).
+
+
+ If the pan button is used while the segment button is checked,
+ it disables all the buttons (1st elif) except the segment button
+ but once it is finished (so the zoom button becomes unchecked)
+ then it enables only the editing buttons (as long as the segment
+ button is still checked) such as New Cell, Add Region, Eraser,
+ Brush,etc.. and the other toolbar buttons (3rd elif)
+
+
+ If the pan button is clicked while the threshold button is checked,
+ it disables all the button except the threshold button (2nd elif).
+ Once the pan button is unchecked, it enables the toolbar buttons
+ (4th elif)
+ In any other case, it just enables all the buttons again.
+ """
+
+ self.Nvgtlbar.pan()
+
+ if self.button_pan.isChecked() and not(self.button_segment.isChecked() or self.button_threshold.isChecked()):
+ self.Disable(self.button_pan)
+
+ elif self.button_pan.isChecked() and self.button_segment.isChecked():
+ self.Disable(self.button_pan)
+ self.button_segment.setEnabled(True)
+
+ elif self.button_pan.isChecked() and self.button_threshold.isChecked():
+ self.Disable(self.button_pan)
+ self.button_threshold.setEnabled(True)
+
+ elif not(self.button_pan.isChecked()) and self.button_segment.isChecked():
+
+ self.button_zoom.setEnabled(True)
+ self.button_home.setEnabled(True)
+ self.button_back.setEnabled(True)
+ self.button_forward.setEnabled(True)
+
+ self.EnableCorrectionsButtons()
+
+ elif not(self.button_pan.isChecked()) and self.button_threshold.isChecked():
+ self.button_zoom.setEnabled(True)
+ self.button_home.setEnabled(True)
+ self.button_back.setEnabled(True)
+ self.button_forward.setEnabled(True)
+
+
+ else:
+ self.Enable(self.button_pan)
+
+
+ def ButtonFluo(self):
+ """This function is called everytime the Extract Fluorescence button is
+ clicked (self.button_extractfluorescence).
+
+ self.FlagFluoExtraction is boolean which is True when the path to the
+ excel file has already been loaded into self.xlsfilename.
+ This pathname changes for each field of view as it is thought to have
+ one xls file per field of view.
+ So at the beginning and each time the user changes field of view,
+ self.FlagFluoExtraction is set to False.
+
+ When it is set to False, this function calls a dialog window where
+ the user is asked to load an already existing xls file for the current
+ field of view or to give a name to create a new xls file for
+ the current field of view. (self.Dialogxls)
+
+ If it set to true, it means that self.xlsfilename contains the path
+ to the xls file for the current field of view and it is directly given
+ to the function that writes the fluorescence into the xls file.
+ (self.ExtractFluo)
+ """
+
+ if self.FlagFluoExtraction:
+ self.ExtractFluo(self.xlsfilename)
+ else:
+ self.DialogXls()
+
+
+ def DialogXls(self):
+ """This function creates a dialog window which gives two options to the
+ user either to load an existing xls file or to give a new name in order
+ to create a new xls file.
+ """
+# creates the window
+ dwind = ddb.FileBrowser()
+
+# this test is True if the user presses ok in the dialog window, if the
+# user presses cancels it returns and nothing happens.
+
+ if dwind.exec_():
+
+# read the entry given by the file browser
+ xlsname = dwind.xlsname
+
+# reads the entry given by the new filename text field.
+ newxlsname = dwind.newxlsentry.text()
+
+# if the string containing the filepath to an existing xls file
+# is not empty then it calls directly the function to write the
+# data into this existing xls file and sets self.xlsfilename
+ if xlsname:
+
+ self.xlsfilename = xlsname
+ self.ExtractFluo(xlsname)
+
+# if xlsname is empty then it creates a new pathfilename and puts
+# the new created xls file into the folder where nd2 is located.
+# the string containing the nd2 namepath is split
+ else:
+ xlsname = ''
+ templist = self.nd2path.split('/')
+
+ for k in range(0, len(templist)-1):
+
+ xlsname = xlsname + templist[k] + '/'
+# this is the new path/filename
+ xlsname = xlsname + newxlsname + '.xlsx'
+ self.xlsfilename = xlsname
+
+# here as a new name has been given, it means that a new xls file
+# should be created, this is done with CreateXls
+ self.CreateXls(xlsname)
+# once there is an existing xls file, it writes in this file
+# using self.ExtractFluo.
+ self.ExtractFluo(xlsname)
+# this flag is set to true, for the current field of view each
+# time extract fluorescence is clicked it writes in the file located
+# at self.xlsfilename.
+ self.FlagFluoExtraction = True
+ else:
+
+ return
+
+
+ def CreateXls(self, xlsfilename):
+ """In case there is no xls file existing, here a new one is created
+ and prepared. For each channel a new sheet is created.
+ In the first row for each sheet, the time indices are written t = 0,
+ t = 1, etc... but only every third column. Because in the row below,
+ three values are extracted 'Total intensity', 'Area' and 'Variance'
+ at each time index. So three columns for each time index are needed,
+ for the three data points.
+ The first column is left empty (starting from third row) because
+ the cell numbers will be written in there.
+ """
+
+# creates a new xls file using xlwt library.
+ book = Workbook()
+ nbrchannels = self.reader.sizec
+
+ for i in range(0,nbrchannels):
+ sheetname = self.reader.channel_names[i]
+# creates a sheet with the name of the corresponding channel.
+ if i == 0:
+ sheet = book.active
+ sheet.title = sheetname
+ else:
+ sheet = book.create_sheet(sheetname)
+ sheet.cell(1,1, 'Cell Number / Time axis')
+ sheet.cell(2,1, 'labels')
+ timeaxissize = self.reader.sizet
+# start writing the time index at column 1, column 0 is reserved for
+# cell numbers.
+ timecolindex = 2
+
+ for t in range(1,timeaxissize+1):
+# in row 0 the time index is written
+ sheet.cell(1,timecolindex).value = 't = {}'.format(t-1)
+# in row 1, the label of the three data points are written
+ sheet.cell(2,timecolindex).value = 'Total Intensity'
+ sheet.cell(2,timecolindex+1).value = 'Total Area'
+ sheet.cell(2,timecolindex+2).value = 'Mean Intensity'
+ sheet.cell(2,timecolindex+3).value = 'Variance'
+# updates the index, where the next time index should be written
+ timecolindex = timecolindex + 4
+
+# saves the xls file.
+ book.save(xlsfilename)
+
+
+
+
+ def ExtractFluo(self, xlsfilename):
+ """This is the function that takes as argument the filepath to the xls
+ file and writes in the file.
+ It iterates over the different channels (or the sheets of the file,
+ each channel has one sheet.), and reads the image corresponding
+ to the time, field of view and channel index. It reads the already
+ existing file and makes a copy in which the data will be written in it.
+
+ The first step of calculating the data is to iterate through each
+ cell/segment of the mask (so each cell is a submatrix of one value
+ in the matrix of the mask).
+ For each of these value /cell, the area is extracted as being
+ the number of pixels corresponding to this cell/value.
+ (it is known from the microscope settings how to convert
+ the pixel in area).
+ The total intensity is just the value of the pixel and it is added over
+ all the pixels corresonding to the cell/value.
+ The mean is then calculated as being the total intensity divided by
+ the number of pixels (which here is equal to the area also).
+ With the mean it is then possible to calculate the variance of the
+ signal for one cell/value.
+
+ Then, it is checked if the value of the cell (cell number) already
+ exists in the first column, if it already exists it continues to
+ find the column corresponding to the time index where the values
+ should be written. It sets the flag to True such that it does not
+ write the cell as new one and adds it at the end of the column
+
+ If the value is not found in the cell number column (new cell or
+ first time writing in the file), the flag is False, thus it adds the
+ cell number at the end of the column.
+ It then saves the xls file.
+
+ """
+
+# disables all the buttons except the one passed in argument.
+ self.Disable(self.button_extractfluorescence)
+# shows a message on the status bar to show that the program is working
+ self.statusBar.showMessage('Extracting the fluorescence...')
+
+# opens the file to read it.
+ book = load_workbook(self.xlsfilename)
+
+# makes a copy of the reading file to write in it the new values.
+# wb = xlscopy(readbook) # a writable copy (can't read values out of this, only write to it)
+
+# iterate over all the channels, so over all the sheets in the file
+ for channel in range(0, self.reader.sizec):
+# loads the picture corresponding to the channel, time index and fov
+ image = self.reader.LoadImageChannel(self.Tindex, self.FOVindex, channel)
+
+# loads the sheet to read out corresponding to the current channel
+ sheet = book.worksheets[channel]
+# sheet = readbook.sheet_by_index(channel)
+
+# this line is here to prevent some errors of streaming into
+# the file due to read file which is open (I am not sure about this
+# but it is a more or less working solution found on stackoverflow)
+# os.remove(xlsfilename)
+
+# load the sheet corresponding to the current channel to write in it
+# writingsheet = wb.get_sheet(channel)
+
+# this index contains the value of the maximum number of rows in the
+# file, it is used to append at the end the cell number column a new
+# cell/value, and it is updated each time a new cell is added.
+ tempidx = sheet.max_row
+
+# np.unique(array) returns an array which contains all the value
+# that appear in self.m.plotmask, so it returns every cell value
+# including the background (value 0) present in self.m.plotmask
+ for val in np.unique(self.m.plotmask):
+
+# exclude the background, as it is not a cell
+ if val != 0:
+
+# this (self.m.plotmask==val).sum() adds one at every pixel
+# where self.m.plotmask has the value val
+ area = (self.m.plotmask == val).sum()
+# it sums the value of the pixel in image at the coordinates
+# where self.m.plotmask equals val.
+ tot_intensity = image[self.m.plotmask == val].sum()
+
+# calculate the mean to use it in the calc. of the variance.
+ mean = tot_intensity/area
+
+# create a copy of plotmask because I had weird experiences
+# with np.where where it modified sometimes the given array
+# (not sure)
+ temparr = self.m.plotmask.copy()
+
+# extract the coordinates of the mask matrix where it equals
+# the current cell value val
+ coord = np.where(temparr == val)
+
+# variable to save the variance.
+ var = 0
+
+# we loop over the coord of the pixel where mask == val
+ for i in range(0,len(coord[0])):
+# extract the intensity at the coordinate
+ val_intensity = image[coord[0][i], coord[1][i]]
+# substract the value of the intensity with the mean,
+# and square it. It is then add to the var.
+ var = var + (val_intensity-mean)*(val_intensity-mean)
+
+# var is then divided by the number of the pixel
+# corresponding to this value (also equal to the area)
+# to get the variance.
+ var = var/area
+
+# if flag is false it means that the cell number
+# corresponding to val is not present in the xls file, first
+# column.
+ flag = False
+
+
+# iterate over all the rows
+ for row in range(sheet.max_row+1):
+
+# test if in the first column 0, the number of the cell
+# is already present
+# if sheet.cell_value(row,0) == str(val):
+ if sheet.cell(row = row+1, column = 1).value == str(val):
+
+# if is present, the column corresponding to the
+# current time index is by iterating over the cols.
+ for col in range(sheet.max_column+1):
+# test if it is the right column
+# if sheet.cell_value(0, col) == 't = {}'.format(self.Tindex):
+ if sheet.cell(row = 1, column = col+1).value == 't = {}'.format(self.Tindex):
+# write in the xls file at the row, col coord
+ sheet.cell(row+1, col+1, str(tot_intensity))
+ sheet.cell(row+1, col+2, str(area))
+ sheet.cell(row+1,col+3, str(mean))
+ sheet.cell(row+1, col+4, str(var))
+ book.save(xlsfilename)
+
+
+# the flag is set to True so that it does
+# not execute the code where the cell is
+# added in the xls file in a new row.
+ flag = True
+ if not flag:
+# this lines are executed if a new cell is detected or if
+# if it is the first time to write in the file.
+ for col in range(sheet.max_column+1):
+ if sheet.cell(row = 1, column = col+1).value == 't = {}'.format(self.Tindex):
+# it write the cell value/cell number in the
+# column
+ sheet.cell(tempidx+1,1, str(val))
+
+# writes the data extracted before
+ sheet.cell(tempidx+1,col+1,str(tot_intensity))
+ sheet.cell(tempidx+1, col+2, str(area))
+ sheet.cell(tempidx+1, col+3, str(mean))
+ sheet.cell(tempidx+1, col+4, str(var))
+# it updates the number of rows as a new cell
+# has been added, so there is one more row.
+ tempidx = tempidx + 1
+# save in the file
+ book.save(xlsfilename)
+
+
+# Enable again all the buttons
+ self.Enable(self.button_extractfluorescence)
+
+# clear the message shown in the status bar
+ self.statusBar.clearMessage()
+
+
+
+ def LaunchBatchPrediction(self):
+ """This function is called whenever the button Launch CNN is pressed.
+ It allows to run the neural network over a time range and selected
+ field of views.
+
+ It creates a dialog window with two entries, that define the time range
+ and a list where the user can select the desired fields of view.
+
+ Once it reads all the value, it calls the neural network function
+ inside of self.PredThreshSeg and it does the prediction of the neural
+ network, thresholds this prediction and then segments it.
+ """
+# creates a dialog window from the LaunchBatchPrediction.py file
+ dlg = lbp.CustomDialog(self)
+
+# this if tests if the user pressed 'ok' in the dialog window
+ if dlg.exec_():
+
+# it tests if the user has entered some values
+# if not it ignores and returns.
+ if dlg.entry1.text()!= '' and dlg.entry2.text() != '':
+
+# reads out the entry given by the user and converts the index
+# to integers
+ time_value1 = int(dlg.entry1.text())
+ time_value2 = int(dlg.entry2.text())
+
+
+# it tests if the first value is smaller or equal such that
+# time_value1 is the lower range of the time range
+# and time_value2 the upper boundary of the range.
+ if time_value1 <= time_value2 :
+
+# displays that the neural network is running
+ self.statusBar.showMessage('Running the neural network...')
+
+# it iterates in the list of the user-selected fields
+# of view, to return the corresponding index, the function
+# dlg.listfov.row(item) is used which gives an integer
+ for item in dlg.listfov.selectedItems():
+
+# iterates over the time indices in the range
+ for t in range(time_value1, time_value2+1):
+
+# calls the neural network for time t and selected
+# fov
+ if dlg.entry_threshold.text() != '':
+ thr_val = float(dlg.entry_threshold.text())
+ else:
+ thr_val = None
+ if dlg.entry_segmentation.text() != '':
+ seg_val = int(dlg.entry_segmentation.text())
+ else:
+ seg_val = 10
+
+ self.PredThreshSeg(t, dlg.listfov.row(item), thr_val, seg_val)
+
+
+# once it has iterated over all the fov, the message in
+# the status bar is cleared and the buttons are enabled.
+ self.statusBar.clearMessage()
+ self.EnableCNNButtons()
+
+ else:
+ return
+ else:
+ return
+ else:
+ return
+
+ def PredThreshSeg(self, timeindex, fovindex, thr_val, seg_val):
+ """
+ This function is called in the LaunchBatchPrediction function.
+ This function calls the neural network function in the
+ InteractionDisk.py file and then thresholds the result
+ of the prediction, saves this thresholded prediction.
+ Then it segments the thresholded prediction and saves the
+ segmentation.
+ """
+# launches the neural network
+ self.reader.LaunchPrediction(timeindex, fovindex)
+# thresholds the prediction
+ self.m.ThresholdMask = self.reader.ThresholdPred(thr_val, timeindex,fovindex)
+# saves the thresholded pred.
+ self.reader.SaveThresholdMask(timeindex, fovindex, self.m.ThresholdMask)
+# segments the thresholded pred.
+ self.m.SegmentedMask = self.reader.Segment(seg_val, timeindex,fovindex)
+# saves the segmentation
+ self.reader.SaveSegMask(timeindex, fovindex, self.m.SegmentedMask)
+
+
+ def LaunchPrediction(self):
+ """This function is not used in the gui, but it can be used to launch
+ the prediction of one picture, with no thresholding and no segmentation
+ """
+ if not(self.reader.TestPredExisting(self.Tindex, self.FOVindex)):
+ self.statusBar.showMessage('Running the neural network...')
+ self.Disable(self.button_cnn)
+ self.reader.LaunchPrediction(self.Tindex, self.FOVindex)
+
+ self.Enable(self.button_cnn)
+
+ self.button_cnn.setEnabled(False)
+ self.button_threshold.setEnabled(True)
+ self.button_segment.setEnabled(True)
+ self.button_cellcorespondance.setEnabled(True)
+ self.statusBar.clearMessage()
+
+ 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()
+
+# if the button to show cell values is checked, then it
+# replots the cell values
+
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+
+# enables the button again
+ self.Enable(self.button_changecellvalue)
+
+# clears the message in the status bar
+ self.statusBar.clearMessage()
+
+
+
+# the button is a checkable and it has to be unchecked else it seems
+# that the button is still in use, because it gets a blue color.
+ self.button_changecellvalue.setChecked(False)
+
+
+
+
+ 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)
+
+# if the button to display the values of the cell is checked,
+# the values are again displayed on the graph after the swap
+# of cells.
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+
+
+ else:
+ return
+
+
+
+ def SelectChannel(self, index):
+ """This function is called when the button to select different channels
+ is used. From the displayed list in the button, the chosen index
+ corresponnds to the same index in the list of channels from the reader.
+ So, it sets the default channel with the new index (called index below)
+ """
+
+# This function attributes the FOV chosen by the user corresponding to
+# the index in the list of options.
+ self.reader.default_channel = index
+# update the pictures using the same function as the one used to
+# change the fields of view.
+ self.ChangeFOV()
+
+
+
+
+ def SelectFov(self, index):
+ """This function is called when the button containing the list of
+ fields od view is used.
+ The index correspondds to the field of view selected in the list.
+
+ """
+
+# This function attributes the FOV chosen by the user corresponding to
+# the index in the list of options. First the mask is automatically
+# saved.
+ self.reader.SaveMask(self.Tindex, self.FOVindex, self.m.plotmask)
+# the new index is set.
+ self.FOVindex = index
+
+# it updates the fov in the plot with the new index.
+ self.ChangeFOV()
+
+# the flag of the fluorescence extraction is set to False (such that
+# if the user extracts fluorescence data in the new field of view,
+# there is a dialog box asking to select the corresponding xls file
+# for this field of view. IF there is no data sheet for this fov, the
+# user can enter a new name to make a new file.)
+ self.FlagFluoExtraction = False
+
+ def ChangeFOV(self):
+
+# it changes the fov or channel according to the choice of the user
+# and it updates the plot shown and it initializes the new fov/channel
+# at t=0 by default.
+
+# set the time index to 0
+ self.Tindex = 0
+
+# load the image and mask for the current plot
+ self.m.currpicture = self.reader.LoadOneImage(self.Tindex,self.FOVindex)
+ self.m.plotmask = self.reader.LoadMask(self.Tindex,self.FOVindex)
+
+# sets the image and the mask to 0 for the previous plot
+ 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)
+
+# load the image and the mask for the next plot.
+ self.m.nextpicture = self.reader.LoadOneImage(self.Tindex+1, self.FOVindex)
+ self.m.nextplotmask = self.reader.LoadMask(self.Tindex+1, self.FOVindex)
+
+
+# once the images and masks are loaded into the variables, they are
+# displaye in the gui.
+ self.m.UpdateBckgrndPicture()
+
+
+# enables the next frame button in case it was disabled when the
+# fov/channel was changed
+ self.button_nextframe.setEnabled(True)
+# disables the previous frame button in case it was active before
+# changing fov/channel.
+ self.button_previousframe.setEnabled(False)
+
+# updates the title of the plots to display the right time indices
+# aboves the plots.
+ self.UpdateTitleSubplots()
+
+# if the button to show cell values is active, it shows the values again.
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+
+# if the button to hide the mask was checked before changing fov/channel,
+# it hides the mask again.
+ if self.button_hidemask.isChecked():
+ self.m.HideMask()
+
+# the button to set the time index is also set to 0/default again.
+ self.button_timeindex.setText('')
+# enables the neural network buttons if there is already an
+# existing prediction for the current image.
+ self.EnableCNNButtons()
+
+ def ChangeTimeFrame(self):
+ """This funcion is called whenever the user gives an new time index,
+ to jump to the new given index, onces "enter" button is pressed.
+ """
+
+# 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.UpdateBckgrndPicture()
+ 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.UpdateBckgrndPicture()
+ 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.UpdateBckgrndPicture()
+
+ self.UpdateTitleSubplots()
+ self.button_timeindex.clearFocus()
+
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+
+ if self.button_hidemask.isChecked():
+ self.m.HideMask()
+ self.EnableCNNButtons()
+
+ else:
+ self.button_timeindex.clearFocus()
+ return
+
+# def keyPressEvent(self, event):
+## print('keypressevengda211111')
+## print(event.key())
+# if not self.button_nextframe.isChecked() and event.key() == Qt.Key_Right:
+# self.button_nextframe.setChecked(True)
+# self.ForwardTime()
+# self.button_nextframe.setChecked(False)
+# else:
+# print('inside keypressevent')
+# event.ignore()
+
+ 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):
+
+ 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()
+# self.m.SegmentedMask = self.reader.Segment(segparamvalue, self.Tindex, self.FOVindex)
+# update the plots to display the segmentation view
+
+ 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()
+
+
+# update the gra
+
+ 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):
+
+ 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()
+# self.m.ThresholdMask = self.reader.ThresholdPred(thresholdvalue, self.Tindex, self.FOVindex)
+# update the plots to display the thresholded view
+
+ def ButtonSaveThresholdMask(self):
+ """saves the thresholed mask
+ """
+# pass
+ 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.button_nextframe.disconnect()
+# self.button_nextframe.setShortcut('')
+
+# self.button_nextframe.setEnabled(False)
+# print(self.button_nextframe.isEnabled())
+# self.button_nextframe.setChecked(False)
+# self.Testbool = False
+ self.BackwardTime()
+# self.button_nextframe.setShortcut(Qt.Key_Right)
+# self.button_nextframe.pressed.connect(self.Test)
+# self.button_nextframe.setChecked(False)
+ if self.Tindex >0:
+ self.button_previousframe.setEnabled(True)
+# self.button_nextframe.pressed.connect(self.Test)
+
+# self.button_nextframe.setChecked(False)
+
+# self.Testbool = True
+ else:
+# print('jamais la dedans?')
+ 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.
+ """
+# self.button_nextframe.setShortcutEnabled(False)
+ if self.button_nextframe.isEnabled():
+ self.button_nextframe.setEnabled(False)
+
+# self.button_nextframe.disconnect()
+# self.button_nextframe.setShortcut('')
+
+# self.button_nextframe.setEnabled(False)
+# print(self.button_nextframe.isEnabled())
+# self.button_nextframe.setChecked(False)
+# self.Testbool = False
+ self.ForwardTime()
+# self.button_nextframe.setShortcut(Qt.Key_Right)
+# self.button_nextframe.pressed.connect(self.Test)
+# self.button_nextframe.setChecked(False)
+
+ self.button_nextframe.setEnabled(True)
+# self.button_nextframe.pressed.connect(self.Test)
+
+# self.button_nextframe.setChecked(False)
+
+# self.Testbool = True
+ else:
+ return
+# print('jamais la dedans?')
+# if QKeyEvent.key() == Qt.Key_Right:
+# QKeyEvent.ignore()
+
+
+ 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.
+ """
+# print(self.Tindex)
+# 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.button_nextframe.setEnabled(False)
+# self.button_nextframe.disconnect()
+ 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.UpdateBckgrndPicture()
+
+ 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.UpdateBckgrndPicture()
+
+ self.button_nextframe.setEnabled(False)
+
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+
+
+
+
+
+ self.Tindex = self.Tindex+1
+ self.UpdateTitleSubplots()
+
+ if self.button_hidemask.isChecked():
+ self.m.HideMask()
+
+ self.Enable(self.button_nextframe)
+
+# self.button_nextframe.setChecked(False)
+
+ self.statusBar.clearMessage()
+# if self.Tindex < self.reader.sizet - 1 :
+# self.button_nextframe.setEnabled(True)
+ self.button_timeindex.setText(str(self.Tindex))
+
+
+ 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.
+ """
+# print(self.Tindex)
+# 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.button_previousframe.setEnabled(False)
+# self.button_previousframe.disconnect()
+ self.Disable(self.button_previousframe)
+ if self.Tindex == 1:
+
+ 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()
+
+ 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.UpdateBckgrndPicture()
+
+
+ self.button_previousframe.setEnabled(False)
+
+
+
+ else:
+
+
+ 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()
+
+ self.m.prevpicture = self.reader.LoadOneImage(self.Tindex-2, self.FOVindex)
+ self.m.prevplotmask = self.reader.LoadMask(self.Tindex-2, self.FOVindex)
+
+ self.m.UpdateBckgrndPicture()
+ if self.Tindex-1 == self.reader.sizet-2:
+ self.button_nextframe.setEnabled(True)
+
+
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+
+
+
+
+# self.button_previousframe.clicked.connect(self.BackwardTime)
+
+ self.Tindex = self.Tindex-1
+ self.UpdateTitleSubplots()
+
+ if self.button_hidemask.isChecked():
+ self.m.HideMask()
+
+ self.Enable(self.button_previousframe)
+
+
+ if self.Tindex > 0:
+ self.button_previousframe.setEnabled(True)
+
+# self.button_previousframe.setChecked(False)
+ self.statusBar.clearMessage()
+ self.button_timeindex.setText(str(self.Tindex))
+
+ 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)
+
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+ 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.ax.set_title('Time index {}'.format(self.Tindex))
+# self.m.ax2.set_title('No frame {}'.format(''))
+# self.m.ax3.set_title('Next Time index {}'.format(self.Tindex+1))
+# self.m.update()
+# self.m.flush_events()
+ 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.ax.set_title('Time index {}'.format(self.Tindex))
+# self.m.ax2.set_title('Previous time index {}'.format(self.Tindex-1))
+# self.m.ax3.set_title('No frame {}'.format(''))
+# self.m.update()
+# self.m.flush_events()
+ 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.ax.set_title('Time index {}'.format(self.Tindex))
+# self.m.ax2.set_title('Previous time index {}'.format(self.Tindex-1))
+# self.m.ax3.set_title('Next Time index {}'.format(self.Tindex+1))
+# self.m.update()
+# self.m.flush_events()
+ 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)
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+ 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)
+
+ if self.button_showval.isChecked():
+ self.m.ShowCellNumbersCurr()
+ self.m.ShowCellNumbersNext()
+ self.m.ShowCellNumbersPrev()
+
+ self.statusBar.clearMessage()
+
+
+
+
+
+ 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_cnn.setEnabled(False)
+ self.button_threshold.setEnabled(True)
+ self.button_segment.setEnabled(True)
+ self.button_cellcorespondance.setEnabled(True)
+ self.button_extractfluorescence.setEnabled(True)
+ else:
+# self.button_cnn.setEnabled(True)
+ 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)
+
+ 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)
+
+# print('set visible')
+# self.ax2.set_visible(False)
+
+ 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
+# self.store_values = []
+
+# 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:
+# print('No cell values found corresponding to the entered value')
+ 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]
+
+ 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)
+
+# print(newx,newy)m
+# 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 UpdateBckgrndPicture(self):
+ """this function can be called to redraw all the pictures and the mask,
+ so it is called whenever a time index is entered by the user and
+ the corresponding pictures and masks are updated. And then they are
+ drawn here.
+ When the user changes time frame using the next or previous time frame
+ buttons, it is also this function which is called.
+ When the user changes the field of view, it is also
+ this function which finally draws all the plots.
+
+ """
+
+ self.currplot.set_data(self.currpicture)
+ self.currplot.set_clim(np.amin(self.currpicture), np.amax(self.currpicture))
+ self.currmask.set_data((self.plotmask%10+1)*(self.plotmask!=0))
+ self.ax.draw_artist(self.currplot)
+ self.ax.draw_artist(self.currmask)
+
+
+ self.previousplot.set_data(self.prevpicture)
+ self.previousplot.set_clim(np.amin(self.prevpicture), np.amax(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.nextplot.set_data(self.nextpicture)
+ self.nextplot.set_clim(np.amin(self.nextpicture), np.amax(self.nextpicture))
+ self.nextmask.set_data((self.nextplotmask % 10 +1 )*(self.nextplotmask != 0))
+ self.ax3.draw_artist(self.nextplot)
+ self.ax3.draw_artist(self.nextmask)
+
+
+ self.update()
+ self.flush_events()
+
+
+ def updatedata(self, flag = True):
+
+
+ """
+ In order to just display the cells so regions with value > 0
+ and also to assign to each of the cell values one color,
+ the modulo 10 of the value is take and we add 1, to distinguish
+ the values of 10,20,30,... from the background (although the bckgrnd
+ gets with the addition the value 1) and the result of the
+ modulo is multiplied with a matrix containing a False value for the
+ background coordinates, setting the background to 0 again.
+ """
+ if flag:
+ self.currmask.set_data((self.plotmask%10+1)*(self.plotmask!=0))
+ else :
+ self.currmask.set_data((self.tempmask%10+1)*(self.tempmask!=0))
+
+
+
+# show the updates by redrawing the array using draw_artist, it is faster
+# to use as it only redraws the array itself, and not everything else.
+
+ self.ax.draw_artist(self.currplot)
+ self.ax.draw_artist(self.currmask)
+# self.ax.text(500,500,'test')
+ self.update()
+ self.flush_events()
+#
+# if self.button_showval_check.isChecked():
+# self.ShowCellNumbersCurr()
+# self.ShowCellNumbersNext()
+# self.ShowCellNumbersPrev()
+
+ def Update3Plots(self):
+ """This function is just used to draw the update the masks on
+ the three subplots. It is only used by the Hidemask function.
+ To "show" the masks again when the button is unchecked.
+ """
+
+# self.currmask.set_data((self.plotmask%10+1)*(self.plotmask!=0))
+ self.ax.draw_artist(self.currplot)
+ self.ax.draw_artist(self.currmask)
+
+ self.ax2.draw_artist(self.previousplot)
+ self.ax2.draw_artist(self.previousmask)
+
+ self.ax3.draw_artist(self.nextplot)
+ self.ax3.draw_artist(self.nextmask)
+
+ self.update()
+ self.flush_events()
+
+ def HideMask(self):
+
+ if self.button_hidemask_check.isChecked():
+ self.ax.draw_artist(self.currplot)
+ self.ax2.draw_artist(self.previousplot)
+ self.ax3.draw_artist(self.nextplot)
+ self.update()
+ self.flush_events()
+
+ else:
+ self.Update3Plots()
+
+
+ def ShowCellNumbersCurr(self):
+ """This function is called to display the cell values and it
+ takes 10 random points inside of the cell, computes the mean of these
+ points and this gives the coordinate where the number will be
+ displayed. The number to be displayed is just given by the value
+ in the mask of the cell.
+ This function is just used for the current time subplot.
+ """
+
+
+ for i,a in enumerate(self.ann_list):
+ a.remove()
+ self.ann_list[:] = []
+
+
+ if self.button_showval_check.isChecked():
+
+ maxval = np.amax(self.plotmask)
+ minval = 1
+ xtemp = []
+ ytemp = []
+ val =[]
+ for k in range(minval,maxval + 1):
+ if k in self.plotmask:
+ indices = np.where(self.plotmask == k)
+ sampley = random.choices(list(indices[0]), k = 10)
+ samplex = random.choices(list(indices[1]), k = 10)
+ meanx = np.mean(samplex)
+ meany = np.mean(sampley)
+ xtemp.append(int(round(meanx)))
+ ytemp.append(int(round(meany)))
+ val.append(k)
+ if xtemp:
+ for i in range(0,len(xtemp)):
+ ann = self.ax.annotate(str(val[i]), (xtemp[i], ytemp[i]))
+ self.ann_list.append(ann)
+
+
+ self.draw()
+# val, ct = np.unique(self.plotmask, return_counts = True)
+# print(val)
+# print(ct)
+
+ else:
+
+ for i,a in enumerate(self.ann_list):
+ a.remove()
+ self.ann_list[:] = []
+
+# self.txt.remove()
+ self.updatedata()
+
+ def ShowCellNumbersPrev(self):
+ """This function is called to display the cell values and it
+ takes 10 random points inside of the cell, computes the mean of these
+ points and this gives the coordinate where the number will be
+ displayed. The number to be displayed is just given by the value
+ in the mask of the cell.
+ This function is just used for the previous time subplot.
+ """
+
+ for i,a in enumerate(self.ann_list_prev):
+ a.remove()
+ self.ann_list_prev[:] = []
+
+
+ if self.button_showval_check.isChecked():
+
+ maxval = np.amax(self.prevplotmask)
+ minval = 1
+ xtemp = []
+ ytemp = []
+ val = []
+
+ for k in range(minval,maxval + 1):
+ if k in self.prevplotmask:
+ indices = np.where(self.prevplotmask == k)
+ sampley = random.choices(list(indices[0]), k = 10)
+ samplex = random.choices(list(indices[1]), k = 10)
+ meanx = np.mean(samplex)
+ meany = np.mean(sampley)
+ xtemp.append(int(round(meanx)))
+ ytemp.append(int(round(meany)))
+ val.append(k)
+ if xtemp:
+ for i in range(0,len(xtemp)):
+ ann = self.ax2.annotate(str(val[i]), (xtemp[i], ytemp[i]))
+ self.ann_list_prev.append(ann)
+
+ self.draw()
+
+ else:
+
+ for i,a in enumerate(self.ann_list_prev):
+ a.remove()
+ self.ann_list_prev[:] = []
+
+
+ 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()
+
+
+ def ShowCellNumbersNext(self):
+
+ """This function is called to display the cell values and it
+ takes 10 random points inside of the cell, computes the mean of these
+ points and this gives the coordinate where the number will be
+ displayed. The number to be displayed is just given by the value
+ in the mask of the cell.
+ This function is just used for the next time subplot.
+ """
+
+ for i,a in enumerate(self.ann_list_next):
+ a.remove()
+ self.ann_list_next[:] = []
+
+
+
+
+ if self.button_showval_check.isChecked():
+
+ maxval = np.amax(self.nextplotmask)
+ minval = 1
+ xtemp = []
+ ytemp = []
+ val = []
+ for k in range(minval,maxval + 1):
+ if k in self.nextplotmask:
+ indices = np.where(self.nextplotmask == k)
+ sampley = random.choices(list(indices[0]), k = 10)
+ samplex = random.choices(list(indices[1]), k = 10)
+ meanx = np.mean(samplex)
+ meany = np.mean(sampley)
+ xtemp.append(int(round(meanx)))
+ ytemp.append(int(round(meany)))
+ val.append(k)
+ if xtemp:
+ for i in range(0,len(xtemp)):
+ ann = self.ax3.annotate(str(val[i]), (xtemp[i], ytemp[i]))
+ self.ann_list_next.append(ann)
+
+ self.draw()
+
+ else:
+
+ for i,a in enumerate(self.ann_list_next):
+ a.remove()
+ self.ann_list_next[:] = []
+
+
+ self.nextmask.set_data((self.nextplotmask%10+1)*(self.nextplotmask!=0))
+
+ self.ax3.draw_artist(self.nextplot)
+ self.ax3.draw_artist(self.nextmask)
+ self.update()
+ self.flush_events()
+
+
+
+ def updateplot(self, posx, posy):
+
+
+
+
+# it updates the plot once the user clicks on the plot and draws a 4x4 pixel dot
+# at the coordinate of the click
+# self.modulomask = self.plotmask.copy()
+ xtemp, ytemp = self.storemouseclicks[0]
+# remove the first coordinate as it should only coorespond
+# to the value that the user wants to attribute to the drawn region
+
+# here we initialize the value attributed to the pixels.
+# it means that the first click selects the value that will be attributed to
+# the pixels inside the polygon (drawn by the following mouse clicks of the user)
+
+ self.cellval = self.plotmask[ytemp, xtemp]
+
+
+
+
+# drawing the 2x2 square ot of the mouse click
+
+
+ if (self.button_newcell_check.isChecked() or self.button_drawmouse_check.isChecked()) and self.cellval == 0:
+ self.tempmask[posy:posy+2, posx:posx+2] = 9
+ else:
+ self.tempmask[posy:posy+2,posx:posx+2] = self.cellval
+
+# plot the mouseclick
+
+ self.updatedata(False)
+
+
+
+ def DrawRegion(self, flag):
+ """
+ this method is used to draw either a new cell (flag = true) or to add a region to
+ an existing cell (flag = false). The flag will just be used to set the
+ value of pixels (= self.cellval) in the drawn region.
+ If flag = true, then the value will be the maximal value plus 1. Such
+ that it attributes a new value to the new cell.
+ If flag = false, then it will use the value of the first click to set
+ the value of the pixels in the new added region.
+ """
+
+
+
+# here the values that have been changed to mark the mouse clicks are
+# restored such that they don't appear when the region/new cell is
+# drawn.
+
+
+
+ if flag:
+# if new cell is added, it sets the value of the drawn pixels to a new value
+# corresponding to the new cell
+ self.cellval = np.amax(self.plotmask) + 1
+ else:
+# The first value is taken out as it is just used to set the value
+# to the new region.
+# self.store_values.pop(0)
+ self.storemouseclicks.pop(0)
+
+
+ if len(self.storemouseclicks) <= 2:
+# if only two points or less have been click, it cannot make a area
+# so it justs discards these values and returns.
+ self.storemouseclicks = list(self.storemouseclicks)
+
+ self.storemouseclicks.clear()
+
+ self.updatedata(True)
+# self.store_values.clear()
+ return
+
+ else:
+# add the first point because to use the path function, one has to close
+# the path by returning to the initial point.
+ self.storemouseclicks.append(self.storemouseclicks[0])
+
+# codes are requested by the path function in order to make a polygon
+# out of the points that have been selected.
+
+ codes = np.zeros(len(self.storemouseclicks))
+ codes[0] = Path.MOVETO
+ codes[len(codes)-1]= Path.CLOSEPOLY
+ codes[1:len(codes)-1] = Path.LINETO
+ codes = list(codes)
+
+# out of the coordinates of the mouse clicks and of the code, it makes
+# a path/contour which corresponds to the added region/new cell.
+ path = Path(self.storemouseclicks, codes)
+
+
+
+ self.storemouseclicks = np.array(self.storemouseclicks)
+
+# Take a square around the drawn region, where the drawn region fits inside.
+ minx = min(self.storemouseclicks[:,0])
+ maxx = max(self.storemouseclicks[:,0])
+
+ miny = min(self.storemouseclicks[:,1])
+ maxy= max(self.storemouseclicks[:,1])
+
+# creates arrays of coordinates of the whole square surrounding
+# the drawn region
+ array_x = np.arange(minx, maxx, 1)
+ array_y = np.arange(miny, maxy, 1)
+#
+ array_coord = []
+# takes all the coordinates to couple them and store them in array_coord
+ for xi in range(0,len(array_x)):
+ for yi in range(0,len(array_y)):
+
+ array_coord.append((array_x[xi], array_y[yi]))
+
+# path_contains_points returns an array of bool values
+# where for each coordinates it tests if it is inside the path
+
+ pix_inside_path = path.contains_points(array_coord)
+
+# for each coordinate where the contains_points method returned true
+# the value of the self.currpicture matrix is changed, it draws the region
+# defined by the user
+
+ for j in range(0,len(pix_inside_path)):
+ if pix_inside_path[j]:
+ x,y = array_coord[j]
+ self.plotmask[y,x]= self.cellval
+
+
+# once the self.currpicture has been updated it is drawn by callinf the
+# updatedata method.
+
+ self.updatedata()
+
+
+ self.storemouseclicks = list(self.storemouseclicks)
+
+# empty the lists ready for the next region to be drawn.
+ self.storemouseclicks.clear()
+# self.store_values.clear()
+
+
+
+if __name__ == '__main__':
+ app = QApplication(sys.argv)
+ 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()
diff --git a/InteractionDisk_temp.py b/InteractionDisk_temp.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5c41a6ffae7111aae841926b0a27cf05d270788
--- /dev/null
+++ b/InteractionDisk_temp.py
@@ -0,0 +1,468 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Oct 15 15:00:29 2019
+
+This program reads out the images from the nd2 file and creates or
+reads the hdf file containing the segmentation.
+"""
+from nd2reader import ND2Reader
+#import matplotlib.pyplot as plt
+import numpy as np
+
+import h5py
+import os.path
+import skimage.io
+#import segment as seg
+import neural_network as nn
+
+
+
+import matplotlib.pyplot as plt
+import CellCorrespondance as cc
+import matplotlib.pyplot as plt
+
+
+class Reader:
+
+ def __init__(self, hdfpathname, newhdfname, nd2pathname):
+
+
+# Initializes the data corresponding to the sizes of the pictures,
+# the number of different fields of views(Npos) taken in the experiment.
+# And it also sets the number of time frames per field of view.
+ self.nd2path = nd2pathname
+ self.hdfpath = hdfpathname
+ self.newhdfname = newhdfname
+
+ with ND2Reader(self.nd2path) as images:
+ self.sizex = images.sizes['x']
+ self.sizey = images.sizes['y']
+ self.sizec = images.sizes['c']
+ self.sizet = images.sizes['t']
+ self.Npos = images.sizes['v']
+ self.channel_names = images.metadata['channels']
+
+ #create the labels which index the masks with respect to time and
+ #fov indices in the hdf5 file
+ self.fovlabels = []
+ self.tlabels = []
+ self.InitLabels()
+
+ self.default_channel = 0
+
+ self.name = self.hdfpath
+
+ self.predictname = ''
+ self.thresholdname = ''
+ self.segmentname = ''
+
+# self.channelwindow = chch.CustomDialog(self)
+#
+# if self.channelwindow.exec_():
+#
+# self.default_channel = self.channelwindow.button_channel.currentIndex()
+
+
+
+
+
+
+# create an new hfd5 file if no one existing already
+ self.Inithdf()
+
+
+
+
+ def InitLabels(self):
+ """Create two lists containing all the possible fields of view and time
+ labels, in order to access the arrays in the hdf5 file.
+ """
+
+ for i in range(0, self.Npos):
+ self.fovlabels.append('FOV' + str(i))
+
+ for j in range(0, self.sizet):
+ self.tlabels.append('T'+ str(j))
+
+
+
+ def Inithdf(self):
+ """If the file already exists then it is loaded else
+ a new hdf5 file is created and for every fields of view
+ a new group is created in the createhdf method
+ """
+
+ if not self.hdfpath:
+ return self.Createhdf()
+ else:
+#
+ temp = self.hdfpath[:-3]
+
+ self.thresholdname = temp + '_thresholded' + '.h5'
+ self.segmentname = temp + '_segmented' + '.h5'
+ self.predictname = temp + '_predicted' + '.h5'
+
+#
+
+ def Createhdf(self):
+
+ """In this method, for each field of view one group is created. And
+ in each one of these group, there will be for each time frame a
+ corresponding dataset equivalent to a 2d array containing the
+ corresponding masks data (segmented/thresholded/predicted).
+ """
+# print('createhdf')
+
+ self.hdfpath = ''
+ templist = self.nd2path.split('/')
+ for k in range(0, len(templist)-1):
+ self.hdfpath = self.hdfpath+templist[k]+'/'
+
+ self.hdfpath = self.hdfpath + self.newhdfname + '.h5'
+
+ hf = h5py.File(self.hdfpath, 'w')
+
+ for i in range(0, self.Npos):
+
+ grpname = self.fovlabels[i]
+ hf.create_group(grpname)
+
+ hf.close()
+
+
+
+
+ for k in range(0, len(templist)-1):
+ self.thresholdname = self.thresholdname+templist[k]+'/'
+ self.thresholdname = self.thresholdname + self.newhdfname + '_thresholded' + '.h5'
+
+ hf = h5py.File(self.thresholdname,'w')
+
+ for i in range(0, self.Npos):
+
+ grpname = self.fovlabels[i]
+ hf.create_group(grpname)
+
+ hf.close()
+
+ for k in range(0, len(templist)-1):
+ self.segmentname = self.segmentname+templist[k]+'/'
+ self.segmentname = self.segmentname + self.newhdfname + '_segmented' + '.h5'
+
+ hf = h5py.File(self.segmentname,'w')
+
+ for i in range(0, self.Npos):
+
+ grpname = self.fovlabels[i]
+ hf.create_group(grpname)
+
+ hf.close()
+
+ for k in range(0, len(templist)-1):
+ self.predictname = self.predictname+templist[k]+'/'
+ self.predictname = self.predictname + self.newhdfname + '_predicted' + '.h5'
+
+ hf = h5py.File(self.predictname,'w')
+
+ for i in range(0, self.Npos):
+
+ grpname = self.fovlabels[i]
+ hf.create_group(grpname)
+
+ hf.close()
+
+ def LoadMask(self, currentT, currentFOV):
+ """this method is called when one mask should be loaded from the file
+ on the disk to the user's buffer. If there is no mask corresponding
+ in the file, it creates the mask corresponding to the given time and
+ field of view index and returns an array filled with zeros.
+ """
+
+ file = h5py.File(self.hdfpath,'r+')
+ if self.TestTimeExist(currentT,currentFOV,file):
+ mask = np.array(file['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])], dtype = np.uint16)
+ file.close()
+
+
+ return mask
+
+
+ else:
+
+# change with Matthias code!
+
+ zeroarray = np.zeros([self.sizey, self.sizex],dtype = np.uint16)
+ file.create_dataset('/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT]), data = zeroarray, compression = 'gzip')
+ file.close()
+ return zeroarray
+
+
+ def TestTimeExist(self,currentT, currentFOV, file):
+ """This method tests if the array which is requested by LoadMask
+ already exists or not in the hdf file.
+ """
+
+ for t in file['/{}'.format(self.fovlabels[currentFOV])].keys():
+
+ if t == self.tlabels[currentT]:
+
+
+ return True
+
+ return False
+
+
+
+ def SaveMask(self, currentT, currentFOV, mask):
+ """This function is called when the user wants to save the mask in the
+ hdf5 file on the disk. It overwrites the existing array with the new
+ one given in argument.
+ If it is a new mask, there should already
+ be an existing null array which has been created by the LoadMask method
+ when the new array has been loaded/created in the main before calling
+ this save method.
+ """
+
+ file = h5py.File(self.hdfpath, 'r+')
+
+ if self.TestTimeExist(currentT,currentFOV,file):
+ dataset= file['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])]
+ dataset[:] = mask
+ file.close()
+
+ else:
+
+ file.create_dataset('/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT]), data = mask, compression = 'gzip')
+ file.close()
+
+
+ def SaveThresholdMask(self, currentT, currentFOV, mask):
+ """This function is called when the user wants to save the mask in the
+ hdf5 file on the disk. It overwrites the existing array with the new
+ one given in argument.
+ If it is a new mask, there should already
+ be an existing null array which has been created by the LoadMask method
+ when the new array has been loaded/created in the main before calling
+ this save method.
+ """
+
+ file = h5py.File(self.thresholdname, 'r+')
+
+ if self.TestTimeExist(currentT,currentFOV,file):
+ dataset = file['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])]
+ dataset[:] = mask
+ file.close()
+ else:
+ file.create_dataset('/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT]), data = mask, compression = 'gzip')
+ file.close()
+
+ def SaveSegMask(self, currentT, currentFOV, mask):
+ """This function is called when the user wants to save the mask in the
+ hdf5 file on the disk. It overwrites the existing array with the new
+ one given in argument.
+ If it is a new mask, there should already
+ be an existing null array which has been created by the LoadMask method
+ when the new array has been loaded/created in the main before calling
+ this save method.
+ """
+
+ file = h5py.File(self.segmentname, 'r+')
+
+ if self.TestTimeExist(currentT,currentFOV,file):
+
+ dataset = file['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])]
+ dataset[:] = mask
+ file.close()
+ else:
+ file.create_dataset('/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT]), data = mask, compression = 'gzip')
+ file.close()
+
+
+
+ def TestIndexRange(self,currentT, currentfov):
+ """this method receives the time and the fov index and checks
+ if it is present in the images data.
+ """
+
+ if currentT < (self.sizet-1) and currentfov < self.Npos:
+ return True
+ if currentT == self.sizet - 1 and currentfov < self.Npos:
+ return False
+#
+ def LoadOneImage(self,currentT, currentfov):
+ """This method returns from the nd2 file, the picture requested by the
+ main program as an array. It fixes the fov index and iterates over the
+ time index.
+ """
+
+ with ND2Reader(self.nd2path) as images:
+ images.default_coords['v'] = currentfov
+ images.default_coords['c'] = self.default_channel
+ images.iter_axes = 't'
+
+ if currentT < self.sizet and currentfov < self.Npos:
+ im = images[currentT]
+ return np.array(im, dtype = np.uint16)
+ else:
+ return None
+
+ def LoadSeg(self, currentT, currentFOV):
+
+
+ file = h5py.File(self.segmentname, 'r+')
+
+ if self.TestTimeExist(currentT,currentFOV,file):
+ mask = np.array(file['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])], dtype = np.uint16)
+ file.close()
+
+ return mask
+
+
+ else:
+
+ zeroarray = np.zeros([self.sizey, self.sizex],dtype = np.uint16)
+ file.create_dataset('/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT]), data = zeroarray, compression = 'gzip', compression_opts = 7)
+
+ file.close()
+ return zeroarray
+
+
+
+ def LoadThreshold(self, currentT, currentFOV):
+
+
+ file = h5py.File(self.thresholdname, 'r+')
+
+ if self.TestTimeExist(currentT,currentFOV,file):
+
+ mask = np.array(file['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])], dtype = np.uint16)
+ file.close()
+
+ return mask
+
+
+ else:
+
+ zeroarray = np.zeros([self.sizey, self.sizex],dtype = np.uint16)
+ file.create_dataset('/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT]), data = zeroarray, compression = 'gzip', compression_opts = 7)
+
+ file.close()
+ return zeroarray
+
+ def Segment(self, segparamvalue, currentT, currentFOV):
+ print(segparamvalue)
+
+# Check if thresholded version exists
+ filethr = h5py.File(self.thresholdname, 'r+')
+
+ if self.TestTimeExist(currentT, currentFOV, filethr):
+
+ tmpthrmask = np.array(filethr['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])])
+
+ segmentedmask = nn.segment(tmpthrmask, segparamvalue)
+ filethr.close()
+
+ return segmentedmask
+
+
+ else:
+
+ filethr.close()
+ return np.zeros([self.sizey,self.sizex], dtype = np.uint16)
+
+
+ def ThresholdPred(self, thvalue, currentT, currentFOV):
+ print(thvalue)
+
+ fileprediction = h5py.File(self.predictname,'r+')
+ if self.TestTimeExist(currentT, currentFOV, fileprediction):
+
+ pred = np.array(fileprediction['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])])
+ fileprediction.close()
+ if thvalue == None:
+ thresholdedmask = nn.threshold(pred)
+ else:
+ thresholdedmask = nn.threshold(pred,thvalue)
+
+ return thresholdedmask
+ else:
+ fileprediction.close()
+ return np.zeros([self.sizey, self.sizex], dtype = np.uint16)
+
+# def LaunchPrediction(self, currentT, currentFOV):
+
+
+ def TestPredExisting(self, currentT, currentFOV):
+
+ file = h5py.File(self.predictname, 'r+')
+ if self.TestTimeExist(currentT, currentFOV, file):
+ file.close()
+ return True
+ else:
+ file.close()
+ return False
+
+
+
+
+
+ def LaunchPrediction(self, currentT, currentFOV):
+
+ """It launches the neural neutwork on the current image and creates
+ an hdf file with the prediction for the time T and corresponding FOV.
+ """
+
+ file = h5py.File(self.predictname, 'r+')
+
+ with ND2Reader(self.nd2path) as images:
+ images.default_coords['v'] = currentFOV
+ images.default_coords['c'] = self.default_channel
+ images.iter_axes = 't'
+ temp = images[currentT]
+ #temp = np.array(temp, dtype = np.uint16)
+ temp = np.array(temp)
+ pred = nn.prediction(temp)
+ file.create_dataset('/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT]), data = pred, compression = 'gzip', compression_opts = 7)
+
+ file.close()
+
+
+
+
+ def CellCorrespondance(self, currentT, currentFOV):
+ print('in cell Correspondance')
+ filemasks = h5py.File(self.hdfpath, 'r+')
+ fileseg = h5py.File(self.segmentname,'r+')
+ if self.TestTimeExist(currentT-1, currentFOV, filemasks):
+
+ if self.TestTimeExist(currentT, currentFOV, fileseg):
+ print('inside cellcorerspoindacefunction')
+ prevmask = np.array(filemasks['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT-1])])
+ nextmask = np.array(fileseg['/{}/{}'.format(self.fovlabels[currentFOV], self.tlabels[currentT])])
+ newmask, notifymask = cc.CellCorrespondancePlusTheReturn(nextmask, prevmask)
+ filemasks.close()
+ fileseg.close()
+ return newmask, notifymask
+
+ else:
+ filemasks.close()
+ fileseg.close()
+ null = np.zeros([self.sizey, self.sizex])
+
+ return null, null
+ else:
+
+ filemasks.close()
+ fileseg.close()
+ null = np.zeros([self.sizey, self.sizex])
+ return null, null
+
+ def LoadImageChannel(self,currentT, currentFOV, ch):
+
+ with ND2Reader(self.nd2path) as images:
+ images.default_coords['v'] = currentFOV
+ images.default_coords['t'] = currentT
+ images.iter_axes = 'c'
+ im = images[ch]
+ return np.array(im)