celldetective 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

celldetective/gui/tableUI.py

@@ -2,10 +2,9 @@ from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QMainWindow, QTableView,
 from PyQt5.QtCore import Qt, QAbstractTableModel
 import pandas as pd
 import matplotlib.pyplot as plt
-from matplotlib.cm import viridis
 plt.rcParams['svg.fonttype'] = 'none'
 from celldetective.gui.gui_utils import FigureCanvas, center_window
-from celldetective.utils import differentiate_per_track
+from celldetective.utils import differentiate_per_track, collapse_trajectories_by_status
 import numpy as np
 import seaborn as sns
 import matplotlib.cm as mcm
@@ -335,7 +334,7 @@ class TableUI(QMainWindow, Styles):
 		self.tracks = False
 
 		if self.population=='pairs':
-			self.groupby_cols = ['position','reference_population', 'neighbor_population','REFERENCE_ID', 'NEIGHBOR_ID', 'FRAME']
+			self.groupby_cols = ['position','reference_population', 'neighbor_population','REFERENCE_ID', 'NEIGHBOR_ID']
 			self.tracks = True # for now
 		else:
 			if 'TRACK_ID' in data.columns:
@@ -959,7 +958,7 @@ class TableUI(QMainWindow, Styles):
 					pass
 			
 			if self.population=='pairs':
-				for col in self.groupby_cols[1:]: #['neighbor_population', 'reference_population', 'NEIGHBOR_ID', 'REFERENCE_ID']
+				for col in reversed(self.groupby_cols): #['neighbor_population', 'reference_population', 'NEIGHBOR_ID', 'REFERENCE_ID']
 					if col in group_table:
 						first_column = group_table.pop(col)
 						group_table.insert(0, col, first_column)				
@@ -1005,41 +1004,7 @@ class TableUI(QMainWindow, Styles):
 
 		elif self.per_status_option.isChecked():
 
-			status_of_interest = self.per_status_cb.currentText()
-			self.projection_mode = f'{self.status_operation.currentText()} per {status_of_interest}'
-			self.data = self.data.dropna(subset=status_of_interest,ignore_index=True)
-			unique_statuses = np.unique(self.data[status_of_interest].to_numpy())
-
-			df_sections = []
-			for s in unique_statuses:
-				subtab = self.data.loc[self.data[status_of_interest]==s,:]
-				op = getattr(subtab.groupby(self.groupby_cols), self.status_operation.currentText())
-				subtab_projected = op(subtab.groupby(self.groupby_cols))
-				frame_duration = subtab.groupby(self.groupby_cols).size().to_numpy()
-				for c in self.static_columns:
-					try:
-						subtab_projected[c] = subtab.groupby(self.groupby_cols)[c].apply(lambda x: x.unique()[0])
-					except Exception as e:
-						print(e)
-						pass
-				subtab_projected['duration_in_state'] = frame_duration
-				df_sections.append(subtab_projected)
-
-			group_table = pd.concat(df_sections,axis=0,ignore_index=True)
-
-			if self.population=='pairs':
-				for col in ['duration_in_state',status_of_interest, 'neighbor_population', 'reference_population', 'NEIGHBOR_ID', 'REFERENCE_ID']:
-					first_column = group_table.pop(col) 
-					group_table.insert(0, col, first_column)				
-			else:
-				for col in ['duration_in_state',status_of_interest,'TRACK_ID']:
-					first_column = group_table.pop(col) 
-					group_table.insert(0, col, first_column)
-
-			group_table.pop('FRAME')
-			group_table = group_table.sort_values(by=self.groupby_cols + [status_of_interest],ignore_index=True)
-			group_table = group_table.reset_index(drop=True)
-
+			group_table = collapse_trajectories_by_status(self.data, status=self.per_status_cb.currentText(),population=self.population, projection=self.status_operation.currentText(), groupby_columns=self.groupby_cols)
 
 		self.subtable = TableUI(group_table,f"Group by tracks: {self.projection_mode}", plot_mode="static")
 		self.subtable.show()

celldetective/gui/thresholds_gui.py

@@ -4,19 +4,15 @@ import skimage
 from PyQt5.QtWidgets import QAction, QMenu, QMainWindow, QMessageBox, QLabel, QWidget, QFileDialog, QHBoxLayout, \
 	QGridLayout, QLineEdit, QScrollArea, QVBoxLayout, QComboBox, QPushButton, QApplication, QPushButton, QRadioButton, QButtonGroup
 from PyQt5.QtGui import QDoubleValidator, QIntValidator
-from matplotlib.backends.backend_qt import NavigationToolbar2QT
 from matplotlib.patches import Circle
-from mpl_toolkits.axes_grid1 import make_axes_locatable
 from scipy import ndimage
 from skimage.morphology import disk
 
 from celldetective.filters import std_filter, gauss_filter
-from celldetective.gui.gui_utils import center_window, FigureCanvas, ListWidget, FilterChoice, color_from_class
+from celldetective.gui.gui_utils import center_window, FigureCanvas, ListWidget, FilterChoice, color_from_class, help_generic
 from celldetective.utils import get_software_location, extract_experiment_channels, rename_intensity_column, estimate_unreliable_edge
 from celldetective.io import auto_load_number_of_frames, load_frames
-from celldetective.segmentation import threshold_image, identify_markers_from_binary, apply_watershed, \
-	segment_frame_from_thresholds
-from scipy.ndimage import binary_fill_holes
+from celldetective.segmentation import threshold_image, identify_markers_from_binary, apply_watershed
 import scipy.ndimage as ndi
 from PyQt5.QtCore import Qt, QSize
 from glob import glob
@@ -31,7 +27,6 @@ from skimage.measure import regionprops_table
 import json
 import os
 
-from celldetective.gui.viewers import StackVisualizer
 from celldetective.gui import Styles
 
 class ThresholdConfigWizard(QMainWindow, Styles):
@@ -50,6 +45,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.setMinimumHeight(int(0.8 * self.screen_height))
 		self.setWindowTitle("Threshold configuration wizard")
 		center_window(self)
+		self.setWindowIcon(self.celldetective_icon)
 		self._createActions()
 		self._createMenuBar()
 
@@ -150,7 +146,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 	def populate_left_panel(self):
 
-		self.filters_qlist = ListWidget(self, FilterChoice, [])
+		self.filters_qlist = ListWidget(FilterChoice, [])
 
 		grid_preprocess = QGridLayout()
 		grid_preprocess.setContentsMargins(20, 20, 20, 20)
@@ -174,9 +170,17 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.add_filter.setIconSize(QSize(20, 20))
 		self.add_filter.clicked.connect(self.filters_qlist.addItem)
 
+		self.help_prefilter_btn = QPushButton()
+		self.help_prefilter_btn.setIcon(icon(MDI6.help_circle,color=self.help_color))
+		self.help_prefilter_btn.setIconSize(QSize(20, 20))
+		self.help_prefilter_btn.clicked.connect(self.help_prefilter)
+		self.help_prefilter_btn.setStyleSheet(self.button_select_all)
+		self.help_prefilter_btn.setToolTip("Help.")
+
 		# filter_list_option_grid.addWidget(QLabel(""),90)
 		filter_list_option_grid.addWidget(self.delete_filter, 5)
 		filter_list_option_grid.addWidget(self.add_filter, 5)
+		filter_list_option_grid.addWidget(self.help_prefilter_btn, 5)
 
 		grid_preprocess.addLayout(filter_list_option_grid, 0, 0, 1, 3)
 		grid_preprocess.addWidget(self.filters_qlist, 1, 0, 1, 3)
@@ -259,6 +263,30 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		for p in self.properties_box_widgets:
 			p.setEnabled(False)
 
+	def help_prefilter(self):
+
+		"""
+		Helper for prefiltering strategy
+		"""
+
+		dict_path = os.sep.join([get_software_location(),'celldetective','gui','help','prefilter-for-segmentation.json'])
+
+		with open(dict_path) as f:
+			d = json.load(f)
+
+		suggestion = help_generic(d)
+		if isinstance(suggestion, str):
+			print(f"{suggestion=}")
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Information)
+			msgBox.setTextFormat(Qt.RichText)
+			msgBox.setText(f"The suggested technique is to {suggestion}.\nSee a tutorial <a href='https://celldetective.readthedocs.io/en/latest/segment.html'>here</a>.")
+			msgBox.setWindowTitle("Info")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None		
+
 	def generate_marker_contents(self):
 
 		marker_box = QVBoxLayout()
@@ -412,7 +440,6 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 		"""
 
-		print("this is the loaded position: ", self.pos)
 		if isinstance(self.pos, str):
 			movies = glob(self.pos + f"movie/{self.parent_window.parent_window.parent_window.movie_prefix}*.tif")
 
@@ -438,6 +465,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 			self.close()
 		else:
 			self.stack_path = movies[0]
+			print(f'Attempt to read stack {os.path.split(self.stack_path)[-1]}')
 			self.len_movie = self.parent_window.parent_window.parent_window.len_movie
 			len_movie_auto = auto_load_number_of_frames(self.stack_path)
 			if len_movie_auto is not None:
@@ -449,8 +477,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 			self.nbr_channels = len(self.channels)
 			self.current_channel = 0
 			self.img = load_frames(0, self.stack_path, normalize_input=False)
-			print(self.img.shape)
-			print(f'{self.stack_path} successfully located.')
+			print(f'Detected image shape: {self.img.shape}...')
 
 	def show_image(self):
 

celldetective/gui/viewers.py

@@ -6,15 +6,14 @@ from celldetective.measure import contour_of_instance_segmentation
 from celldetective.utils import _get_img_num_per_channel, estimate_unreliable_edge
 from tifffile import imread
 import matplotlib.pyplot as plt 
-from stardist import fill_label_holes
 from pathlib import Path
 from natsort import natsorted
 from glob import glob
 import os
 
-from PyQt5.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget
+from PyQt5.QtWidgets import QWidget, QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget
 from PyQt5.QtCore import Qt, QSize
-from celldetective.gui.gui_utils import FigureCanvas, QuickSliderLayout, center_window
+from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout
 from celldetective.gui import Styles
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QLabeledDoubleRangeSlider
 from superqt.fonticon import icon
@@ -89,9 +88,9 @@ class StackVisualizer(QWidget, Styles):
 		if self.create_frame_slider:
 			self.generate_frame_slider()
 
-		center_window(self)
 		self.canvas.layout.setContentsMargins(15,15,15,30)
 		self.setAttribute(Qt.WA_DeleteOnClose)
+		center_window(self)
 
 	def show(self):
 		# Display the widget
@@ -142,7 +141,7 @@ class StackVisualizer(QWidget, Styles):
 	def generate_figure_canvas(self):
 		# Generate the figure canvas for displaying images
 
-		self.fig, self.ax = plt.subplots(tight_layout=True) #figsize=(5, 5)
+		self.fig, self.ax = plt.subplots(figsize=(5,5),tight_layout=True) #figsize=(5, 5)
 		self.canvas = FigureCanvas(self.fig, title=self.window_title, interactive=True)
 		self.ax.clear()
 		self.im = self.ax.imshow(self.init_frame, cmap='gray', interpolation='none', **self.imshow_kwargs)
@@ -197,13 +196,13 @@ class StackVisualizer(QWidget, Styles):
 		contrast_layout = QuickSliderLayout(
 											label='Contrast: ',
 											slider=self.contrast_slider,
-											slider_initial_value=[np.nanpercentile(self.init_frame, 1),np.nanpercentile(self.init_frame, 99.99)],
+											slider_initial_value=[np.nanpercentile(self.init_frame, 0.1),np.nanpercentile(self.init_frame, 99.99)],
 											slider_range=(np.nanmin(self.init_frame),np.nanmax(self.init_frame)),
 											decimal_option=True,
 											precision=1.0E-05,
 											)
 		contrast_layout.setContentsMargins(15,0,15,0)
-		self.im.set_clim(vmin=np.nanpercentile(self.init_frame, 1),vmax=np.nanpercentile(self.init_frame, 99.99))
+		self.im.set_clim(vmin=np.nanpercentile(self.init_frame, 0.1),vmax=np.nanpercentile(self.init_frame, 99.99))
 		self.contrast_slider.valueChanged.connect(self.change_contrast)
 		self.canvas.layout.addLayout(contrast_layout)
 

celldetective/io.py

@@ -17,15 +17,11 @@ from pathlib import Path, PurePath
 from shutil import copyfile
 from celldetective.utils import ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
 import json
-import threading
 from skimage.measure import regionprops_table
 from celldetective.utils import _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel
-import matplotlib.pyplot as plt
-from celldetective.filters import std_filter, median_filter, gauss_filter
-from stardist import fill_label_holes
 from celldetective.utils import interpolate_nan
-from scipy.interpolate import griddata
-
+import concurrent.futures
+from tifffile import imwrite
 
 def get_experiment_wells(experiment):
 	
@@ -628,7 +624,7 @@ def locate_stack(position, prefix='Aligned'):
 
 	stack_path = glob(position + os.sep.join(['movie', f'{prefix}*.tif']))
 	assert len(stack_path) > 0, f"No movie with prefix {prefix} found..."
-	stack = imread(stack_path[0].replace('\\', '/'), is_mmstack=False)
+	stack = imread(stack_path[0].replace('\\', '/'))
 	if stack.ndim == 4:
 		stack = np.moveaxis(stack, 1, -1)
 	elif stack.ndim == 3:
@@ -681,6 +677,49 @@ def locate_labels(position, population='target'):
 
 	return labels
 
+def fix_missing_labels(position, population='target', prefix='Aligned'):
+	
+	"""
+	Fix missing label files by creating empty label images for frames that do not have corresponding label files.
+
+	This function locates missing label files in a sequence of frames and creates empty labels (filled with zeros) 
+	for the frames that are missing. The function works for two types of populations: 'target' or 'effector'.
+
+	Parameters
+	----------
+	position : str
+		The file path to the folder containing the images/label files. This is the root directory where 
+		the label files are expected to be found.
+	population : str, optional
+		Specifies whether to look for 'target' or 'effector' labels. Accepts 'target' or 'effector' 
+		as valid values. Default is 'target'.
+	prefix : str, optional
+		The prefix used to locate the image stack (default is 'Aligned').
+
+	Returns
+	-------
+	None
+		The function creates new label files in the corresponding folder for any frames missing label files.
+	"""
+
+	if not position.endswith(os.sep):
+		position += os.sep
+
+	stack = locate_stack(position, prefix=prefix)
+	template = np.zeros((stack[0].shape[0], stack[0].shape[1]))
+	all_frames = np.arange(len(stack))
+
+	if population.lower() == "target" or population.lower() == "targets":
+		label_path = natsorted(glob(position + os.sep.join(["labels_targets", "*.tif"])))
+	elif population.lower() == "effector" or population.lower() == "effectors":
+		label_path = natsorted(glob(position + os.sep.join(["labels_effectors", "*.tif"])))
+
+	path = os.path.split(label_path[0])[0]
+	int_valid = [int(lbl.split(os.sep)[-1].split('.')[0]) for lbl in label_path]
+	to_create = [x for x in all_frames if x not in int_valid]
+	to_create = [str(x).zfill(4)+'.tif' for x in to_create]
+	for file in to_create:
+		imwrite(os.sep.join([path, file]), template)
 
 
 def locate_stack_and_labels(position, prefix='Aligned', population="target"):
@@ -832,7 +871,6 @@ def auto_load_number_of_frames(stack_path):
 			nslices = int(attr[np.argmax([s.startswith("frames") for s in attr])].split("=")[-1])
 			if nslices > 1:
 				len_movie = nslices
-				print(f"Auto-detected movie length movie: {len_movie}")
 			else:
 				break_the_code()
 		except:
@@ -840,7 +878,6 @@ def auto_load_number_of_frames(stack_path):
 				# try nslices
 				frames = int(attr[np.argmax([s.startswith("slices") for s in attr])].split("=")[-1])
 				len_movie = frames
-				print(f"Auto-detected movie length movie: {len_movie}")
 			except:
 				pass
 
@@ -1123,96 +1160,41 @@ def relabel_segmentation(labels, data, properties, column_labels={'track': "trac
 	else:
 		df = pd.DataFrame(data,columns=[column_labels['track'],column_labels['frame'],'z', column_labels['y'],column_labels['x']])
 		df = df.drop(columns=['z'])
+
 	df = df.merge(pd.DataFrame(properties),left_index=True, right_index=True)
 	df = df.sort_values(by=[column_labels['track'],column_labels['frame']])
+	df.loc[df['dummy'],column_labels['label']] = np.nan
 
 	new_labels = np.zeros_like(labels)
 
 	def rewrite_labels(indices):
 
 		for t in tqdm(indices):
+
 			f = int(t)
-			tracks_at_t = df.loc[df[column_labels['frame']] == f, column_labels['track']].to_numpy()
-			identities = df.loc[df[column_labels['frame']] == f, column_labels['label']].to_numpy()
+			cells = df.loc[df[column_labels['frame']] == f, [column_labels['track'], column_labels['label']]].to_numpy()
+			tracks_at_t = cells[:,0]
+			identities = cells[:,1]
 
+			# exclude NaN
 			tracks_at_t = tracks_at_t[identities == identities]
 			identities = identities[identities == identities]
 
 			for k in range(len(identities)):
 				loc_i, loc_j = np.where(labels[f] == identities[k])
-				new_labels[f, loc_i, loc_j] = int(tracks_at_t[k])
+				new_labels[f, loc_i, loc_j] = round(tracks_at_t[k])
 
 	# Multithreading
 	indices = list(df[column_labels['frame']].unique())
 	chunks = np.array_split(indices, n_threads)
-	threads = []
-	for i in range(n_threads):
-		thread_i = threading.Thread(target=rewrite_labels, args=[chunks[i]])
-		threads.append(thread_i)
-	for th in threads:
-		th.start()
-	for th in threads:
-		th.join()
 
-	return new_labels
-
-# def relabel_segmentation(labels, data, properties, column_labels={'track': "track", 'frame': 'frame', 'y': 'y', 'x': 'x', 'label': 'class_id'}, threads=1):
-
-# 	"""
-
-# 	Relabel the segmentation labels based on the provided tracking data and properties.
-
-# 	Parameters
-# 	----------
-# 	labels : ndarray
-# 		The original segmentation labels.
-# 	data : ndarray
-# 		The tracking data containing information about tracks, frames, y-coordinates, and x-coordinates.
-# 	properties : ndarray
-# 		The properties associated with the tracking data.
-# 	column_labels : dict, optional
-# 		A dictionary specifying the column labels for the tracking data. The default is {'track': "track",
-# 		'frame': 'frame', 'y': 'y', 'x': 'x', 'label': 'class_id'}.
-
-# 	Returns
-# 	-------
-# 	ndarray
-# 		The relabeled segmentation labels.
-
-# 	Notes
-# 	-----
-# 	This function relabels the segmentation labels based on the provided tracking data and properties.
-# 	It creates a DataFrame from the tracking data and properties, merges them based on the indices, and sorts them by track and frame.
-# 	Then, it iterates over unique frames in the DataFrame, retrieves the tracks and identities at each frame,
-# 	and updates the corresponding labels with the new track values.
-
-# 	Examples
-# 	--------
-# 	>>> relabeled = relabel_segmentation(labels, data, properties, column_labels={'track': "track", 'frame': 'frame',
-# 	...                                                                 'y': 'y', 'x': 'x', 'label': 'class_id'})
-# 	# Relabel the segmentation labels based on the provided tracking data and properties.
+	with concurrent.futures.ThreadPoolExecutor() as executor:
+		executor.map(rewrite_labels, chunks)
 	
-# 	"""
-
-# 	df = pd.DataFrame(data,columns=[column_labels['track'],column_labels['frame'],column_labels['y'],column_labels['x']])
-# 	df = df.merge(pd.DataFrame(properties),left_index=True, right_index=True)
-# 	df = df.sort_values(by=[column_labels['track'],column_labels['frame']])
-
-# 	new_labels = np.zeros_like(labels)
-
-# 	for t in tqdm(df[column_labels['frame']].unique()):
-# 		f = int(t)
-# 		tracks_at_t = df.loc[df[column_labels['frame']]==f, column_labels['track']].to_numpy()
-# 		identities = df.loc[df[column_labels['frame']]==f, column_labels['label']].to_numpy()
-
-# 		tracks_at_t = tracks_at_t[identities==identities]
-# 		identities = identities[identities==identities]
+	print("\nDone.")
 
-# 		for k in range(len(identities)):
-# 			loc_i,loc_j = np.where(labels[f]==identities[k])
-# 			new_labels[f,loc_i,loc_j] = int(tracks_at_t[k])
+	return new_labels
 
-# 	return new_labels
 
 def control_tracking_btrack(position, prefix="Aligned", population="target", relabel=True, flush_memory=True, threads=1):
 
@@ -1280,16 +1262,13 @@ def view_on_napari_btrack(data, properties, graph, stack=None, labels=None, rela
 	"""
 
 	if (labels is not None) * relabel:
-		print('Relabeling the cell masks with the track ID.')
+		print('Replacing the cell mask labels with the track ID...')
 		labels = relabel_segmentation(labels, data, properties, threads=threads)
 
-	if data.shape[1]==4:
-		vertices = data[:, 1:]
-	else:
-		vertices = data[:, 2:]
+	vertices = data[:, [1,-2,-1]]
+
 	viewer = napari.Viewer()
 	if stack is not None:
-		print(f'{stack.shape=}')
 		viewer.add_image(stack, channel_axis=-1, colormap=["gray"] * stack.shape[-1])
 	if labels is not None:
 		viewer.add_labels(labels, name='segmentation', opacity=0.4)
@@ -1297,7 +1276,6 @@ def view_on_napari_btrack(data, properties, graph, stack=None, labels=None, rela
 	if data.shape[1]==4:
 		viewer.add_tracks(data, properties=properties, graph=graph, name='tracks')
 	else:
-		print(data)
 		viewer.add_tracks(data[:,[0,1,3,4]], properties=properties, graph=graph, name='tracks')		
 	viewer.show(block=True)
 
@@ -1616,7 +1594,7 @@ def correct_annotation(filename):
 	def save_widget():
 		return export_labels()
 
-	img = imread(filename.replace('\\','/'),is_mmstack=False)
+	img = imread(filename.replace('\\','/'))
 	if img.ndim==3:
 		img = np.moveaxis(img, 0, -1)
 	elif img.ndim==2: