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

celldetective/gui/viewers.py

@@ -11,9 +11,10 @@ from natsort import natsorted
 from glob import glob
 import os
 
-from PyQt5.QtWidgets import QWidget, QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget
+from PyQt5.QtWidgets import QWidget, QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget, QShortcut
 from PyQt5.QtCore import Qt, QSize
-from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout
+from PyQt5.QtGui import QKeySequence
+from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout, QHSeperationLine, ThresholdLineEdit
 from celldetective.gui import Styles
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QLabeledDoubleRangeSlider
 from superqt.fonticon import icon
@@ -21,6 +22,7 @@ from fonticon_mdi6 import MDI6
 from matplotlib_scalebar.scalebar import ScaleBar
 import gc
 from celldetective.utils import mask_edges
+from scipy.ndimage import shift
 
 class StackVisualizer(QWidget, Styles):
 
@@ -739,4 +741,262 @@ class CellSizeViewer(StackVisualizer):
 		
 		self.diameter = value
 		self.circ.set_radius(self.diameter//2)
-		self.canvas.canvas.draw_idle()
+		self.canvas.canvas.draw_idle()
+
+
+class ChannelOffsetViewer(StackVisualizer):
+
+	def __init__(self, parent_window=None, *args, **kwargs):
+		
+		self.parent_window = parent_window
+		self.overlay_target_channel = -1
+		self.shift_vertical = 0
+		self.shift_horizontal = 0
+		super().__init__(*args, **kwargs)
+
+		self.load_stack()
+		self.canvas.layout.addWidget(QHSeperationLine())
+		
+		self.generate_overlay_channel_cb()
+		self.generate_overlay_imshow()
+		
+		self.generate_overlay_alpha_slider()
+		self.generate_overlay_contrast_slider()
+
+		self.generate_overlay_shift()
+		self.generate_add_to_parent_btn()
+
+		if self.overlay_target_channel==-1:
+			index = len(self.channel_names) -1
+		else:
+			index = self.overlay_target_channel
+		self.channels_overlay_cb.setCurrentIndex(index)
+		self.frame_slider.valueChanged.connect(self.change_overlay_frame)
+
+		self.define_keyboard_shortcuts()
+
+		self.channels_overlay_cb.setCurrentIndex(self.parent_window.channels_cb.currentIndex())
+		self.set_channel_index(0)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
+	def generate_overlay_imshow(self):
+		self.im_overlay = self.ax.imshow(self.overlay_init_frame, cmap='Blues', interpolation='none',alpha=0.5, **self.imshow_kwargs)
+
+	def generate_overlay_alpha_slider(self):
+		# Generate the contrast slider if enabled
+		
+		self.overlay_alpha_slider = QLabeledDoubleSlider()
+		alpha_layout = QuickSliderLayout(
+											label='Overlay\ntransparency: ',
+											slider=self.overlay_alpha_slider,
+											slider_initial_value=0.5,
+											slider_range=(0,1.0),
+											decimal_option=True,
+											precision=1.0E-05,
+											)
+		alpha_layout.setContentsMargins(15,0,15,0)
+		self.overlay_alpha_slider.valueChanged.connect(self.change_alpha_overlay)
+		self.canvas.layout.addLayout(alpha_layout)
+
+
+	def generate_overlay_contrast_slider(self):
+		# Generate the contrast slider if enabled
+		
+		self.overlay_contrast_slider = QLabeledDoubleRangeSlider()
+		contrast_layout = QuickSliderLayout(
+											label='Overlay contrast: ',
+											slider=self.overlay_contrast_slider,
+											slider_initial_value=[np.nanpercentile(self.overlay_init_frame, 0.1),np.nanpercentile(self.overlay_init_frame, 99.99)],
+											slider_range=(np.nanmin(self.overlay_init_frame),np.nanmax(self.overlay_init_frame)),
+											decimal_option=True,
+											precision=1.0E-05,
+											)
+		contrast_layout.setContentsMargins(15,0,15,0)
+		self.im_overlay.set_clim(vmin=np.nanpercentile(self.overlay_init_frame, 0.1),vmax=np.nanpercentile(self.overlay_init_frame, 99.99))
+		self.overlay_contrast_slider.valueChanged.connect(self.change_contrast_overlay)
+		self.canvas.layout.addLayout(contrast_layout)
+
+	def set_overlay_channel_index(self, value):
+		# Set the channel index based on dropdown value
+
+		self.overlay_target_channel = value
+		self.overlay_init_contrast = True
+		if self.mode == 'direct':
+			self.overlay_last_frame = self.stack[-1,:,:,self.overlay_target_channel]
+		elif self.mode == 'virtual':
+			self.overlay_last_frame = load_frames(self.img_num_per_channel[self.overlay_target_channel, self.stack_length-1], 
+										  self.stack_path,
+										  normalize_input=False).astype(float)[:,:,0]
+		self.change_overlay_frame(self.frame_slider.value())
+		self.overlay_init_contrast = False
+
+	def generate_overlay_channel_cb(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('Overlay channel: '), 25)
+
+		self.channels_overlay_cb = QComboBox()
+		self.channels_overlay_cb.addItems(self.channel_names)
+		self.channels_overlay_cb.currentIndexChanged.connect(self.set_overlay_channel_index)
+		channel_layout.addWidget(self.channels_overlay_cb, 75)
+		self.canvas.layout.addLayout(channel_layout)
+
+	def generate_overlay_shift(self):
+
+		shift_layout = QHBoxLayout()
+		shift_layout.setContentsMargins(15,0,15,0)
+		shift_layout.addWidget(QLabel('shift (h): '), 20, alignment=Qt.AlignRight)
+
+		self.apply_shift_btn = QPushButton('Apply')
+		self.apply_shift_btn.setStyleSheet(self.button_style_sheet_2)
+		self.apply_shift_btn.setToolTip('Apply the shift to the overlay channel.')
+		self.apply_shift_btn.clicked.connect(self.shift_generic)
+
+		self.set_shift_btn = QPushButton('Set')
+
+		self.horizontal_shift_le = ThresholdLineEdit(init_value=self.shift_horizontal, connected_buttons=[self.apply_shift_btn, self.set_shift_btn],placeholder='horizontal shift [pixels]', value_type='float')
+		shift_layout.addWidget(self.horizontal_shift_le, 20)
+
+		shift_layout.addWidget(QLabel('shift (v): '), 20, alignment=Qt.AlignRight)
+
+		self.vertical_shift_le = ThresholdLineEdit(init_value=self.shift_vertical, connected_buttons=[self.apply_shift_btn, self.set_shift_btn],placeholder='vertical shift [pixels]', value_type='float')
+		shift_layout.addWidget(self.vertical_shift_le, 20)
+
+		shift_layout.addWidget(self.apply_shift_btn, 20)
+
+		self.canvas.layout.addLayout(shift_layout)
+
+
+	def change_overlay_frame(self, value):
+		# Change the displayed frame based on slider value
+		
+		if self.mode=='virtual':
+
+			self.overlay_init_frame = load_frames(self.img_num_per_channel[self.overlay_target_channel, value], 
+								self.stack_path,
+								normalize_input=False
+								).astype(float)[:,:,0]
+		elif self.mode=='direct':
+			self.overlay_init_frame = self.stack[value,:,:,self.overlay_target_channel].copy()
+		
+		self.im_overlay.set_data(self.overlay_init_frame)
+		
+		if self.overlay_init_contrast:
+			self.im_overlay.autoscale()
+			I_min, I_max = self.im_overlay.get_clim()
+			self.overlay_contrast_slider.setRange(np.nanmin([self.overlay_init_frame,self.overlay_last_frame]),np.nanmax([self.overlay_init_frame,self.overlay_last_frame]))
+			self.overlay_contrast_slider.setValue((I_min,I_max))
+
+		if self.create_contrast_slider:
+			self.change_contrast_overlay(self.overlay_contrast_slider.value())
+	
+	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.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)
+
+		self.init_frame = load_frames(self.img_num_per_channel[self.target_channel, self.mid_time], 
+									  self.stack_path,
+									  normalize_input=False).astype(float)[:,:,0]
+		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.overlay_init_frame = load_frames(self.img_num_per_channel[self.overlay_target_channel, self.mid_time], 
+									  self.stack_path,
+									  normalize_input=False).astype(float)[:,:,0]
+		self.overlay_last_frame = load_frames(self.img_num_per_channel[self.overlay_target_channel, self.stack_length-1], 
+									  self.stack_path,
+									  normalize_input=False).astype(float)[:,:,0]
+	
+	def change_contrast_overlay(self, value):
+		# Change contrast based on slider value
+
+		vmin = value[0]
+		vmax = value[1]
+		self.im_overlay.set_clim(vmin=vmin, vmax=vmax)
+		self.fig.canvas.draw_idle()
+
+	def change_alpha_overlay(self, value):
+		# Change contrast based on slider value
+
+		alpha = value
+		self.im_overlay.set_alpha(alpha)
+		self.fig.canvas.draw_idle()
+
+
+	def define_keyboard_shortcuts(self):
+		
+		self.shift_up_shortcut = QShortcut(QKeySequence(Qt.Key_Up), self.canvas)
+		self.shift_up_shortcut.activated.connect(self.shift_overlay_up)
+		
+		self.shift_down_shortcut = QShortcut(QKeySequence(Qt.Key_Down), self.canvas)
+		self.shift_down_shortcut.activated.connect(self.shift_overlay_down)
+
+		self.shift_left_shortcut = QShortcut(QKeySequence(Qt.Key_Left), self.canvas)
+		self.shift_left_shortcut.activated.connect(self.shift_overlay_left)
+		
+		self.shift_right_shortcut = QShortcut(QKeySequence(Qt.Key_Right), self.canvas)
+		self.shift_right_shortcut.activated.connect(self.shift_overlay_right)
+
+
+	def shift_overlay_up(self):
+		self.shift_vertical -= 2
+		self.vertical_shift_le.set_threshold(self.shift_vertical)
+		#self.shift_generic()
+		self.apply_shift_btn.click()
+
+	def shift_overlay_down(self):
+		self.shift_vertical += 2
+		self.vertical_shift_le.set_threshold(self.shift_vertical)
+		#self.shift_generic()
+		self.apply_shift_btn.click()
+
+	def shift_overlay_left(self):
+		self.shift_horizontal -= 2
+		self.horizontal_shift_le.set_threshold(self.shift_horizontal)
+		#self.shift_generic()
+		self.apply_shift_btn.click()
+
+	def shift_overlay_right(self):
+		self.shift_horizontal += 2
+		self.horizontal_shift_le.set_threshold(self.shift_horizontal)
+		#self.shift_generic()
+		self.apply_shift_btn.click()
+
+	def shift_generic(self):
+		self.shift_vertical = self.vertical_shift_le.get_threshold()
+		self.shift_horizontal = self.horizontal_shift_le.get_threshold()
+		self.shifted_frame = shift(self.overlay_init_frame, [self.shift_vertical, self.shift_horizontal],prefilter=False)
+		self.im_overlay.set_data(self.shifted_frame)
+		self.fig.canvas.draw_idle()
+
+	def generate_add_to_parent_btn(self):
+		
+		add_hbox = QHBoxLayout()
+		add_hbox.setContentsMargins(0,5,0,5)
+		self.set_shift_btn.clicked.connect(self.set_parent_attributes)
+		self.set_shift_btn.setStyleSheet(self.button_style_sheet)
+		add_hbox.addWidget(QLabel(''),33)
+		add_hbox.addWidget(self.set_shift_btn, 33)
+		add_hbox.addWidget(QLabel(''),33)		
+		self.canvas.layout.addLayout(add_hbox)
+
+	def set_parent_attributes(self):
+
+		idx = self.channels_overlay_cb.currentIndex()
+		self.parent_window.channels_cb.setCurrentIndex(idx)
+		self.parent_window.vertical_shift_le.set_threshold(self.vertical_shift_le.get_threshold())
+		self.parent_window.horizontal_shift_le.set_threshold(self.horizontal_shift_le.get_threshold())
+		self.close()

celldetective/io.py

@@ -24,6 +24,54 @@ import concurrent.futures
 from tifffile import imwrite
 from stardist import fill_label_holes
 
+def extract_experiment_from_well(well_path):
+	if not well_path.endswith(os.sep):
+		well_path += os.sep
+	exp_path_blocks = well_path.split(os.sep)[:-2]
+	experiment = os.sep.join(exp_path_blocks)
+	return experiment
+
+def extract_well_from_position(pos_path):
+	if not pos_path.endswith(os.sep):
+		pos_path += os.sep
+	well_path_blocks = pos_path.split(os.sep)[:-2]
+	well_path = os.sep.join(well_path_blocks)+os.sep
+	return well_path
+
+def extract_experiment_from_position(pos_path):
+	if not pos_path.endswith(os.sep):
+		pos_path += os.sep
+	exp_path_blocks = pos_path.split(os.sep)[:-3]
+	experiment = os.sep.join(exp_path_blocks)
+	return experiment
+
+def collect_experiment_metadata(pos_path=None, well_path=None):
+	
+	if pos_path is not None:
+		if not pos_path.endswith(os.sep):
+			pos_path += os.sep
+		experiment = extract_experiment_from_position(pos_path)
+		well_path = extract_well_from_position(pos_path)
+	elif well_path is not None:
+		if not well_path.endswith(os.sep):
+			well_path += os.sep
+		experiment = extract_experiment_from_well(well_path)
+		
+	wells = list(get_experiment_wells(experiment))
+	idx = wells.index(well_path)
+	well_name, well_nbr = extract_well_name_and_number(well_path)
+	if pos_path is not None:
+		pos_name = extract_position_name(pos_path)
+	else:
+		pos_name = 0
+	concentrations = get_experiment_concentrations(experiment, dtype=float)
+	cell_types = get_experiment_cell_types(experiment)
+	antibodies = get_experiment_antibodies(experiment)
+	pharmaceutical_agents = get_experiment_pharmaceutical_agents(experiment)
+	
+	return {"pos_path": pos_path, "pos_name": pos_name, "well_path": well_path, "well_name": well_name, "well_nbr": well_nbr, "experiment": experiment, "antibody": antibodies[idx], "concentration": concentrations[idx], "cell_type": cell_types[idx], "pharmaceutical_agent": pharmaceutical_agents[idx]}
+
+
 def get_experiment_wells(experiment):
 	
 	"""
@@ -712,12 +760,17 @@ def fix_missing_labels(position, population='target', prefix='Aligned'):
 
 	if population.lower() == "target" or population.lower() == "targets":
 		label_path = natsorted(glob(position + os.sep.join(["labels_targets", "*.tif"])))
+		path = position + os.sep + "labels_targets"
 	elif population.lower() == "effector" or population.lower() == "effectors":
 		label_path = natsorted(glob(position + os.sep.join(["labels_effectors", "*.tif"])))
+		path = position + os.sep + "labels_effectors"
 
-	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]
+	if label_path!=[]:
+		#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]
+	else:
+		to_create = all_frames
 	to_create = [str(x).zfill(4)+'.tif' for x in to_create]
 	for file in to_create:
 		imwrite(os.sep.join([path, file]), template)