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

celldetective/measure.py

@@ -311,7 +311,7 @@ def measure_features(img, label, features=['area', 'intensity_mean'], channels=N
 
 	if isinstance(features, list):
 		features = features.copy()
-		
+
 	if features is None:
 		features = []
 
@@ -986,6 +986,69 @@ def blob_detection(image, label, diameter, threshold=0., channel_name=None, targ
 
 	return detections
 
+
+# def blob_detectionv0(image, label, threshold, diameter):
+# 	"""
+# 	Perform blob detection on an image based on labeled regions.
+
+# 	Parameters:
+# 	- image (numpy.ndarray): The input image data.
+# 	- label (numpy.ndarray): An array specifying labeled regions in the image.
+# 	- threshold (float): The threshold value for blob detection.
+# 	- diameter (float): The expected diameter of blobs.
+
+# 	Returns:
+# 	- dict: A dictionary containing information about detected blobs.
+
+# 	This function performs blob detection on an image based on labeled regions. It iterates over each labeled region
+# 	and detects blobs within the region using the Difference of Gaussians (DoG) method. Detected blobs are filtered
+# 	based on the specified threshold and expected diameter. The function returns a dictionary containing the number of
+# 	detected blobs and their mean intensity for each labeled region.
+
+# 	Example:
+# 	>>> image = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+# 	>>> label = np.array([[0, 1, 1], [2, 2, 0], [3, 3, 0]])
+# 	>>> threshold = 0.1
+# 	>>> diameter = 5.0
+# 	>>> result = blob_detection(image, label, threshold, diameter)
+# 	>>> print(result)
+# 	{1: [1, 4.0], 2: [0, nan], 3: [0, nan]}
+
+# 	Note:
+# 	- Blobs are detected using the Difference of Gaussians (DoG) method.
+# 	- Detected blobs are filtered based on the specified threshold and expected diameter.
+# 	- The returned dictionary contains information about the number of detected blobs and their mean intensity
+# 	  for each labeled region.
+# 	"""
+# 	blob_labels = {}
+# 	dilated_image = ndimage.grey_dilation(label, footprint=disk(10))
+# 	for mask_index in np.unique(label):
+# 		if mask_index == 0:
+# 			continue
+# 		removed_background = image.copy()
+# 		one_mask = label.copy()
+# 		one_mask[np.where(label != mask_index)] = 0
+# 		dilated_copy = dilated_image.copy()
+# 		dilated_copy[np.where(dilated_image != mask_index)] = 0
+# 		removed_background[np.where(dilated_copy == 0)] = 0
+# 		min_sigma = (1 / (1 + math.sqrt(2))) * diameter
+# 		max_sigma = math.sqrt(2) * min_sigma
+# 		blobs = blob_dog(removed_background, threshold=threshold, min_sigma=min_sigma,
+# 										 max_sigma=max_sigma)
+
+# 		mask = np.array([one_mask[int(y), int(x)] != 0 for y, x, r in blobs])
+# 		if not np.any(mask):
+# 			continue
+# 		blobs_filtered = blobs[mask]
+# 		binary_blobs = np.zeros_like(label)
+# 		for blob in blobs_filtered:
+# 			y, x, r = blob
+# 			rr, cc = dsk((y, x), r, shape=binary_blobs.shape)
+# 			binary_blobs[rr, cc] = 1
+# 		spot_intensity = regionprops_table(binary_blobs, removed_background, ['intensity_mean'])
+# 		blob_labels[mask_index] = [blobs_filtered.shape[0], spot_intensity['intensity_mean'][0]]
+# 	return blob_labels
+
 ### Classification ####
 
 def estimate_time(df, class_attr, model='step_function', class_of_interest=[2], r2_threshold=0.5):
@@ -1163,13 +1226,15 @@ def classify_transient_events(data, class_attr, pre_event=None):
 		assert 'class_'+pre_event in cols,"Pre-event class does not seem to be a valid column in the DataFrame..."
 
 	stat_col = class_attr.replace('class','status')
+	continuous_stat_col = stat_col.replace('status_','smooth_status_')
+	df[continuous_stat_col] = df[stat_col].copy()
 
 	for tid,track in df.groupby(sort_cols):
 
 		indices = track[class_attr].index
 
 		if pre_event is not None:
-			
+
 			if track['class_'+pre_event].values[0]==1:
 				df.loc[indices, class_attr] = np.nan
 				df.loc[indices, stat_col] = np.nan
@@ -1180,7 +1245,8 @@ def classify_transient_events(data, class_attr, pre_event=None):
 				indices_pre = track.loc[track['FRAME']<=t_pre_event,class_attr].index
 				df.loc[indices_pre, stat_col] = np.nan # set to NaN all statuses before pre-event
 				track.loc[track['FRAME']<=t_pre_event, stat_col] = np.nan
-		
+				track.loc[track['FRAME']<=t_pre_event, continuous_stat_col] = np.nan
+
 		status = track[stat_col].to_numpy()
 		timeline = track['FRAME'].to_numpy()
 		timeline_safe = timeline[status==status]
@@ -1189,24 +1255,35 @@ def classify_transient_events(data, class_attr, pre_event=None):
 		peaks, _ = find_peaks(status_safe)
 		widths, _, left, right = peak_widths(status_safe, peaks, rel_height=1)
 		minimum_weight = 0
-
+		
 		if len(peaks)>0:
 			idx = np.argmax(widths)
-			peak = peaks[idx]; width = widths[idx]; 
+			peak = peaks[idx]; width = widths[idx];
 			if width >= minimum_weight:
 				left = left[idx]; right = right[idx];
 				left = timeline_safe[int(left)]; right = timeline_safe[int(right)];
-				
+
 				df.loc[indices, class_attr] = 0
-				df.loc[indices, class_attr.replace('class_','t_')] = left + (right - left)/2.0
+				t0 = left #take onset + (right - left)/2.0
+				df.loc[indices, class_attr.replace('class_','t_')] = t0
+				df.loc[track.loc[track[stat_col].isnull(),class_attr].index, continuous_stat_col] = np.nan
+				df.loc[track.loc[track['FRAME']<t0,class_attr].index, continuous_stat_col] = 0
+				df.loc[track.loc[track['FRAME']>=t0,class_attr].index, continuous_stat_col] = 1
 			else:
 				df.loc[indices, class_attr] = 1
-				df.loc[indices, class_attr.replace('class_','t_')] = -1				
+				df.loc[indices, class_attr.replace('class_','t_')] = -1
+				df.loc[indices, continuous_stat_col] = 0
 		else:
 			df.loc[indices, class_attr] = 1
 			df.loc[indices, class_attr.replace('class_','t_')] = -1
-
-		
+			df.loc[indices, continuous_stat_col] = 0
+
+	# restate NaN for out of scope timepoints
+	df.loc[df[stat_col].isnull(),continuous_stat_col] = np.nan
+	if 'inst_'+stat_col in list(df.columns):
+		df = df.drop(columns=['inst_'+stat_col])
+	df = df.rename(columns={stat_col: 'inst_'+stat_col})
+	df = df.rename(columns={continuous_stat_col: stat_col})
 	print("Classes: ",df.loc[df['FRAME']==0,class_attr].value_counts())
 
 	return df
@@ -1286,7 +1363,7 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 			indices_pre_detection = track.loc[track['FRAME']<=t_firstdetection,class_attr].index
 			track.loc[indices_pre_detection,stat_col] = 0.0
 			df.loc[indices_pre_detection,stat_col] = 0.0
-		
+
 		# The non-NaN part of track (post pre-event)
 		track_valid = track.dropna(subset=stat_col, inplace=False)
 		status_values = track_valid[stat_col].to_numpy()
@@ -1300,7 +1377,7 @@ def classify_irreversible_events(data, class_attr, r2_threshold=0.5, percentile_
 		else:
 			# ambiguity, possible transition, use `unique_state` technique after
 			df.loc[indices, class_attr] = 2
-		
+
 	print("Classes after initial pass: ",df.loc[df['FRAME']==0,class_attr].value_counts())
 
 	df.loc[df[class_attr]!=2, class_attr.replace('class', 't')] = -1
@@ -1363,7 +1440,7 @@ def classify_unique_states(df, class_attr, percentile=50, pre_event=None):
 		assert 'class_'+pre_event in cols,"Pre-event class does not seem to be a valid column in the DataFrame..."
 
 	stat_col = class_attr.replace('class','status')
-	
+
 	for tid, track in df.groupby(sort_cols):
 
 		indices = track[class_attr].index
@@ -1488,4 +1565,25 @@ def classify_tracks_from_query(df, event_name, query, irreversible_event=True, u
 
 	df = interpret_track_classification(df, class_attr, irreversible_event=irreversible_event, unique_state=unique_state, r2_threshold=r2_threshold, percentile_recovery=percentile_recovery)
 
-	return df
+	return df
+
+def measure_radial_distance_to_center(df, volume, column_labels={'track': "TRACK_ID", 'time': 'FRAME', 'x': 'POSITION_X', 'y': 'POSITION_Y'}):
+
+	try:
+		df['radial_distance'] = np.sqrt((df[column_labels['x']] - volume[0] / 2) ** 2 + (df[column_labels['y']] - volume[1] / 2) ** 2)
+	except Exception as e:
+		print(f"{e=}")
+
+	return df
+
+def center_of_mass_to_abs_coordinates(df):
+	
+	center_of_mass_x_cols = [c for c in list(df.columns) if c.endswith('centre_of_mass_x')]
+	center_of_mass_y_cols = [c for c in list(df.columns) if c.endswith('centre_of_mass_y')]
+	for c in center_of_mass_x_cols:
+		df.loc[:,c.replace('_x','_POSITION_X')] = df[c] + df['POSITION_X']
+	for c in center_of_mass_y_cols:
+		df.loc[:,c.replace('_y','_POSITION_Y')] = df[c] + df['POSITION_Y']
+	df = df.drop(columns = center_of_mass_x_cols+center_of_mass_y_cols)
+
+	return df

celldetective/scripts/measure_cells.py

@@ -7,8 +7,8 @@ import os
 import json
 from celldetective.io import auto_load_number_of_frames, load_frames, fix_missing_labels, locate_labels, extract_position_name
 from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _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 celldetective.utils import _remove_invalid_cols, remove_redundant_features, remove_trajectory_measurements, _extract_coordinates_from_features
+from celldetective.measure import drop_tonal_features, measure_features, measure_isotropic_intensity, center_of_mass_to_abs_coordinates, measure_radial_distance_to_center
 from pathlib import Path, PurePath
 from glob import glob
 from tqdm import tqdm
@@ -16,7 +16,6 @@ import numpy as np
 import pandas as pd
 from natsort import natsorted
 from art import tprint
-import threading
 import datetime
 
 tprint("Measure")
@@ -68,7 +67,7 @@ instr_path = PurePath(expfolder,Path(f"{instruction_file}"))
 print('Looking for measurement instruction file...')
 
 if os.path.exists(instr_path):
-	
+
 	with open(instr_path, 'r') as f:
 		instructions = json.load(f)
 		print(f"Measurement instruction file successfully loaded...")
@@ -171,14 +170,6 @@ else:
 	features += ['centroid']
 	do_iso_intensities = False
 
-# if 'centroid' not in features:
-# 	features += ['centroid']
-
-# 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:
@@ -236,7 +227,7 @@ with open(pos + f'log_{mode}.json', 'a') as f:
 
 def measure_index(indices):
 
-	global column_labels
+	#global column_labels
 
 	for t in tqdm(indices,desc="frame"):
 
@@ -258,10 +249,7 @@ def measure_index(indices):
 											 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)
+				positions_at_t = _extract_coordinates_from_features(feature_table, timepoint=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)
@@ -278,25 +266,14 @@ def measure_index(indices):
 			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')]]
 
-		center_of_mass_x_cols = [c for c in list(measurements_at_t.columns) if c.endswith('centre_of_mass_x')]
-		center_of_mass_y_cols = [c for c in list(measurements_at_t.columns) if c.endswith('centre_of_mass_y')]
-		for c in center_of_mass_x_cols:
-			measurements_at_t.loc[:,c.replace('_x','_POSITION_X')] = measurements_at_t[c] + measurements_at_t['POSITION_X']
-		for c in center_of_mass_y_cols:
-			measurements_at_t.loc[:,c.replace('_y','_POSITION_Y')] = measurements_at_t[c] + measurements_at_t['POSITION_Y']
-		measurements_at_t = measurements_at_t.drop(columns = center_of_mass_x_cols+center_of_mass_y_cols)
-		
-		try:
-			measurements_at_t['radial_distance'] = np.sqrt((measurements_at_t[column_labels['x']] - img.shape[0] / 2) ** 2 + (
-					measurements_at_t[column_labels['y']] - img.shape[1] / 2) ** 2)
-		except Exception as e:
-			print(f"{e=}")
+		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=column_labels)
 
 		if measurements_at_t is not None:
 			measurements_at_t[column_labels['time']] = t
 			timestep_dataframes.append(measurements_at_t)
 
-	return 
+	return
 
 
 print(f"Starting the measurements with {n_threads} thread(s)...")
@@ -327,12 +304,10 @@ if len(timestep_dataframes)>0:
 		df = df.dropna(subset=[column_labels['track']])
 	else:
 		df['ID'] = np.arange(len(df))
+		df = df.sort_values(by=[column_labels['time'], 'ID'])
 
 	df = df.reset_index(drop=True)
-	
-	invalid_cols = [c for c in list(df.columns) if c.startswith('Unnamed')]
-	if len(invalid_cols)>0:
-		df = df.drop(invalid_cols, axis=1)	
+	df = _remove_invalid_cols(df)
 
 	df.to_csv(pos+os.sep.join(["output", "tables", table_name]), index=False)
 	print(f'Measurement table successfully exported in  {os.sep.join(["output", "tables"])}...')

celldetective/scripts/segment_cells.py

@@ -6,21 +6,17 @@ import argparse
 import datetime
 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, extract_position_name
-from celldetective.utils import interpolate_nan, _estimate_scale_factor, _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel
+from celldetective.io import locate_segmentation_model, auto_load_number_of_frames, extract_position_name, _load_frames_to_segment, _check_label_dims
+from celldetective.utils import _prep_stardist_model, _prep_cellpose_model, _rescale_labels, _segment_image_with_stardist_model,_segment_image_with_cellpose_model,_get_normalize_kwargs_from_config, _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 skimage.transform import resize
 from csbdeep.io import save_tiff_imagej_compatible
 import gc
 from art import tprint
-from scipy.ndimage import zoom
-
+import concurrent.futures
 
 tprint("Segment")
 
@@ -91,9 +87,7 @@ print(f'Required channels: {required_channels} located at channel indices {chann
 required_spatial_calibration = input_config['spatial_calibration']
 print(f'Spatial calibration expected by the model: {required_spatial_calibration}...')
 
-normalization_percentile = input_config['normalization_percentile']
-normalization_clip = input_config['normalization_clip']
-normalization_values = input_config['normalization_values']
+normalize_kwargs = _get_normalize_kwargs_from_config(input_config)
 
 model_type = input_config['model_type']
 
@@ -142,81 +136,40 @@ with open(pos+f'log_{mode}.json', 'a') as f:
 # Loop over all frames and segment
 def segment_index(indices):
 
-	global scale
-
 	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.")
-		scale_model = scale
+		model, scale_model = _prep_stardist_model(modelname, Path(model_complete_path).parent, use_gpu=use_gpu, scale=scale)
 
 	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,
-		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 {modelname} successfully loaded.')
+		model, scale_model = _prep_cellpose_model(modelname, model_complete_path, use_gpu=use_gpu, n_channels=len(required_channels), scale=scale)
 
 	for t in tqdm(indices,desc="frame"):
-		
-		# Load channels at time t
-		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])
-
-		f = load_frames(img_num_channels[:,t], file, scale=scale_model, normalize_input=True, normalize_kwargs={"percentiles": percentiles, 'values': values, 'clip': normalization_clip})
-		f = np.moveaxis([interpolate_nan(f[:,:,c].copy()) for c in range(f.shape[-1])],0,-1)
-
-		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)
+		f = _load_frames_to_segment(file, img_num_channels[:,t], scale_model=scale_model, normalize_kwargs=normalize_kwargs)
 
+		if model_type=="stardist":
+			Y_pred = _segment_image_with_stardist_model(f, model=model, return_details=False)
 		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)
+			Y_pred = _segment_image_with_cellpose_model(f, model=model, diameter=diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold)
 
 		if scale is not None:
-			Y_pred = zoom(Y_pred, [1./scale_model,1./scale_model],order=0)
+			Y_pred = _rescale_labels(Y_pred, scale_model=scale_model)
 
-		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)
+		Y_pred = _check_label_dims(Y_pred, file)
 
 		save_tiff_imagej_compatible(pos+os.sep.join([label_folder,f"{str(t).zfill(4)}.tif"]), Y_pred, axes='YX')
 
 		del f;
-		del template;
 		del Y_pred;
 		gc.collect()
 
+	del model;
+	gc.collect()
+
 	return
 
 
 print(f"Starting the segmentation with {n_threads} thread(s) and GPU={use_gpu}...")
 
-import concurrent.futures
-
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)

celldetective/scripts/segment_cells_thresholds.py

@@ -16,6 +16,7 @@ import numpy as np
 from csbdeep.io import save_tiff_imagej_compatible
 import gc
 from art import tprint
+import concurrent.futures
 
 tprint("Segment")
 
@@ -124,8 +125,6 @@ def segment_index(indices):
 
 print(f"Starting the segmentation with {n_threads} thread(s)...")
 
-import concurrent.futures
-
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)

celldetective/scripts/track_cells.py

@@ -6,8 +6,8 @@ import argparse
 import datetime
 import os
 import json
-from celldetective.io import auto_load_number_of_frames, load_frames, interpret_tracking_configuration, extract_position_name
-from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
+from celldetective.io import auto_load_number_of_frames, interpret_tracking_configuration, extract_position_name
+from celldetective.utils import _mask_intensity_measurements, extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, extract_experiment_channels
 from celldetective.measure import drop_tonal_features, measure_features
 from celldetective.tracking import track
 from pathlib import Path, PurePath
@@ -19,7 +19,8 @@ import gc
 import os
 from natsort import natsorted
 from art import tprint
-from tifffile import imread
+import concurrent.futures
+
 
 tprint("Track")
 
@@ -173,35 +174,39 @@ if not btrack_option:
 
 def measure_index(indices):
 
+	props = []
+
 	for t in tqdm(indices,desc="frame"):
 		
 		# Load channels at time t
-		img = load_frames(img_num_channels[:,t], file, scale=None, normalize_input=False)
-		lbl = imread(label_path[t])
+		img = _load_frames_to_measure(file, indices=img_num_channels[:,t])
+		lbl = locate_labels(pos, population=mode, frames=t)
+		if lbl is None:
+			continue
 
 		df_props = measure_features(img, lbl, features = features+['centroid'], border_dist=None, 
 										channels=channel_names, haralick_options=haralick_options, verbose=False, 
 									)
 		df_props.rename(columns={'centroid-1': 'x', 'centroid-0': 'y'},inplace=True)
 		df_props['t'] = int(t)
-		timestep_dataframes.append(df_props)
-	return 
 
+		props.append(df_props)
 
+	return props
 
 print(f"Measuring features with {n_threads} thread(s)...")
 
-import concurrent.futures
-
 # Multithreading
 indices = list(range(img_num_channels.shape[1]))
 chunks = np.array_split(indices, n_threads)
 
+timestep_dataframes = []
 with concurrent.futures.ThreadPoolExecutor() as executor:
 	results = executor.map(measure_index, chunks)
 	try:
 		for i,return_value in enumerate(results):
-			print(f"Thread {i} output check: ",return_value)
+			print(f"Thread {i} completed...")
+			timestep_dataframes.extend(return_value)
 	except Exception as e:
 		print("Exception: ", e)
 
@@ -210,15 +215,7 @@ print('Features successfully measured...')
 df = pd.concat(timestep_dataframes)	
 df.reset_index(inplace=True, drop=True)
 
-if mask_channels is not None:
-	cols_to_drop = []
-	for mc in mask_channels:
-		columns = df.columns
-		col_contains = [mc in c for c in columns]
-		to_remove = np.array(columns)[np.array(col_contains)]
-		cols_to_drop.extend(to_remove)
-	if len(cols_to_drop)>0:
-		df = df.drop(cols_to_drop, axis=1)
+df = _mask_intensity_measurements(df, mask_channels)
 
 # do tracking
 if btrack_option:

celldetective/segmentation.py

@@ -8,12 +8,9 @@ from .utils import _estimate_scale_factor, _extract_channel_indices
 from pathlib import Path
 from tqdm import tqdm
 import numpy as np
-from stardist.models import StarDist2D
-from cellpose.models import CellposeModel
-from skimage.transform import resize
-from celldetective.io import _view_on_napari, locate_labels, locate_stack, _view_on_napari
+from celldetective.io import _view_on_napari, locate_labels, locate_stack, _view_on_napari, _check_label_dims
 from celldetective.filters import * #rework this to give a name
-from celldetective.utils import rename_intensity_column, mask_edges, estimate_unreliable_edge
+from celldetective.utils import interpolate_nan_multichannel,_rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes, _rescale_labels, rename_intensity_column, mask_edges, _prep_stardist_model, _prep_cellpose_model, estimate_unreliable_edge,_get_normalize_kwargs_from_config, _segment_image_with_stardist_model, _segment_image_with_cellpose_model
 from stardist import fill_label_holes
 import scipy.ndimage as ndi
 from skimage.segmentation import watershed
@@ -99,9 +96,7 @@ 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']
 
-	normalization_percentile = input_config['normalization_percentile']
-	normalization_clip = input_config['normalization_clip']
-	normalization_values = input_config['normalization_values']
+	normalize_kwargs = _get_normalize_kwargs_from_config(input_config)
 
 	if model_type=='cellpose':
 		diameter = input_config['diameter']
@@ -116,28 +111,10 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 	print(f"{spatial_calibration=} {required_spatial_calibration=} Scale = {scale}...")
 
 	if model_type=='stardist':
-
-		model = StarDist2D(None, name=model_name, basedir=Path(model_path).parent)
-		model.config.use_gpu = use_gpu
-		model.use_gpu = use_gpu
-		print(f"StarDist model {model_name} successfully loaded.")
-		scale_model = scale
+		model, scale_model = _prep_stardist_model(model_name, Path(model_path).parent, use_gpu=use_gpu, scale=scale)
 
 	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_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.')
+		model, scale_model = _prep_cellpose_model(model_path.split('/')[-2], model_path, use_gpu=use_gpu, n_channels=len(required_channels), scale=scale)		
 
 	labels = []
 
@@ -149,11 +126,7 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 		channel_indices[channel_indices==None] = 0
 
 		frame = stack[t]
-		#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)
+		frame = _rearrange_multichannel_frame(frame).astype(float)
 
 		frame_to_segment = np.zeros((frame.shape[0], frame.shape[1], len(required_channels))).astype(float)
 		for ch in channel_intersection:
@@ -162,45 +135,25 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 		frame = frame_to_segment
 		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})
+		frame = normalize_multichannel(frame, **normalize_kwargs)
 		
 		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 = zoom_multiframes(frame, scale_model)
 		
-		frame = np.moveaxis([interpolate_nan(frame[:,:,c].copy()) for c in range(frame.shape[-1])],0,-1)
+		frame = _fix_no_contrast(frame)
+		frame = interpolate_nan_multichannel(frame)
 		frame[:,:,none_channel_indices] = 0.
 
 		if model_type=="stardist":
-
-			Y_pred, details = model.predict_instances(frame, n_tiles=model._guess_n_tiles(frame), show_tile_progress=False, verbose=False)
-			Y_pred = Y_pred.astype(np.uint16)
+			Y_pred = _segment_image_with_stardist_model(frame, model=model, return_details=False)
 
 		elif model_type=="cellpose":
-			
-			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)
+			Y_pred = _segment_image_with_cellpose_model(frame, model=model, diameter=diameter, cellprob_threshold=cellprob_threshold, flow_threshold=flow_threshold)
 
 		if Y_pred.shape != stack[0].shape[:2]:
-			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)
+			Y_pred = _rescale_labels(Y_pred, scale_model)
+		
+		Y_pred = _check_label_dims(Y_pred, template=template)
 
 		labels.append(Y_pred)
 
@@ -315,6 +268,7 @@ def segment_frame_from_thresholds(frame, target_channel=0, thresholds=None, equa
 	"""
 
 	img = frame[:,:,target_channel]
+	img = interpolate_nan(img)
 	if equalize_reference is not None:
 		img = match_histograms(img, equalize_reference)
 	img_mc = frame.copy()