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

celldetective/_version.py

@@ -1 +1 @@
-__version__ = "1.3.7.post1"
+__version__ = "1.3.8"

celldetective/gui/btrack_options.py

@@ -379,15 +379,15 @@ class ConfigTracking(QMainWindow, Styles):
 		clean_traj_sublayout.addWidget(self.extrapolate_post_checkbox)
 		clean_traj_sublayout.addWidget(self.extrapolate_pre_checkbox)
 
-		self.interpolate_na_features_checkbox = QCheckBox('Interpolate features of missed detections')
-		self.interpolate_na_features_checkbox.setIcon(icon(MDI6.format_color_fill,color="k"))
+		# self.interpolate_na_features_checkbox = QCheckBox('Interpolate features of missed detections')
+		# self.interpolate_na_features_checkbox.setIcon(icon(MDI6.format_color_fill,color="k"))
 
-		clean_traj_sublayout.addWidget(self.interpolate_na_features_checkbox)
+		# clean_traj_sublayout.addWidget(self.interpolate_na_features_checkbox)
 		clean_traj_sublayout.addStretch()
 
 		self.post_proc_options_to_disable = [self.post_proc_lbl, self.min_tracklength_slider, self.remove_not_in_first_checkbox,
 											self.remove_not_in_last_checkbox, self.interpolate_gaps_checkbox, self.extrapolate_post_checkbox,
-											self.extrapolate_pre_checkbox, self.interpolate_na_features_checkbox]
+											self.extrapolate_pre_checkbox] #, self.interpolate_na_features_checkbox
 
 		layout.addLayout(clean_traj_sublayout)
 
@@ -898,7 +898,7 @@ class ConfigTracking(QMainWindow, Styles):
 									   "interpolate_position_gaps": self.interpolate_gaps_checkbox.isChecked(), 
 									   "extrapolate_tracks_pre": self.extrapolate_pre_checkbox.isChecked(),
 									   "extrapolate_tracks_post": self.extrapolate_post_checkbox.isChecked(),
-									   'interpolate_na': self.interpolate_na_features_checkbox.isChecked()
+									   'interpolate_na': False, #self.interpolate_na_features_checkbox.isChecked()
 									   }
 		else:
 
@@ -1044,7 +1044,7 @@ class ConfigTracking(QMainWindow, Styles):
 					self.uncheck_post_proc()
 					self.ContentsPostProc.hide()
 					for element in [self.remove_not_in_last_checkbox, self.remove_not_in_first_checkbox, self.interpolate_gaps_checkbox, 
-									self.extrapolate_post_checkbox, self.extrapolate_pre_checkbox, self.interpolate_na_features_checkbox]:
+									self.extrapolate_post_checkbox, self.extrapolate_pre_checkbox]: #self.interpolate_na_features_checkbox
 						element.setChecked(False)
 					self.min_tracklength_slider.setValue(0)
 
@@ -1063,8 +1063,8 @@ class ConfigTracking(QMainWindow, Styles):
 						self.extrapolate_pre_checkbox.setChecked(post_processing_options["extrapolate_tracks_pre"])
 					if "extrapolate_tracks_post" in post_processing_options:
 						self.extrapolate_post_checkbox.setChecked(post_processing_options["extrapolate_tracks_post"])
-					if "interpolate_na" in post_processing_options:
-						self.interpolate_na_features_checkbox.setChecked(post_processing_options["interpolate_na"])
+					# if "interpolate_na" in post_processing_options:
+					# 	self.interpolate_na_features_checkbox.setChecked(post_processing_options["interpolate_na"])
 
 	def locate_image(self):
 		

celldetective/gui/classifier_widget.py

@@ -212,6 +212,8 @@ class ClassifierWidget(QWidget, Styles):
 		self.frame_slider.valueChanged.connect(self.set_frame)
 		self.alpha_slider.valueChanged.connect(self.set_transparency)
 
+		self.setAttribute(Qt.WA_DeleteOnClose)
+
 	def activate_prereq_cb(self):
 		if self.prereq_event_check.isChecked():
 			self.prereq_event_cb.setEnabled(True)
@@ -276,6 +278,12 @@ class ClassifierWidget(QWidget, Styles):
 		self.propscanvas.canvas.draw_idle()
 		self.propscanvas.canvas.setMinimumHeight(self.screen_height//5)
 
+	def closeEvent(self, event):
+		self.ax_props.cla()
+		self.fig_props.clf()
+		plt.close(self.fig_props)
+		super().closeEvent(event) 
+
 	def update_props_scatter(self, feature_changed=True):
 
 		try:

celldetective/gui/configure_new_exp.py

@@ -429,7 +429,7 @@ class ConfigNewExperiment(QMainWindow, Styles):
 		Write all user input parameters to a configuration file associated to an experiment.
 		"""
 
-		config = ConfigParser()
+		config = ConfigParser(interpolation=None)
 
 		# add a new section and some values
 		config.add_section('MovieSettings')

celldetective/gui/json_readers.py

@@ -49,7 +49,7 @@ class ConfigEditor(QWidget, Styles):
         file_name = self.config_path
         #self.file_edit.setText(file_name)
 
-        config = configparser.ConfigParser()
+        config = configparser.ConfigParser(interpolation=None)
         config.read(file_name)
 
         # Create a layout for each section of the config file
@@ -93,12 +93,10 @@ class ConfigEditor(QWidget, Styles):
         # Save the configuration to the file
         file_name = self.config_path
             
-        config = configparser.ConfigParser()
+        config = configparser.ConfigParser(interpolation=None)
 
         # Update the values in the config object
 
-
-
         for key, (section, edit_box) in self.sections.items():
             if not config.has_section(section):
                 config.add_section(section)

celldetective/gui/plot_signals_ui.py

@@ -117,7 +117,10 @@ class ConfigSignalPlot(QWidget, Styles):
 		all_cms = list(colormaps)
 		for cm in all_cms:
 			if hasattr(matplotlib.cm, str(cm).lower()):
-				self.cbs[-1].addColormap(cm.lower())
+				try:
+					self.cbs[-1].addColormap(cm.lower())
+				except:
+					pass
 
 		self.cbs[0].setCurrentIndex(1)
 		self.cbs[0].setCurrentIndex(0)
@@ -138,13 +141,14 @@ class ConfigSignalPlot(QWidget, Styles):
 		self.abs_time_checkbox.stateChanged.connect(self.switch_ref_time_mode)
 
 		select_layout = QHBoxLayout()
+		select_layout.setContentsMargins(20,3,20,3)
 		select_layout.addWidget(QLabel('select cells\nwith query: '), 33)
 		self.query_le = QLineEdit()
 		select_layout.addWidget(self.query_le, 66)
 		main_layout.addLayout(select_layout)
 
 		time_calib_layout = QHBoxLayout()
-		time_calib_layout.setContentsMargins(20,20,20,20)
+		time_calib_layout.setContentsMargins(20,3,20,3)
 		time_calib_layout.addWidget(QLabel('time calibration\n(frame to min)'), 33)
 		self.time_calibration_le = QLineEdit(str(self.FrameToMin).replace('.',','))
 		self.time_calibration_le.setValidator(self.float_validator)
@@ -152,6 +156,14 @@ class ConfigSignalPlot(QWidget, Styles):
 		#time_calib_layout.addWidget(QLabel(' min'))
 		main_layout.addLayout(time_calib_layout)
 
+		pool_layout = QHBoxLayout()
+		pool_layout.setContentsMargins(20,3,20,3)
+		self.pool_option_cb = QComboBox()
+		self.pool_option_cb.addItems(['mean','median'])
+		pool_layout.addWidget(QLabel('pool\nprojection:'), 33)
+		pool_layout.addWidget(self.pool_option_cb, 66)
+		main_layout.addLayout(pool_layout)
+
 		self.submit_btn = QPushButton('Submit')
 		self.submit_btn.setStyleSheet(self.button_style_sheet)
 		self.submit_btn.clicked.connect(self.process_signal)
@@ -271,9 +283,10 @@ class ConfigSignalPlot(QWidget, Styles):
 			self.feature_selected = self.feature_cb.currentText()
 			self.feature_choice_widget.close()
 			self.compute_signal_functions()
-			self.interpret_pos_location()
-			self.plot_window = GenericSignalPlotWidget(parent_window=self, df=self.df, df_pos_info = self.df_pos_info, df_well_info = self.df_well_info, feature_selected=self.feature_selected, title='plot signals')
-			self.plot_window.show()
+			if self.open_widget:
+				self.interpret_pos_location()
+				self.plot_window = GenericSignalPlotWidget(parent_window=self, df=self.df, df_pos_info = self.df_pos_info, df_well_info = self.df_well_info, feature_selected=self.feature_selected, title='plot signals')
+				self.plot_window.show()
 
 	def process_signal(self):
 
@@ -335,7 +348,19 @@ class ConfigSignalPlot(QWidget, Styles):
 
 	def compute_signal_functions(self):
 
-		# REPLACE EVRYTHING WITH MEAN_SIGNAL FUNCTION
+		# Check to move at the beginning
+		self.open_widget = True
+		if len(self.time_columns)==0:
+			msgBox = QMessageBox()
+			msgBox.setIcon(QMessageBox.Warning)
+			msgBox.setText("No synchronizing time is available...")
+			msgBox.setWindowTitle("Warning")
+			msgBox.setStandardButtons(QMessageBox.Ok)
+			returnValue = msgBox.exec()
+			if returnValue == QMessageBox.Ok:
+				pass
+			self.open_widget = False
+			return None
 
 		# Per position signal
 		max_time = int(self.df.FRAME.max()) + 1
@@ -346,9 +371,9 @@ class ConfigSignalPlot(QWidget, Styles):
 
 		for block,movie_group in self.df.groupby(['well','position']):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time)
-			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time)		
-			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time)
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
+			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())		
+			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(movie_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
 			self.mean_plots_timeline = timeline_all
 
 			self.df_pos_info.loc[self.df_pos_info['pos_path'] == block[1], 'signal'] = [
@@ -361,9 +386,9 @@ class ConfigSignalPlot(QWidget, Styles):
 		# Per well
 		for well,well_group in self.df.groupby('well'):
 
-			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time)
-			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time)			
-			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time)
+			well_signal_mean, well_std_mean, timeline_all, matrix_all = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=None, return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
+			well_signal_event, well_std_event, timeline_event, matrix_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[0], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())			
+			well_signal_no_event, well_std_no_event, timeline_no_event, matrix_no_event = mean_signal(well_group, self.feature_selected, class_col, time_col=time_col, class_value=[1], return_matrix=True, forced_max_duration=max_time, projection=self.pool_option_cb.currentText())
 			
 			self.df_well_info.loc[self.df_well_info['well_path']==well,'signal'] = [{'mean_all': well_signal_mean, 'std_all': well_std_mean,'matrix_all': matrix_all,'mean_event': well_signal_event, 'std_event': well_std_event,
 																					'matrix_event': matrix_event,'mean_no_event': well_signal_no_event, 'std_no_event': well_std_no_event, 'matrix_no_event': matrix_no_event, 'timeline':  self.mean_plots_timeline}]
@@ -418,23 +443,7 @@ class ConfigSignalPlot(QWidget, Styles):
 					cid+=1
 				except:
 					pass
-		return matrix		
-
-	def col_mean(self, matrix):
-
-		mean_line = np.zeros(matrix.shape[1])
-		mean_line[:] = np.nan
-		std_line = np.copy(mean_line)
-
-		for k in range(matrix.shape[1]):
-			values = matrix[:,k]
-			#values = values[values!=0]
-			if len(values[values==values])>2:
-				mean_line[k] = np.nanmean(values)
-				std_line[k] = np.nanstd(values)
-
-		return mean_line, std_line
-
+		return matrix
 
 	def switch_ref_time_mode(self):
 		if self.abs_time_checkbox.isChecked():

celldetective/gui/process_block.py

@@ -1362,6 +1362,7 @@ class NeighPanel(QFrame, Styles):
 		self.pair_signal_models_list.addItems(signal_models)
 
 	def open_signal_annotator_configuration_ui(self):
+		self.mode = 'pairs'
 		self.ConfigSignalAnnotator = ConfigSignalAnnotator(self)
 		self.ConfigSignalAnnotator.show()
 

celldetective/gui/processes/downloader.py

@@ -0,0 +1,108 @@
+import os
+import ssl
+from tqdm import tqdm
+from multiprocessing import Process
+from glob import glob
+import shutil
+from urllib.request import urlopen
+import zipfile
+import tempfile
+import time
+from pathlib import Path
+import json
+
+class DownloadProcess(Process):
+
+	def __init__(self, queue=None, process_args=None, *args, **kwargs):
+		
+		super().__init__(*args, **kwargs)
+		
+		if process_args is not None:
+			for key, value in process_args.items():
+				setattr(self, key, value)
+
+		self.queue = queue
+		self.progress = True
+
+		file_path = Path(os.path.dirname(os.path.realpath(__file__)))
+		zenodo_json = os.sep.join([str(file_path.parents[2]),"celldetective", "links", "zenodo.json"])
+		print(f"{zenodo_json=}")
+		
+		with open(zenodo_json,"r") as f:
+			zenodo_json = json.load(f)
+		all_files = list(zenodo_json['files']['entries'].keys())
+		all_files_short = [f.replace(".zip","") for f in all_files]
+		zenodo_url = zenodo_json['links']['files'].replace('api/','')
+		full_links = ["/".join([zenodo_url, f]) for f in all_files]
+		index = all_files_short.index(self.file)
+		
+		self.zip_url = full_links[index]
+		self.path_to_zip_file = os.sep.join([self.output_dir, 'temp.zip'])
+
+		self.sum_done = 0
+		self.t0 = time.time()
+
+	def download_url_to_file(self, url, dst):
+
+		file_size = None
+		ssl._create_default_https_context = ssl._create_unverified_context
+		u = urlopen(url)
+		meta = u.info()
+		if hasattr(meta, 'getheaders'):
+			content_length = meta.getheaders("Content-Length")
+		else:
+			content_length = meta.get_all("Content-Length")
+		if content_length is not None and len(content_length) > 0:
+			file_size = int(content_length[0])
+		# We deliberately save it in a temp file and move it after
+		dst = os.path.expanduser(dst)
+		dst_dir = os.path.dirname(dst)
+		f = tempfile.NamedTemporaryFile(delete=False, dir=dst_dir)
+
+		try:
+			with tqdm(total=file_size, disable=not self.progress,
+					  unit='B', unit_scale=True, unit_divisor=1024) as pbar:
+				while True:
+					buffer = u.read(8192) #8192
+					if len(buffer) == 0:
+						break
+					f.write(buffer)
+					pbar.update(len(buffer))
+					self.sum_done+=len(buffer) / file_size * 100
+					mean_exec_per_step = (time.time() - self.t0) / (self.sum_done*file_size / 100 + 1)
+					pred_time = (file_size - (self.sum_done*file_size / 100 + 1)) * mean_exec_per_step
+					self.queue.put([self.sum_done, pred_time])
+			f.close()
+			shutil.move(f.name, dst)
+		finally:
+			f.close()
+			if os.path.exists(f.name):
+				os.remove(f.name)
+
+	def run(self):
+		
+		self.download_url_to_file(fr"{self.zip_url}",self.path_to_zip_file)
+		with zipfile.ZipFile(self.path_to_zip_file, 'r') as zip_ref:
+			zip_ref.extractall(self.output_dir)
+		
+		file_to_rename = glob(os.sep.join([self.output_dir,self.file,"*[!.json][!.png][!.h5][!.csv][!.npy][!.tif][!.ini]"]))
+		if len(file_to_rename)>0 and not file_to_rename[0].endswith(os.sep) and not self.file.startswith('demo'):
+			os.rename(file_to_rename[0], os.sep.join([self.output_dir,self.file,self.file]))
+
+		os.remove(self.path_to_zip_file)
+		self.queue.put([100,0])
+		time.sleep(0.5)
+
+		# Send end signal
+		self.queue.put("finished")
+		self.queue.close()
+
+	def end_process(self):
+
+		self.terminate()
+		self.queue.put("finished")
+
+	def abort_process(self):
+		
+		self.terminate()
+		self.queue.put("error")