celldetective 1.0.2__py3-none-any.whl

celldetective/scripts/analyze_signals.py

@@ -0,0 +1,51 @@
+"""
+Copright © 2022 Laboratoire Adhesion et Inflammation, Authored by Remy Torro.
+"""
+
+import argparse
+import os
+import gc
+from art import tprint
+from celldetective.signals import analyze_signals
+import pandas as pd
+
+tprint("Signals")
+
+parser = argparse.ArgumentParser(description="Classify and regress the signals based on the provided model.",
+								formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+parser.add_argument('-p',"--position", required=True, help="Path to the position")
+parser.add_argument('-m',"--model", required=True, help="Path to the model")
+parser.add_argument("--mode", default="target", choices=["target","effector","targets","effectors"],help="Cell population of interest")
+parser.add_argument("--use_gpu", default="True", choices=["True","False"],help="use GPU")
+
+args = parser.parse_args()
+process_arguments = vars(args)
+pos = str(process_arguments['position'])
+model = str(process_arguments['model'])
+mode = str(process_arguments['mode'])
+use_gpu = process_arguments['use_gpu']
+if use_gpu=='True' or use_gpu=='true' or use_gpu=='1':
+	use_gpu = True
+else:
+	use_gpu = False
+
+column_labels = {'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}
+
+if mode.lower()=="target" or mode.lower()=="targets":
+	table_name = "trajectories_targets.csv"
+
+elif mode.lower()=="effector" or mode.lower()=="effectors":
+	table_name = "trajectories_effectors.csv"
+
+# Load trajectories, add centroid if not in trajectory
+trajectories = pos+os.sep.join(['output','tables', table_name])
+if os.path.exists(trajectories):
+	trajectories = pd.read_csv(trajectories)
+else:
+	print('The trajectories table could not be found. Abort.')
+	os.abort()
+
+trajectories = analyze_signals(trajectories.copy(), model, interpolate_na=True, selected_signals=None, column_labels = column_labels, plot_outcome=True,output_dir=pos+'output/')
+trajectories = trajectories.sort_values(by=[column_labels['track'], column_labels['time']])
+trajectories.to_csv(pos+os.sep.join(['output','tables', table_name]), index=False)
+

celldetective/scripts/measure_cells.py

@@ -0,0 +1,275 @@
+"""
+Copright © 2022 Laboratoire Adhesion et Inflammation, Authored by Remy Torro.
+"""
+
+import argparse
+import os
+import json
+from celldetective.io import auto_load_number_of_frames, load_frames
+from celldetective.utils import extract_experiment_channels, _extract_channel_indices_from_config, _extract_channel_indices, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel, extract_experiment_channels
+from celldetective.utils import remove_redundant_features, remove_trajectory_measurements
+from celldetective.measure import drop_tonal_features, measure_features, measure_isotropic_intensity
+from pathlib import Path, PurePath
+from glob import glob
+from shutil import rmtree
+from tqdm import tqdm
+import numpy as np
+import pandas as pd
+import gc
+from natsort import natsorted
+from art import tprint
+from tifffile import imread
+import threading
+
+tprint("Measure")
+
+parser = argparse.ArgumentParser(description="Measure features and intensities in a multichannel timeseries.",
+								formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+parser.add_argument('-p',"--position", required=True, help="Path to the position")
+parser.add_argument("--mode", default="target", choices=["target","effector","targets","effectors"],help="Cell population of interest")
+parser.add_argument("--threads", default="1", help="Number of parallel threads")
+
+args = parser.parse_args()
+process_arguments = vars(args)
+pos = str(process_arguments['position'])
+mode = str(process_arguments['mode'])
+n_threads = int(process_arguments['threads'])
+
+column_labels = {'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}
+
+if mode.lower()=="target" or mode.lower()=="targets":
+	label_folder = "labels_targets"
+	table_name = "trajectories_targets.csv"
+	instruction_file = os.sep.join(["configs","measurement_instructions_targets.json"])
+
+elif mode.lower()=="effector" or mode.lower()=="effectors":
+	label_folder = "labels_effectors"
+	table_name = "trajectories_effectors.csv"
+	instruction_file = os.sep.join(["configs","measurement_instructions_effectors.json"])
+
+# Locate experiment config
+parent1 = Path(pos).parent
+expfolder = parent1.parent
+config = PurePath(expfolder,Path("config.ini"))
+assert os.path.exists(config),'The configuration file for the experiment could not be located. Abort.'
+print("Configuration file: ",config)
+
+# from exp config fetch spatial calib, channel names
+movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]
+spatial_calibration = float(ConfigSectionMap(config,"MovieSettings")["pxtoum"])
+time_calibration = float(ConfigSectionMap(config,"MovieSettings")["frametomin"])
+len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+channel_names, channel_indices = extract_experiment_channels(config)
+nbr_channels = len(channel_names)
+
+# from tracking instructions, fetch btrack config, features, haralick, clean_traj, idea: fetch custom timeline?
+instr_path = PurePath(expfolder,Path(f"{instruction_file}"))
+if os.path.exists(instr_path):
+	print(f"Tracking instructions for the {mode} population has been successfully located.")
+	with open(instr_path, 'r') as f:
+		instructions = json.load(f)
+		print("Reading the following instructions: ", instructions)
+	if 'background_correction' in instructions:
+		background_correction = instructions['background_correction']
+
+	if 'features' in instructions:
+		features = instructions['features']
+	else:
+		features = None
+
+	if 'border_distances' in instructions:
+		border_distances = instructions['border_distances']
+	else:
+		border_distances = None
+
+	if 'spot_detection' in instructions:
+		spot_detection = instructions['spot_detection']
+	else:
+		spot_detection = None
+
+	if 'haralick_options' in instructions:
+		haralick_options = instructions['haralick_options']
+	else:
+		haralick_options = None
+
+	if 'intensity_measurement_radii' in instructions:
+		intensity_measurement_radii = instructions['intensity_measurement_radii']
+	else:
+		intensity_measurement_radii = None
+
+	if 'isotropic_operations' in instructions:
+		isotropic_operations = instructions['isotropic_operations']
+	else:
+		isotropic_operations = None
+
+	if 'clear_previous' in instructions:
+		clear_previous = instructions['clear_previous']
+	else:
+		clear_previous = True
+
+else:
+	print('No measurement instructions found. Use default measurements.')
+	features = ['area', 'intensity_mean']
+	border_distances = None
+	haralick_options = None
+	clear_previous = False
+	background_correction = None
+	spot_detection = None
+	intensity_measurement_radii = 10
+	isotropic_operations = ['mean']
+
+if features is None:
+	features = []
+
+# from pos fetch labels
+label_path = natsorted(glob(os.sep.join([pos, label_folder, '*.tif'])))
+if len(label_path)>0:
+	print(f"Found {len(label_path)} segmented frames...")
+else:
+	print(f"No segmented frames have been found. Please run segmentation first, skipping... Features cannot be computed.")
+	features = None
+	haralick_options = None
+	border_distances = None
+	label_path = None
+
+# Do this if features or Haralick is not None, else don't need stack
+try:
+	file = glob(pos+os.sep.join(["movie", f"{movie_prefix}*.tif"]))[0]
+except IndexError:
+	print('Movie could not be found. Check the prefix. If you intended to measure texture or tone, this will not be performed.')
+	file = None
+	haralick_option = None
+	features = drop_tonal_features(features)
+
+# Load trajectories, add centroid if not in trajectory
+trajectories = pos+os.sep.join(['output','tables', table_name])
+if os.path.exists(trajectories):
+	trajectories = pd.read_csv(trajectories)
+	if 'TRACK_ID' not in list(trajectories.columns):
+		do_iso_intensities = False
+		intensity_measurement_radii = None
+		if clear_previous:
+			trajectories = remove_trajectory_measurements(trajectories, column_labels)
+	else:
+		if clear_previous:
+			trajectories = remove_trajectory_measurements(trajectories, column_labels)
+else:
+	trajectories = None
+	do_features = True
+	features += ['centroid']
+	do_iso_intensities = False
+
+
+if (features is not None) and (trajectories is not None):
+	features = remove_redundant_features(features, 
+										trajectories.columns,
+										channel_names=channel_names
+										)
+
+len_movie_auto = auto_load_number_of_frames(file)
+if len_movie_auto is not None:
+	len_movie = len_movie_auto
+
+img_num_channels = _get_img_num_per_channel(channel_indices, len_movie, nbr_channels)
+
+
+# Test what to do
+if (file is None) or (intensity_measurement_radii is None):
+	do_iso_intensities = False
+	print('Either no image, no positions or no radii were provided... Isotropic intensities will not be computed...')
+else:
+	do_iso_intensities = True
+
+if label_path is None:
+	do_features = False
+	print('No labels were provided... Features will not be computed...')
+else:
+	do_features = True
+
+#######################################
+# Loop over all frames and find objects
+#######################################
+
+timestep_dataframes = []
+if trajectories is None:
+	print('Use features as a substitute for the trajectory table.')
+	if 'label' not in features:
+		features.append('label')
+
+
+def measure_index(indices):
+
+	global column_labels
+
+	for t in tqdm(indices,desc="frame"):
+
+		if file is not None:
+			img = load_frames(img_num_channels[:,t], file, scale=None, normalize_input=False)
+
+		if label_path is not None:
+			lbl = imread(label_path[t])
+
+		if trajectories is not None:
+
+			positions_at_t = trajectories.loc[trajectories[column_labels['time']]==t].copy()
+
+		if do_features:
+			feature_table = measure_features(img, lbl, features=features, border_dist=border_distances,
+											 channels=channel_names, haralick_options=haralick_options, verbose=False,
+											 normalisation_list=background_correction, spot_detection=spot_detection)
+			if trajectories is None:
+				positions_at_t = feature_table[['centroid-1', 'centroid-0', 'class_id']].copy()
+				positions_at_t['ID'] = np.arange(len(positions_at_t))  # temporary ID for the cells, that will be reset at the end since they are not tracked
+				positions_at_t.rename(columns={'centroid-1': 'POSITION_X', 'centroid-0': 'POSITION_Y'}, inplace=True)
+				positions_at_t['FRAME'] = int(t)
+				column_labels = {'track': "ID", 'time': column_labels['time'], 'x': column_labels['x'],
+								 'y': column_labels['y']}
+			feature_table.rename(columns={'centroid-1': 'POSITION_X', 'centroid-0': 'POSITION_Y'}, inplace=True)
+
+		if do_iso_intensities:
+			iso_table = measure_isotropic_intensity(positions_at_t, img, channels=channel_names, intensity_measurement_radii=intensity_measurement_radii, column_labels=column_labels, operations=isotropic_operations, verbose=False)
+
+		if do_iso_intensities and do_features:
+			measurements_at_t = iso_table.merge(feature_table, how='outer', on='class_id',suffixes=('', '_delme'))
+			measurements_at_t = measurements_at_t[[c for c in measurements_at_t.columns if not c.endswith('_delme')]]
+		elif do_iso_intensities * (not do_features):
+			measurements_at_t = iso_table
+		elif do_features:
+			measurements_at_t = positions_at_t.merge(feature_table, how='outer', on='class_id',suffixes=('', '_delme'))
+			measurements_at_t = measurements_at_t[[c for c in measurements_at_t.columns if not c.endswith('_delme')]]
+			
+		if measurements_at_t is not None:
+			measurements_at_t[column_labels['time']] = t
+			timestep_dataframes.append(measurements_at_t)
+
+# Multithreading
+indices = list(range(img_num_channels.shape[1]))
+chunks = np.array_split(indices, n_threads)
+threads = []
+for i in range(n_threads):
+	thread_i = threading.Thread(target=measure_index, args=[chunks[i]])
+	threads.append(thread_i)
+for th in threads:
+	th.start()
+for th in threads:
+	th.join()
+
+
+if len(timestep_dataframes)>0:
+	df = pd.concat(timestep_dataframes)	
+	df.reset_index(inplace=True, drop=True)
+
+	if trajectories is None:
+		df['ID'] = np.arange(len(df))
+
+	if column_labels['track'] in df.columns:
+		df = df.sort_values(by=[column_labels['track'], column_labels['time']])
+	else:
+		df = df.sort_values(by=column_labels['time'])
+
+	df.to_csv(pos+os.sep.join(["output", "tables", table_name]), index=False)
+	print(f'Measurements successfully written in table {pos+os.sep.join(["output", "tables", table_name])}')
+	print('Done.')
+else:
+	print('No measurement could be performed. Check your inputs.')
+	print('Done.')

celldetective/scripts/segment_cells.py

@@ -0,0 +1,212 @@
+"""
+Copright © 2022 Laboratoire Adhesion et Inflammation, Authored by Remy Torro.
+"""
+
+import argparse
+import os
+import json
+from stardist.models import StarDist2D
+from cellpose.models import CellposeModel
+from celldetective.io import locate_segmentation_model, auto_load_number_of_frames, load_frames
+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 pathlib import Path, PurePath
+from glob import glob
+from shutil import rmtree
+from tqdm import tqdm
+import numpy as np
+from skimage.transform import resize
+from csbdeep.io import save_tiff_imagej_compatible
+import gc
+from art import tprint
+from scipy.ndimage import zoom
+import threading
+
+tprint("Segment")
+
+parser = argparse.ArgumentParser(description="Segment a movie in position with the selected model",
+								formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+parser.add_argument('-p',"--position", required=True, help="Path to the position")
+parser.add_argument('-m',"--model", required=True,help="Model name")
+parser.add_argument("--mode", default="target", choices=["target","effector","targets","effectors"],help="Cell population of interest")
+parser.add_argument("--use_gpu", default="True", choices=["True","False"],help="use GPU")
+parser.add_argument("--threads", default="1",help="Number of parallel threads")
+
+args = parser.parse_args()
+process_arguments = vars(args)
+pos = str(process_arguments['position'])
+mode = str(process_arguments['mode'])
+use_gpu = process_arguments['use_gpu']
+n_threads = int(process_arguments['threads'])
+
+if use_gpu=='True' or use_gpu=='true' or use_gpu=='1':
+	use_gpu = True
+	n_threads = 1  # avoid misbehavior on GPU with multithreading
+else:
+	use_gpu = False
+
+if not use_gpu:
+	os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+n_threads = int(process_arguments['threads'])
+
+modelname = str(process_arguments['model'])
+
+if mode.lower()=="target" or mode.lower()=="targets":
+	label_folder = "labels_targets"
+elif mode.lower()=="effector" or mode.lower()=="effectors":
+	label_folder = "labels_effectors"
+
+# Locate experiment config
+parent1 = Path(pos).parent
+expfolder = parent1.parent
+config = PurePath(expfolder,Path("config.ini"))
+assert os.path.exists(config),'The configuration file for the experiment could not be located. Abort.'
+print("Configuration file: ",config)
+
+####################################
+# Check model requirements #########
+####################################
+
+modelpath = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],"models"])
+print(modelpath)
+model_complete_path = locate_segmentation_model(modelname)
+if model_complete_path is None:
+	print('Model could not be found. Abort.')
+	os.abort()
+else:
+	print(f'Model successfully located in {model_complete_path}')
+
+# load config
+assert os.path.exists(model_complete_path+"config_input.json"),'The configuration for the inputs to the model could not be located. Abort.'
+with open(model_complete_path+"config_input.json") as config_file:
+	input_config = json.load(config_file)
+
+# Parse target channels
+required_channels = input_config["channels"]
+
+channel_indices = _extract_channel_indices_from_config(config, required_channels)
+print(f'Required channels: {required_channels} located at channel indices {channel_indices}.')
+required_spatial_calibration = input_config['spatial_calibration']
+print(f'Expected spatial calibration is {required_spatial_calibration}.')
+
+normalization_percentile = input_config['normalization_percentile']
+normalization_clip = input_config['normalization_clip']
+normalization_values = input_config['normalization_values']
+
+model_type = input_config['model_type']
+
+movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]
+spatial_calibration = float(ConfigSectionMap(config,"MovieSettings")["pxtoum"])
+len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+
+# Try to find the file
+try:
+	file = glob(pos+f"movie/{movie_prefix}*.tif")[0]
+except IndexError:
+	print('Movie could not be found. Check the prefix.')
+	os.abort()
+
+len_movie_auto = auto_load_number_of_frames(file)
+if len_movie_auto is not None:
+	len_movie = len_movie_auto
+
+if model_type=='cellpose':
+	diameter = input_config['diameter']
+	# if diameter!=30:
+	# 	required_spatial_calibration = None 	# ignore spatial calibration and use diameter
+	cellprob_threshold = input_config['cellprob_threshold']
+	flow_threshold = input_config['flow_threshold']
+
+scale = _estimate_scale_factor(spatial_calibration, required_spatial_calibration)
+
+nbr_channels = _extract_nbr_channels_from_config(config)
+print(f'Number of channels in the input movie: {nbr_channels}')
+img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
+
+# If everything OK, prepare output, load models
+print('Erasing previous segmentation folder.')
+if os.path.exists(os.sep.join([pos,label_folder])):
+	rmtree(os.sep.join([pos,label_folder]))
+os.mkdir(os.sep.join([pos,label_folder]))
+print(f'Folder {os.sep.join([pos,label_folder])} successfully generated.')
+
+
+# Loop over all frames and segment
+def segment_index(indices):
+
+	if model_type=='stardist':
+		model = StarDist2D(None, name=modelname, basedir=Path(model_complete_path).parent)
+		model.config.use_gpu = use_gpu
+		model.use_gpu = use_gpu
+		print(f"StarDist model {modelname} successfully loaded.")
+
+	elif model_type=='cellpose':
+
+		import torch
+		if not use_gpu:
+			device = torch.device("cpu")
+		else:
+			device = torch.device("cuda")
+
+		model = CellposeModel(gpu=use_gpu, device=device, pretrained_model=model_complete_path+modelname, model_type=None, nchan=len(required_channels)) #diam_mean=30.0,
+		model.diam_mean = 30.0
+		print(f'Cellpose model {modelname} successfully loaded.')
+
+	for t in tqdm(indices,desc="frame"):
+		
+		# Load channels at time t
+		f = load_frames(img_num_channels[:,t], file, scale=scale, normalize_input=False)
+		f = normalize_per_channel([f], normalization_percentile_mode=normalization_percentile, normalization_values=normalization_values,
+									normalization_clipping=normalization_clip)
+		f = f[0]
+		if np.any(img_num_channels[:,t]==-1):
+			f[:,:,np.where(img_num_channels[:,t]==-1)[0]] = 0.
+
+		if model_type=="stardist":
+			Y_pred, details = model.predict_instances(f, n_tiles=model._guess_n_tiles(f), show_tile_progress=False, verbose=False)
+			Y_pred = Y_pred.astype(np.uint16)
+
+		elif model_type=="cellpose":
+
+			img = np.moveaxis(f, -1, 0)
+			Y_pred, _, _ = model.eval(img, diameter = diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold, channels=None, normalize=False)
+			Y_pred = Y_pred.astype(np.uint16)
+
+		if scale is not None:
+			Y_pred = zoom(Y_pred, [1./scale,1./scale],order=0)
+
+		template = load_frames(0,file,scale=1,normalize_input=False)
+		if Y_pred.shape != template.shape[:2]:
+			Y_pred = resize(Y_pred, template.shape[:2], order=0)
+
+		save_tiff_imagej_compatible(os.sep.join([pos,label_folder,f"{str(t).zfill(4)}.tif"]), Y_pred, axes='YX')
+
+		del f;
+		del template;
+		del Y_pred;
+		gc.collect()
+
+# Multithreading
+indices = list(range(img_num_channels.shape[1]))
+chunks = np.array_split(indices, n_threads)
+threads = []
+for i in range(n_threads):
+	thread_i = threading.Thread(target=segment_index, args=[chunks[i]])
+	threads.append(thread_i)
+for th in threads:
+	th.start()
+for th in threads:
+	th.join()
+
+print('Done.')
+
+try:
+	del model
+except:
+	pass
+
+gc.collect()
+
+
+
+
+

celldetective/scripts/segment_cells_thresholds.py

@@ -0,0 +1,140 @@
+"""
+Copright © 2022 Laboratoire Adhesion et Inflammation, Authored by Remy Torro.
+"""
+
+import argparse
+import os
+import json
+from celldetective.io import auto_load_number_of_frames, load_frames
+from celldetective.segmentation import segment_frame_from_thresholds
+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, extract_experiment_channels
+from pathlib import Path, PurePath
+from glob import glob
+from shutil import rmtree
+from tqdm import tqdm
+import numpy as np
+from csbdeep.io import save_tiff_imagej_compatible
+import gc
+from art import tprint
+import threading
+
+tprint("Segment")
+
+parser = argparse.ArgumentParser(description="Segment a movie in position with a threshold pipeline",
+								formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+parser.add_argument('-p',"--position", required=True, help="Path to the position")
+parser.add_argument('-c',"--config", required=True,help="Threshold instructions")
+parser.add_argument("--mode", default="target", choices=["target","effector","targets","effectors"],help="Cell population of interest")
+parser.add_argument("--threads", default="1",help="Number of parallel threads")
+
+args = parser.parse_args()
+process_arguments = vars(args)
+pos = str(process_arguments['position'])
+mode = str(process_arguments['mode'])
+n_threads = int(process_arguments['threads'])
+
+threshold_instructions = str(process_arguments['config'])
+equalize = False
+
+if os.path.exists(threshold_instructions):
+	with open(threshold_instructions, 'r') as f:
+		threshold_instructions = json.load(f)
+		required_channels = [threshold_instructions['target_channel']]
+		if 'equalize_reference' in threshold_instructions:
+			equalize_info = threshold_instructions['equalize_reference']
+			equalize = equalize_info[0]
+			equalize_time = equalize_info[1]
+
+else:
+	print('The configuration path is not valid. Abort.')
+	os.abort()
+
+print('The following instructions were successfully loaded: ', threshold_instructions)
+
+if mode.lower()=="target" or mode.lower()=="targets":
+	label_folder = "labels_targets"
+elif mode.lower()=="effector" or mode.lower()=="effectors":
+	label_folder = "labels_effectors"
+
+# Locate experiment config
+parent1 = Path(pos).parent
+expfolder = parent1.parent
+config = PurePath(expfolder,Path("config.ini"))
+assert os.path.exists(config),'The configuration file for the experiment could not be located. Abort.'
+print("Configuration file: ",config)
+
+
+channel_indices = _extract_channel_indices_from_config(config, required_channels)
+# need to abort if channel not found
+print(f'Required channels: {required_channels} located at channel indices {channel_indices}.')
+
+threshold_instructions.update({'target_channel': channel_indices[0]})
+
+movie_prefix = ConfigSectionMap(config,"MovieSettings")["movie_prefix"]
+len_movie = float(ConfigSectionMap(config,"MovieSettings")["len_movie"])
+channel_names, channel_indices = extract_experiment_channels(config)
+threshold_instructions.update({'channel_names': channel_names})
+
+# Try to find the file
+try:
+	file = glob(pos+f"movie/{movie_prefix}*.tif")[0]
+except IndexError:
+	print('Movie could not be found. Check the prefix.')
+	os.abort()
+
+len_movie_auto = auto_load_number_of_frames(file)
+if len_movie_auto is not None:
+	len_movie = len_movie_auto
+
+nbr_channels = _extract_nbr_channels_from_config(config)
+print(f'Number of channels in the input movie: {nbr_channels}')
+img_num_channels = _get_img_num_per_channel(np.arange(nbr_channels), len_movie, nbr_channels)
+
+# If everything OK, prepare output, load models
+print('Erasing previous segmentation folder.')
+if os.path.exists(os.sep.join([pos,label_folder])):
+	rmtree(os.sep.join([pos,label_folder]))
+os.mkdir(os.sep.join([pos,label_folder]))
+print(f'Folder {os.sep.join([pos,label_folder])} successfully generated.')
+
+if equalize:
+	f_reference = load_frames(img_num_channels[:,equalize_time], file, scale=None, normalize_input=False)
+	f_reference = f_reference[:,:,threshold_instructions['target_channel']]
+else:
+	f_reference = None
+
+threshold_instructions.update({'equalize_reference': f_reference})
+print(threshold_instructions)
+
+# Loop over all frames and segment
+def segment_index(indices):
+
+	for t in tqdm(indices,desc="frame"):
+		
+		# Load channels at time t
+		f = load_frames(img_num_channels[:,t], file, scale=None, normalize_input=False)
+		mask = segment_frame_from_thresholds(f, **threshold_instructions)
+		save_tiff_imagej_compatible(os.sep.join([pos, label_folder, f"{str(t).zfill(4)}.tif"]), mask.astype(np.uint16), axes='YX')
+
+		del f;
+		del mask;
+		gc.collect()
+
+# Multithreading
+indices = list(range(img_num_channels.shape[1]))
+chunks = np.array_split(indices, n_threads)
+threads = []
+for i in range(n_threads):
+	thread_i = threading.Thread(target=segment_index, args=[chunks[i]])
+	threads.append(thread_i)
+for th in threads:
+	th.start()
+for th in threads:
+	th.join()
+
+print('Done.')
+gc.collect()
+
+
+
+