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

celldetective/gui/tableUI.py

@@ -166,7 +166,7 @@ class DifferentiateColWidget(QWidget, Styles):
 		layout.addLayout(measurement_layout)
 
 		self.window_size_slider = QLabeledSlider()
-		self.window_size_slider.setRange(1,np.nanmax(self.parent_window.data.FRAME.to_numpy()))
+		self.window_size_slider.setRange(1,int(np.nanmax(self.parent_window.data.FRAME.to_numpy())))
 		self.window_size_slider.setValue(3)
 		window_layout = QHBoxLayout()
 		window_layout.addWidget(QLabel('window size: '), 25)
@@ -215,6 +215,108 @@ class DifferentiateColWidget(QWidget, Styles):
 		self.parent_window.table_view.setModel(self.parent_window.model)
 		self.close()
 
+
+
+class OperationOnColsWidget(QWidget, Styles):
+
+	def __init__(self, parent_window, column1=None, column2=None, operation='divide'):
+
+		super().__init__()
+		self.parent_window = parent_window
+		self.column1 = column1
+		self.column2 = column2
+		self.operation = operation
+
+		self.setWindowTitle(self.operation)
+		# Create the QComboBox and add some items
+		center_window(self)
+		
+		layout = QVBoxLayout(self)
+		layout.setContentsMargins(30,30,30,30)
+
+		self.col1_cb = QComboBox()
+		self.col1_cb.addItems(list(self.parent_window.data.columns))
+		if self.column1 is not None:
+			idx = self.col1_cb.findText(self.column1)
+			self.col1_cb.setCurrentIndex(idx)
+
+		numerator_layout = QHBoxLayout()
+		numerator_layout.addWidget(QLabel('column 1: '), 25)
+		numerator_layout.addWidget(self.col1_cb, 75)
+		layout.addLayout(numerator_layout)
+
+		self.col2_cb = QComboBox()
+		self.col2_cb.addItems(list(self.parent_window.data.columns))
+		if self.column2 is not None:
+			idx = self.col2_cb.findText(self.column2)
+			self.col2_cb.setCurrentIndex(idx)
+
+		denominator_layout = QHBoxLayout()
+		denominator_layout.addWidget(QLabel('column 2: '), 25)
+		denominator_layout.addWidget(self.col2_cb, 75)
+		layout.addLayout(denominator_layout)
+
+		self.submit_btn = QPushButton('Compute')
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self.compute)
+		layout.addWidget(self.submit_btn, 30)
+
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
+	def compute(self):
+
+		test = self._check_cols_before_operation()
+		if not test:
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Warning)
+			msgBox.setText(f"Operation could not be performed, one of the column types is object...")
+			msgBox.setWindowTitle("Warning")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				return None
+			else:
+				return None
+		else:
+			if self.operation=='divide':
+				name = f"{self.col1_txt}/{self.col2_txt}"
+				with np.errstate(divide='ignore', invalid='ignore'):
+					res = np.true_divide(self.col1, self.col2)
+					res[res == np.inf] = np.nan
+					res[self.col1!=self.col1] = np.nan
+					res[self.col2!=self.col2] = np.nan
+					self.parent_window.data[name] = res
+
+			elif self.operation=='multiply':
+				name = f"{self.col1_txt}*{self.col2_txt}"
+				res = np.multiply(self.col1, self.col2)
+
+			elif self.operation=='add':
+				name = f"{self.col1_txt}+{self.col2_txt}"
+				res = np.add(self.col1, self.col2)
+
+			elif self.operation=='subtract':
+				name = f"{self.col1_txt}-{self.col2_txt}"
+				res = np.subtract(self.col1, self.col2)				
+			
+			self.parent_window.data[name] = res
+			self.parent_window.model = PandasModel(self.parent_window.data)
+			self.parent_window.table_view.setModel(self.parent_window.model)
+			self.close()
+
+	def _check_cols_before_operation(self):
+
+		self.col1_txt = self.col1_cb.currentText()
+		self.col2_txt = self.col2_cb.currentText()
+		
+		self.col1 = self.parent_window.data[self.col1_txt].to_numpy()
+		self.col2 = self.parent_window.data[self.col2_txt].to_numpy()
+
+		test = np.all([self.col1.dtype!='O', self.col2.dtype!='O'])
+
+		return test
+
+
 class CalibrateColWidget(GenericOpColWidget):
 	
 	def __init__(self, *args, **kwargs):
@@ -563,12 +665,34 @@ class TableUI(QMainWindow, Styles):
 		self.log_action = QAction('&Log (decimal)...', self)
 		self.log_action.triggered.connect(self.take_log_of_selected_feature)
 		#self.derivative_action.setShortcut("Ctrl+D")
-		self.mathMenu.addAction(self.log_action)						
+		self.mathMenu.addAction(self.log_action)
+
+
+		self.divide_action = QAction('&Divide...', self)
+		self.divide_action.triggered.connect(self.divide_signals)
+		#self.derivative_action.setShortcut("Ctrl+D")
+		self.mathMenu.addAction(self.divide_action)
+
+		self.multiply_action = QAction('&Multiply...', self)
+		self.multiply_action.triggered.connect(self.multiply_signals)
+		#self.derivative_action.setShortcut("Ctrl+D")
+		self.mathMenu.addAction(self.multiply_action)	
+
+		self.add_action = QAction('&Add...', self)
+		self.add_action.triggered.connect(self.add_signals)
+		#self.derivative_action.setShortcut("Ctrl+D")
+		self.mathMenu.addAction(self.add_action)	
+
+		self.subtract_action = QAction('&Subtract...', self)
+		self.subtract_action.triggered.connect(self.subtract_signals)
+		#self.derivative_action.setShortcut("Ctrl+D")
+		self.mathMenu.addAction(self.subtract_action)	
 
-		self.onehot_action = QAction('&One hot to categorical...', self)
-		self.onehot_action.triggered.connect(self.transform_one_hot_cols_to_categorical)
-		#self.onehot_action.setShortcut("Ctrl+D")
-		self.mathMenu.addAction(self.onehot_action)		
+
+		# self.onehot_action = QAction('&One hot to categorical...', self)
+		# self.onehot_action.triggered.connect(self.transform_one_hot_cols_to_categorical)
+		# #self.onehot_action.setShortcut("Ctrl+D")
+		# self.mathMenu.addAction(self.onehot_action)		
 
 	def collapse_pairs_in_neigh(self):
 
@@ -734,6 +858,96 @@ class TableUI(QMainWindow, Styles):
 			pos_group.to_csv(pos[0]+os.sep.join(['output', 'tables', f'trajectories_{self.population}.csv']), index=False)
 		print("Done...")
 
+	def divide_signals(self):
+
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if isinstance(col_idx, (list, np.ndarray)):
+			cols = np.array(list(self.data.columns))
+			if len(col_idx)>0:
+				selected_col1 = str(cols[col_idx[0]])
+				if len(col_idx)>1:
+					selected_col2 = str(cols[col_idx[1]])
+				else:
+					selected_col2 = None
+			else:
+				selected_col1 = None
+				selected_col2 = None
+		else:
+			selected_col1 = None
+			selected_col2 = None
+
+		self.divWidget = OperationOnColsWidget(self, column1=selected_col1, column2=selected_col2, operation='divide')
+		self.divWidget.show()
+
+
+	def multiply_signals(self):
+
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if isinstance(col_idx, (list, np.ndarray)):
+			cols = np.array(list(self.data.columns))
+			if len(col_idx)>0:
+				selected_col1 = str(cols[col_idx[0]])
+				if len(col_idx)>1:
+					selected_col2 = str(cols[col_idx[1]])
+				else:
+					selected_col2 = None
+			else:
+				selected_col1 = None
+				selected_col2 = None
+		else:
+			selected_col1 = None
+			selected_col2 = None
+
+		self.mulWidget = OperationOnColsWidget(self, column1=selected_col1, column2=selected_col2, operation='multiply')
+		self.mulWidget.show()
+
+	def add_signals(self):
+
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if isinstance(col_idx, (list, np.ndarray)):
+			cols = np.array(list(self.data.columns))
+			if len(col_idx)>0:
+				selected_col1 = str(cols[col_idx[0]])
+				if len(col_idx)>1:
+					selected_col2 = str(cols[col_idx[1]])
+				else:
+					selected_col2 = None
+			else:
+				selected_col1 = None
+				selected_col2 = None
+		else:
+			selected_col1 = None
+			selected_col2 = None
+
+		self.addiWidget = OperationOnColsWidget(self, column1=selected_col1, column2=selected_col2, operation='add')
+		self.addiWidget.show()
+
+	def subtract_signals(self):
+
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		if isinstance(col_idx, (list, np.ndarray)):
+			cols = np.array(list(self.data.columns))
+			if len(col_idx)>0:
+				selected_col1 = str(cols[col_idx[0]])
+				if len(col_idx)>1:
+					selected_col2 = str(cols[col_idx[1]])
+				else:
+					selected_col2 = None
+			else:
+				selected_col1 = None
+				selected_col2 = None
+		else:
+			selected_col1 = None
+			selected_col2 = None
+
+		self.subWidget = OperationOnColsWidget(self, column1=selected_col1, column2=selected_col2, operation='subtract')
+		self.subWidget.show()
+
+
 	def differenciate_selected_feature(self):
 		
 		# check only one col selected and assert is numerical
@@ -742,9 +956,12 @@ class TableUI(QMainWindow, Styles):
 		
 		x = self.table_view.selectedIndexes()
 		col_idx = np.unique(np.array([l.column() for l in x]))
-		if col_idx!=0:
+		if isinstance(col_idx, (list, np.ndarray)):
 			cols = np.array(list(self.data.columns))
-			selected_col = str(cols[col_idx][0])
+			if len(col_idx)>0:
+				selected_col = str(cols[col_idx[0]])
+			else:
+				selected_col = None
 		else:
 			selected_col = None
 
@@ -759,9 +976,12 @@ class TableUI(QMainWindow, Styles):
 		
 		x = self.table_view.selectedIndexes()
 		col_idx = np.unique(np.array([l.column() for l in x]))
-		if col_idx!=0:
+		if isinstance(col_idx, (list, np.ndarray)):
 			cols = np.array(list(self.data.columns))
-			selected_col = str(cols[col_idx][0])
+			if len(col_idx)>0:
+				selected_col = str(cols[col_idx[0]])
+			else:
+				selected_col = None
 		else:
 			selected_col = None
 
@@ -772,9 +992,12 @@ class TableUI(QMainWindow, Styles):
 		
 		x = self.table_view.selectedIndexes()
 		col_idx = np.unique(np.array([l.column() for l in x]))
-		if col_idx!=0:
+		if isinstance(col_idx, (list, np.ndarray)):
 			cols = np.array(list(self.data.columns))
-			selected_col = str(cols[col_idx][0])
+			if len(col_idx)>0:
+				selected_col = str(cols[col_idx[0]])
+			else:
+				selected_col = None
 		else:
 			selected_col = None
 
@@ -790,9 +1013,12 @@ class TableUI(QMainWindow, Styles):
 		
 		x = self.table_view.selectedIndexes()
 		col_idx = np.unique(np.array([l.column() for l in x]))
-		if col_idx!=0:
+		if isinstance(col_idx, (list, np.ndarray)):
 			cols = np.array(list(self.data.columns))
-			selected_col = str(cols[col_idx][0])
+			if len(col_idx)>0:
+				selected_col = str(cols[col_idx[0]])
+			else:
+				selected_col = None
 		else:
 			selected_col = None
 
@@ -804,11 +1030,14 @@ class TableUI(QMainWindow, Styles):
 
 		x = self.table_view.selectedIndexes()
 		col_idx = np.unique(np.array([l.column() for l in x]))
-		if list(col_idx):
+		if isinstance(col_idx, (list, np.ndarray)):
 			cols = np.array(list(self.data.columns))
-			selected_cols = cols[col_idx]
+			if len(col_idx)>0:
+				selected_col = str(cols[col_idx[0]])
+			else:
+				selected_col = None
 		else:
-			selected_cols = None
+			selected_col = None
 
 		self.mergewidget = MergeOneHotWidget(self, selected_columns=selected_cols)
 		self.mergewidget.show()
@@ -874,7 +1103,7 @@ class TableUI(QMainWindow, Styles):
 		self.projection_option.setChecked(True)
 		self.projection_option.toggled.connect(self.enable_projection_options)
 		self.projection_op_cb = QComboBox()
-		self.projection_op_cb.addItems(['mean','median','min','max', 'prod', 'sum'])
+		self.projection_op_cb.addItems(['mean','median','min','max','first','last','prod','sum'])
 
 		projection_layout = QHBoxLayout()
 		projection_layout.addWidget(self.projection_option, 33)
@@ -1044,8 +1273,11 @@ class TableUI(QMainWindow, Styles):
 		all_cms = list(colormaps)
 		for cm in all_cms:
 			if hasattr(matplotlib.cm, str(cm).lower()):
-				self.cmap_cb.addColormap(cm.lower())
-		
+				try:
+					self.cmap_cb.addColormap(cm.lower())
+				except:
+					pass
+					
 		hbox = QHBoxLayout()
 		hbox.addWidget(QLabel('colormap: '), 33)
 		hbox.addWidget(self.cmap_cb, 66)

celldetective/gui/viewers.py

@@ -932,7 +932,7 @@ class CellSizeViewer(StackVisualizer):
 	  with interactive sliders for diameter adjustment and circle display.
 	"""
 
-	def __init__(self, initial_diameter=40, set_radius_in_list=False, diameter_slider_range=(0,200), parent_le=None, parent_list_widget=None, *args, **kwargs):
+	def __init__(self, initial_diameter=40, set_radius_in_list=False, diameter_slider_range=(0,500), parent_le=None, parent_list_widget=None, *args, **kwargs):
 		# Initialize the widget and its attributes
 		
 		super().__init__(*args, **kwargs)

celldetective/io.py

@@ -16,7 +16,7 @@ import concurrent.futures
 from csbdeep.utils import normalize_mi_ma
 from csbdeep.io import save_tiff_imagej_compatible
 
-import skimage.io as skio
+import imageio.v2 as imageio
 from skimage.measure import regionprops_table, label
 
 from btrack.datasets import cell_config
@@ -400,6 +400,23 @@ def get_experiment_metadata(experiment):
 	metadata = ConfigSectionMap(config, "Metadata")
 	return metadata
 
+def get_experiment_labels(experiment):
+
+	config = get_config(experiment)
+	wells = get_experiment_wells(experiment)
+	nbr_of_wells = len(wells)
+
+	labels = ConfigSectionMap(config, "Labels")
+	for k in list(labels.keys()):
+		values = labels[k].split(',')
+		if nbr_of_wells != len(values):
+			values = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
+		if np.all([s.isnumeric() for s in values]):
+			values = [float(s) for s in values]
+		labels.update({k: values})
+
+	return labels
+
 
 def get_experiment_concentrations(experiment, dtype=str):
 	
@@ -982,10 +999,8 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 	wells = get_experiment_wells(experiment)
 
 	movie_prefix = ConfigSectionMap(config, "MovieSettings")["movie_prefix"]
-	concentrations = get_experiment_concentrations(experiment, dtype=float)
-	cell_types = get_experiment_cell_types(experiment)
-	antibodies = get_experiment_antibodies(experiment)
-	pharmaceutical_agents = get_experiment_pharmaceutical_agents(experiment)
+
+	labels = get_experiment_labels(experiment)
 	metadata = get_experiment_metadata(experiment) # None or dict of metadata
 	well_labels = _extract_labels_from_config(config, len(wells))
 
@@ -1001,14 +1016,8 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 
 		well_name, well_number = extract_well_name_and_number(well_path)
 		widx = well_indices[k]
-
 		well_alias = well_labels[widx]
 
-		well_concentration = concentrations[widx]
-		well_antibody = antibodies[widx]
-		well_cell_type = cell_types[widx]
-		well_pharmaceutical_agent = pharmaceutical_agents[widx]
-
 		positions = get_positions_in_well(well_path)
 		if position_indices is not None:
 			try:
@@ -1037,10 +1046,13 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 				df_pos['well_name'] = well_name
 				df_pos['pos_name'] = pos_name
 
-				df_pos['concentration'] = well_concentration
-				df_pos['antibody'] = well_antibody
-				df_pos['cell_type'] = well_cell_type
-				df_pos['pharmaceutical_agent'] = well_pharmaceutical_agent
+				for k in list(labels.keys()):
+					values = labels[k]
+					try:
+						df_pos[k] = values[widx]
+					except Exception as e:
+						print(f"{e=}")
+
 				if metadata is not None:
 					keys = list(metadata.keys())
 					for k in keys:
@@ -1052,10 +1064,6 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 				pos_dict = {'pos_path': pos_path, 'pos_index': real_pos_index, 'pos_name': pos_name, 'table_path': table,
 					 'stack_path': stack_path,'well_path': well_path, 'well_index': real_well_index, 'well_name': well_name,
 					 'well_number': well_number, 'well_alias': well_alias}
-				# if metadata is not None:
-				# 	keys = list(metadata.keys())
-				# 	for k in keys:
-				# 		pos_dict.update({k: metadata[k]})
 
 				df_pos_info.append(pos_dict)
 
@@ -3335,7 +3343,7 @@ def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=fl
 	"""
 
 	try:
-		frames = skio.imread(stack_path, key=img_nums, plugin="tifffile")
+		frames = imageio.imread(stack_path, key=img_nums)
 	except Exception as e:
 		print(
 			f'Error in loading the frame {img_nums} {e}. Please check that the experiment channel information is consistent with the movie being read.')

celldetective/segmentation.py

@@ -8,10 +8,12 @@ from .utils import _estimate_scale_factor, _extract_channel_indices
 from pathlib import Path
 from tqdm import tqdm
 import numpy as np
-from celldetective.io import _view_on_napari, locate_labels, locate_stack, _view_on_napari, _check_label_dims
+from celldetective.io import _view_on_napari, locate_labels, locate_stack, _view_on_napari, _check_label_dims, auto_correct_masks
 from celldetective.filters import * #rework this to give a name
 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
+from stardist.matching import matching
+
 import scipy.ndimage as ndi
 from skimage.segmentation import watershed
 from skimage.feature import peak_local_max
@@ -717,5 +719,50 @@ def train_segmentation_model(config, use_gpu=True):
 	cmd = f'python "{script_path}" --config "{config}" --use_gpu "{use_gpu}"'
 	subprocess.call(cmd, shell=True)
 
+
+def merge_instance_segmentation(labels, iou_matching_threshold=0.05, mode='OR'):
+
+	label_reference = labels[0]
+	for i in range(1,len(labels)):
+
+		label_to_merge = labels[i]
+		pairs = matching(label_reference,label_to_merge, thresh=0.5, criterion='iou', report_matches=True).matched_pairs
+		scores = matching(label_reference,label_to_merge, thresh=0.5, criterion='iou', report_matches=True).matched_scores
+		
+		accepted_pairs = []
+		for k,p in enumerate(pairs):
+			s = scores[k]
+			if s > iou_matching_threshold:
+				accepted_pairs.append(p)
+		
+		merge = np.copy(label_reference)
+
+		for p in accepted_pairs:
+			merge[np.where(merge==p[0])] = 0.
+			cdt1 = label_reference==p[0]
+			cdt2 = label_to_merge==p[1]
+			if mode=='OR':
+				cdt = np.logical_or(cdt1, cdt2)
+			elif mode=='AND':
+				cdt = np.logical_and(cdt1, cdt2)
+			elif mode=='XOR':
+				cdt = np.logical_xor(cdt1,cdt2)
+			loc_i, loc_j = np.where(cdt)
+			merge[loc_i, loc_j] = p[0]
+
+		cells_to_ignore = [p[1] for p in accepted_pairs]
+		for c in cells_to_ignore:
+			label_to_merge[label_to_merge==c] = 0
+
+		label_to_merge[label_to_merge!=0] = label_to_merge[label_to_merge!=0] + int(np.amax(label_reference))
+		merge[label_to_merge!=0] = label_to_merge[label_to_merge!=0]
+
+		label_reference = merge
+
+	merge = auto_correct_masks(merge)
+
+	return merge
+
+
 if __name__ == "__main__":
 	print(segment(None,'test'))

celldetective/signals.py

@@ -33,6 +33,7 @@ import time
 import math
 import pandas as pd
 from pandas.api.types import is_numeric_dtype
+from scipy.stats import median_abs_deviation
 
 abs_path = os.sep.join([os.path.split(os.path.dirname(os.path.realpath(__file__)))[0],'celldetective'])
 
@@ -680,11 +681,22 @@ class SignalDetectionModel(object):
 		if 'label' in model_config:
 			self.label = model_config['label']
 
-		self.n_channels = self.model_class.layers[0].input_shape[0][-1]
-		self.model_signal_length = self.model_class.layers[0].input_shape[0][-2]
-		self.n_classes = self.model_class.layers[-1].output_shape[-1]
+		try:
+			self.n_channels = self.model_class.layers[0].input_shape[0][-1]
+			self.model_signal_length = self.model_class.layers[0].input_shape[0][-2]
+			self.n_classes = self.model_class.layers[-1].output_shape[-1]
+			model_class_input_shape = self.model_class.layers[0].input_shape[0]
+			model_reg_input_shape = self.model_reg.layers[0].input_shape[0]
+		except AttributeError:
+			self.n_channels = self.model_class.input_shape[-1] #self.model_class.layers[0].input.shape[0][-1]
+			self.model_signal_length = self.model_class.input_shape[-2] #self.model_class.layers[0].input[0].shape[0][-2]
+			self.n_classes = self.model_class.output_shape[-1] #self.model_class.layers[-1].output[0].shape[-1]
+			model_class_input_shape = self.model_class.input_shape
+			model_reg_input_shape = self.model_reg.input_shape
+		except Exception as e:
+			print(e)		
 
-		assert self.model_class.layers[0].input_shape[0] == self.model_reg.layers[0].input_shape[0], f"mismatch between input shape of classification: {self.model_class.layers[0].input_shape[0]} and regression {self.model_reg.layers[0].input_shape[0]} models... Error."
+		assert model_class_input_shape==model_reg_input_shape, f"mismatch between input shape of classification: {self.model_class.layers[0].input_shape[0]} and regression {self.model_reg.layers[0].input_shape[0]} models... Error."
 
 		return True
 
@@ -1015,8 +1027,15 @@ class SignalDetectionModel(object):
 		# 	plt.plot(self.x[i,:,0])
 		# 	plt.show()
 
-		assert self.x.shape[-1] == self.model_class.layers[0].input_shape[0][-1], f"Shape mismatch between the input shape and the model input shape..."
-		assert self.x.shape[-2] == self.model_class.layers[0].input_shape[0][-2], f"Shape mismatch between the input shape and the model input shape..."
+		try:
+			n_channels = self.model_class.layers[0].input_shape[0][-1]
+			model_signal_length = self.model_class.layers[0].input_shape[0][-2]
+		except AttributeError:
+			n_channels = self.model_class.input_shape[-1]
+			model_signal_length = self.model_class.input_shape[-2]
+
+		assert self.x.shape[-1] == n_channels, f"Shape mismatch between the input shape and the model input shape..."
+		assert self.x.shape[-2] == model_signal_length, f"Shape mismatch between the input shape and the model input shape..."
 
 		self.class_predictions_one_hot = self.model_class.predict(self.x)
 		self.class_predictions = self.class_predictions_one_hot.argmax(axis=1)
@@ -1072,8 +1091,15 @@ class SignalDetectionModel(object):
 												normalization_values=self.normalization_values, normalization_clip=self.normalization_clip,
 												)
 
-		assert self.x.shape[-1] == self.model_reg.layers[0].input_shape[0][-1], f"Shape mismatch between the input shape and the model input shape..."
-		assert self.x.shape[-2] == self.model_reg.layers[0].input_shape[0][-2], f"Shape mismatch between the input shape and the model input shape..."
+		try:
+			n_channels = self.model_reg.layers[0].input_shape[0][-1]
+			model_signal_length = self.model_reg.layers[0].input_shape[0][-2]
+		except AttributeError:
+			n_channels = self.model_reg.input_shape[-1]
+			model_signal_length = self.model_reg.input_shape[-2]
+		
+		assert self.x.shape[-1] == n_channels, f"Shape mismatch between the input shape and the model input shape..."
+		assert self.x.shape[-2] == model_signal_length, f"Shape mismatch between the input shape and the model input shape..."
 
 		if np.any(self.class_predictions==0):
 			self.time_predictions = self.model_reg.predict(self.x[self.class_predictions==0])*self.model_signal_length
@@ -2749,7 +2775,7 @@ def sliding_msd_drift(x, y, timeline, window, mode='bi', n_points_migration=7,
 		
 	return s_diffusion, s_velocity
 
-def columnwise_mean(matrix, min_nbr_values = 1):
+def columnwise_mean(matrix, min_nbr_values = 1, projection='mean'):
 	
 	"""
 	Calculate the column-wise mean and standard deviation of non-NaN elements in the input matrix.
@@ -2788,12 +2814,16 @@ def columnwise_mean(matrix, min_nbr_values = 1):
 		values = matrix[:,k]
 		values = values[values==values]
 		if len(values[values==values])>min_nbr_values:
-			mean_line[k] = np.nanmean(values)
-			mean_line_std[k] = np.nanstd(values)
+			if projection=='mean':
+				mean_line[k] = np.nanmean(values)
+				mean_line_std[k] = np.nanstd(values)
+			elif projection=='median':
+				mean_line[k] = np.nanmedian(values)
+				mean_line_std[k] = median_abs_deviation(values, center=np.nanmedian, nan_policy='omit')
 	return mean_line, mean_line_std
 
 
-def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], return_matrix=False, forced_max_duration=None, min_nbr_values=2,conflict_mode='mean'):
+def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], return_matrix=False, forced_max_duration=None, min_nbr_values=2,conflict_mode='mean', projection='mean'):
 
 	"""
 	Calculate the mean and standard deviation of a specified signal for tracks of a given class in the input DataFrame.
@@ -2884,7 +2914,7 @@ def mean_signal(df, signal_name, class_col, time_col=None, class_value=[0], retu
 		signal_matrix[trackid,timeline_shifted.astype(int)] = signal
 		trackid+=1
 	
-	mean_signal, std_signal = columnwise_mean(signal_matrix, min_nbr_values=min_nbr_values)
+	mean_signal, std_signal = columnwise_mean(signal_matrix, min_nbr_values=min_nbr_values, projection=projection)
 	actual_timeline = np.linspace(-max_duration, max_duration, 2*max_duration+1)
 	if return_matrix:
 		return mean_signal, std_signal, actual_timeline, signal_matrix

celldetective/tracking.py

@@ -441,9 +441,14 @@ def interpolate_per_track(group_df):
 
 	"""
 
-	interpolated_group = group_df.interpolate(method='linear',limit_direction="both")
+	for c in list(group_df.columns):
+		group_df_new_dtype = group_df[c].infer_objects(copy=False)
+		if group_df_new_dtype.dtype!='O':
+			group_df[c] = group_df_new_dtype.interpolate(method='linear',limit_direction="both")
+	
+	#interpolated_group = group_df.interpolate(method='linear',limit_direction="both")
 
-	return interpolated_group
+	return group_df
 
 def interpolate_nan_properties(trajectories, track_label="TRACK_ID"):
 

celldetective/utils.py

@@ -1794,7 +1794,7 @@ def ConfigSectionMap(path,section):
 
 	"""
 
-	Config = configparser.ConfigParser()
+	Config = configparser.ConfigParser(interpolation=None)
 	Config.read(path)
 	dict1 = {}
 	try:

{celldetective-1.3.7.post2.dist-info → celldetective-1.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: celldetective
-Version: 1.3.7.post2
+Version: 1.3.8
 Summary: description
 Home-page: http://github.com/remyeltorro/celldetective
 Author: Rémy Torro