celldetective 1.3.7.post1__py3-none-any.whl → 1.3.8__py3-none-any.whl

celldetective/gui/processes/measure_cells.py

@@ -0,0 +1,346 @@
+from multiprocessing import Process
+import time
+import datetime
+import os
+import json
+from pathlib import Path, PurePath
+
+from celldetective.io import auto_load_number_of_frames, load_frames, locate_labels
+from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel
+from celldetective.utils import remove_trajectory_measurements, _extract_coordinates_from_features, _remove_invalid_cols
+from celldetective.measure import drop_tonal_features, measure_features, measure_isotropic_intensity, measure_radial_distance_to_center, center_of_mass_to_abs_coordinates
+
+from glob import glob
+from tqdm import tqdm
+import numpy as np
+import concurrent.futures
+import pandas as pd
+from natsort import natsorted
+from art import tprint
+
+
+class MeasurementProcess(Process):
+
+	def __init__(self, queue=None, process_args=None):
+		
+		super().__init__()
+		
+		self.queue = queue
+
+		if process_args is not None:
+			for key, value in process_args.items():
+				setattr(self, key, value)
+
+		self.column_labels = {'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}
+
+		tprint("Measure")
+
+		# Experiment		
+		self.prepare_folders()
+
+		self.locate_experiment_config()
+		self.extract_experiment_parameters()
+		self.read_measurement_instructions()
+		self.detect_movie_and_labels()
+		self.detect_tracks()
+		self.detect_channels()
+
+		self.check_possible_measurements()
+
+		self.write_log()
+
+		self.sum_done = 0
+		self.t0 = time.time()
+
+	def check_possible_measurements(self):
+
+		if (self.file is None) or (self.intensity_measurement_radii is None):
+			self.do_iso_intensities = False
+			print('Either no image, no positions or no radii were provided... Isotropic intensities will not be computed...')
+		else:
+			self.do_iso_intensities = True
+
+		if self.label_path is None:
+			self.do_features = False
+			print('No labels were provided... Features will not be computed...')
+		else:
+			self.do_features = True
+		
+		if self.trajectories is None:
+			print('Use features as a substitute for the trajectory table.')
+			if 'label' not in self.features:
+				self.features.append('label')
+
+
+	def read_measurement_instructions(self):
+
+		print('Looking for measurement instruction file...')
+		instr_path = PurePath(self.expfolder,Path(f"{self.instruction_file}"))
+		if os.path.exists(instr_path):
+			with open(instr_path, 'r') as f:
+				self.instructions = json.load(f)
+				print(f"Measurement instruction file successfully loaded...")
+				print(f"Instructions: {self.instructions}...")
+
+			if 'background_correction' in self.instructions:
+				self.background_correction = self.instructions['background_correction']
+			else:
+				self.background_correction = None
+
+			if 'features' in self.instructions:
+				self.features = self.instructions['features']
+			else:
+				self.features = None
+
+			if 'border_distances' in self.instructions:
+				self.border_distances = self.instructions['border_distances']
+			else:
+				self.border_distances = None
+
+			if 'spot_detection' in self.instructions:
+				self.spot_detection = self.instructions['spot_detection']
+			else:
+				self.spot_detection = None
+
+			if 'haralick_options' in self.instructions:
+				self.haralick_options = self.instructions['haralick_options']
+			else:
+				self.haralick_options = None
+
+			if 'intensity_measurement_radii' in self.instructions:
+				self.intensity_measurement_radii = self.instructions['intensity_measurement_radii']
+			else:
+				self.intensity_measurement_radii = None
+
+			if 'isotropic_operations' in self.instructions:
+				self.isotropic_operations = self.instructions['isotropic_operations']
+			else:
+				self.isotropic_operations = None
+
+			if 'clear_previous' in self.instructions:
+				self.clear_previous = self.instructions['clear_previous']
+			else:
+				self.clear_previous = True
+
+		else:
+			print('No measurement instructions found. Use default measurements.')
+			self.features = ['area', 'intensity_mean']
+			self.border_distances = None
+			self.haralick_options = None
+			self.clear_previous = False
+			self.background_correction = None
+			self.spot_detection = None
+			self.intensity_measurement_radii = 10
+			self.isotropic_operations = ['mean']
+
+		if self.features is None:
+			self.features = []
+
+
+	def detect_channels(self):
+		self.img_num_channels = _get_img_num_per_channel(self.channel_indices, self.len_movie, self.nbr_channels)
+
+	def write_log(self):
+
+		features_log=f'features: {self.features}'
+		border_distances_log=f'border_distances: {self.border_distances}'
+		haralick_options_log=f'haralick_options: {self.haralick_options}'
+		background_correction_log=f'background_correction: {self.background_correction}'
+		spot_detection_log=f'spot_detection: {self.spot_detection}'
+		intensity_measurement_radii_log=f'intensity_measurement_radii: {self.intensity_measurement_radii}'
+		isotropic_options_log=f'isotropic_operations: {self.isotropic_operations} \n'
+		log='\n'.join([features_log,border_distances_log,haralick_options_log,background_correction_log,spot_detection_log,intensity_measurement_radii_log,isotropic_options_log])
+		with open(self.pos + f'log_{self.mode}.txt', 'a') as f:
+			f.write(f'{datetime.datetime.now()} MEASURE \n')
+			f.write(log+'\n')
+
+	def prepare_folders(self):
+
+		if self.mode.lower()=="target" or self.mode.lower()=="targets":
+			self.label_folder = "labels_targets"
+			self.table_name = "trajectories_targets.csv"
+			self.instruction_file = os.sep.join(["configs","measurement_instructions_targets.json"])
+
+		elif self.mode.lower()=="effector" or self.mode.lower()=="effectors":
+			self.label_folder = "labels_effectors"
+			self.table_name = "trajectories_effectors.csv"
+			self.instruction_file = os.sep.join(["configs","measurement_instructions_effectors.json"])
+
+	def extract_experiment_parameters(self):
+
+		self.movie_prefix = ConfigSectionMap(self.config,"MovieSettings")["movie_prefix"]
+		self.spatial_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["pxtoum"])
+		self.time_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["frametomin"])
+		self.len_movie = float(ConfigSectionMap(self.config,"MovieSettings")["len_movie"])
+		self.shape_x = int(ConfigSectionMap(self.config,"MovieSettings")["shape_x"])
+		self.shape_y = int(ConfigSectionMap(self.config,"MovieSettings")["shape_y"])
+
+		self.channel_names, self.channel_indices = extract_experiment_channels(self.config)
+		self.nbr_channels = len(self.channel_names)
+
+	def locate_experiment_config(self):
+
+		parent1 = Path(self.pos).parent
+		self.expfolder = parent1.parent
+		self.config = PurePath(self.expfolder,Path("config.ini"))
+
+		if not os.path.exists(self.config):
+			print('The configuration file for the experiment was not found...')
+			self.abort_process()
+
+	def detect_tracks(self):
+
+		# Load trajectories, add centroid if not in trajectory
+		self.trajectories = self.pos+os.sep.join(['output','tables', self.table_name])
+		if os.path.exists(self.trajectories):
+			print('trajectory exists...')
+			self.trajectories = pd.read_csv(self.trajectories)
+			if 'TRACK_ID' not in list(self.trajectories.columns):
+				self.do_iso_intensities = False
+				self.intensity_measurement_radii = None
+				if self.clear_previous:
+					print('No TRACK_ID... Clear previous measurements...')
+					self.trajectories = None #remove_trajectory_measurements(trajectories, column_labels)
+					self.do_features = True
+					self.features += ['centroid']
+			else:
+				if self.clear_previous:
+					print('TRACK_ID found... Clear previous measurements...')
+					self.trajectories = remove_trajectory_measurements(self.trajectories, self.column_labels)
+		else:
+			self.trajectories = None
+			self.do_features = True
+			self.features += ['centroid']
+			self.do_iso_intensities = False
+
+	def detect_movie_and_labels(self):
+
+		self.label_path = natsorted(glob(os.sep.join([self.pos, self.label_folder, '*.tif'])))
+		if len(self.label_path)>0:
+			print(f"Found {len(self.label_path)} segmented frames...")
+		else:
+			self.features = None
+			self.haralick_options = None
+			self.border_distances = None
+			self.label_path = None
+
+		try:
+			self.file = glob(self.pos+os.sep.join(["movie", f"{self.movie_prefix}*.tif"]))[0]
+		except IndexError:
+			self.file = None
+			self.haralick_option = None
+			self.features = drop_tonal_features(self.features)
+
+		len_movie_auto = auto_load_number_of_frames(self.file)
+		if len_movie_auto is not None:
+			self.len_movie = len_movie_auto
+
+	def parallel_job(self, indices):
+
+		measurements = []
+
+		for t in tqdm(indices,desc="frame"):
+
+			if self.file is not None:
+				img = load_frames(self.img_num_channels[:,t], self.file, scale=None, normalize_input=False)
+
+			if self.label_path is not None:
+				
+				lbl = locate_labels(self.pos, population=self.mode, frames=t)
+				if lbl is None:
+					continue
+
+			if self.trajectories is not None:
+
+				positions_at_t = self.trajectories.loc[self.trajectories[self.column_labels['time']]==t].copy()
+
+			if self.do_features:
+				feature_table = measure_features(img, lbl, features=self.features, border_dist=self.border_distances,
+												 channels=self.channel_names, haralick_options=self.haralick_options, verbose=False,
+												 normalisation_list=self.background_correction, spot_detection=self.spot_detection)
+				if self.trajectories is None:
+					positions_at_t = _extract_coordinates_from_features(feature_table, timepoint=t)
+					column_labels = {'track': "ID", 'time': self.column_labels['time'], 'x': self.column_labels['x'],
+									 'y': self.column_labels['y']}
+				feature_table.rename(columns={'centroid-1': 'POSITION_X', 'centroid-0': 'POSITION_Y'}, inplace=True)
+			
+			if self.do_iso_intensities and not self.trajectories is None:
+				iso_table = measure_isotropic_intensity(positions_at_t, img, channels=self.channel_names, intensity_measurement_radii=self.intensity_measurement_radii, column_labels=self.column_labels, operations=self.isotropic_operations, verbose=False)
+
+			if self.do_iso_intensities and self.do_features and not self.trajectories is None:
+				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 self.do_iso_intensities * (not self.do_features) * (not self.trajectories is None):
+				measurements_at_t = iso_table
+			elif self.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')]]
+		
+			measurements_at_t = center_of_mass_to_abs_coordinates(measurements_at_t)
+			measurements_at_t = measure_radial_distance_to_center(measurements_at_t, volume=img.shape, column_labels=self.column_labels)
+
+			self.sum_done+=1/self.len_movie*100
+			mean_exec_per_step = (time.time() - self.t0) / (self.sum_done*self.len_movie / 100 + 1)
+			pred_time = (self.len_movie - (self.sum_done*self.len_movie / 100 + 1)) * mean_exec_per_step
+			self.queue.put([self.sum_done, pred_time])
+			
+			if measurements_at_t is not None:
+				measurements_at_t[self.column_labels['time']] = t
+			else:
+				measurements_at_t = pd.DataFrame()
+
+			measurements.append(measurements_at_t)
+
+		return measurements
+
+	def run(self):
+
+		self.indices = list(range(self.img_num_channels.shape[1]))
+		chunks = np.array_split(self.indices, self.n_threads)
+
+		self.timestep_dataframes = []
+		with concurrent.futures.ThreadPoolExecutor(max_workers=self.n_threads) as executor:
+			results = executor.map(self.parallel_job, chunks) #list(map(lambda x: executor.submit(self.parallel_job, x), chunks))
+			try:
+				for i,return_value in enumerate(results):
+					print(f'Thread {i} completed...')
+					self.timestep_dataframes.extend(return_value)
+			except Exception as e:
+				print("Exception: ", e)
+		
+		print('Measurements successfully performed...')
+
+		if len(self.timestep_dataframes)>0:
+
+			df = pd.concat(self.timestep_dataframes)	
+
+			if self.trajectories is not None:
+				df = df.sort_values(by=[self.column_labels['track'],self.column_labels['time']])
+				df = df.dropna(subset=[self.column_labels['track']])
+			else:
+				df['ID'] = np.arange(len(df))
+				df = df.sort_values(by=[self.column_labels['time'], 'ID'])
+
+			df = df.reset_index(drop=True)
+			df = _remove_invalid_cols(df)
+			
+			df.to_csv(self.pos+os.sep.join(["output", "tables", self.table_name]), index=False)
+			print(f'Measurement table successfully exported in  {os.sep.join(["output", "tables"])}...')
+			print('Done.')
+		else:
+			print('No measurement could be performed. Check your inputs.')
+			print('Done.')	
+		
+		# Send end signal
+		self.queue.put("finished")
+		self.queue.close()
+
+	def end_process(self):
+
+		self.terminate()
+		self.queue.put("finished")
+
+	def abort_process(self):
+		
+		self.terminate()
+		self.queue.put("error")

celldetective/gui/processes/segment_cells.py

@@ -0,0 +1,354 @@
+from multiprocessing import Process
+import time
+import datetime
+import os
+import json
+import numpy as np
+from celldetective.io import extract_position_name, locate_segmentation_model, auto_load_number_of_frames, load_frames, _check_label_dims, _load_frames_to_segment
+from celldetective.utils import _rescale_labels, _segment_image_with_stardist_model, _segment_image_with_cellpose_model, _prep_stardist_model, _prep_cellpose_model, _get_normalize_kwargs_from_config, extract_experiment_channels, _estimate_scale_factor, _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel
+
+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
+from celldetective.segmentation import segment_frame_from_thresholds, merge_instance_segmentation
+import gc
+from art import tprint
+
+import concurrent.futures
+
+class BaseSegmentProcess(Process):
+
+	def __init__(self, queue=None, process_args=None, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+		
+		self.queue = queue
+
+		if process_args is not None:
+			for key, value in process_args.items():
+				setattr(self, key, value)
+
+		tprint("Segment")
+
+		# Experiment
+		self.locate_experiment_config()
+
+		print(f"Position: {extract_position_name(self.pos)}...")
+		print("Configuration file: ",self.config)
+		print(f"Population: {self.mode}...")
+
+		self.extract_experiment_parameters()
+		self.detect_movie_length()
+		self.write_folders()
+
+	def write_folders(self):
+
+		self.mode = self.mode.lower()
+
+		if self.mode=="target" or self.mode=="targets":
+			self.label_folder = "labels_targets"
+		elif self.mode=="effector" or self.mode=="effectors":
+			self.label_folder = "labels_effectors"
+
+		if os.path.exists(self.pos+self.label_folder):
+			print('Erasing the previous labels folder...')
+			rmtree(self.pos+self.label_folder)
+		os.mkdir(self.pos+self.label_folder)
+		print(f'Labels folder successfully generated...')
+
+
+	def extract_experiment_parameters(self):
+
+		self.spatial_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["pxtoum"])
+		self.len_movie = float(ConfigSectionMap(self.config,"MovieSettings")["len_movie"])
+		self.movie_prefix = ConfigSectionMap(self.config,"MovieSettings")["movie_prefix"]
+		self.nbr_channels = _extract_nbr_channels_from_config(self.config)
+		self.channel_names, self.channel_indices = extract_experiment_channels(self.config)
+
+	def locate_experiment_config(self):
+
+		parent1 = Path(self.pos).parent
+		expfolder = parent1.parent
+		self.config = PurePath(expfolder,Path("config.ini"))
+
+		if not os.path.exists(self.config):
+			print('The configuration file for the experiment could not be located. Abort.')
+			self.abort_process()
+
+	def detect_movie_length(self):
+
+		try:
+			self.file = glob(self.pos+f"movie/{self.movie_prefix}*.tif")[0]
+		except Exception as e:
+			print(f'Error {e}.\nMovie could not be found. Check the prefix.')
+			self.abort_process()
+
+		len_movie_auto = auto_load_number_of_frames(self.file)
+		if len_movie_auto is not None:
+			self.len_movie = len_movie_auto
+
+	def end_process(self):
+
+		self.terminate()
+		self.queue.put("finished")
+
+	def abort_process(self):
+		
+		self.terminate()
+		self.queue.put("error")
+
+
+class SegmentCellDLProcess(BaseSegmentProcess):
+	
+	def __init__(self, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+
+		self.check_gpu()
+
+		# Model
+		self.locate_model_path()
+		self.extract_model_input_parameters()
+		self.detect_channels()
+		self.detect_rescaling()
+
+		self.write_log()
+
+		self.sum_done = 0
+		self.t0 = time.time()
+
+	def extract_model_input_parameters(self):
+
+		self.required_channels = self.input_config["channels"]
+		self.normalize_kwargs = _get_normalize_kwargs_from_config(self.input_config)
+
+		self.model_type = self.input_config['model_type']
+		self.required_spatial_calibration = self.input_config['spatial_calibration']
+		print(f'Spatial calibration expected by the model: {self.required_spatial_calibration}...')
+		
+		if self.model_type=='cellpose':
+			self.diameter = self.input_config['diameter']
+			self.cellprob_threshold = self.input_config['cellprob_threshold']
+			self.flow_threshold = self.input_config['flow_threshold']
+
+	def write_log(self):
+
+		log=f'segmentation model: {self.model_name}\n'
+		with open(self.pos+f'log_{self.mode}.txt', 'a') as f:
+			f.write(f'{datetime.datetime.now()} SEGMENT \n')
+			f.write(log)
+
+	def detect_channels(self):
+		
+		self.channel_indices = _extract_channel_indices_from_config(self.config, self.required_channels)
+		print(f'Required channels: {self.required_channels} located at channel indices {self.channel_indices}.')
+		self.img_num_channels = _get_img_num_per_channel(self.channel_indices, int(self.len_movie), self.nbr_channels)
+
+	def detect_rescaling(self):
+
+		self.scale = _estimate_scale_factor(self.spatial_calibration, self.required_spatial_calibration)
+		print(f"Scale: {self.scale}...")
+
+	def locate_model_path(self):
+
+		self.model_complete_path = locate_segmentation_model(self.model_name)
+		if self.model_complete_path is None:
+			print('Model could not be found. Abort.')
+			self.abort_process()
+		else:
+			print(f'Model path: {self.model_complete_path}...')
+		
+		if not os.path.exists(self.model_complete_path+"config_input.json"):
+			print('The configuration for the inputs to the model could not be located. Abort.')
+			self.abort_process()
+
+		with open(self.model_complete_path+"config_input.json") as config_file:
+			self.input_config = json.load(config_file)
+					
+	def check_gpu(self):
+
+		if not self.use_gpu:
+			os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
+
+	def run(self):
+
+		try:
+
+			if self.model_type=='stardist':
+				model, scale_model = _prep_stardist_model(self.model_name, Path(self.model_complete_path).parent, use_gpu=self.use_gpu, scale=self.scale)
+
+			elif self.model_type=='cellpose':
+				model, scale_model = _prep_cellpose_model(self.model_name, self.model_complete_path, use_gpu=self.use_gpu, n_channels=len(self.required_channels), scale=self.scale)
+
+			for t in tqdm(range(self.len_movie),desc="frame"):
+				
+				f = _load_frames_to_segment(self.file, self.img_num_channels[:,t], scale_model=scale_model, normalize_kwargs=self.normalize_kwargs)
+
+				if self.model_type=="stardist":
+					Y_pred = _segment_image_with_stardist_model(f, model=model, return_details=False)
+
+				elif self.model_type=="cellpose":
+					Y_pred = _segment_image_with_cellpose_model(f, model=model, diameter=self.diameter, cellprob_threshold=self.cellprob_threshold, flow_threshold=self.flow_threshold)
+
+				if self.scale is not None:
+					Y_pred = _rescale_labels(Y_pred, scale_model=scale_model)
+				
+				Y_pred = _check_label_dims(Y_pred, file=self.file)
+
+				save_tiff_imagej_compatible(self.pos+os.sep.join([self.label_folder,f"{str(t).zfill(4)}.tif"]), Y_pred, axes='YX')
+				
+				del f;
+				del Y_pred;
+				gc.collect()
+				
+				# Send signal for progress bar
+				self.sum_done+=1/self.len_movie*100
+				mean_exec_per_step = (time.time() - self.t0) / (t+1)
+				pred_time = (self.len_movie - (t+1)) * mean_exec_per_step
+				self.queue.put([self.sum_done, pred_time])
+
+		except Exception as e:
+			print(e)
+
+		try:
+			del model
+		except:
+			pass		
+		
+		gc.collect()
+
+		# Send end signal
+		self.queue.put("finished")
+		self.queue.close()
+
+
+class SegmentCellThresholdProcess(BaseSegmentProcess):
+	
+	def __init__(self, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+
+		self.equalize = False
+
+		# Model
+
+		self.load_threshold_config()
+		self.extract_threshold_parameters()
+		self.detect_channels()
+		self.prepare_equalize()
+
+		self.write_log()
+
+		self.sum_done = 0
+		self.t0 = time.time()
+
+	def prepare_equalize(self):
+
+		for i in range(len(self.instructions)):
+
+			if self.equalize[i]:
+				f_reference = load_frames(self.img_num_channels[:,self.equalize_time[i]], self.file, scale=None, normalize_input=False)
+				f_reference = f_reference[:,:,self.instructions[i]['target_channel']]
+			else:
+				f_reference = None
+
+			self.instructions[i].update({'equalize_reference': f_reference})
+
+	def load_threshold_config(self):
+
+		self.instructions = []
+		for inst in self.threshold_instructions:
+			if os.path.exists(inst):
+				with open(inst, 'r') as f:
+					self.instructions.append(json.load(f))
+			else:
+				print('The configuration path is not valid. Abort.')
+				self.abort_process()
+
+	def extract_threshold_parameters(self):
+		
+		self.required_channels = []
+		self.equalize = []
+		self.equalize_time = []
+
+		for i in range(len(self.instructions)):
+			ch = [self.instructions[i]['target_channel']]
+			self.required_channels.append(ch)
+
+			if 'equalize_reference' in self.instructions[i]:
+				equalize, equalize_time = self.instructions[i]['equalize_reference']	
+				self.equalize.append(equalize)
+				self.equalize_time.append(equalize_time)
+
+	def write_log(self):
+
+		log=f'Threshold segmentation: {self.threshold_instructions}\n'
+		with open(self.pos+f'log_{self.mode}.txt', 'a') as f:
+			f.write(f'{datetime.datetime.now()} SEGMENT \n')
+			f.write(log)
+
+	def detect_channels(self):
+
+		for i in range(len(self.instructions)):
+			
+			self.channel_indices = _extract_channel_indices_from_config(self.config, self.required_channels[i])
+			print(f'Required channels: {self.required_channels[i]} located at channel indices {self.channel_indices}.')
+			self.instructions[i].update({'target_channel': self.channel_indices[0]})
+			self.instructions[i].update({'channel_names': self.channel_names})
+		
+		self.img_num_channels = _get_img_num_per_channel(np.arange(self.nbr_channels), self.len_movie, self.nbr_channels)
+
+	def parallel_job(self, indices):
+
+		try:
+
+			for t in tqdm(indices,desc="frame"): #for t in tqdm(range(self.len_movie),desc="frame"):
+				
+				# Load channels at time t
+				masks = []
+				for i in range(len(self.instructions)):
+					f = load_frames(self.img_num_channels[:,t], self.file, scale=None, normalize_input=False)
+					mask = segment_frame_from_thresholds(f, **self.instructions[i])
+					#print(f'Frame {t}; segment with {self.instructions[i]=}...')
+					masks.append(mask)
+
+				if len(self.instructions)>1:
+					mask = merge_instance_segmentation(masks, mode='OR')
+
+				save_tiff_imagej_compatible(os.sep.join([self.pos, self.label_folder, f"{str(t).zfill(4)}.tif"]), mask.astype(np.uint16), axes='YX')
+
+				del f;
+				del mask;
+				gc.collect()
+
+				# Send signal for progress bar
+				self.sum_done+=1/self.len_movie*100
+				mean_exec_per_step = (time.time() - self.t0) / (self.sum_done*self.len_movie / 100 + 1)
+				pred_time = (self.len_movie - (self.sum_done*self.len_movie / 100 + 1)) * mean_exec_per_step
+				self.queue.put([self.sum_done, pred_time])
+
+		except Exception as e:
+			print(e)
+
+		return
+			
+
+	def run(self):
+
+		self.indices = list(range(self.img_num_channels.shape[1]))
+		chunks = np.array_split(self.indices, self.n_threads)
+
+		with concurrent.futures.ThreadPoolExecutor(max_workers=self.n_threads) as executor:
+			results = results = executor.map(self.parallel_job, chunks) #list(map(lambda x: executor.submit(self.parallel_job, x), chunks))
+			try:
+				for i,return_value in enumerate(results):
+					print(f"Thread {i} output check: ",return_value)
+			except Exception as e:
+				print("Exception: ", e)
+
+		# Send end signal
+		self.queue.put("finished")
+		self.queue.close()