celldetective 1.3.6.post2__py3-none-any.whl → 1.3.7__py3-none-any.whl

celldetective/gui/process_block.py

@@ -1,4 +1,4 @@
-from PyQt5.QtWidgets import QFrame, QGridLayout, QComboBox, QListWidget, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, QCheckBox, \
+from PyQt5.QtWidgets import QDialog, QFrame, QGridLayout, QComboBox, QListWidget, QLabel, QPushButton, QVBoxLayout, QHBoxLayout, QCheckBox, \
 	QMessageBox, QWidget
 from PyQt5.QtCore import Qt, QSize
 from superqt.fonticon import icon
@@ -10,7 +10,7 @@ from celldetective.gui.signal_annotator import MeasureAnnotator
 from celldetective.gui.signal_annotator2 import SignalAnnotator2
 from celldetective.io import get_segmentation_models_list, control_segmentation_napari, get_signal_models_list, \
 	control_tracks, load_experiment_tables, get_pair_signal_models_list
-from celldetective.io import locate_segmentation_model, fix_missing_labels, auto_load_number_of_frames, load_frames, locate_signal_model
+from celldetective.io import locate_segmentation_model, extract_position_name, fix_missing_labels, auto_load_number_of_frames, load_frames, locate_signal_model
 from celldetective.gui import SegmentationModelLoader, ClassifierWidget, ConfigNeighborhoods, ConfigSegmentationModelTraining, ConfigTracking, SignalAnnotator, ConfigSignalModelTraining, ConfigMeasurements, ConfigSignalAnnotator, TableUI
 from celldetective.gui.gui_utils import QHSeperationLine
 from celldetective.relative_measurements import rel_measure_at_position
@@ -37,6 +37,14 @@ from celldetective.gui.layouts import CellposeParamsWidget, StarDistParamsWidget
 from celldetective.gui import Styles
 from celldetective.utils import get_software_location
 
+from celldetective.gui.workers import ProgressWindow
+from celldetective.gui.processes.segment_cells import SegmentCellThresholdProcess, SegmentCellDLProcess
+from celldetective.gui.processes.track_cells import TrackingProcess
+from celldetective.gui.processes.measure_cells import MeasurementProcess
+
+import time
+import asyncio
+
 class ProcessPanel(QFrame, Styles):
 	def __init__(self, parent_window, mode):
 
@@ -52,6 +60,8 @@ class ProcessPanel(QFrame, Styles):
 		self.wells = np.array(self.parent_window.wells,dtype=str)
 		self.cellpose_calibrated = False
 		self.stardist_calibrated = False
+		self.use_gpu = self.parent_window.parent_window.use_gpu
+		self.n_threads = self.parent_window.parent_window.n_threads
 
 		self.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.grid = QGridLayout(self)
@@ -264,7 +274,7 @@ class ProcessPanel(QFrame, Styles):
 		#self.to_disable.append(self.cell_models_list)
 
 		self.train_signal_model_btn = QPushButton("TRAIN")
-		self.train_signal_model_btn.setToolTip("Open a dialog box to create a new target segmentation model.")
+		self.train_signal_model_btn.setToolTip("Train or retrain an event detection model\non newly annotated data.")
 		self.train_signal_model_btn.setIcon(icon(MDI6.redo_variant,color='black'))
 		self.train_signal_model_btn.setIconSize(QSize(20, 20))
 		self.train_signal_model_btn.setStyleSheet(self.button_style_sheet_3)
@@ -284,7 +294,7 @@ class ProcessPanel(QFrame, Styles):
 		self.signal_models_list.addItems(signal_models)
 
 	def generate_tracking_options(self):
-		
+
 		grid_track = QHBoxLayout()
 
 		self.track_action = QCheckBox("TRACK")
@@ -363,7 +373,7 @@ class ProcessPanel(QFrame, Styles):
 		self.segment_action = QCheckBox("SEGMENT")
 		self.segment_action.setStyleSheet(self.menu_check_style)
 		self.segment_action.setIcon(icon(MDI6.bacteria, color='black'))
-		self.segment_action.setToolTip(f"Segment the {self.mode} cells on the images.")
+		self.segment_action.setToolTip(f"Segment the {self.mode[:-1]} cells on the images.")
 		self.segment_action.toggled.connect(self.enable_segmentation_model_list)
 		#self.to_disable.append(self.segment_action)
 		grid_segment.addWidget(self.segment_action, 90)
@@ -390,6 +400,7 @@ class ProcessPanel(QFrame, Styles):
 		model_zoo_layout = QHBoxLayout()
 		model_zoo_layout.addWidget(QLabel("Model zoo:"),90)
 		self.seg_model_list = QComboBox()
+		self.seg_model_list.currentIndexChanged.connect(self.reset_generalist_setup)
 		#self.to_disable.append(self.tc_seg_model_list)
 		self.seg_model_list.setGeometry(50, 50, 200, 30)
 		self.init_seg_model_list()
@@ -682,6 +693,10 @@ class ProcessPanel(QFrame, Styles):
 		self.ConfigSignalAnnotator = ConfigSignalAnnotator(self)
 		self.ConfigSignalAnnotator.show()
 
+	def reset_generalist_setup(self, index):
+		self.cellpose_calibrated = False
+		self.stardist_calibrated = False
+
 	def process_population(self):
 
 		# if self.parent_window.well_list.currentText().startswith('Multiple'):
@@ -750,18 +765,19 @@ class ProcessPanel(QFrame, Styles):
 			self.model_name = self.seg_models[self.seg_model_list.currentIndex()]
 		print(self.model_name, self.seg_model_list.currentIndex())
 
-		if self.model_name.startswith('CP') and self.model_name in self.seg_models_generic and not self.cellpose_calibrated:
+		if self.segment_action.isChecked() and self.model_name.startswith('CP') and self.model_name in self.seg_models_generic and not self.cellpose_calibrated:
 
 			self.diamWidget = CellposeParamsWidget(self, model_name=self.model_name)
 			self.diamWidget.show()
 			return None
 
-		if self.model_name.startswith('SD') and self.model_name in self.seg_models_generic and not self.stardist_calibrated:
+		if self.segment_action.isChecked() and self.model_name.startswith('SD') and self.model_name in self.seg_models_generic and not self.stardist_calibrated:
 
 			self.diamWidget = StarDistParamsWidget(self, model_name = self.model_name)
 			self.diamWidget.show()
 			return None
 
+		self.movie_prefix = self.parent_window.movie_prefix
 
 		for w_idx in self.well_index:
 
@@ -775,6 +791,7 @@ class ProcessPanel(QFrame, Styles):
 
 				self.pos = natsorted(glob(well+f"{os.path.split(well)[-1].replace('W','').replace(os.sep,'')}*/"))[pos_idx]
 				print(f"Position {self.pos}...\nLoading stack movie...")
+				self.pos_name = extract_position_name(self.pos)
 
 				if not os.path.exists(self.pos + 'output/'):
 					os.mkdir(self.pos + 'output/')
@@ -805,9 +822,27 @@ class ProcessPanel(QFrame, Styles):
 								return None
 						else:
 							print(f"Segmentation from threshold config: {self.threshold_config}")
-							segment_from_threshold_at_position(self.pos, self.mode, self.threshold_config, threads=self.parent_window.parent_window.n_threads)
+							process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads, "threshold_instructions": self.threshold_config, "use_gpu": self.use_gpu}
+							self.job = ProgressWindow(SegmentCellThresholdProcess, parent_window=self, title="Segment", process_args = process_args)
+							result = self.job.exec_()
+							if result == QDialog.Accepted:
+								pass
+							elif result == QDialog.Rejected:
+								return None
+							#segment_from_threshold_at_position(self.pos, self.mode, self.threshold_config, threads=self.parent_window.parent_window.n_threads)
 					else:
-						segment_at_position(self.pos, self.mode, self.model_name, stack_prefix=self.parent_window.movie_prefix, use_gpu=self.parent_window.parent_window.use_gpu, threads=self.parent_window.parent_window.n_threads)
+						# model = locate_segmentation_model(self.model_name)
+						# if model is None:
+						# 	process = {"output_dir": self.output_dir, "file": self.model_name}
+						# 	self.download_model_job = ProgressWindow(DownloadProcess, parent_window=self, title="Download", process_args = args)
+
+						process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads, "model_name": self.model_name, "use_gpu": self.use_gpu}
+						self.job = ProgressWindow(SegmentCellDLProcess, parent_window=self, title="Segment", process_args = process_args)
+						result = self.job.exec_()
+						if result == QDialog.Accepted:
+							pass
+						elif result == QDialog.Rejected:
+							return None
 
 				if self.track_action.isChecked():
 					if os.path.exists(os.sep.join([self.pos, 'output', 'tables', f'trajectories_{self.mode}.csv'])) and not self.parent_window.position_list.isMultipleSelection():
@@ -819,10 +854,25 @@ class ProcessPanel(QFrame, Styles):
 						returnValue = msgBox.exec()
 						if returnValue == QMessageBox.No:
 							return None
-					track_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
+
+					process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads}
+					self.job = ProgressWindow(TrackingProcess, parent_window=self, title="Tracking", process_args=process_args)
+					result = self.job.exec_()
+					if result == QDialog.Accepted:
+						pass
+					elif result == QDialog.Rejected:
+						return None
+					#track_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
 
 				if self.measure_action.isChecked():
-					measure_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
+					process_args = {"pos": self.pos, "mode": self.mode, "n_threads": self.n_threads}
+					self.job = ProgressWindow(MeasurementProcess, parent_window=self, title="Measurement", process_args=process_args)
+					result = self.job.exec_()
+					if result == QDialog.Accepted:
+						pass
+					elif result == QDialog.Rejected:
+						return None
+					#measure_at_position(self.pos, self.mode, threads=self.parent_window.parent_window.n_threads)
 
 				table = os.sep.join([self.pos, 'output', 'tables', f'trajectories_{self.mode}.csv'])
 				if self.signal_analysis_action.isChecked() and os.path.exists(table):
@@ -845,12 +895,11 @@ class ProcessPanel(QFrame, Styles):
 
 			# self.stack = None
 		self.parent_window.update_position_options()
-
 		for action in [self.segment_action, self.track_action, self.measure_action, self.signal_analysis_action]:
 			if action.isChecked():
 				action.setChecked(False)
 
-		self.cellpose_calibrated = False
+		self.reset_generalist_setup(0)
 
 	def open_napari_tracking(self):
 		print(f'View the tracks before post-processing for position {self.parent_window.pos} in napari...')
@@ -1207,7 +1256,7 @@ class NeighPanel(QFrame, Styles):
 		self.neigh_action.setChecked(False)
 
 	def open_classifier_ui_pairs(self):
-		
+
 		self.mode = "pairs"
 		self.load_available_tables()
 		if self.df is None:

celldetective/gui/retrain_segmentation_model_options.py

@@ -1,4 +1,4 @@
-from PyQt5.QtWidgets import QMainWindow, QApplication,QRadioButton, QMessageBox, QScrollArea, QComboBox, QFrame, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QDialog, QMainWindow, QApplication,QRadioButton, QMessageBox, QScrollArea, QComboBox, QFrame, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QDoubleValidator, QIntValidator, QIcon
 from celldetective.gui.gui_utils import center_window
@@ -17,6 +17,8 @@ import os
 from glob import glob
 from datetime import datetime
 from celldetective.gui import Styles
+from celldetective.gui.processes.train_segmentation_model import TrainSegModelProcess
+from celldetective.gui.workers import ProgressWindow
 
 class ConfigSegmentationModelTraining(QMainWindow, Styles):
 	
@@ -29,6 +31,7 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		
 		super().__init__()
 		self.parent_window = parent_window
+		self.use_gpu = self.parent_window.use_gpu
 		self.setWindowTitle("Train segmentation model")
 		self.setWindowIcon(QIcon(os.sep.join(['celldetective','icons','mexican-hat.png'])))
 		self.mode = self.parent_window.mode
@@ -239,7 +242,7 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		self.augmentation_slider.setSingleStep(0.01)
 		self.augmentation_slider.setTickInterval(0.01)		
 		self.augmentation_slider.setOrientation(1)
-		self.augmentation_slider.setRange(1, 5)
+		self.augmentation_slider.setRange(0.01, 3)
 		self.augmentation_slider.setValue(2.0)
 
 		augmentation_hbox.addWidget(self.augmentation_slider, 70)
@@ -597,24 +600,34 @@ class ConfigSegmentationModelTraining(QMainWindow, Styles):
 		epochs = self.epochs_slider.value()
 		spatial_calib = float(self.spatial_calib_le.text().replace(',','.'))
 
-		training_instructions = {'model_name': model_name,'model_type': model_type, 'pretrained': pretrained_model, 'spatial_calibration': spatial_calib, 'channel_option': channels, 'normalization_percentile': normalization_mode,
+		self.training_instructions = {'model_name': model_name,'model_type': model_type, 'pretrained': pretrained_model, 'spatial_calibration': spatial_calib, 'channel_option': channels, 'normalization_percentile': normalization_mode,
 		'normalization_clip': clip_values,'normalization_values': norm_values, 'ds': data_folders, 'augmentation_factor': aug_factor, 'validation_split': val_split,
 		'learning_rate': lr, 'batch_size': bs, 'epochs': epochs}
 
-		print(training_instructions)
 
 		model_folder = os.sep.join([self.software_models_dir,model_name, ''])
 		print(model_folder)
 		if not os.path.exists(model_folder):
 			os.mkdir(model_folder)
 
-		training_instructions.update({'target_directory': self.software_models_dir})
+		self.training_instructions.update({'target_directory': self.software_models_dir})
+
+		print(f"Set of instructions: {self.training_instructions}")
+
+		self.instructions = model_folder+"training_instructions.json"
 
-		print(f"Set of instructions: {training_instructions}")
 		with open(model_folder+"training_instructions.json", 'w') as f:
-			json.dump(training_instructions, f, indent=4)
+			json.dump(self.training_instructions, f, indent=4)
 		
-		train_segmentation_model(model_folder+"training_instructions.json", use_gpu=self.parent_window.parent_window.parent_window.use_gpu)
+		# process_args = {"instructions": self.instructions, "use_gpu": self.use_gpu}
+		# self.job = ProgressWindow(TrainSegModelProcess, parent_window=self, title="Training", position_info=False, process_args=process_args)
+		# result = self.job.exec_()
+		# if result == QDialog.Accepted:
+		# 	pass
+		# elif result == QDialog.Rejected:
+		# 	return None		
+
+		train_segmentation_model(self.instructions, use_gpu=self.parent_window.parent_window.parent_window.use_gpu)
 
 		self.parent_window.init_seg_model_list()
 		idx = self.parent_window.seg_model_list.findText(model_name)

celldetective/gui/retrain_signal_model_options.py

@@ -1,4 +1,4 @@
-from PyQt5.QtWidgets import QMainWindow, QApplication, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QMainWindow, QApplication, QDialog, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QDoubleValidator, QIntValidator, QIcon
 from celldetective.gui.gui_utils import center_window
@@ -16,6 +16,8 @@ from glob import glob
 from datetime import datetime
 from celldetective.gui import Styles
 from pandas.api.types import is_numeric_dtype
+from celldetective.gui.processes.train_signal_model import TrainSignalModelProcess
+from celldetective.gui.workers import ProgressWindow
 
 class ConfigSignalModelTraining(QMainWindow, Styles):
 	
@@ -584,6 +586,14 @@ class ConfigSignalModelTraining(QMainWindow, Styles):
 		with open(model_folder+"training_instructions.json", 'w') as f:
 			json.dump(training_instructions, f, indent=4)
 		
-		train_signal_model(model_folder+"training_instructions.json")
+		# self.instructions = model_folder+"training_instructions.json"
+		# process_args = {"instructions": self.instructions} # "use_gpu": self.use_gpu
+		# self.job = ProgressWindow(TrainSignalModelProcess, parent_window=self, title="Training", position_info=False, process_args=process_args)
+		# result = self.job.exec_()
+		# if result == QDialog.Accepted:
+		# 	pass
+		# elif result == QDialog.Rejected:
+		# 	return None	
 
+		train_signal_model(model_folder+"training_instructions.json")
 		self.parent_window.refresh_signal_models()

celldetective/gui/signal_annotator.py

@@ -83,6 +83,15 @@ class SignalAnnotator(QMainWindow, Styles):
 
 			self.populate_widget()
 
+	def resizeEvent(self, event):
+		
+		super().resizeEvent(event)
+
+		try:
+			self.cell_fig.tight_layout()
+		except:
+			pass
+
 	def populate_widget(self):
 
 		"""

celldetective/gui/signal_annotator2.py

@@ -134,6 +134,14 @@ class SignalAnnotator2(QMainWindow,Styles):
 
 		self.setAttribute(Qt.WA_DeleteOnClose)
 
+	def resizeEvent(self, event):
+
+		super().resizeEvent(event)
+		try:
+			self.cell_fig.tight_layout()
+		except:
+			pass
+
 	def populate_widget(self):
 
 		"""

celldetective/gui/styles.py

@@ -125,6 +125,7 @@ class Styles(object):
 				font-size: 8px;
 			}
 			QPushButton:hover {
+				color: white;
 				background-color: #2070EB;
 			}
 			QPushButton:pressed {

celldetective/gui/tableUI.py

@@ -1337,7 +1337,7 @@ class TableUI(QMainWindow, Styles):
 				file_name += ".csv"
 			invalid_cols = [c for c in list(self.data.columns) if c.startswith('Unnamed')]
 			if len(invalid_cols)>0:
-				self.data = self.data.drop(invalid_cols, axis=1)	
+				self.data = self.data.drop(invalid_cols, axis=1)
 			self.data.to_csv(file_name, index=False)
 
 	def test_bool(self, array):

celldetective/gui/workers.py

@@ -0,0 +1,136 @@
+from multiprocessing import Queue
+from PyQt5.QtWidgets import QDialog, QPushButton, QVBoxLayout, QHBoxLayout, QWidget, QLabel, QProgressBar
+from PyQt5.QtCore import QRunnable, QObject, pyqtSignal, QThreadPool, QSize, Qt
+from celldetective.gui.gui_utils import center_window
+import time
+import math
+
+class ProgressWindow(QDialog):
+
+	def __init__(self, process=None, parent_window=None, title="", position_info=True, process_args=None):
+		QDialog.__init__(self)
+
+		self.setWindowTitle(f'{title} Progress')
+		self.__process = process
+		self.parent_window = parent_window
+		self.position_info = position_info
+		if self.position_info:
+			self.pos_name = self.parent_window.pos_name
+
+		#self.__btn_run = QPushButton("Start")
+		self.__btn_stp = QPushButton("Cancel")
+		if self.position_info:
+			self.position_label = QLabel(f'Processing position {self.pos_name}...')
+		self.__label   = QLabel("Idle")
+		self.time_left_lbl = QLabel('')
+
+		self.progress_bar = QProgressBar()
+		self.progress_bar.setValue(0)
+
+		self.__runner  = Runner(process=self.__process, progress_bar=self.progress_bar, process_args=process_args, remaining_time_label=self.time_left_lbl)
+		self.pool = QThreadPool.globalInstance()
+		#print("Multithreading with maximum %d threads" % self.pool.maxThreadCount())
+
+		#self.__btn_run.clicked.connect(self.__run_net)
+		self.__btn_stp.clicked.connect(self.__stp_net)
+		self.__runner.signals.finished.connect(self.__on_finished)
+		self.__runner.signals.finished.connect(self.__on_error)
+		self.__runner.signals.update.connect(self.progress_bar.setValue)
+		self.__runner.signals.update_time.connect(self.time_left_lbl.setText)
+
+		self.__btn_stp.setDisabled(True)
+
+		self.layout = QVBoxLayout()
+		if self.position_info:
+			self.layout.addWidget(self.position_label)
+		self.layout.addWidget(self.time_left_lbl)
+		self.layout.addWidget(self.progress_bar)
+		self.btn_layout = QHBoxLayout()
+		self.btn_layout.addWidget(self.__btn_stp)
+		self.btn_layout.addWidget(self.__label)
+		self.layout.addLayout(self.btn_layout)
+
+		self.setLayout(self.layout)
+		self.setFixedSize(QSize(250, 130))
+		self.__run_net()
+		self.setModal(True)
+		center_window(self)
+
+	def closeEvent(self, evnt):
+		# if self._want_to_close:
+		# 	super(MyDialog, self).closeEvent(evnt)
+		# else:
+		evnt.ignore()
+		self.setWindowState(Qt.WindowMinimized)
+
+	def __run_net(self):
+		#self.__btn_run.setDisabled(True)
+		self.__btn_stp.setEnabled(True)
+		self.__label.setText("Running...")
+		self.pool.start(self.__runner)
+
+	def __stp_net(self):
+		self.__runner.close()
+		print('\n Job cancelled... Abort.')
+		self.reject()
+
+	def __on_finished(self):
+		self.__btn_stp.setDisabled(True)
+		self.__label.setText("\nFinished!")
+		self.__runner.close()
+		self.accept()
+
+	def __on_error(self):
+		self.__btn_stp.setDisabled(True)
+		self.__label.setText("\nError")
+		self.__runner.close()
+		self.accept()
+
+class Runner(QRunnable):
+
+	def __init__(self, process=None, progress_bar=None, remaining_time_label=None, process_args=None):
+		QRunnable.__init__(self)
+
+		print(f"{process_args=}")
+		self.progress_bar = progress_bar
+		#self.parent_window = parent_window
+		self.remaining_time_label = remaining_time_label
+		self.__queue = Queue()
+		self.__process = process(self.__queue, process_args=process_args)
+		self.signals = RunnerSignal()
+
+	def run(self):
+		self.__process.start()
+		while True:
+			try:
+				data = self.__queue.get()
+				if len(data)==2:
+					progress, time = data
+					time = int(time)
+					remaining_minutes = time // 60
+					remaining_seconds = int(time % 60)
+					time_left = "About "+str(remaining_minutes)+" min and "+str(remaining_seconds)+" s remaining"
+					if remaining_minutes == 0:
+						time_left = "About "+str(remaining_seconds)+" s remaining"
+					self.signals.update_time.emit(time_left)
+					if isinstance(progress, (float,int)):
+						self.signals.update.emit(math.ceil(progress))
+				if data == "finished":
+					self.signals.finished.emit()
+					break
+				elif data == "error":
+					self.signals.error.emit()
+			except Exception as e:
+				print(e)
+				pass
+
+	def close(self):
+		self.__process.end_process()
+
+
+class RunnerSignal(QObject):
+
+	update = pyqtSignal(int)
+	update_time = pyqtSignal(str)
+	finished = pyqtSignal()
+	error = pyqtSignal()

celldetective/io.py

@@ -19,16 +19,16 @@ from csbdeep.io import save_tiff_imagej_compatible
 import skimage.io as skio
 from skimage.measure import regionprops_table, label
 
-from scipy.ndimage import zoom
 from btrack.datasets import cell_config
 from magicgui import magicgui
 from pathlib import Path, PurePath
 from shutil import copyfile, rmtree
 
-from celldetective.utils import ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
-from celldetective.utils import _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel
+from celldetective.utils import _rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes,ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
+from celldetective.utils import interpolate_nan_multichannel, _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel
 
 from stardist import fill_label_holes
+from skimage.transform import resize
 
 
 def extract_experiment_from_well(well_path):
@@ -1190,7 +1190,11 @@ def locate_labels(position, population='target', frames=None):
 	elif isinstance(frames, (int,float, np.int_)):
 
 		tzfill = str(int(frames)).zfill(4)
-		idx = label_names.index(f"{tzfill}.tif")
+		try:
+			idx = label_names.index(f"{tzfill}.tif")
+		except:
+			idx = -1
+
 		if idx==-1:
 			labels = None
 		else:
@@ -1200,7 +1204,11 @@ def locate_labels(position, population='target', frames=None):
 		labels = []
 		for f in frames:
 			tzfill = str(int(f)).zfill(4)
-			idx = label_names.index(f"{tzfill}.tif")
+			try:
+				idx = label_names.index(f"{tzfill}.tif")
+			except:
+				idx = -1
+			
 			if idx==-1:
 				labels.append(None)
 			else:
@@ -2842,7 +2850,7 @@ def get_segmentation_models_list(mode='targets', return_path=False):
 		return available_models, modelpath
 
 
-def locate_segmentation_model(name):
+def locate_segmentation_model(name, download=True):
 	
 	"""
 	Locates a specified segmentation model within the local 'celldetective' directory or
@@ -2882,13 +2890,15 @@ def locate_segmentation_model(name):
 		if name == m.replace('\\', os.sep).split(os.sep)[-2]:
 			match = m
 			return match
-	# else no match, try zenodo
-	files, categories = get_zenodo_files()
-	if name in files:
-		index = files.index(name)
-		cat = categories[index]
-		download_zenodo_file(name, os.sep.join([main_dir, cat]))
-		match = os.sep.join([main_dir, cat, name]) + os.sep
+	if download:
+		# else no match, try zenodo
+		files, categories = get_zenodo_files()
+		if name in files:
+			index = files.index(name)
+			cat = categories[index]
+			download_zenodo_file(name, os.sep.join([main_dir, cat]))
+			match = os.sep.join([main_dir, cat, name]) + os.sep
+
 	return match
 
 
@@ -3306,27 +3316,16 @@ def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=fl
 			f'Error in loading the frame {img_nums} {e}. Please check that the experiment channel information is consistent with the movie being read.')
 		return None
 
-	if frames.ndim == 3:
-		# Systematically move channel axis to the end
-		channel_axis = np.argmin(frames.shape)
-		frames = np.moveaxis(frames, channel_axis, -1)
-
-	if frames.ndim==2:
-		frames = frames[:,:,np.newaxis].astype(float)
+	frames = _rearrange_multichannel_frame(frames)
 
 	if normalize_input:
 		frames = normalize_multichannel(frames, **normalize_kwargs)
 
 	if scale is not None:
-		frames = [zoom(frames[:,:,c].copy(), [scale,scale], order=3, prefilter=False) for c in range(frames.shape[-1])]
-		frames = np.moveaxis(frames,0,-1)
+		frames = zoom_multiframes(frames, scale)
 
 	# add a fake pixel to prevent auto normalization errors on images that are uniform
-	# to revisit
-	for k in range(frames.shape[2]):
-		unique_values = np.unique(frames[:, :, k])
-		if len(unique_values) == 1:
-			frames[0, 0, k] += 1
+	frames = _fix_no_contrast(frames)
 
 	return frames.astype(dtype)
 
@@ -3532,6 +3531,33 @@ def extract_experiment_folder_output(experiment_folder, destination_folder):
 			for t in tab_path:
 				copyfile(t, os.sep.join([output_tables_folder, os.path.split(t)[-1]]))
 
+def _load_frames_to_segment(file, indices, scale_model=None, normalize_kwargs=None):
+	
+	frames = load_frames(indices, file, scale=scale_model, normalize_input=True, normalize_kwargs=normalize_kwargs)
+	frames = interpolate_nan_multichannel(frames)
+
+	if np.any(indices==-1):
+		frames[:,:,np.where(indices==-1)[0]] = 0.
+
+	return frames
+
+def _load_frames_to_measure(file, indices):
+	return load_frames(indices, file, scale=None, normalize_input=False)
+
+
+def _check_label_dims(lbl, file=None, template=None):
+	
+	if file is not None:
+		template = load_frames(0,file,scale=1,normalize_input=False)
+	elif template is not None:
+		template = template
+	else:
+		return lbl
+
+	if lbl.shape != template.shape[:2]:
+		lbl = resize(lbl, template.shape[:2], order=0)
+	return lbl
+
 
 if __name__ == '__main__':
 	control_segmentation_napari("/home/limozin/Documents/Experiments/MinimumJan/W4/401/", prefix='Aligned',