celldetective 1.1.1__tar.gz → 1.1.1.post1__tar.gz

{celldetective-1.1.1 → celldetective-1.1.1.post1}/PKG-INFO

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

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/extra_properties.py

@@ -7,7 +7,7 @@ If intensity is in function name, it will be replaced by the name of the channel
 import warnings
 
 import numpy as np
-from scipy.ndimage import distance_transform_edt
+from scipy.ndimage import distance_transform_edt, center_of_mass
 from scipy.spatial.distance import euclidean
 
 

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/filters.py

@@ -1,21 +1,36 @@
 from skimage.filters import difference_of_gaussians, threshold_otsu, threshold_local, threshold_niblack, threshold_sauvola
+from celldetective.utils import interpolate_nan
 import scipy.ndimage as snd
 import numpy as np
 
-def gauss_filter(img, sigma, *kwargs):
+def gauss_filter(img, sigma, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return snd.gaussian_filter(img.astype(float), sigma, *kwargs)
 
-def median_filter(img, size, *kwargs):
+def median_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	size = int(size)
 	return snd.median_filter(img, size, *kwargs)
 
-def maximum_filter(img, size, *kwargs):
+def maximum_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.maximum_filter(img.astype(float), size, *kwargs)
 
-def minimum_filter(img, size, *kwargs):
+def minimum_filter(img, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.minimum_filter(img.astype(float), size, *kwargs)
 
-def percentile_filter(img, percentile, size, *kwargs):
+def percentile_filter(img, percentile, size, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
+
 	return snd.percentile_filter(img.astype(float), percentile, size, *kwargs)
 
 def subtract_filter(img, value, *kwargs):
@@ -24,14 +39,19 @@ def subtract_filter(img, value, *kwargs):
 def abs_filter(img, *kwargs):
 	return np.abs(img)
 
-def ln_filter(img, *kwargs):
+def ln_filter(img, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 
 	img[np.where(img>0.)] = np.log(img[np.where(img>0.)])
 	img[np.where(img<=0.)] = 0.
 
 	return img
 
-def variance_filter(img, size):
+def variance_filter(img, size, interpolate=True):
+
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 
 	size = int(size)
 	img = img.astype(float)
@@ -41,8 +61,10 @@ def variance_filter(img, size):
 
 	return img
 
-def std_filter(img, size):
+def std_filter(img, size, interpolate=True):
 
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	size = int(size)
 	img = img.astype(float)
 	win_mean = snd.uniform_filter(img, (size,size), mode='wrap')
@@ -53,10 +75,14 @@ def std_filter(img, size):
 
 	return img
 
-def laplace_filter(img, output=float, *kwargs):
+def laplace_filter(img, output=float, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return snd.laplace(img.astype(float), *kwargs)
 
-def dog_filter(img, sigma_low, sigma_high, *kwargs):
+def dog_filter(img, sigma_low, sigma_high, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	return difference_of_gaussians(img.astype(float), sigma_low, sigma_high, *kwargs)
 
 def otsu_filter(img, *kwargs):
@@ -82,7 +108,9 @@ def sauvola_filter(img, *kwargs):
 def log_filter(img, sigma, *kwargs):
 	return snd.gaussian_laplace(img.astype(float), sigma, *kwargs)
 
-def tophat_filter(img, size, connectivity=4, *kwargs):
+def tophat_filter(img, size, connectivity=4, interpolate=True, *kwargs):
+	if interpolate:
+		img = interpolate_nan(img.astype(float))
 	structure = snd.generate_binary_structure(rank=2, connectivity=connectivity)
 	img = snd.white_tophat(img.astype(float), structure=structure, size=size, *kwargs)
 	return img

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/gui/classifier_widget.py

@@ -136,9 +136,10 @@ class ClassifierWidget(QWidget, Styles):
 
 		self.irreversible_event_btn = QRadioButton('irreversible event')
 		self.unique_state_btn = QRadioButton('unique state')
-		self.time_corr_options = [self.irreversible_event_btn, self.unique_state_btn]
 		time_corr_btn_group = QButtonGroup()
 		self.unique_state_btn.click()
+		self.time_corr_options = [self.irreversible_event_btn, self.unique_state_btn]
+
 		for btn in self.time_corr_options:
 			time_corr_btn_group.addButton(btn)
 			btn.setEnabled(False)
@@ -148,8 +149,28 @@ class ClassifierWidget(QWidget, Styles):
 		time_corr_layout.addWidget(self.irreversible_event_btn, 50,alignment=Qt.AlignCenter)
 		layout.addLayout(time_corr_layout)
 
+		self.r2_slider = QLabeledDoubleSlider()
+		self.r2_slider.setValue(0.75)
+		self.r2_slider.setRange(0,1)
+		self.r2_slider.setSingleStep(0.01)
+		self.r2_slider.setOrientation(1)
+		self.r2_label = QLabel('R2 tolerance:')
+		self.r2_label.setToolTip('Minimum R2 between the fit sigmoid and the binary response to the filters to accept the event.')
+		r2_threshold_layout = QHBoxLayout()
+		r2_threshold_layout.addWidget(QLabel(''), 50)
+		r2_threshold_layout.addWidget(self.r2_label, 15)
+		r2_threshold_layout.addWidget(self.r2_slider, 35)
+		layout.addLayout(r2_threshold_layout)	
+		
+		self.irreversible_event_btn.clicked.connect(self.activate_r2)
+		self.unique_state_btn.clicked.connect(self.activate_r2)
+
+		for wg in [self.r2_slider, self.r2_label]:
+			wg.setEnabled(False)
+
 		layout.addWidget(QLabel())
 
+
 		self.submit_btn = QPushButton('apply')
 		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.clicked.connect(self.submit_classification)
@@ -158,14 +179,30 @@ class ClassifierWidget(QWidget, Styles):
 		self.frame_slider.valueChanged.connect(self.set_frame)
 		self.alpha_slider.valueChanged.connect(self.set_transparency)
 
+	def activate_r2(self):
+		if self.irreversible_event_btn.isChecked() and self.time_corr.isChecked():
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(True)
+		else:
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(False)				
+
 	def activate_time_corr_options(self):
 
 		if self.time_corr.isChecked():
 			for btn in self.time_corr_options:
 				btn.setEnabled(True)
+			if self.irreversible_event_btn.isChecked():
+				for wg in [self.r2_slider, self.r2_label]:
+					wg.setEnabled(True)
+			else:
+				for wg in [self.r2_slider, self.r2_label]:
+					wg.setEnabled(False)				
 		else:
 			for btn in self.time_corr_options:
 				btn.setEnabled(False)
+			for wg in [self.r2_slider, self.r2_label]:
+				wg.setEnabled(False)
 
 	def init_class(self):
 
@@ -207,8 +244,20 @@ class ClassifierWidget(QWidget, Styles):
 			self.scat_props.set_alpha(self.currentAlpha)
 			self.ax_props.set_xlabel(self.features_cb[1].currentText())
 			self.ax_props.set_ylabel(self.features_cb[0].currentText())
-		self.ax_props.set_xlim(1*self.df[self.features_cb[1].currentText()].min(),1.0*self.df[self.features_cb[1].currentText()].max())
-		self.ax_props.set_ylim(1*self.df[self.features_cb[0].currentText()].min(),1.0*self.df[self.features_cb[0].currentText()].max())
+
+
+		feat_x = self.features_cb[1].currentText()
+		feat_y = self.features_cb[0].currentText()
+		min_x = self.df.dropna(subset=feat_x)[feat_x].min()
+		max_x = self.df.dropna(subset=feat_x)[feat_x].max()
+		min_y = self.df.dropna(subset=feat_y)[feat_y].min()
+		max_y = self.df.dropna(subset=feat_y)[feat_y].max()
+
+		if min_x==min_x and max_x==max_x:
+			self.ax_props.set_xlim(min_x, max_x)
+		if min_y==min_y and max_y==max_y:
+			self.ax_props.set_ylim(min_y, max_y)
+		
 		if feature_changed:
 			self.propscanvas.canvas.toolbar.update()
 		self.propscanvas.canvas.draw_idle()
@@ -400,15 +449,16 @@ class ClassifierWidget(QWidget, Styles):
 			timeline = group['FRAME'].values
 			
 			try:
-				popt, pcov = curve_fit(step_function, timeline, status_signal,p0=[self.df['FRAME'].max()//2, 0.5],maxfev=10000)
-				r2 = r2_score(status_signal, step_function(timeline, *popt))
+				popt, pcov = curve_fit(step_function, timeline.astype(int), status_signal, p0=[self.df['FRAME'].max()//2, 0.8],maxfev=30000)
+				values = [step_function(t, *popt) for t in timeline]
+				r2 = r2_score(status_signal,values)
 			except Exception as e:
 				print(e)
 				self.df.loc[indices, self.class_name_user] = 2.0
 				self.df.loc[indices, self.class_name_user.replace('class','t')] = -1
 				continue
 
-			if r2 > 0.7:
+			if r2 > float(self.r2_slider.value()):
 				t0 = popt[0]
 				self.df.loc[indices, self.class_name_user.replace('class','t')] = t0
 				self.df.loc[indices, self.class_name_user] = 0.0
@@ -426,4 +476,3 @@ class ClassifierWidget(QWidget, Styles):
 
 
 
-

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/gui/layouts.py

@@ -702,12 +702,12 @@ class BackgroundModelFreeCorrectionLayout(QGridLayout, Styles):
 						   show_progress_per_pos = False,
 							)
 		
-
 		self.viewer = StackVisualizer(
 									  stack=corrected_stacks[0],
 									  window_title='Corrected channel',
 									  frame_slider = True,
-									  contrast_slider = True
+									  contrast_slider = True,
+									  target_channel=self.channels_cb.currentIndex(),
 									 )
 		self.viewer.show()
 	

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/gui/tableUI.py

@@ -232,6 +232,11 @@ class TableUI(QMainWindow, Styles):
 			self.plot_action.setShortcut("Ctrl+p")
 			self.fileMenu.addAction(self.plot_action)		
 
+			self.plot_inst_action = QAction("&Plot instantaneous...", self)
+			self.plot_inst_action.triggered.connect(self.plot_instantaneous)
+			self.plot_inst_action.setShortcut("Ctrl+i")
+			self.fileMenu.addAction(self.plot_inst_action)	
+
 			self.groupby_action = QAction("&Group by tracks...", self)
 			self.groupby_action.triggered.connect(self.set_projection_mode_tracks)
 			self.groupby_action.setShortcut("Ctrl+g")
@@ -408,7 +413,7 @@ class TableUI(QMainWindow, Styles):
 		self.status_operation.setEnabled(False)
 		self.status_operation.addItems(['mean','median','min','max', 'prod', 'sum'])
 
-		status_cols = np.array([c.startswith('status_') for c in cols])
+		status_cols = np.array([c.startswith('status_') or c.startswith('group_') for c in cols])
 		status_cols = list(cols[status_cols])
 		if 'status' in list(self.data.columns):
 			status_cols.append('status')
@@ -739,6 +744,15 @@ class TableUI(QMainWindow, Styles):
 		else:
 			return array
 
+	def plot_instantaneous(self):
+		
+		if self.plot_mode=='plot_track_signals':
+			self.plot_mode = 'static'
+			self.plot()
+			self.plot_mode = 'plot_track_signals'
+		elif self.plot_mode=="static":
+			self.plot()
+
 	def plot(self):
 		if self.plot_mode == "static":
 	

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/gui/thresholds_gui.py

@@ -2,7 +2,7 @@ import math
 
 import skimage
 from PyQt5.QtWidgets import QAction, QMenu, QMainWindow, QMessageBox, QLabel, QWidget, QFileDialog, QHBoxLayout, \
-	QGridLayout, QLineEdit, QScrollArea, QVBoxLayout, QComboBox, QPushButton, QApplication, QPushButton
+	QGridLayout, QLineEdit, QScrollArea, QVBoxLayout, QComboBox, QPushButton, QApplication, QPushButton, QRadioButton, QButtonGroup
 from PyQt5.QtGui import QDoubleValidator, QIntValidator
 from matplotlib.backends.backend_qt import NavigationToolbar2QT
 from matplotlib.patches import Circle
@@ -17,6 +17,7 @@ from celldetective.io import auto_load_number_of_frames, load_frames
 from celldetective.segmentation import threshold_image, identify_markers_from_binary, apply_watershed, \
 	segment_frame_from_thresholds
 from scipy.ndimage import binary_fill_holes
+import scipy.ndimage as ndi
 from PyQt5.QtCore import Qt, QSize
 from glob import glob
 from superqt.fonticon import icon
@@ -263,10 +264,20 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		marker_box = QVBoxLayout()
 		marker_box.setContentsMargins(30, 30, 30, 30)
 
-		marker_lbl = QLabel('Markers')
+		marker_lbl = QLabel('Objects')
 		marker_lbl.setStyleSheet("font-weight: bold;")
 		marker_box.addWidget(marker_lbl, alignment=Qt.AlignCenter)
 
+		object_option_hbox = QHBoxLayout()
+		self.marker_option = QRadioButton('markers')
+		self.all_objects_option = QRadioButton('all non-contiguous objects')
+		self.marker_option_group = QButtonGroup()
+		self.marker_option_group.addButton(self.marker_option)
+		self.marker_option_group.addButton(self.all_objects_option)
+		object_option_hbox.addWidget(self.marker_option, 50, alignment=Qt.AlignCenter)
+		object_option_hbox.addWidget(self.all_objects_option, 50, alignment=Qt.AlignCenter)
+		marker_box.addLayout(object_option_hbox)
+
 		hbox_footprint = QHBoxLayout()
 		hbox_footprint.addWidget(QLabel('Footprint: '), 20)
 		self.footprint_slider = QLabeledSlider()
@@ -275,7 +286,8 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.footprint_slider.setRange(1, self.binary.shape[0] // 4)
 		self.footprint_slider.setValue(self.footprint)
 		self.footprint_slider.valueChanged.connect(self.set_footprint)
-		hbox_footprint.addWidget(self.footprint_slider, 80)
+		hbox_footprint.addWidget(self.footprint_slider, 30)
+		hbox_footprint.addWidget(QLabel(''), 50)
 		marker_box.addLayout(hbox_footprint)
 
 		hbox_distance = QHBoxLayout()
@@ -286,7 +298,8 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.min_dist_slider.setRange(0, self.binary.shape[0] // 4)
 		self.min_dist_slider.setValue(self.min_dist)
 		self.min_dist_slider.valueChanged.connect(self.set_min_dist)
-		hbox_distance.addWidget(self.min_dist_slider, 80)
+		hbox_distance.addWidget(self.min_dist_slider, 30)
+		hbox_distance.addWidget(QLabel(''), 50)
 		marker_box.addLayout(hbox_distance)
 
 		hbox_marker_btns = QHBoxLayout()
@@ -305,8 +318,23 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		hbox_marker_btns.addWidget(self.watershed_btn)
 		marker_box.addLayout(hbox_marker_btns)
 
+		self.marker_option.clicked.connect(self.enable_marker_options)
+		self.all_objects_option.clicked.connect(self.enable_marker_options)
+		self.marker_option.click()
+
 		self.left_panel.addLayout(marker_box)
 
+	def enable_marker_options(self):
+		if self.marker_option.isChecked():
+			self.footprint_slider.setEnabled(True)
+			self.min_dist_slider.setEnabled(True)
+			self.markers_btn.setEnabled(True)
+		else:
+			self.footprint_slider.setEnabled(False)
+			self.min_dist_slider.setEnabled(False)
+			self.markers_btn.setEnabled(False)
+			self.watershed_btn.setEnabled(True)	
+
 	def generate_props_contents(self):
 
 		properties_box = QVBoxLayout()
@@ -675,7 +703,10 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 
 	def apply_watershed_to_selection(self):
 
-		self.labels = apply_watershed(self.binary, self.coords, self.edt_map)
+		if self.marker_option.isChecked():
+			self.labels = apply_watershed(self.binary, self.coords, self.edt_map)
+		else:
+			self.labels,_ = ndi.label(self.binary.astype(int))
 
 		self.current_channel = self.channels_cb.currentIndex()
 		t = int(self.frame_slider.value())
@@ -806,6 +837,7 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 			"marker_footprint_size": self.footprint,
 			"feature_queries": [self.property_query_le.text()],
 			"equalize_reference": [self.equalize_option, self.frame_slider.value()],
+			"do_watershed": self.marker_option.isChecked(),
 		}
 
 		print('The following instructions will be written: ', instructions)
@@ -873,6 +905,13 @@ class ThresholdConfigWizard(QMainWindow, Styles):
 		self.property_query_le.setText(feature_queries[0])
 		self.submit_query_btn.click()
 
+		if 'do_watershed' in threshold_instructions:
+			do_watershed = threshold_instructions['do_watershed']
+			if do_watershed:
+				self.marker_option.click()
+			else:
+				self.all_objects_option.click()
+
 
 class ThresholdNormalisation(ThresholdConfigWizard):
 	def __init__(self, min_threshold, current_channel, parent_window=None):

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/io.py

@@ -1238,12 +1238,23 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 	"""
 	position = position.replace('\\','/')
 	if population.lower()=="target" or population.lower()=="targets":
-		napari_data = np.load(position+os.sep.join(['output','tables','napari_target_trajectories.npy']), allow_pickle=True)
+		if os.path.exists(position+os.sep.join(['output','tables','napari_target_trajectories.npy'])):
+			napari_data = np.load(position+os.sep.join(['output','tables','napari_target_trajectories.npy']), allow_pickle=True)
+		else:
+			napari_data = None
 	elif population.lower()=="effector" or population.lower()=="effectors":
-		napari_data = np.load(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy']), allow_pickle=True)
-	data = napari_data.item()['data']
-	properties = napari_data.item()['properties']
-	graph = napari_data.item()['graph']
+		if os.path.exists(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy'])):
+			napari_data = np.load(position+os.sep.join(['output', 'tables', 'napari_effector_trajectories.npy']), allow_pickle=True)
+		else:
+			napari_data = None
+	if napari_data is not None:
+		data = napari_data.item()['data']
+		properties = napari_data.item()['properties']
+		graph = napari_data.item()['graph']
+	else:
+		data = None
+		properties = None
+		graph = None
 	if return_stack:
 		stack,labels = locate_stack_and_labels(position, prefix=prefix, population=population)
 	else:
@@ -1968,15 +1979,19 @@ def normalize_multichannel(multichannel_frame, percentiles=None,
 			v = values[c]
 		else:
 			v = None
-		norm = normalize(mf[:,:,c].copy(),
-							  percentiles=percentiles[c],
-							  values=v,
-							  ignore_gray_value=ignore_gray_value,
-							  clip=clip,
-							  amplification=amplification,
-							  dtype=dtype,
-							  )
-		mf_new.append(norm)
+
+		if np.all(mf[:,:,c]==0.):
+			mf_new.append(mf[:,:,c].copy())
+		else:
+			norm = normalize(mf[:,:,c].copy(),
+								  percentiles=percentiles[c],
+								  values=v,
+								  ignore_gray_value=ignore_gray_value,
+								  clip=clip,
+								  amplification=amplification,
+								  dtype=dtype,
+								  )
+			mf_new.append(norm)
 
 	return np.moveaxis(mf_new,0,-1)
 

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/scripts/segment_cells.py

@@ -9,7 +9,7 @@ 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 celldetective.utils import interpolate_nan, _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
@@ -121,6 +121,7 @@ if model_type=='cellpose':
 	flow_threshold = input_config['flow_threshold']
 
 scale = _estimate_scale_factor(spatial_calibration, required_spatial_calibration)
+print(f"Scale = {scale}...")
 
 nbr_channels = _extract_nbr_channels_from_config(config)
 print(f'Number of channels in the input movie: {nbr_channels}')
@@ -140,6 +141,7 @@ 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)
@@ -156,7 +158,11 @@ def segment_index(indices):
 			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
+		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.')
 
 	for t in tqdm(indices,desc="frame"):
@@ -172,10 +178,12 @@ def segment_index(indices):
 				percentiles.append(None)
 				values.append(normalization_values[k])
 
-		f = load_frames(img_num_channels[:,t], file, scale=scale, normalize_input=True, normalize_kwargs={"percentiles": percentiles, 'values': values, 'clip': normalization_clip})
+		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)
@@ -188,7 +196,7 @@ def segment_index(indices):
 			Y_pred = Y_pred.astype(np.uint16)
 
 		if scale is not None:
-			Y_pred = zoom(Y_pred, [1./scale,1./scale],order=0)
+			Y_pred = zoom(Y_pred, [1./scale_model,1./scale_model],order=0)
 
 		template = load_frames(0,file,scale=1,normalize_input=False)
 		if Y_pred.shape != template.shape[:2]:

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/segmentation.py

@@ -116,6 +116,10 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 
 	elif model_type=='cellpose':
 		model = CellposeModel(gpu=use_gpu, pretrained_model=model_path+model_path.split('/')[-2], 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
 
 	labels = []
 	if (time_flat_normalization)*normalize:
@@ -133,7 +137,7 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 			frame = normalize_multichannel(frame, values=normalization_values)
 
 		if scale is not None:
-			frame = [ndi.zoom(frame[:,:,c].copy(), [scale,scale], order=3, prefilter=False) for c in range(frame.shape[-1])]
+			frame = [ndi.zoom(frame[:,:,c].copy(), [scale_model,scale_model], order=3, prefilter=False) for c in range(frame.shape[-1])]
 
 		if model_type=="stardist":
 
@@ -142,16 +146,11 @@ def segment(stack, model_name, channels=None, spatial_calibration=None, view_on_
 
 		elif model_type=="cellpose":
 
-			if stack.ndim==3:
-				channels_cp = [[0,0]]
-			else:
-				channels_cp = [[0,1]]
-
-			Y_pred, _, _ = model.eval([frame], diameter = diameter, flow_threshold=flow_threshold, channels=channels_cp, normalize=normalize)
-			Y_pred = Y_pred[0].astype(np.uint16)
+			Y_pred, _, _ = model.eval(frame, 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,1./scale],order=0)
+			Y_pred = ndi.zoom(Y_pred, [1./scale_model,1./scale_model],order=0)
 
 
 		if Y_pred.shape != stack[0].shape[:2]:
@@ -229,7 +228,7 @@ def segment_from_thresholds(stack, target_channel=0, thresholds=None, view_on_na
 	return masks
 
 def segment_frame_from_thresholds(frame, target_channel=0, thresholds=None, equalize_reference=None,
-								  filters=None, marker_min_distance=30, marker_footprint_size=20, marker_footprint=None, feature_queries=None, channel_names=None):
+								  filters=None, marker_min_distance=30, marker_footprint_size=20, marker_footprint=None, feature_queries=None, channel_names=None, do_watershed=True):
 	
 	"""
 	Segments objects within a single frame based on intensity thresholds and optional image processing steps.
@@ -276,8 +275,13 @@ def segment_frame_from_thresholds(frame, target_channel=0, thresholds=None, equa
 	img = filter_image(img, filters=filters)
 	edge = estimate_unreliable_edge(filters)
 	binary_image = threshold_image(img, thresholds[0], thresholds[1], fill_holes=True, edge_exclusion=edge)
-	coords,distance = identify_markers_from_binary(binary_image, marker_min_distance, footprint_size=marker_footprint_size, footprint=marker_footprint, return_edt=True)
-	instance_seg = apply_watershed(binary_image, coords, distance)
+	
+	if do_watershed:
+		coords,distance = identify_markers_from_binary(binary_image, marker_min_distance, footprint_size=marker_footprint_size, footprint=marker_footprint, return_edt=True)
+		instance_seg = apply_watershed(binary_image, coords, distance)
+	else:
+		instance_seg, _ = ndi.label(binary_image.astype(int).copy())
+
 	instance_seg = filter_on_property(instance_seg, intensity_image=img_mc, queries=feature_queries, channel_names=channel_names)
 
 	return instance_seg

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective/utils.py

@@ -2220,6 +2220,9 @@ def interpolate_nan(img, method='nearest'):
 	Interpolate NaN on single channel array 2D
 	"""
 
+	if np.all(img==0):
+		return img
+
 	if np.any(img.flatten()!=img.flatten()):
 		# then need to interpolate
 		x_grid, y_grid = np.meshgrid(np.arange(img.shape[1]),np.arange(img.shape[0]))

{celldetective-1.1.1 → celldetective-1.1.1.post1}/celldetective.egg-info/PKG-INFO

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

{celldetective-1.1.1 → celldetective-1.1.1.post1}/setup.py

@@ -18,7 +18,7 @@ except:
     requirements = [str(ir.requirement) for ir in requirements]
 
 setup(name='celldetective',
-			version='1.1.1',
+			version='1.1.1.post1',
 			description='description',
 			long_description=(this_directory / "README.md").read_text(),
 			#long_description=open('README.rst',encoding="utf8").read(),