celldetective 1.3.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

celldetective/gui/process_block.py

@@ -30,10 +30,10 @@ import json
 import psutil
 from celldetective.neighborhood import compute_neighborhood_at_position, compute_contact_neighborhood_at_position
 from celldetective.gui.gui_utils import FigureCanvas
-from celldetective.preprocessing import correct_background_model_free, correct_background_model
+from celldetective.preprocessing import correct_background_model_free, correct_background_model, correct_channel_offset
 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
 from celldetective.gui.gui_utils import ThresholdLineEdit, QuickSliderLayout, help_generic
-from celldetective.gui.layouts import CellposeParamsWidget, StarDistParamsWidget, BackgroundModelFreeCorrectionLayout, ProtocolDesignerLayout, BackgroundFitCorrectionLayout
+from celldetective.gui.layouts import CellposeParamsWidget, StarDistParamsWidget, BackgroundModelFreeCorrectionLayout, ProtocolDesignerLayout, BackgroundFitCorrectionLayout, ChannelOffsetOptionsLayout
 from celldetective.gui import Styles
 from celldetective.utils import get_software_location
 
@@ -166,10 +166,10 @@ class ProcessPanel(QFrame, Styles):
 		self.generate_signal_analysis_options()
 
 		self.grid_contents.addWidget(QHSeperationLine(), 9, 0, 1, 4)
-		self.view_tab_btn = QPushButton("View table")
+		self.view_tab_btn = QPushButton("Explore table")
 		self.view_tab_btn.setStyleSheet(self.button_style_sheet_2)
 		self.view_tab_btn.clicked.connect(self.view_table_ui)
-		self.view_tab_btn.setToolTip('View table')
+		self.view_tab_btn.setToolTip('Explore table')
 		self.view_tab_btn.setIcon(icon(MDI6.table,color="#1565c0"))
 		self.view_tab_btn.setIconSize(QSize(20, 20))
 		#self.view_tab_btn.setEnabled(False)
@@ -177,7 +177,7 @@ class ProcessPanel(QFrame, Styles):
 
 		self.grid_contents.addWidget(QHSeperationLine(), 9, 0, 1, 4)
 		self.submit_btn = QPushButton("Submit")
-		self.submit_btn.setStyleSheet(self.button_style_sheet_2)
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.clicked.connect(self.process_population)
 		self.grid_contents.addWidget(self.submit_btn, 11, 0, 1, 4)
 
@@ -228,7 +228,7 @@ class ProcessPanel(QFrame, Styles):
 
 		signal_layout = QVBoxLayout()
 		signal_hlayout = QHBoxLayout()
-		self.signal_analysis_action = QCheckBox("SIGNAL ANALYSIS")
+		self.signal_analysis_action = QCheckBox("DETECT EVENTS")
 		self.signal_analysis_action.setStyleSheet("""
 			font-size: 10px;
 			padding-left: 10px;
@@ -1283,10 +1283,10 @@ class NeighPanel(QFrame, Styles):
 		self.grid_contents.addLayout(signal_layout, 7, 0, 1, 4)
 		self.grid_contents.addWidget(QHSeperationLine(), 11, 0, 1, 4)
 
-		self.view_tab_btn = QPushButton("View table")
+		self.view_tab_btn = QPushButton("Explore table")
 		self.view_tab_btn.setStyleSheet(self.button_style_sheet_2)
 		self.view_tab_btn.clicked.connect(self.view_table_ui)
-		self.view_tab_btn.setToolTip('View table')
+		self.view_tab_btn.setToolTip('Explore table')
 		self.view_tab_btn.setIcon(icon(MDI6.table,color="#1565c0"))
 		self.view_tab_btn.setIconSize(QSize(20, 20))
 		#self.view_tab_btn.setEnabled(False)
@@ -1295,7 +1295,7 @@ class NeighPanel(QFrame, Styles):
 		#self.grid_contents.addWidget(QLabel(''), 12, 0, 1, 4)
 
 		self.submit_btn = QPushButton("Submit")
-		self.submit_btn.setStyleSheet(self.button_style_sheet_2)
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.setToolTip("Compute the neighborhoods of the selected positions.")
 		self.submit_btn.clicked.connect(self.process_neighborhood)
 		self.grid_contents.addWidget(self.submit_btn, 14, 0, 1, 4)
@@ -1657,12 +1657,33 @@ class PreprocessingPanel(QFrame, Styles):
 
 		self.protocol_layout.title_layout.addWidget(self.help_background_btn, 5, alignment=Qt.AlignRight)
 
+		
+		self.channel_offset_correction_layout = QVBoxLayout()
+
+		self.channel_shift_lbl = QLabel("CHANNEL OFFSET CORRECTION")
+		self.channel_shift_lbl.setStyleSheet("""
+			font-weight: bold;
+			padding: 0px;
+			""")
+		self.channel_offset_correction_layout.addWidget(self.channel_shift_lbl, alignment=Qt.AlignCenter)
+
+		self.channel_offset_options_layout = ChannelOffsetOptionsLayout(self)
+		self.channel_offset_correction_layout.addLayout(self.channel_offset_options_layout)
+		
+		self.protocol_layout.correction_layout.addWidget(QLabel(''))
+		self.protocol_layout.correction_layout.addLayout(self.channel_offset_correction_layout)
+
 		self.grid_contents.addLayout(self.protocol_layout,0,0,1,4)
+
 		self.submit_preprocessing_btn = QPushButton("Submit")
-		self.submit_preprocessing_btn.setStyleSheet(self.button_style_sheet_2)
+		self.submit_preprocessing_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_preprocessing_btn.clicked.connect(self.launch_preprocessing)
+		
 		self.grid_contents.addWidget(self.submit_preprocessing_btn, 1,0,1,4)
 
+	def add_offset_instructions_to_parent_list(self):
+		print('adding instructions')
+
 
 	def launch_preprocessing(self):
 
@@ -1712,7 +1733,7 @@ class PreprocessingPanel(QFrame, Styles):
 				export_prefix = None
 
 			if correction_protocol['correction_type']=='model-free':
-
+				print(f'Model-free correction; {movie_prefix=} {export_prefix=}')
 				correct_background_model_free(self.exp_dir, 
 								   well_option=well_option,
 								   position_option=pos_option,
@@ -1726,7 +1747,7 @@ class PreprocessingPanel(QFrame, Styles):
 								)
 			
 			elif correction_protocol['correction_type']=='fit':
-
+				print(f'Fit correction; {movie_prefix=} {export_prefix=} {correction_protocol=}')
 				correct_background_model(self.exp_dir,
 								   well_option=well_option,
 								   position_option=pos_option,
@@ -1738,6 +1759,19 @@ class PreprocessingPanel(QFrame, Styles):
 								   export_prefix = export_prefix,
 								   **correction_protocol,
 								)
+			elif correction_protocol['correction_type']=='offset':
+				print(f'Offset correction; {movie_prefix=} {export_prefix=} {correction_protocol=}')
+				correct_channel_offset(self.exp_dir,
+								   well_option=well_option,
+								   position_option=pos_option,
+								   export= True,
+								   return_stacks=False,
+								   show_progress_per_well = True,
+								   show_progress_per_pos = True,
+								   movie_prefix = movie_prefix,
+								   export_prefix = export_prefix,
+								   **correction_protocol,
+								)
 		print('Done.')
 
 

celldetective/gui/retrain_segmentation_model_options.py

@@ -8,7 +8,7 @@ from superqt import QLabeledDoubleSlider,QLabeledSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 from celldetective.utils import get_software_location
-from celldetective.io import get_segmentation_datasets_list, locate_segmentation_dataset
+from celldetective.io import get_segmentation_datasets_list, locate_segmentation_dataset, get_segmentation_models_list
 from celldetective.segmentation import train_segmentation_model
 from celldetective.gui.layouts import CellposeParamsWidget
 import numpy as np
@@ -85,8 +85,11 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		self.submit_btn.clicked.connect(self.prep_model)
 		self.main_layout.addWidget(self.submit_btn)
 		self.submit_btn.setEnabled(False)
+		self.submit_warning = QLabel('')
+		self.main_layout.addWidget(self.submit_warning)
 
 		self.spatial_calib_le.textChanged.connect(self.activate_train_btn)
+		self.modelname_le.setText(f"Untitled_model_{datetime.today().strftime('%Y-%m-%d')}")
 
 		#self.populate_left_panel()
 		#grid.addLayout(self.left_side, 0, 0, 1, 1)
@@ -273,6 +276,7 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		modelname_layout.addWidget(QLabel('Model name: '), 30)
 		self.modelname_le = QLineEdit()
 		self.modelname_le.setText(f"Untitled_model_{datetime.today().strftime('%Y-%m-%d')}")
+		self.modelname_le.textChanged.connect(self.activate_train_btn)
 		modelname_layout.addWidget(self.modelname_le, 70)
 		layout.addLayout(modelname_layout)
 
@@ -317,13 +321,21 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		spatial_calib_layout.addWidget(self.spatial_calib_le, 70)
 		layout.addLayout(spatial_calib_layout)
 
-
-
 	def activate_train_btn(self):
-		if self.spatial_calib_le.text()=='':
-			self.submit_btn.setEnabled(False)
-		elif not np.all([cb.currentText()=='--' for cb in self.ch_norm.channel_cbs]):
+
+		current_name = self.modelname_le.text()
+		models = get_segmentation_models_list(mode=self.mode, return_path=False)
+		if not current_name in models and not self.spatial_calib_le.text()=='' and not np.all([cb.currentText()=='--' for cb in self.ch_norm.channel_cbs]):
 			self.submit_btn.setEnabled(True)
+			self.submit_warning.setText('')
+		else:
+			self.submit_btn.setEnabled(False)
+			if current_name in models:
+				self.submit_warning.setText('A model with this name already exists... Please pick another.')
+			elif self.spatial_calib_le.text()=='':
+				self.submit_warning.setText('Please provide a valid spatial calibration...')
+			elif np.all([cb.currentText()=='--' for cb in self.ch_norm.channel_cbs]):
+				self.submit_warning.setText('Please provide valid channels...')
 
 	def rescale_slider(self):
 		if self.stardist_model.isChecked():
@@ -336,11 +348,13 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 
 	def showDialog_pretrained(self):
 
-		try:
-			self.cancel_pretrained.click()
-		except:
-			pass
+		# try:
+		# 	self.cancel_pretrained.click()
+		# except Exception as e:
+		# 	print(e)
+		# 	pass
 
+		self.clear_pretrained()
 		self.pretrained_model = None
 		self.pretrained_model = QFileDialog.getExistingDirectory(
 						self, "Open Directory",

celldetective/gui/survival_ui.py

@@ -125,6 +125,13 @@ class ConfigSurvival(QWidget, Styles):
 		select_layout.addWidget(self.query_le, 66)
 		main_layout.addLayout(select_layout)
 
+		time_cut_layout = QHBoxLayout()
+		time_cut_layout.addWidget(QLabel('cut observation time [min]: '), 33)
+		self.query_time_cut = QLineEdit()
+		self.query_time_cut.setValidator(self.float_validator)
+		time_cut_layout.addWidget(self.query_time_cut, 66)
+		main_layout.addLayout(time_cut_layout)
+
 		self.cbs[0].setCurrentIndex(0)
 		self.cbs[1].setCurrentText('t_firstdetection')
 
@@ -259,17 +266,27 @@ class ConfigSurvival(QWidget, Styles):
 
 	def compute_survival_functions(self):
 
+		cut_observation_time = None
+		try:
+			cut_observation_time = float(self.query_time_cut.text()) / self.FrameToMin
+			if not 0<cut_observation_time<=(self.df['FRAME'].max()):
+				print('Invalid cut time (larger than movie length)... Not applied.')
+				cut_observation_time = None		
+		except Exception as e:
+			pass
+		print(f"{cut_observation_time=}")
+
 		# Per position survival
 		for block,movie_group in self.df.groupby(['well','position']):
 
-			ks = compute_survival(movie_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin)
+			ks = compute_survival(movie_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time)
 			if ks is not None:
 				self.df_pos_info.loc[self.df_pos_info['pos_path']==block[1],'survival_fit'] = ks
 
 		# Per well survival
 		for well,well_group in self.df.groupby('well'):
 
-			ks = compute_survival(well_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin)
+			ks = compute_survival(well_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time)
 			if ks is not None:
 				self.df_well_info.loc[self.df_well_info['well_path']==well,'survival_fit'] = ks
 

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

@@ -766,6 +766,9 @@ def locate_stack_and_labels(position, prefix='Aligned', population="target"):
 	position = position.replace('\\', '/')
 	labels = locate_labels(position, population=population)
 	stack = locate_stack(position, prefix=prefix)
+	if len(labels) < len(stack):
+		fix_missing_labels(position, population=population, prefix=prefix)
+		labels = locate_labels(position, population=population)
 	assert len(stack) == len(
 		labels), f"The shape of the stack {stack.shape} does not match with the shape of the labels {labels.shape}"
 
@@ -1272,7 +1275,7 @@ def view_on_napari_btrack(data, properties, graph, stack=None, labels=None, rela
 	if stack is not None:
 		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)
+		viewer.add_labels(labels.astype(int), name='segmentation', opacity=0.4)
 	viewer.add_points(vertices, size=4, name='points', opacity=0.3)
 	if data.shape[1]==4:
 		viewer.add_tracks(data, properties=properties, graph=graph, name='tracks')