diff --git a/GUI_main.py b/GUI_main.py
index a3ee0b37d33ebaaf7b17a92322a747ff2a75b6c6..8f56d0a78a2e7da25fb7a425d203384b8c0784d5 100644
--- a/GUI_main.py
+++ b/GUI_main.py
@@ -50,15 +50,18 @@ the corresponding picture. This mask can also be corrected using the
usual buttons (because the Cell Correspondance makes also mistakes).
"""
+import os
import sys
import numpy as np
+import pandas as pd
+import h5py
# For writing excel files
-from openpyxl import load_workbook
-from openpyxl import Workbook
+#from openpyxl import load_workbook
+#from openpyxl import Workbook
# Import everything for the Graphical User Interface from the PyQt5 library.
-from PyQt5.QtWidgets import (QApplication, QMainWindow, QDialog,
+from PyQt5.QtWidgets import (QApplication, QMainWindow, QDialog, QFileDialog,
QMessageBox, QPushButton, QCheckBox, QAction, QStatusBar, QLabel)
from PyQt5 import QtGui
@@ -66,6 +69,9 @@ from PyQt5 import QtGui
from matplotlib.backends.qt_compat import QtWidgets
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
+from sklearn.decomposition import PCA
+import imageio
+
#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")
@@ -91,12 +97,6 @@ import DialogFileBrowser as dfb
#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.
@@ -113,6 +113,9 @@ import InitLayout
# PlotCanvas for fast plotting
from PlotCanvas import PlotCanvas
+
+import Extract as extr
+from image_loader import load_image
class NavigationToolbar(NavigationToolbar):
@@ -149,7 +152,6 @@ class App(QMainWindow):
# 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
@@ -234,7 +236,7 @@ class App(QMainWindow):
self.button_changecellvalue = QPushButton('Change cell value')
self.buttonlist.append(self.button_changecellvalue)
- self.button_extractfluorescence = QPushButton('Extract Fluorescence')
+ self.button_extractfluorescence = QPushButton('Extract')
self.buttonlist.append(self.button_extractfluorescence)
self.button_hide_show = QPushButton('CNN')
@@ -468,133 +470,70 @@ class App(QMainWindow):
else:
self.Enable(self.button_pan)
-
-# -----------------------------------------------------------------------------
-# EXTRACTING FLUORESCENCE
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_():
- xlsname = dwind.xlsname
- 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
-
- self.CreateXls(xlsname)
- 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
+ self.Disable(self.button_extractfluorescence)
+ self.WriteStatusBar('Extracting ...')
+
+ # Get last image with mask
+ for time_index in range(self.reader.sizet, 0, -1):
+ # Test if time has a mask
+ file = h5py.File(self.reader.hdfpath, 'r+')
+ time_exist = self.reader.TestTimeExist(time_index, self.FOVindex, file)
+ file.close()
+
+ if not time_exist:
+ continue
+
+ # load picture and sheet
+ image = self.reader.LoadImageChannel(time_index, self.FOVindex,
+ self.reader.default_channel)
+ mask = self.reader.LoadMask(time_index, self.FOVindex)
+
+ # Break if mask is non-empty
+ if mask.sum()>0:
+ break
+
+ # Launch dialog with last image
+ dlg = extr.Extract(image, mask, self.reader.channel_names)
+ dlg.exec()
+ if dlg.exit_code == 1: # Fluorescence
+ self.ExtractFluo(dlg.cells, dlg.outfile, dlg.file_list)
+ elif dlg.exit_code == 2: # Mask
+ self.ExtractMask(dlg.cells, dlg.outfile)
- else:
- return
+ self.Enable(self.button_extractfluorescence)
+ self.ClearStatusBar()
- 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.
- """
-
- book = Workbook()
- nbrchannels = self.reader.sizec
+ def ExtractMask(self, cell_list, outfile):
+ """Extract the mask to the specified tiff file. Only take cells
+ specified by the cell_list"""
- 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):
- sheet.cell(1,timecolindex).value = 't = {}'.format(t-1)
- 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
-
- try:
- book.save(xlsfilename)
- except TypeError:
- QMessageBox.critical(self, "Error", "TypeError encountered. \
- Make sure you have openpyxl version 3.0.1 \
- installed. If the problem persists contact \
- the developers.")
-
-
- def ExtractFluo(self, xlsfilename):
+ mask_list = []
+ for time_index in range(0, self.reader.sizet):
+
+ # Test if time has a mask
+ file = h5py.File(self.reader.hdfpath, 'r+')
+ time_exist = self.reader.TestTimeExist(time_index, self.FOVindex, file)
+ file.close()
+
+ if not time_exist:
+ continue
+
+ mask = self.reader.LoadMask(time_index, self.FOVindex)
+ all_cells = np.unique(mask)
+ for cell in set(all_cells)-set(cell_list):
+ mask[mask==cell] = 0
+ mask_list.append(mask)
+
+ imageio.mimwrite(outfile, np.array(mask_list, dtype=np.uint16))
+
+
+ def ExtractFluo(self, cells_to_use, csv_filename, channel_list):
"""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,
@@ -626,96 +565,99 @@ class App(QMainWindow):
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.
- """
- self.Disable(self.button_extractfluorescence)
- self.WriteStatusBar('Extracting the fluorescence...')
- # opens the file to read it.
- book = load_workbook(self.xlsfilename)
-
+ """
+ # List of cell properties
+ cell_list = []
- # 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)
+ for time_index in range(0, self.reader.sizet):
+ # Test if time has a mask
+ file = h5py.File(self.reader.hdfpath, 'r+')
+ time_exist = self.reader.TestTimeExist(time_index, self.FOVindex, file)
+ file.close()
- # loads the sheet to read out corresponding to the current channel
- sheet = book.worksheets[channel]
+ if not time_exist:
+ continue
+ mask = self.reader.LoadMask(time_index, self.FOVindex)
- # 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):
-
- # Skip background
- if val == 0:
- continue
-
- # Calculate stats
- area = (self.m.plotmask == val).sum()
- tot_intensity = image[self.m.plotmask == val].sum()
- mean = tot_intensity/area
- var = np.var(image[self.m.plotmask==val])
-
- # if flag is false it means that the cell number
- # corresponding to val is not present in the xls file, first
- # column.
- flag = False
+ for channel in channel_list:
+ # check if channel is in list of nd2 channels
+ try:
+ channel_ix = self.reader.channel_names.index(channel)
+ image = self.reader.LoadImageChannel(time_index, self.FOVindex, channel_ix)
- # 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
- book.save(xlsfilename)
-
+ # channel is a file
+ except ValueError:
+ image = load_image(channel, ix=time_index)
+
+ for val in np.unique(mask):
+ # bg is not cell
+ if val == 0:
+ continue
+ # disregard cells not in cell_list
+ if not (val in cells_to_use):
+ continue
+
+ # Calculate stats
+ stats = self.cell_statistics(image, mask == val)
+ stats['Time'] = time_index
+ stats['Channel'] = channel
+ stats['Cell'] = val
+ cell_list.append(stats)
+
+ # Use Pandas to write csv
+ df = pd.DataFrame(cell_list)
+ df.to_csv(csv_filename, index=False)
+
self.Enable(self.button_extractfluorescence)
self.ClearStatusBar()
+ def cell_statistics(self, image, mask):
+ """Calculate statistics about cells. Passing None to image will
+ create dictionary to zeros, which allows to extract dictionary keys"""
+ if image is not None:
+ cell_vals = image[mask]
+ area = mask.sum()
+ tot_intensity = cell_vals.sum()
+ mean = tot_intensity/area if area > 0 else 0
+ var = np.var(cell_vals)
+
+ # Center of mass
+ y,x = mask.nonzero()
+ # sample = np.random.choice(len(x), size=50, replace=True)
+ com_x = np.mean(x)
+ com_y = np.mean(y)
+
+ # PCA only works for multiple points
+ if area > 1:
+ pca = PCA().fit(np.array([y,x]).T)
+ pc1_x, pc1_y = pca.components_[0,:]
+ angle = np.arctan(pc1_y / pc1_x) / np.pi * 360
+ v1, v2 = pca.explained_variance_
+ roundness = v2 / v1
+ else:
+ angle = 0
+ roundness = 1
+
+ else:
+ mean = 0
+ var = 0
+ tot_intensity = 0
+ com_x = 0
+ com_y = 0
+ angle = 0
+ roundness = 0
+
+ return {'Mean': mean,
+ 'Variance': var,
+ 'Total Intensity': tot_intensity,
+ 'Center of Mass X': com_x,
+ 'Center of Mass Y': com_y,
+ 'Cell Angle': angle,
+ 'Roundness': roundness}
+
# -----------------------------------------------------------------------------
# NEURAL NETWORK
def ShowHideCNNbuttons(self):
@@ -820,7 +762,6 @@ class App(QMainWindow):
self.ReloadThreeMasks()
-
self.m.UpdatePlots()
self.ClearStatusBar()
self.EnableCNNButtons()
@@ -842,25 +783,7 @@ class App(QMainWindow):
self.m.SegmentedMask = self.reader.Segment(seg_val, timeindex,fovindex)
self.reader.SaveSegMask(timeindex, fovindex, self.m.SegmentedMask)
self.reader.SaveMask(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.WriteStatusBar('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.ClearStatusBar()
-
+
def SelectChannel(self, index):
"""This function is called when the button to select different channels
@@ -885,14 +808,7 @@ class App(QMainWindow):
# 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):
"""
diff --git a/disk/DialogDataBrowser.py b/disk/DialogDataBrowser.py
deleted file mode 100644
index fe6c8fe6b6d1a70ed2a950205ab55459eb6f14e5..0000000000000000000000000000000000000000
--- a/disk/DialogDataBrowser.py
+++ /dev/null
@@ -1,65 +0,0 @@
-# -*- 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/disk/DialogFileBrowser.py b/disk/DialogFileBrowser.py
index e645820909eb79ef2d8eabbb75a50671e2b903a4..bf1ad3b6a2dd27d4512c5b35a20c5a3df71119f8 100644
--- a/disk/DialogFileBrowser.py
+++ b/disk/DialogFileBrowser.py
@@ -24,11 +24,11 @@ class FileBrowser(QDialog):
self.button_opennd2.setToolTip("Browse for an image file")
self.button_opennd2.setMaximumWidth(150)
- self.button_openfolder = QPushButton('Open image folder')
- self.button_openfolder.setEnabled(True)
- self.button_openfolder.clicked.connect(self.getfolder)
- self.button_openfolder.setToolTip("Browse for folder with images")
- self.button_openfolder.setMaximumWidth(150)
+# self.button_openfolder = QPushButton('Open image folder')
+# self.button_openfolder.setEnabled(True)
+# self.button_openfolder.clicked.connect(self.getfolder)
+# self.button_openfolder.setToolTip("Browse for folder with images")
+# self.button_openfolder.setMaximumWidth(150)
self.button_openhdf = QPushButton('Open mask file')
self.button_openhdf.setEnabled(True)
@@ -66,7 +66,7 @@ class FileBrowser(QDialog):
self.labelfolder.setText('No folder selected')
flo.addRow(self.labelnd2, self.button_opennd2)
- flo.addRow(self.labelfolder, self.button_openfolder)
+# flo.addRow(self.labelfolder, self.button_openfolder)
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)
@@ -79,9 +79,17 @@ class FileBrowser(QDialog):
def getnd2path(self):
- self.nd2name,_ = QFileDialog.getOpenFileName(self, 'Open image file','', 'Image files (*.nd2 *.tif *.tiff)')
+# self.nd2name,_ = QFileDialog.getOpenFileName(self, 'Open image file','', 'Image files (*.nd2 *.tif *.tiff)')
# print(self.nd2name)
# print(self.nd2name)
+
+ dlg = QFileDialog(self, 'Open image file or folder')
+ dlg.setProxyModel(None)
+ if dlg.exec():
+ self.nd2name = dlg.selectedFiles()[0]
+ else:
+ return
+
if self.nd2name != '':
self.labelnd2.setText(self.nd2name)
@@ -91,7 +99,7 @@ class FileBrowser(QDialog):
self.labelhdf.setText(self.hdfname)
self.newhdfentry.setText("")
- def getfolder(self):
- self.nd2name = QFileDialog.getExistingDirectory(self, ("Select Image Folder"))
- if self.nd2name != '':
- self.labelnd2.setText(self.nd2name)
+# def getfolder(self):
+# self.nd2name = QFileDialog.getExistingDirectory(self, ("Select Image Folder"))
+# if self.nd2name != '':
+# self.labelnd2.setText(self.nd2name)
diff --git a/disk/InteractionDisk_temp.py b/disk/InteractionDisk_temp.py
index 6e57a284da84f4a46e074cb580c3414c7d521bea..715fab53c7b72d3308a24a1e1b421188d01a254b 100644
--- a/disk/InteractionDisk_temp.py
+++ b/disk/InteractionDisk_temp.py
@@ -259,7 +259,7 @@ class Reader:
"""This method tests if the array which is requested by LoadMask
already exists or not in the hdf file.
"""
- if currentT <= len(self.tlabels) - 1:
+ if currentT <= len(self.tlabels) - 1 and currentT >= 0:
for t in file['/{}'.format(self.fovlabels[currentFOV])].keys():
# currentT is a number
# self.tlabels is some string that indexes the time point? E.g., T0?
diff --git a/misc/Extract.py b/misc/Extract.py
new file mode 100644
index 0000000000000000000000000000000000000000..66c48b75e01ff6781a174ef0cd6722dff3f59eef
--- /dev/null
+++ b/misc/Extract.py
@@ -0,0 +1,428 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+GUI to select and deselect cells at extraction time.
+"""
+
+import sys
+import os
+import numpy as np
+from PyQt5.QtWidgets import (QApplication, QPushButton, QLabel,
+ QHBoxLayout, QVBoxLayout, QListWidget,
+ QFileDialog, QMessageBox, QDialog)
+from PyQt5.QtCore import Qt
+
+
+from PIL import Image, ImageDraw
+sys.path.append("../disk")
+from image_loader import load_image
+
+#Import from matplotlib to use it to display the pictures and masks.
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+
+from matplotlib import cm
+from matplotlib.colors import LinearSegmentedColormap
+from matplotlib.figure import Figure
+
+
+class Extract(QDialog):
+
+
+ def __init__(self, image, mask, channel_names=[]):
+ parent = None
+ super(Extract, self).__init__(parent)
+ self.setWindowFlags(Qt.WindowStaysOnTopHint)
+# image, mask = _test_data()
+ self.pc = PlotCanvas(image, mask)
+ self.file_list = channel_names
+ self.init_UI()
+ self.exit_code = 0 # 0: Cancel, 1: Fluorescence, 2: Mask
+
+ def init_UI(self):
+ # Extract Buttons
+ title_extr = QLabel('Extract for selected cells')
+ self.extr_mask = _create_button("Extract Mask", self.do_extr_mask)
+ self.extr_fluo = _create_button("Extract Fluorescence", self.do_extr_fluo)
+ self.done = _create_button("Cancel", self.do_cancel)
+ self.done.setDefault(True)
+
+ extr_box = QVBoxLayout()
+ extr_box.addWidget(title_extr)
+ extr_box.addWidget(self.extr_mask)
+ extr_box.addWidget(self.extr_fluo)
+ extr_box.addWidget(self.done)
+ extr_box.setAlignment(Qt.AlignTop)
+
+ # Select Button
+ title_select = QLabel('Select / Deselect Cells for Extraction')
+ self.sel_mult = _create_button("Select Multiple", self.do_sel_mult,
+ "Left-click several times to draw polygon "
+ "on image around cells to select, "
+ "right-click to confirm")
+ self.sel_sngl = _create_button("Select Single", self.do_sel_sngl,
+ "Left-click to select cell, right-click "
+ "to abort")
+ self.desel_mult = _create_button("Deselect Multiple", self.do_desel_mult,
+ "Left-click several times to draw polygon "
+ "on image around cells to deselect, "
+ "right-click to confirm")
+ self.desel_sngl = _create_button("Deselect Single", self.do_desel_sngl,
+ "Left-click to deselect cell, right-click "
+ "to abort")
+
+ sel_box = QVBoxLayout()
+ sel_box.addWidget(title_select)
+ sel_box.addWidget(self.sel_mult)
+ sel_box.addWidget(self.sel_sngl)
+ sel_box.addWidget(self.desel_mult)
+ sel_box.addWidget(self.desel_sngl)
+ sel_box.setAlignment(Qt.AlignTop)
+
+ # Additional Fluorescence File
+ file_title = QLabel("Manage files from which to extract fluorescence")
+ self.list_channels = QListWidget()
+ self.add_file = _create_button('Add', self.do_add_file)
+ self.remove_file = _create_button('Remove', self.do_remove_file)
+
+ add_remove = QHBoxLayout()
+ add_remove.addWidget(self.add_file)
+ add_remove.addWidget(self.remove_file)
+
+ manage_box = QVBoxLayout()
+ manage_box.addWidget(file_title)
+ manage_box.addWidget(self.list_channels)
+ manage_box.addLayout(add_remove)
+ manage_box.setAlignment(Qt.AlignTop)
+
+ # Button list
+ self.buttons = [self.extr_mask,
+ self.extr_fluo,
+ self.done,
+ self.sel_mult,
+ self.sel_sngl,
+ self.desel_mult,
+ self.desel_sngl,
+ self.add_file,
+ self.remove_file,
+ self.list_channels]
+
+ # Buttons
+ buttons = QHBoxLayout()
+ buttons.addLayout(sel_box)
+ buttons.addLayout(manage_box)
+ buttons.addLayout(extr_box)
+
+ # Plot Canvas
+ full = QVBoxLayout()
+ full.addWidget(self.pc)
+ full.addStretch(.5)
+ full.addLayout(buttons)
+
+ # Add channel list
+ self.do_show_list()
+
+ self.setLayout(full)
+ self.setGeometry(300, 300, 600, 600)
+ self.setWindowTitle('Extracting')
+ self.show()
+
+ def do_extr_fluo(self):
+ self.outfile, _ = QFileDialog.getSaveFileName(
+ self,"Specify CSV File for Exporting Fluorescence",
+ "","All Files (*);;Text Files (*.csv)")
+ _, ext = os.path.splitext(self.outfile)
+ if ext == '':
+ self.outfile += '.csv'
+ elif ext != '.csv':
+ QMessageBox.critical(self,'Error','Must specify .csv file')
+ return
+
+ self.exit_code = 1
+ self.cells = self.pc.sellist
+ self.close()
+
+ def do_cancel(self):
+ self.close()
+
+ def do_extr_mask(self):
+ self.outfile, _ = QFileDialog.getSaveFileName(
+ self,"Specify TIFF File for Exporting Mask",
+ "","All Files (*);;Image File (*.tiff)")
+ _, ext = os.path.splitext(self.outfile)
+ if ext == '':
+ self.outfile += '.tif'
+ elif ext != '.tif' or ext!='.tiff':
+ QMessageBox.critical(self,'Error','Must specify .tif file')
+ return
+
+ self.exit_code = 2
+ self.cells = self.pc.sellist
+ self.close()
+
+ def do_sel_mult(self):
+ """Callback for selecting multiple"""
+ self.pc.storemouseclicks = []
+ def to_connect(e):
+ self.pc.multiple_click(e, self.do_sel_mult_process)
+ self.pc.connect_id = self.pc.mpl_connect(
+ 'button_press_event',
+ to_connect)
+ self.deactivate_all()
+
+ def do_sel_mult_process(self):
+ """Process selecting multiple"""
+ cells = self.cells_in_polygon()
+ self.pc.sellist = self.pc.sellist.union(cells)
+ self.disconnect()
+
+ def do_desel_mult(self):
+ self.pc.storemouseclicks = []
+ """Callback for deselecting multiple"""
+ def to_connect(e):
+ self.pc.multiple_click(e, self.do_desel_mult_process)
+ self.pc.connect_id = self.pc.mpl_connect(
+ 'button_press_event',
+ to_connect)
+ self.deactivate_all()
+
+ def do_desel_mult_process(self):
+ """Process deselect multiple"""
+ cells = self.cells_in_polygon()
+ self.pc.sellist = self.pc.sellist - cells
+ self.disconnect()
+
+ def cells_in_polygon(self):
+ """Extracts cells inside of polygon specified by pc.storemouseclicks"""
+ nx, ny = self.pc.mask.shape
+ img = Image.new('L', (ny, nx), 0)
+ ImageDraw.Draw(img).polygon(self.pc.storemouseclicks, outline=1, fill=1)
+ polygon = np.array(img).astype(bool)
+ return set(np.unique(self.pc.mask[polygon]))
+
+ def do_sel_sngl(self):
+ """Select single cell"""
+ def to_connect(e):
+ self.pc.single_click(e, self.do_sel_sngl_process)
+ self.pc.connect_id = self.pc.mpl_connect(
+ 'button_press_event',
+ to_connect)
+ self.deactivate_all()
+
+ def do_sel_sngl_process(self, x, y):
+ """Process selected cell"""
+ if x is not None:
+ cell = self.pc.mask[y,x]
+ self.pc.sellist.add(cell)
+ self.disconnect()
+
+ def do_desel_sngl(self):
+ """Deselect single cell"""
+ def to_connect(e):
+ self.pc.single_click(e, self.do_desel_sngl_process)
+ self.pc.connect_id = self.pc.mpl_connect(
+ 'button_press_event',
+ to_connect)
+ self.deactivate_all()
+
+ def do_desel_sngl_process(self, x, y):
+ """Process deselected cell"""
+ if x is not None:
+ cell = self.pc.mask[y,x]
+ self.pc.sellist.remove(cell)
+ self.disconnect()
+
+ def disconnect(self):
+ """Disconnects callback, updates plots, activates buttons"""
+ self.pc.update_plots()
+ self.pc.mpl_disconnect(self.pc.connect_id)
+ self.activate_all()
+
+ def deactivate_all(self):
+ for b in self.buttons:
+ b.setEnabled(False)
+
+ def activate_all(self):
+ for b in self.buttons:
+ b.setEnabled(True)
+
+ def do_add_file(self):
+ dlg = QFileDialog()
+ dlg.setProxyModel(None)
+ if dlg.exec():
+ full_files = dlg.selectedFiles()
+ if self.test_file(full_files):
+ self.file_list = self.file_list + full_files
+ self.do_show_list()
+
+ def do_remove_file(self):
+ item_to_remove = self.list_channels.currentItem()
+ remove_ix = self.list_channels.row(item_to_remove)
+ self.file_list.pop(remove_ix)
+ self.do_show_list()
+
+ def do_show_list(self):
+ self.list_channels.clear()
+ for file in self.file_list:
+ _, name = os.path.split(file)
+ self.list_channels.addItem(name)
+
+ def test_file(self, files):
+ """Tests if input image has appropriate size and contains data"""
+ for f in files:
+ try:
+ im = load_image(f, 0)
+ except ValueError:
+ QMessageBox.critical(self, "Error", "Could not load file")
+ return False
+ if not im.shape == self.pc.mask.shape:
+ QMessageBox.critical(self, "Error", "Loaded image has wrong size")
+ return False
+ return True
+
+
+
+class PlotCanvas(FigureCanvas):
+
+
+ def __init__(self, image, mask, parent=None, figsize=(5,4)):
+ """this class defines the canvas. It initializes a figure, which is then
+ used to plot our data using imshow.
+ """
+ fig = Figure()
+ self.ax = fig.add_subplot(111)
+ super(PlotCanvas, self).__init__(fig)
+ self.setParent(parent)
+
+ self.image = image
+ self.mask = mask
+ self.sellist = set(np.unique(mask)) # selected cells
+ self.vismask = mask.copy() # mask with only selected cells
+
+ self.ax_image, self.ax_mask = self.initialize_plots(image, mask, self.ax)
+ self.storemouseclicks = []
+ self.connect_id = None
+
+ def initialize_plots(self, picture, mask, ax):
+ """Creates plots at initialization"""
+ newcmp = _colormap(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', cmap = newcmp,
+ vmin=0, vmax=11))
+
+ def single_click(self, event, call_after):
+ """Function for single click, calls call_after afterwards with
+ the clicked points (or None, None) if abort click."""
+ if (event.button == 1
+ and (event.xdata != None and event.ydata != None)
+ and self.ax == event.inaxes):
+ x = int(event.xdata)
+ y = int(event.ydata)
+ call_after(x, y)
+ else:
+ call_after(None, None)
+
+ def multiple_click(self, event, call_after):
+ """Function to keep track of multiple left clicks, confirmed with
+ a right click. After right click, the function call_after is called"""
+
+ if (event.button == 1 # left click
+ and (event.xdata != None and event.ydata != None)
+ and self.ax == event.inaxes):
+
+ newx = int(event.xdata)
+ newy = int(event.ydata)
+ self.storemouseclicks.append((newx, newy))
+ self.draw_click(newx, newy)
+
+ elif (event.button == 3): # right click
+ self.mpl_disconnect(self.connect_id)
+ call_after()
+
+ def draw_click(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.vismask[posy:posy+2, posx:posx+2] = 9
+ self.redraw_mask()
+
+ def redraw_mask(self):
+ """Redraw mask with current self.vismask"""
+ self.ax_mask.set_data((self.vismask%10+1)*(self.vismask!=0))
+ self.ax.draw_artist(self.ax_image)
+ self.ax.draw_artist(self.ax_mask)
+ self.update()
+ self.flush_events()
+
+ def recalculate_vismask(self):
+ """Recalculates vismask with current list of cells to show"""
+ tmp = self.mask.copy()
+ all_cells = set(np.unique(tmp))
+ to_remove = all_cells - self.sellist
+ for cell in to_remove:
+ tmp[tmp==cell] = 0
+ self.vismask = tmp
+
+ def update_plots(self):
+ """Shows plot with currently selected cells"""
+ self.recalculate_vismask()
+ self.redraw_mask()
+
+def _create_button(text, connect, tooltip=None):
+ """Initializes button, connects with callback connect"""
+ button = QPushButton(text)
+ button.clicked.connect(connect)
+ button.setMaximumWidth(150)
+
+ if tooltip is not None:
+ button.setToolTip(tooltip)
+
+ return button
+
+def _colormap(Ncolors=21):
+ """Creates colormap for segmentation mask"""
+ jet = cm.get_cmap('jet', Ncolors)
+
+ cmaplist = [(0,0,0,0)]
+ for i in range(jet.N):
+ r,g,b,_ = jet(i)
+ cmaplist.append((r,g,b,.2))
+ cmap = LinearSegmentedColormap.from_list('Custom cmap', cmaplist, Ncolors)
+ return cmap
+
+def _poly_to_mask(polygon, shape):
+ """Converts polygon to mask"""
+ img = Image.new('L', shape, 0)
+ ImageDraw.Draw(img).polygon(polygon, outline=0, fill=1)
+ return np.array(img).astype(int)
+
+def _poly_to_line(polygon, shape):
+ """Converts polygon to line"""
+ img = Image.new('L', shape, 0)
+ ImageDraw.Draw(img).polygon(polygon, outline=1, fill=0)
+ return np.array(img).astype(int)
+
+def _test_data():
+ """Creates test data"""
+ im = np.zeros((100,100))
+ mask = np.zeros(im.shape)
+
+ poly1 = [(20,20),(30,30),(20,40),(10,30)]
+ poly2 = [(50,50),(60,60),(50,70),(40,60)]
+
+ mask += _poly_to_mask(poly1, im.shape)
+ mask += _poly_to_mask(poly2, im.shape)*2
+ im += _poly_to_line(poly1, im.shape)
+ im += _poly_to_line(poly2, im.shape)
+
+ return im, mask
+
+
+if __name__ == '__main__':
+ app = QApplication(sys.argv)
+ ex = Extract(*_test_data())
+ sys.exit(app.exec_())
\ No newline at end of file
diff --git a/packages.txt b/packages.txt
index d95f41c72e00cd7350db93c2217db0349f9a84dc..9b8d1215f6799150ed0613fe628c434a687e37b9 100644
--- a/packages.txt
+++ b/packages.txt
@@ -12,3 +12,5 @@ install pytiff
install pandas
install munkres
install sklearn
+install imageio
+install Pillow
\ No newline at end of file
diff --git a/unet/neural_network.py b/unet/neural_network.py
index b0c3906e4afeafb93242152aba824ca280e68884..e5d5b0d1141449c8287e12f99c2eee1e987bdb78 100644
--- a/unet/neural_network.py
+++ b/unet/neural_network.py
@@ -47,46 +47,21 @@ def prediction(im):
im: a numpy array image (numpy array), with max size 2048x2048
Return:
res: the predicted distribution of probability of the labels (numpy array)
- """
- imsize=im.shape
- im = im[0:2048,0:2048] #crop image if too large
- im = np.pad(im,
- ((0, max(0,2048 - imsize[0])),(0, max(0,2048 - imsize[1]))),
- constant_values=0) # pad with zeros if too small
-
- path_test = './tmp/test/image/'
- create_directory_if_not_exists(path_test)
-
+ """
+ # pad with zeros such that is divisible by 16
+ (nrow, ncol) = im.shape
+ row_add = 16-nrow%16
+ col_add = 16-ncol%16
+ padded = np.pad(im, ((0, row_add), (0, col_add)))
+
# WHOLE CELL PREDICTION
- testGene = testGenerator(path_test,
- 1,
- target_size = (2048,2048))
-
model = unet(pretrained_weights = None,
- input_size = (2048,2048,1))
+ input_size = (None,None,1))
model.load_weights('unet/unet_weights_batchsize_25_Nepochs_100_SJR0_10.hdf5')
- results = model.predict_generator(testGene,
- 1,
- verbose=1)
+ results = model.predict(padded[np.newaxis,:,:,np.newaxis], batch_size=1)
res = results[0,:,:,0]
- res = res[0:imsize[0],0:imsize[1]] #crop if needed, e.g., im was smaller than 2048x2048
- res = np.pad(res,
- ((0, max(0,imsize[0] - 2048)),
- (0, max(0,imsize[0] - 2048) )),
- constant_values=0) # pad with zeros if too small
-
- return res
-
+ return res[:nrow, :ncol]
-def testGenerator(test_path,num_image = 30,target_size = (256,256),
- flag_multi_class = False,as_gray = True):
- for i in range(num_image):
- img = io.imread(os.path.join(test_path,"%d.png"%i),as_gray = as_gray)
- img = img / 255
- img = trans.resize(img,target_size)
- img = np.reshape(img,img.shape+(1,)) if (not flag_multi_class) else img
- img = np.reshape(img,(1,)+img.shape)
- yield img
diff --git a/unet/segment.py b/unet/segment.py
index 07f594a3ae8a0ed307cd2ec3fda1167a9eba4c96..7176e0e7d4b9701057fe807f6406fecc99c8f319 100644
--- a/unet/segment.py
+++ b/unet/segment.py
@@ -68,7 +68,6 @@ def cell_merge(wsh, pred):
objcounter = 0 # will build up a new watershed mask, have to run a counter because some objects lost
for obj1 in range(wsh.max()):
- print("Processing cell ",obj1+1," of ",wsh.max()," for oversegmentation.")
dil1 = dil_objs[obj1,:,:]
# check if mask has been deleted
@@ -105,7 +104,6 @@ def cell_merge(wsh, pred):
dil_objs[obj1,:,:] = np.logical_or(dil1, dil2)
dil_objs[obj2,:,:] = np.zeros((wshshape[0], wshshape[1]))
obj_coords[obj1,:] = get_bounding_box(dil_objs[obj1,:,:])
- print("Merged cell ",obj1+1," and ",obj2+1,".")
wshclean = wshclean + orig1*objcounter