celldetective 1.3.2__py3-none-any.whl → 1.3.3.post1__py3-none-any.whl

celldetective/gui/viewers.py

@@ -2,7 +2,7 @@ import numpy as np
 from celldetective.io import auto_load_number_of_frames, load_frames
 from celldetective.filters import *
 from celldetective.segmentation import filter_image, threshold_image
-from celldetective.measure import contour_of_instance_segmentation
+from celldetective.measure import contour_of_instance_segmentation, extract_blobs_in_image
 from celldetective.utils import _get_img_num_per_channel, estimate_unreliable_edge
 from tifffile import imread
 import matplotlib.pyplot as plt 
@@ -13,7 +13,7 @@ import os
 
 from PyQt5.QtWidgets import QWidget, QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget, QShortcut
 from PyQt5.QtCore import Qt, QSize
-from PyQt5.QtGui import QKeySequence
+from PyQt5.QtGui import QKeySequence, QDoubleValidator
 from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout, QHSeperationLine, ThresholdLineEdit
 from celldetective.gui import Styles
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QLabeledDoubleRangeSlider
@@ -22,7 +22,11 @@ from fonticon_mdi6 import MDI6
 from matplotlib_scalebar.scalebar import ScaleBar
 import gc
 from celldetective.utils import mask_edges
-from scipy.ndimage import shift
+from scipy.ndimage import shift, grey_dilation
+from skimage.feature import blob_dog
+import math
+from skimage.morphology import disk
+from matplotlib.patches import Circle
 
 class StackVisualizer(QWidget, Styles):
 
@@ -80,6 +84,7 @@ class StackVisualizer(QWidget, Styles):
 		self.imshow_kwargs = imshow_kwargs
 		self.PxToUm = PxToUm
 		self.init_contrast = False
+		self.channel_trigger = False
 
 		self.load_stack() # need to get stack, frame etc
 		self.generate_figure_canvas()
@@ -123,13 +128,8 @@ class StackVisualizer(QWidget, Styles):
 
 	def locate_image_virtual(self):
 		# Locate the stack of images if provided as a file
-		self.stack_length = auto_load_number_of_frames(self.stack_path)
-		if self.stack_length is None:
-			stack = imread(self.stack_path)
-			self.stack_length = len(stack)
-			del stack
-			gc.collect()
 
+		self.stack_length = auto_load_number_of_frames(self.stack_path)
 		self.mid_time = self.stack_length // 2
 		self.img_num_per_channel = _get_img_num_per_channel(np.arange(self.n_channels), self.stack_length, self.n_channels)
 
@@ -146,7 +146,7 @@ class StackVisualizer(QWidget, Styles):
 		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)
+		self.im = self.ax.imshow(self.init_frame, cmap='gray', interpolation='none', zorder=0, **self.imshow_kwargs)
 		if self.PxToUm is not None:
 			scalebar = ScaleBar(self.PxToUm,
 								"um",
@@ -250,12 +250,23 @@ class StackVisualizer(QWidget, Styles):
 			self.last_frame = load_frames(self.img_num_per_channel[self.target_channel, self.stack_length-1], 
 										  self.stack_path,
 										  normalize_input=False).astype(float)[:,:,0]
-		self.change_frame(self.frame_slider.value())
+		self.change_frame_from_channel_switch(self.frame_slider.value())
+		self.channel_trigger = False
 		self.init_contrast = False
 
+	def change_frame_from_channel_switch(self, value):
+		
+		self.channel_trigger = True
+		self.change_frame(value)
+
 	def change_frame(self, value):
+
 		# Change the displayed frame based on slider value
-		
+		if self.channel_trigger:
+			self.switch_from_channel = True
+		else:
+			self.switch_from_channel = False
+
 		if self.mode=='virtual':
 
 			self.init_frame = load_frames(self.img_num_per_channel[self.target_channel, value], 
@@ -279,7 +290,7 @@ class StackVisualizer(QWidget, Styles):
 	
 	def closeEvent(self, event):
 		# Event handler for closing the widget
-		self.canvas.close()
+		self.canvas.close()	
 
 
 class ThresholdedStackVisualizer(StackVisualizer):
@@ -617,6 +628,249 @@ class CellEdgeVisualizer(StackVisualizer):
 
 		self.edge_labels = contour_of_instance_segmentation(self.init_label, edge_size)
 
+class SpotDetectionVisualizer(StackVisualizer):
+	
+	def __init__(self, parent_channel_cb=None, parent_diameter_le=None, parent_threshold_le=None, cell_type='targets', labels=None, *args, **kwargs):
+
+		super().__init__(*args, **kwargs)
+		
+		self.cell_type = cell_type
+		self.labels = labels
+		self.detection_channel = self.target_channel
+		self.parent_channel_cb = parent_channel_cb
+		self.parent_diameter_le = parent_diameter_le
+		self.parent_threshold_le = parent_threshold_le
+		self.spot_sizes = []
+
+		self.floatValidator = QDoubleValidator()
+		self.init_scatter()
+		self.generate_detection_channel()
+		self.generate_spot_detection_params()
+		self.generate_add_measurement_btn()
+		self.load_labels()
+		self.change_frame(self.mid_time)
+
+		self.ax.callbacks.connect('xlim_changed', self.update_marker_sizes)
+		self.ax.callbacks.connect('ylim_changed', self.update_marker_sizes)
+
+		self.apply_diam_btn.clicked.connect(self.detect_and_display_spots)
+		self.apply_thresh_btn.clicked.connect(self.detect_and_display_spots)
+		
+		self.channels_cb.setCurrentIndex(self.target_channel)
+		self.detection_channel_cb.setCurrentIndex(self.target_channel)
+
+	def update_marker_sizes(self, event=None):
+		
+		# Get axis bounds
+		xlim = self.ax.get_xlim()
+		ylim = self.ax.get_ylim()
+
+		# Data-to-pixel scale
+		ax_width_in_pixels = self.ax.bbox.width
+		ax_height_in_pixels = self.ax.bbox.height
+
+		x_scale = (xlim[1] - xlim[0]) / ax_width_in_pixels
+		y_scale = (ylim[1] - ylim[0]) / ax_height_in_pixels
+
+		# Choose the smaller scale for square pixels
+		scale = min(x_scale, y_scale)
+
+		# Convert radius_px to data units
+		if len(self.spot_sizes)>0:
+
+			radius_data_units = self.spot_sizes / scale
+
+			# Convert to scatter `s` size (points squared)
+			radius_pts = radius_data_units * (72. / self.fig.dpi )
+			size = np.pi * (radius_pts ** 2)
+
+			# Update scatter sizes
+			self.spot_scat.set_sizes(size)
+			self.fig.canvas.draw_idle()
+
+	def init_scatter(self):
+		self.spot_scat = self.ax.scatter([],[], s=50, facecolors='none', edgecolors='tab:red',zorder=100)
+		self.canvas.canvas.draw()
+
+	def change_frame(self, value):
+
+		super().change_frame(value)
+		if not self.switch_from_channel:
+			self.reset_detection()
+
+		if self.mode=='virtual':
+			self.init_label = imread(self.mask_paths[value])
+			self.target_img = load_frames(self.img_num_per_channel[self.detection_channel, value], 
+								self.stack_path,
+								normalize_input=False).astype(float)[:,:,0]
+		elif self.mode=='direct':
+			self.init_label = self.labels[value,:,:]
+			self.target_img = self.stack[value,:,:,self.detection_channel].copy()
+
+	def detect_and_display_spots(self):
+
+		self.reset_detection()
+		self.control_valid_parameters() # set current diam and threshold
+		blobs_filtered = extract_blobs_in_image(self.target_img, self.init_label,threshold=self.thresh, diameter=self.diameter)
+		if blobs_filtered is not None:
+			self.spot_positions = np.array([[x,y] for y,x,_ in blobs_filtered])
+			
+			self.spot_sizes = np.sqrt(2)*np.array([sig for _,_,sig in blobs_filtered])
+			print(f"{self.spot_sizes=}")
+			#radius_pts = self.spot_sizes * (self.fig.dpi / 72.0)
+			#sizes = np.pi*(radius_pts**2)
+
+			self.spot_scat.set_offsets(self.spot_positions)
+			#self.spot_scat.set_sizes(sizes)
+			self.update_marker_sizes()
+			self.canvas.canvas.draw()
+
+	def reset_detection(self):
+		
+		self.ax.scatter([], []).get_offsets()
+		empty_offset = np.ma.masked_array([0, 0], mask=True)
+		self.spot_scat.set_offsets(empty_offset)
+		self.canvas.canvas.draw()
+
+	def load_labels(self):
+
+		# Load the cell labels
+		if self.labels is not None:
+
+			if isinstance(self.labels, list):
+				self.labels = np.array(self.labels)
+
+			assert self.labels.ndim==3,'Wrong dimensions for the provided labels, expect TXY'
+			assert len(self.labels)==self.stack_length
+
+			self.mode = 'direct'
+			self.init_label = self.labels[self.mid_time,:,:]
+		else:
+			self.mode = 'virtual'
+			assert isinstance(self.stack_path, str)
+			assert self.stack_path.endswith('.tif')
+			self.locate_labels_virtual()
+	
+	def locate_labels_virtual(self):
+		# Locate virtual labels
+
+		labels_path = str(Path(self.stack_path).parent.parent) + os.sep + f'labels_{self.cell_type}' + os.sep
+		self.mask_paths = natsorted(glob(labels_path + '*.tif'))
+		
+		if len(self.mask_paths) == 0:
+
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Critical)
+			msgBox.setText("No labels were found for the selected cells. Abort.")
+			msgBox.setWindowTitle("Critical")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			self.close()
+
+		self.init_label = imread(self.mask_paths[self.frame_slider.value()])
+	
+	def generate_detection_channel(self):
+
+		assert self.channel_names is not None
+		assert len(self.channel_names)==self.n_channels
+
+		channel_layout = QHBoxLayout()
+		channel_layout.setContentsMargins(15,0,15,0)
+		channel_layout.addWidget(QLabel('Detection\nchannel: '), 25)
+
+		self.detection_channel_cb = QComboBox()
+		self.detection_channel_cb.addItems(self.channel_names)
+		self.detection_channel_cb.currentIndexChanged.connect(self.set_detection_channel_index)
+		channel_layout.addWidget(self.detection_channel_cb, 75)
+		self.canvas.layout.addLayout(channel_layout)
+
+	def set_detection_channel_index(self, value):
+
+		self.detection_channel = value
+		if self.mode == 'direct':
+			self.last_frame = self.stack[-1,:,:,self.target_channel]
+		elif self.mode == 'virtual':
+			self.target_img = load_frames(self.img_num_per_channel[self.detection_channel, self.stack_length-1], 
+										  self.stack_path,
+										  normalize_input=False).astype(float)[:,:,0]
+
+	def generate_spot_detection_params(self):
+
+		self.spot_diam_le = QLineEdit('1')
+		self.spot_diam_le.setValidator(self.floatValidator)
+		self.apply_diam_btn = QPushButton('Set')
+		self.apply_diam_btn.setStyleSheet(self.button_style_sheet_2)
+
+		self.spot_thresh_le = QLineEdit('0')
+		self.spot_thresh_le.setValidator(self.floatValidator)
+		self.apply_thresh_btn = QPushButton('Set')
+		self.apply_thresh_btn.setStyleSheet(self.button_style_sheet_2)		
+
+		self.spot_diam_le.textChanged.connect(self.control_valid_parameters)
+		self.spot_thresh_le.textChanged.connect(self.control_valid_parameters)
+
+		spot_diam_layout = QHBoxLayout()
+		spot_diam_layout.setContentsMargins(15,0,15,0)
+		spot_diam_layout.addWidget(QLabel('Spot diameter: '), 25)
+		spot_diam_layout.addWidget(self.spot_diam_le, 65)
+		spot_diam_layout.addWidget(self.apply_diam_btn, 10)
+		self.canvas.layout.addLayout(spot_diam_layout)
+
+		spot_thresh_layout = QHBoxLayout()
+		spot_thresh_layout.setContentsMargins(15,0,15,0)
+		spot_thresh_layout.addWidget(QLabel('Detection\nthreshold: '), 25)
+		spot_thresh_layout.addWidget(self.spot_thresh_le, 65)
+		spot_thresh_layout.addWidget(self.apply_thresh_btn, 10)
+		self.canvas.layout.addLayout(spot_thresh_layout)
+
+	def generate_add_measurement_btn(self):
+
+		add_hbox = QHBoxLayout()
+		self.add_measurement_btn = QPushButton('Add measurement')
+		self.add_measurement_btn.clicked.connect(self.set_measurement_in_parent_list)
+		self.add_measurement_btn.setIcon(icon(MDI6.plus,color="white"))
+		self.add_measurement_btn.setIconSize(QSize(20, 20))
+		self.add_measurement_btn.setStyleSheet(self.button_style_sheet)
+		add_hbox.addWidget(QLabel(''),33)
+		add_hbox.addWidget(self.add_measurement_btn, 33)
+		add_hbox.addWidget(QLabel(''),33)		
+		self.canvas.layout.addLayout(add_hbox)
+
+	def control_valid_parameters(self):
+		
+		valid_diam = False
+		try:
+			self.diameter = float(self.spot_diam_le.text().replace(',','.'))
+			valid_diam = True
+		except:
+			valid_diam = False
+
+		valid_thresh = False
+		try:
+			self.thresh = float(self.spot_thresh_le.text().replace(',','.'))
+			valid_thresh = True
+		except:
+			valid_thresh = False
+
+		if valid_diam and valid_thresh:
+			self.apply_diam_btn.setEnabled(True)
+			self.apply_thresh_btn.setEnabled(True)
+			self.add_measurement_btn.setEnabled(True)
+		else:
+			self.apply_diam_btn.setEnabled(False)
+			self.apply_thresh_btn.setEnabled(False)
+			self.add_measurement_btn.setEnabled(False)
+
+	def set_measurement_in_parent_list(self):
+
+		if self.parent_channel_cb is not None:
+			self.parent_channel_cb.setCurrentIndex(self.detection_channel)
+		if self.parent_diameter_le is not None:
+			self.parent_diameter_le.setText(self.spot_diam_le.text())
+		if self.parent_threshold_le is not None:
+			self.parent_threshold_le.setText(self.spot_thresh_le.text())
+		self.close()
+
 class CellSizeViewer(StackVisualizer):
 
 	"""

celldetective/io.py

@@ -14,7 +14,7 @@ from btrack.datasets import cell_config
 from magicgui import magicgui
 from csbdeep.io import save_tiff_imagej_compatible
 from pathlib import Path, PurePath
-from shutil import copyfile
+from shutil import copyfile, rmtree
 from celldetective.utils import ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
 import json
 from skimage.measure import regionprops_table
@@ -674,10 +674,20 @@ 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('\\', '/'))
+	stack_length = auto_load_number_of_frames(stack_path[0])
+
 	if stack.ndim == 4:
 		stack = np.moveaxis(stack, 1, -1)
 	elif stack.ndim == 3:
-		stack = stack[:, :, :, np.newaxis]
+		if min(stack.shape)!=stack_length:
+			channel_axis = np.argmin(stack.shape)
+			if channel_axis!=(stack.ndim-1):
+				stack = np.moveaxis(stack, channel_axis, -1)
+			stack = stack[np.newaxis, :, :, :]
+		else:
+			stack = stack[:, :, :, np.newaxis]
+	elif stack.ndim==2:
+		stack = stack[np.newaxis, :, :, np.newaxis]
 
 	return stack
 
@@ -912,6 +922,7 @@ def auto_load_number_of_frames(stack_path):
 		return None
 
 	stack_path = stack_path.replace('\\','/')
+	n_channels=1
 
 	with TiffFile(stack_path) as tif:
 		try:
@@ -921,7 +932,8 @@ def auto_load_number_of_frames(stack_path):
 				tif_tags[name] = value
 			img_desc = tif_tags["ImageDescription"]
 			attr = img_desc.split("\n")
-		except:
+			n_channels = int(attr[np.argmax([s.startswith("channels") for s in attr])].split("=")[-1])
+		except Exception as e:
 			pass
 		try:
 			# Try nframes
@@ -948,6 +960,10 @@ def auto_load_number_of_frames(stack_path):
 	if 'len_movie' not in locals():
 		stack = imread(stack_path)
 		len_movie = len(stack)
+		if len_movie==n_channels and stack.ndim==3:
+			len_movie = 1
+		if stack.ndim==2:
+			len_movie = 1
 		del stack
 	gc.collect()
 
@@ -1585,6 +1601,8 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 
 			for k, sq in enumerate(squares):
 				print(f"ROI: {sq}")
+				pad_to_256=False
+
 				xmin = int(sq[0, 1])
 				xmax = int(sq[2, 1])
 				if xmax < xmin:
@@ -1596,8 +1614,9 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 				print(f"{xmin=};{xmax=};{ymin=};{ymax=}")
 				frame = viewer.layers['Image'].data[t][xmin:xmax, ymin:ymax]
 				if frame.shape[1] < 256 or frame.shape[0] < 256:
-					print("crop too small!")
-					continue
+					pad_to_256 = True
+					print("Crop too small! Padding with zeros to reach 256*256 pixels...")
+					#continue
 				multichannel = [frame]
 				for i in range(len(channel_indices) - 1):
 					try:
@@ -1605,8 +1624,21 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 						multichannel.append(frame)
 					except:
 						pass
-				multichannel = np.array(multichannel)        
-				save_tiff_imagej_compatible(annotation_folder + f"{exp_name}_{position.split(os.sep)[-2]}_{str(t).zfill(4)}_roi_{xmin}_{xmax}_{ymin}_{ymax}_labelled.tif", labels_layer[xmin:xmax,ymin:ymax].astype(np.int16), axes='YX')
+				multichannel = np.array(multichannel)
+				lab = labels_layer[xmin:xmax,ymin:ymax].astype(np.int16)
+				if pad_to_256:
+					shape = multichannel.shape
+					pad_length_x = max([0,256 - multichannel.shape[1]])
+					if pad_length_x>0 and pad_length_x%2==1:
+						pad_length_x += 1
+					pad_length_y = max([0,256 - multichannel.shape[2]])
+					if pad_length_y>0 and pad_length_y%2==1:
+						pad_length_y += 1
+					padded_image = np.array([np.pad(im, ((pad_length_x//2,pad_length_x//2), (pad_length_y//2,pad_length_y//2)), mode='constant') for im in multichannel])
+					padded_label = np.pad(lab,((pad_length_x//2,pad_length_x//2), (pad_length_y//2,pad_length_y//2)), mode='constant')
+					lab = padded_label; multichannel = padded_image;
+
+				save_tiff_imagej_compatible(annotation_folder + f"{exp_name}_{position.split(os.sep)[-2]}_{str(t).zfill(4)}_roi_{xmin}_{xmax}_{ymin}_{ymax}_labelled.tif", lab, axes='YX')
 				save_tiff_imagej_compatible(annotation_folder + f"{exp_name}_{position.split(os.sep)[-2]}_{str(t).zfill(4)}_roi_{xmin}_{xmax}_{ymin}_{ymax}.tif", multichannel, axes='CYX')
 				info = {"spatial_calibration": spatial_calibration, "channels": list(channel_names), 'cell_type': ct, 'antibody': ab, 'concentration': conc, 'pharmaceutical_agent': pa}
 				info_name = annotation_folder + f"{exp_name}_{position.split(os.sep)[-2]}_{str(t).zfill(4)}_roi_{xmin}_{xmax}_{ymin}_{ymax}.json"
@@ -1645,6 +1677,7 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 		population += 's'
 	output_folder = position + f'labels_{population}{os.sep}'
 
+	print(f"{stack.shape}")
 	viewer = napari.Viewer()
 	viewer.add_image(stack, channel_axis=-1, colormap=["gray"] * stack.shape[-1])
 	viewer.add_labels(labels.astype(int), name='segmentation', opacity=0.4)
@@ -1832,10 +1865,24 @@ def get_segmentation_models_list(mode='targets', return_path=False):
 
 	available_models = natsorted(glob(modelpath + '*/'))
 	available_models = [m.replace('\\', '/').split('/')[-2] for m in available_models]
+
+	# Auto model cleanup
+	to_remove = []
+	for model in available_models:
+		path = modelpath + model
+		files = glob(path+os.sep+"*")
+		if path+os.sep+"config_input.json" not in files:
+			rmtree(path)
+			to_remove.append(model)
+	for m in to_remove:
+		available_models.remove(m)
+
+
 	for rm in repository_models:
 		if rm not in available_models:
 			available_models.append(rm)
 
+
 	if not return_path:
 		return available_models
 	else: