celldetective 1.1.1.post3__py3-none-any.whl → 1.1.1.post4__py3-none-any.whl

celldetective/neighborhood.py

@@ -48,14 +48,14 @@ def set_live_status(setA,setB,status, not_status_option):
 
 	"""
 
-
-	if status is None:
+	print(f"Provided statuses: {status}...")
+	if status is None or status==["live_status","live_status"] or status==[None,None]:
 		setA.loc[:,'live_status'] = 1
 		setB.loc[:,'live_status'] = 1
 		status = ['live_status', 'live_status']
 	elif isinstance(status,list):
 		assert len(status)==2,'Please provide only two columns to classify cells as alive or dead.'
-		if status[0] is None:
+		if status[0] is None or status[0]=='live_status':
 			setA.loc[:,'live_status'] = 1
 			status[0] = 'live_status'
 		elif status[0] is not None and isinstance(not_status_option,list):
@@ -63,7 +63,7 @@ def set_live_status(setA,setB,status, not_status_option):
 			if not_status_option[0]:
 				setA.loc[:,'not_'+status[0]] = [not a if a==0 or a==1 else np.nan for a in setA.loc[:,status[0]].values]
 				status[0] = 'not_'+status[0]
-		if status[1] is None:
+		if status[1] is None or status[1]=='live_status':
 			setB.loc[:,'live_status'] = 1
 			status[1] = 'live_status'
 		elif status[1] is not None and isinstance(not_status_option,list):
@@ -380,16 +380,39 @@ def compute_neighborhood_at_position(pos, distance, population=['targets','effec
 	if df_A_pkl is not None:
 		pkl_columns = np.array(df_A_pkl.columns)
 		neigh_columns = np.array([c.startswith('neighborhood') for c in pkl_columns])
-		cols = list(pkl_columns[neigh_columns]) + ['TRACK_ID','FRAME']
+		cols = list(pkl_columns[neigh_columns]) + ['FRAME']
+
+		if 'TRACK_ID' in list(pkl_columns):
+			cols.append('TRACK_ID')
+			on_cols = ['TRACK_ID','FRAME']
+		else:
+			cols.append('ID')
+			on_cols = ['ID','FRAME']
+
 		print(f'Recover {cols} from the pickle file...')
-		df_A = pd.merge(df_A, df_A_pkl.loc[:,cols], how="outer", on=['TRACK_ID','FRAME'])
-		print(df_A.columns)
+		try:
+			df_A = pd.merge(df_A, df_A_pkl.loc[:,cols], how="outer", on=on_cols)
+			print(df_A.columns)
+		except Exception as e:
+			print(f'Failure to merge pickle and csv files: {e}')
+
 	if df_B_pkl is not None and df_B is not None:
 		pkl_columns = np.array(df_B_pkl.columns)
 		neigh_columns = np.array([c.startswith('neighborhood') for c in pkl_columns])
-		cols = list(pkl_columns[neigh_columns]) + ['TRACK_ID','FRAME']
+		cols = list(pkl_columns[neigh_columns]) + ['FRAME']
+
+		if 'TRACK_ID' in list(pkl_columns):
+			cols.append('TRACK_ID')
+			on_cols = ['TRACK_ID','FRAME']
+		else:
+			cols.append('ID')
+			on_cols = ['ID','FRAME']
+
 		print(f'Recover {cols} from the pickle file...')
-		df_B = pd.merge(df_B, df_B_pkl.loc[:,cols], how="outer", on=['TRACK_ID','FRAME'])
+		try:
+			df_B = pd.merge(df_B, df_B_pkl.loc[:,cols], how="outer", on=on_cols)
+		except Exception as e:
+			print(f'Failure to merge pickle and csv files: {e}')
 
 	if clear_neigh:
 		unwanted = df_A.columns[df_A.columns.str.contains('neighborhood')]
@@ -408,17 +431,22 @@ def compute_neighborhood_at_position(pos, distance, population=['targets','effec
 		elif neighborhood_kwargs['mode']=='self':
 			neigh_col = f'neighborhood_self_circle_{d}_px'
 
-		edge_filter_A = (df_A['POSITION_X'] > td)&(df_A['POSITION_Y'] > td)&(df_A['POSITION_Y'] < (img_shape[0] - td))&(df_A['POSITION_X'] < (img_shape[1] - td))
-		edge_filter_B = (df_B['POSITION_X'] > td)&(df_B['POSITION_Y'] > td)&(df_B['POSITION_Y'] < (img_shape[0] - td))&(df_B['POSITION_X'] < (img_shape[1] - td))
-		df_A.loc[~edge_filter_A, neigh_col] = np.nan
-		df_B.loc[~edge_filter_B, neigh_col] = np.nan
+		# edge_filter_A = (df_A['POSITION_X'] > td)&(df_A['POSITION_Y'] > td)&(df_A['POSITION_Y'] < (img_shape[0] - td))&(df_A['POSITION_X'] < (img_shape[1] - td))
+		# edge_filter_B = (df_B['POSITION_X'] > td)&(df_B['POSITION_Y'] > td)&(df_B['POSITION_Y'] < (img_shape[0] - td))&(df_B['POSITION_X'] < (img_shape[1] - td))
+		# df_A.loc[~edge_filter_A, neigh_col] = np.nan
+		# df_B.loc[~edge_filter_B, neigh_col] = np.nan
 
+		print('Count neighborhood...')
 		df_A = compute_neighborhood_metrics(df_A, neigh_col, metrics=['inclusive','exclusive','intermediate'], decompose_by_status=True)
 		if neighborhood_kwargs['symmetrize']:
 			df_B = compute_neighborhood_metrics(df_B, neigh_col, metrics=['inclusive','exclusive','intermediate'], decompose_by_status=True)
+		print('Done...')
 		
-		df_A = mean_neighborhood_before_event(df_A, neigh_col, event_time_col)
-		df_A = mean_neighborhood_after_event(df_A, neigh_col, event_time_col)
+		if 'TRACK_ID' in list(df_A.columns):
+			print('Estimate average neighborhood before/after event...')
+			df_A = mean_neighborhood_before_event(df_A, neigh_col, event_time_col)
+			df_A = mean_neighborhood_after_event(df_A, neigh_col, event_time_col)
+			print('Done...')
 
 	df_A.to_pickle(path_A.replace('.csv','.pkl'))
 	if not population[0]==population[1]:
@@ -485,9 +513,14 @@ def compute_neighborhood_metrics(neigh_table, neigh_col, metrics=['inclusive','e
 
 	neigh_table = neigh_table.reset_index(drop=True)
 	if 'position' in list(neigh_table.columns):
-		groupbycols = ['position','TRACK_ID']
+		groupbycols = ['position']
 	else:
-		groupbycols = ['TRACK_ID']
+		groupbycols = []
+	if 'TRACK_ID' in list(neigh_table.columns):
+		groupbycols.append('TRACK_ID')
+	else:
+		groupbycols.append('ID')
+
 	neigh_table.sort_values(by=groupbycols+['FRAME'],inplace=True)
 
 	for tid,group in neigh_table.groupby(groupbycols):
@@ -607,10 +640,16 @@ def mean_neighborhood_before_event(neigh_table, neigh_col, event_time_col, metri
 	"""
 
 
+	neigh_table = neigh_table.reset_index(drop=True)
 	if 'position' in list(neigh_table.columns):
-		groupbycols = ['position','TRACK_ID']
+		groupbycols = ['position']
 	else:
-		groupbycols = ['TRACK_ID']
+		groupbycols = []
+	if 'TRACK_ID' in list(neigh_table.columns):
+		groupbycols.append('TRACK_ID')
+	else:
+		groupbycols.append('ID')
+
 	neigh_table.sort_values(by=groupbycols+['FRAME'],inplace=True)
 	suffix = '_before_event'
 	
@@ -681,10 +720,16 @@ def mean_neighborhood_after_event(neigh_table, neigh_col, event_time_col, metric
 	"""
 
 
+	neigh_table = neigh_table.reset_index(drop=True)
 	if 'position' in list(neigh_table.columns):
-		groupbycols = ['position','TRACK_ID']
+		groupbycols = ['position']
+	else:
+		groupbycols = []
+	if 'TRACK_ID' in list(neigh_table.columns):
+		groupbycols.append('TRACK_ID')
 	else:
-		groupbycols = ['TRACK_ID']
+		groupbycols.append('ID')
+
 	neigh_table.sort_values(by=groupbycols+['FRAME'],inplace=True)
 	suffix = '_after_event'
 	
@@ -1096,6 +1141,8 @@ def compute_contact_neighborhood_at_position(pos, distance, population=['targets
 
 	df_A, path_A = get_position_table(pos, population=population[0], return_path=True)
 	df_B, path_B = get_position_table(pos, population=population[1], return_path=True)
+	if df_A is None or df_B is None:
+		return None
 
 	df_A_pkl = get_position_pickle(pos, population=population[0], return_path=False)
 	df_B_pkl = get_position_pickle(pos, population=population[1], return_path=False)
@@ -1103,16 +1150,39 @@ def compute_contact_neighborhood_at_position(pos, distance, population=['targets
 	if df_A_pkl is not None:
 		pkl_columns = np.array(df_A_pkl.columns)
 		neigh_columns = np.array([c.startswith('neighborhood') for c in pkl_columns])
-		cols = list(pkl_columns[neigh_columns]) + ['TRACK_ID','FRAME']
+		cols = list(pkl_columns[neigh_columns]) + ['FRAME']
+		
+		if 'TRACK_ID' in list(pkl_columns):
+			cols.append('TRACK_ID')
+			on_cols = ['TRACK_ID','FRAME']
+		else:
+			cols.append('ID')
+			on_cols = ['ID','FRAME']
+
 		print(f'Recover {cols} from the pickle file...')
-		df_A = pd.merge(df_A, df_A_pkl.loc[:,cols], how="outer", on=['TRACK_ID','FRAME'])
-		print(df_A.columns)
+		try:
+			df_A = pd.merge(df_A, df_A_pkl.loc[:,cols], how="outer", on=on_cols)
+			print(df_A.columns)
+		except Exception as e:
+			print(f'Failure to merge pickle and csv files: {e}')
+
 	if df_B_pkl is not None and df_B is not None:
 		pkl_columns = np.array(df_B_pkl.columns)
 		neigh_columns = np.array([c.startswith('neighborhood') for c in pkl_columns])
-		cols = list(pkl_columns[neigh_columns]) + ['TRACK_ID','FRAME']
+		cols = list(pkl_columns[neigh_columns]) + ['FRAME']
+
+		if 'TRACK_ID' in list(pkl_columns):
+			cols.append('TRACK_ID')
+			on_cols = ['TRACK_ID','FRAME']
+		else:
+			cols.append('ID')
+			on_cols = ['ID','FRAME']
+
 		print(f'Recover {cols} from the pickle file...')
-		df_B = pd.merge(df_B, df_B_pkl.loc[:,cols], how="outer", on=['TRACK_ID','FRAME'])
+		try:
+			df_B = pd.merge(df_B, df_B_pkl.loc[:,cols], how="outer", on=on_cols)
+		except Exception as e:
+			print(f'Failure to merge pickle and csv files: {e}')
 
 	labelsA = locate_labels(pos, population=population[0])
 	if population[1]==population[0]:

celldetective/preprocessing.py

@@ -15,8 +15,6 @@ from gc import collect
 from lmfit import Parameters, Model, models
 import tifffile.tifffile as tiff
 
-from tifffile import imwrite
-
 def estimate_background_per_condition(experiment, threshold_on_std=1, well_option='*', target_channel="channel_name", frame_range=[0,5], mode="timeseries", activation_protocol=[['gauss',2],['std',4]], show_progress_per_pos=False, show_progress_per_well=True):
 	
 	"""
@@ -98,53 +96,65 @@ def estimate_background_per_condition(experiment, threshold_on_std=1, well_optio
 		for l,pos_path in enumerate(tqdm(positions, disable=not show_progress_per_pos)):
 			
 			stack_path = get_position_movie_path(pos_path, prefix=movie_prefix)
+			if stack_path is not None:
+				len_movie_auto = auto_load_number_of_frames(stack_path)
+				if len_movie_auto is not None:
+					len_movie = len_movie_auto
+					img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
 
-			if mode=="timeseries":
-
-				frames = load_frames(img_num_channels[0,frame_range[0]:frame_range[1]], stack_path, normalize_input=False)
-				frames = np.moveaxis(frames, -1, 0).astype(float)
-
-				for i in range(len(frames)):
-					if np.all(frames[i].flatten()==0):
-						frames[i,:,:] = np.nan
-
-				frame_mean = np.nanmean(frames, axis=0)
-				
-				frame = frame_mean.copy().astype(float)
-				std_frame = filter_image(frame.copy(),filters=activation_protocol)
-				edge = estimate_unreliable_edge(activation_protocol)
-				mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
-				frame[np.where(mask.astype(int)==1)] = np.nan
-
-			elif mode=="tiles":
+				if mode=="timeseries":
 
-				frames = load_frames(img_num_channels[0,:], stack_path, normalize_input=False).astype(float)
-				frames = np.moveaxis(frames, -1, 0).astype(float)
+					frames = load_frames(img_num_channels[0,frame_range[0]:frame_range[1]], stack_path, normalize_input=False)
+					frames = np.moveaxis(frames, -1, 0).astype(float)
 
-				new_frames = []
-				for i in range(len(frames)):
+					for i in range(len(frames)):
+						if np.all(frames[i].flatten()==0):
+							frames[i,:,:] = np.nan
 
-					if np.all(frames[i].flatten()==0):
-						empty_frame = np.zeros_like(frames[i])
-						empty_frame[:,:] = np.nan
-						new_frames.append(empty_frame)
-						continue
-
-					f = frames[i].copy()
-					std_frame = filter_image(f.copy(),filters=activation_protocol)
+					frame_mean = np.nanmean(frames, axis=0)
+					
+					frame = frame_mean.copy().astype(float)
+					std_frame = filter_image(frame.copy(),filters=activation_protocol)
 					edge = estimate_unreliable_edge(activation_protocol)
 					mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
-					f[np.where(mask.astype(int)==1)] = np.nan
-					new_frames.append(f.copy())
-				
-				frame = np.nanmedian(new_frames, axis=0)
+					frame[np.where(mask.astype(int)==1)] = np.nan
+
+				elif mode=="tiles":
+
+					frames = load_frames(img_num_channels[0,:], stack_path, normalize_input=False).astype(float)
+					frames = np.moveaxis(frames, -1, 0).astype(float)
+
+					new_frames = []
+					for i in range(len(frames)):
+
+						if np.all(frames[i].flatten()==0):
+							empty_frame = np.zeros_like(frames[i])
+							empty_frame[:,:] = np.nan
+							new_frames.append(empty_frame)
+							continue
+
+						f = frames[i].copy()
+						std_frame = filter_image(f.copy(),filters=activation_protocol)
+						edge = estimate_unreliable_edge(activation_protocol)
+						mask = threshold_image(std_frame, threshold_on_std, np.inf, foreground_value=1, edge_exclusion=edge)
+						f[np.where(mask.astype(int)==1)] = np.nan
+						new_frames.append(f.copy())
+					
+					frame = np.nanmedian(new_frames, axis=0)
+			else:
+				print(f'Stack not found for position {pos_path}...')
+				frame = []
 
 			# store
 			frame_mean_per_position.append(frame)
 
-		background = np.nanmedian(frame_mean_per_position,axis=0)
-		backgrounds.append({"bg": background, "well": well_path})
-		print(f"Background successfully computed for well {well_name}...")
+		try:
+			background = np.nanmedian(frame_mean_per_position,axis=0)
+			backgrounds.append({"bg": background, "well": well_path})
+			print(f"Background successfully computed for well {well_name}...")
+		except Exception as e:
+			print(e)
+			backgrounds.append(None)		
 
 	return backgrounds
 
@@ -266,28 +276,35 @@ def correct_background_model_free(
 			
 			stack_path = get_position_movie_path(pos_path, prefix=movie_prefix)
 			print(f'Applying the correction to position {extract_position_name(pos_path)}...')
-
-			corrected_stack = apply_background_to_stack(stack_path, 
-														background,
-														target_channel_index=channel_indices[0],
-														nbr_channels=nbr_channels,
-														stack_length=len_movie,
-														threshold_on_std=threshold_on_std,
-														optimize_option=optimize_option,
-														opt_coef_range=opt_coef_range,
-														opt_coef_nbr=opt_coef_nbr,
-														operation=operation,
-														clip=clip,
-														export=export,
-														activation_protocol=activation_protocol,
-														prefix=export_prefix,
-													  )
-			print('Correction successful.')
-			if return_stacks:
-				stacks.append(corrected_stack)
+			if stack_path is not None:
+				len_movie_auto = auto_load_number_of_frames(stack_path)
+				if len_movie_auto is not None:
+					len_movie = len_movie_auto
+					img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
+
+				corrected_stack = apply_background_to_stack(stack_path, 
+															background,
+															target_channel_index=channel_indices[0],
+															nbr_channels=nbr_channels,
+															stack_length=len_movie,
+															threshold_on_std=threshold_on_std,
+															optimize_option=optimize_option,
+															opt_coef_range=opt_coef_range,
+															opt_coef_nbr=opt_coef_nbr,
+															operation=operation,
+															clip=clip,
+															export=export,
+															activation_protocol=activation_protocol,
+															prefix=export_prefix,
+														  )
+				print('Correction successful.')
+				if return_stacks:
+					stacks.append(corrected_stack)
+				else:
+					del corrected_stack
+				collect()
 			else:
-				del corrected_stack
-			collect()
+				stacks.append(None)
 
 	if return_stacks:
 		return stacks
@@ -770,7 +787,10 @@ def correct_background_model(
 			
 			stack_path = get_position_movie_path(pos_path, prefix=movie_prefix)
 			print(f'Applying the correction to position {extract_position_name(pos_path)}...')
-			print(stack_path)
+			len_movie_auto = auto_load_number_of_frames(stack_path)
+			if len_movie_auto is not None:
+				len_movie = len_movie_auto
+				img_num_channels = _get_img_num_per_channel(channel_indices, int(len_movie), nbr_channels)
 
 			corrected_stack = fit_and_apply_model_background_to_stack(stack_path, 
 														target_channel_index=channel_indices[0],

celldetective/segmentation.py

@@ -20,6 +20,7 @@ from skimage.segmentation import watershed
 from skimage.feature import peak_local_max
 from skimage.measure import regionprops_table
 from skimage.exposure import match_histograms
+from scipy.ndimage import zoom
 import pandas as pd
 import subprocess
 
@@ -27,7 +28,7 @@ import subprocess
 abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],'celldetective'])
 
 def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_napari=False,
-			use_gpu=True, time_flat_normalization=False, time_flat_percentiles=(0.0,99.99)):
+			use_gpu=True, channel_axis=-1):
 	
 	"""
 	
@@ -85,7 +86,10 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 	if not use_gpu:
 		os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
 	else:
-		os.environ['CUDA_VISIBLE_DEVICES'] = '0'		
+		os.environ['CUDA_VISIBLE_DEVICES'] = '0'
+
+	if channel_axis != -1:
+		stack = np.moveaxis(stack, channel_axis, -1)
 
 	if channels is not None:
 		assert len(channels)==stack.shape[-1],f'The channel names provided do not match with the expected number of channels in the stack: {stack.shape[-1]}.'
@@ -96,48 +100,83 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 	required_spatial_calibration = input_config['spatial_calibration']
 	model_type = input_config['model_type']
 
-	if 'normalize' in input_config:
-		normalize = input_config['normalize']
-	else:
-		normalize = True
+	normalization_percentile = input_config['normalization_percentile']
+	normalization_clip = input_config['normalization_clip']
+	normalization_values = input_config['normalization_values']
 
 	if model_type=='cellpose':
 		diameter = input_config['diameter']
-		if diameter!=30:
-			required_spatial_calibration = None
+		# if diameter!=30:
+		# 	required_spatial_calibration = None
 		cellprob_threshold = input_config['cellprob_threshold']
 		flow_threshold = input_config['flow_threshold']
 
 	scale = _estimate_scale_factor(spatial_calibration, required_spatial_calibration)
 
 	if model_type=='stardist':
+
 		model = StarDist2D(None, name=model_name, basedir=Path(model_path).parent)
-		print(f"StarDist model {model_name} successfully loaded")
+		model.config.use_gpu = use_gpu
+		model.use_gpu = use_gpu
+		print(f"StarDist model {model_name} successfully loaded.")
+		scale_model = scale
 
 	elif model_type=='cellpose':
-		model = CellposeModel(gpu=use_gpu, pretrained_model=model_path+model_path.split('/')[-2], diam_mean=30.0)
+		
+		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_path+model_path.split('/')[-2], model_type=None, nchan=len(required_channels))
 		if scale is None:
 			scale_model = model.diam_mean / model.diam_labels
 		else:
 			scale_model = scale * model.diam_mean / model.diam_labels
+		print(f"Diam mean: {model.diam_mean}; Diam labels: {model.diam_labels}; Final rescaling: {scale_model}...")
+		print(f'Cellpose model {model_name} successfully loaded.')
 
 	labels = []
-	if (time_flat_normalization)*normalize:
-		normalization_values = get_stack_normalization_values(stack[:,:,:,channel_indices], percentiles=time_flat_percentiles)
-	else:
-		normalization_values = [None]*len(channel_indices)
 
 	for t in tqdm(range(len(stack)),desc="frame"):
 
 		# normalize
-		frame = stack[t,:,:,np.array(channel_indices)]
-		if np.argmin(frame.shape)!=(frame.ndim-1):
-			frame = np.moveaxis(frame,np.argmin(frame.shape),-1)
-		if normalize:
-			frame = normalize_multichannel(frame, values=normalization_values)
-
-		if scale is not None:
-			frame = [ndi.zoom(frame[:,:,c].copy(), [scale_model,scale_model], order=3, prefilter=False) for c in range(frame.shape[-1])]
+		channel_indices = np.array(channel_indices)
+		none_channel_indices = np.where(channel_indices==None)[0]
+		channel_indices[channel_indices==None] = 0
+		print(channel_indices)
+
+		frame = stack[t,:,:,channel_indices.astype(int)].astype(float)
+		if frame.ndim==2:
+			frame = frame[:,:,np.newaxis]
+		if frame.ndim==3 and np.array(frame.shape).argmin()==0:
+			frame = np.moveaxis(frame,0,-1)
+		template = frame.copy()
+
+		values = []
+		percentiles = []
+		for k in range(len(normalization_percentile)):
+			if normalization_percentile[k]:
+				percentiles.append(normalization_values[k])
+				values.append(None)
+			else:
+				percentiles.append(None)
+				values.append(normalization_values[k])
+
+		frame = normalize_multichannel(frame, **{"percentiles": percentiles, 'values': values, 'clip': normalization_clip})
+		
+		if scale_model is not None:
+			frame = [zoom(frame[:,:,c].copy(), [scale_model,scale_model], order=3, prefilter=False) for c in range(frame.shape[-1])]
+			frame = np.moveaxis(frame,0,-1)
+		
+		for k in range(frame.shape[2]):
+			unique_values = np.unique(frame[:,:,k])
+			if len(unique_values)==1:
+				frame[0,0,k] += 1
+		
+		frame = np.moveaxis([interpolate_nan(frame[:,:,c].copy()) for c in range(frame.shape[-1])],0,-1)
+		frame[:,:,none_channel_indices] = 0.
 
 		if model_type=="stardist":
 
@@ -145,16 +184,15 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 			Y_pred = Y_pred.astype(np.uint16)
 
 		elif model_type=="cellpose":
-
-			Y_pred, _, _ = model.eval(frame, diameter = diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold, channels=None, normalize=False)
+			
+			img = np.moveaxis(frame, -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 = ndi.zoom(Y_pred, [1./scale_model,1./scale_model],order=0)
-
-
 		if Y_pred.shape != stack[0].shape[:2]:
-			Y_pred = resize(Y_pred, stack[0].shape, order=0)
+			Y_pred = zoom(Y_pred, [1./scale_model,1./scale_model],order=0)
+		if Y_pred.shape != template.shape[:2]:
+			Y_pred = resize(Y_pred, template.shape[:2], order=0)
 
 		labels.append(Y_pred)
 

celldetective/utils.py

@@ -23,6 +23,7 @@ from tqdm import tqdm
 import shutil
 import tempfile
 from scipy.interpolate import griddata
+import re
 
 
 def derivative(x, timeline, window, mode='bi'):
@@ -430,6 +431,31 @@ def mask_edges(binary_mask, border_size):
 	return binary_mask
 
 
+def extract_cols_from_query(query: str):
+	
+	# Track variables in a dictionary to be used as a dictionary of globals. From: https://stackoverflow.com/questions/64576913/extract-pandas-dataframe-column-names-from-query-string
+	
+	variables = {}
+
+	while True:
+		try:
+			# Try creating a Expr object with the query string and dictionary of globals.
+			# This will raise an error as long as the dictionary of globals is incomplete.
+			env = pd.core.computation.scope.ensure_scope(level=0, global_dict=variables)
+			pd.core.computation.eval.Expr(query, env=env)
+
+			# Exit the loop when evaluation is successful.
+			break
+		except pd.errors.UndefinedVariableError as e:
+			# This relies on the format defined here: https://github.com/pandas-dev/pandas/blob/965ceca9fd796940050d6fc817707bba1c4f9bff/pandas/errors/__init__.py#L401
+			name = re.findall("name '(.+?)' is not defined", str(e))[0]
+
+			# Add the name to the globals dictionary with a dummy value.
+			variables[name] = None
+
+	return list(variables.keys())
+
+
 def create_patch_mask(h, w, center=None, radius=None):
 
 	"""
@@ -1058,20 +1084,33 @@ def _extract_channel_indices(channels, required_channels):
 	# [0, 1]
 	"""
 
-	if channels is not None:
-		channel_indices = []
-		for ch in required_channels:
-			
+	channel_indices = []
+	for c in required_channels:
+		if c!='None' and c is not None:
 			try:
-				idx = channels.index(ch)
-			except ValueError:
-				print('Mismatch between the channels required by the model and the provided channels.')
-				return None
+				ch_idx = channels.index(c)
+				channel_indices.append(ch_idx)
+			except Exception as e:
+				print(f"Error {e}. The channel required by the model is not available in your data... Check the configuration file.")
+				channels = None
+				break
+		else:
+			channel_indices.append(None)
 
-			channel_indices.append(idx)
-		channel_indices = np.array(channel_indices)
-	else:
-		channel_indices = np.arange(len(required_channels))
+	# if channels is not None:
+	# 	channel_indices = []
+	# 	for ch in required_channels:
+			
+	# 		try:
+	# 			idx = channels.index(ch)
+	# 		except ValueError:
+	# 			print('Mismatch between the channels required by the model and the provided channels.')
+	# 			return None
+
+	# 		channel_indices.append(idx)
+	# 	channel_indices = np.array(channel_indices)
+	# else:
+	# 	channel_indices = np.arange(len(required_channels))
 
 	return channel_indices
 

{celldetective-1.1.1.post3.dist-info → celldetective-1.1.1.post4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: celldetective
-Version: 1.1.1.post3
+Version: 1.1.1.post4
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro