celldetective 1.1.0__tar.gz → 1.1.1__tar.gz

{celldetective-1.1.0 → celldetective-1.1.1}/PKG-INFO

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

{celldetective-1.1.0 → celldetective-1.1.1}/celldetective/__main__.py

@@ -54,6 +54,11 @@ class AppInitWindow(QMainWindow):
 		self.setCentralWidget(central_widget)
 		self.reload_previous_gpu_threads()
 		self.show()
+	
+	def closeEvent(self, event):
+		QApplication.closeAllWindows()
+		event.accept()
+		gc.collect()
 
 	def create_locate_exp_hbox(self):
 
@@ -365,25 +370,6 @@ class AppInitWindow(QMainWindow):
 			if returnValue == QMessageBox.Ok:
 				self.experiment_path_selection.setText('')
 				return None
-	
-	def closeEvent(self, event):
-
-		"""
-		Close child windows if closed.
-		"""
-		
-		try:
-			if self.control_panel:
-				self.control_panel.close()
-		except:
-			pass
-		try:
-			if self.new_exp_window:
-				self.new_exp_window.close()
-		except:
-			pass
-
-		gc.collect()
 
 if __name__ == "__main__":
 

celldetective-1.1.1/celldetective/extra_properties.py

@@ -0,0 +1,110 @@
+"""
+Add extra properties to directly to regionprops
+Functions must take regionmask as first argument and optionally intensity_image as second argument
+If intensity is in function name, it will be replaced by the name of the channel. These measurements are applied automatically to all channels
+
+"""
+import warnings
+
+import numpy as np
+from scipy.ndimage import distance_transform_edt
+from scipy.spatial.distance import euclidean
+
+
+# Percentiles
+
+def intensity_percentile_ninety_nine(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],99)
+
+def intensity_percentile_ninety_five(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],95)
+
+def intensity_percentile_ninety(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],90)
+
+def intensity_percentile_seventy_five(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],75)
+
+def intensity_percentile_fifty(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],50)
+
+def intensity_percentile_twenty_five(regionmask, intensity_image):
+	return np.nanpercentile(intensity_image[regionmask],25)
+
+# STD
+
+def intensity_std(regionmask, intensity_image):
+	return np.nanstd(intensity_image[regionmask])
+
+
+def intensity_median(regionmask, intensity_image):
+	return np.nanmedian(intensity_image[regionmask])
+
+def intensity_nanmean(regionmask, intensity_image):
+	return np.nanmean(intensity_image[regionmask])
+
+def intensity_centre_of_mass_displacement(regionmask, intensity_image):
+	y, x = np.mgrid[:regionmask.shape[0], :regionmask.shape[1]]
+	xtemp = x.copy()
+	ytemp = y.copy()
+	intensity_weighted_center = center_of_mass(intensity_image, regionmask)
+	centroid_x = intensity_weighted_center[1]
+	centroid_y = intensity_weighted_center[0]
+
+	geometric_centroid_x = np.sum(xtemp * regionmask) / np.sum(regionmask)
+	geometric_centroid_y = np.sum(ytemp * regionmask) / np.sum(regionmask)
+	distance = euclidean(np.array((geometric_centroid_y, geometric_centroid_x)), np.array((centroid_y, centroid_x)))
+	delta_x = geometric_centroid_x - centroid_x
+	delta_y = geometric_centroid_y - centroid_y
+	direction_arctan = np.arctan2(delta_y, delta_x) * 180 / np.pi
+	if direction_arctan < 0:
+		direction_arctan += 360
+	return distance, direction_arctan
+
+def intensity_radial_gradient(regionmask, intensity_image):
+	warnings.filterwarnings('ignore', message="Polyfit may be poorly conditioned")
+	cell_mask = regionmask.copy()
+	intensity = intensity_image.copy()
+	y = intensity[cell_mask].flatten()
+	x = distance_transform_edt(cell_mask)
+	x = x[cell_mask].flatten()
+	params = np.polyfit(x, y, 1)
+	line = np.poly1d(params)
+
+	return line.coefficients[0], line.coefficients[1]
+
+
+def intensity_centre_of_mass_displacement_edge(regionmask, intensity_image):
+	edt = distance_transform_edt(regionmask)
+	min_distance = 0
+	max_distance = 0.1*edt.max()
+	thresholded = (edt <= max_distance) * (edt > min_distance)
+	edge_mask = np.copy(regionmask)
+	edge_mask[np.where(thresholded == 0)] = 0
+	y, x = np.mgrid[:edge_mask.shape[0], :edge_mask.shape[1]]
+	xtemp = x.copy()
+	ytemp = y.copy()
+	intensity_edge = intensity_image.copy()
+	intensity_edge[np.where(edge_mask == 0)] = 0.
+	sum_intensity_edge = np.sum(intensity_edge)
+	sum_regionmask = np.sum(regionmask)
+
+	if sum_intensity_edge != 0 and sum_regionmask != 0:
+		y, x = np.mgrid[:regionmask.shape[0], :regionmask.shape[1]]
+		xtemp = x.copy()
+		ytemp = y.copy()
+		intensity_weighted_center = center_of_mass(intensity_image, regionmask)
+		centroid_x = intensity_weighted_center[1]
+		centroid_y = intensity_weighted_center[0]
+
+		geometric_centroid_x = np.sum(xtemp * regionmask) / np.sum(regionmask)
+		geometric_centroid_y = np.sum(ytemp * regionmask) / np.sum(regionmask)
+		distance = euclidean(np.array((geometric_centroid_y, geometric_centroid_x)), np.array((centroid_y, centroid_x)))
+		delta_x = geometric_centroid_x - centroid_x
+		delta_y = geometric_centroid_y - centroid_y
+		direction_arctan = np.arctan2(delta_y, delta_x) * 180 / np.pi
+		if direction_arctan < 0:
+			direction_arctan += 360
+		return distance, direction_arctan
+	else:
+		return np.nan, np.nan

{celldetective-1.1.0 → celldetective-1.1.1}/celldetective/gui/control_panel.py

@@ -319,6 +319,11 @@ class ControlPanel(QMainWindow, Styles):
 					process_block.ConfigSignalAnnotator.close()
 			except:
 				pass
+			try:
+				if process_block.tab_ui:
+					process_block.tab_ui.close()
+			except:
+				pass
 
 		try:
 			if self.cfg_editor:

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

@@ -192,6 +192,7 @@ class BackgroundFitCorrectionLayout(QGridLayout, Styles):
 						   clip = clip,
 						   export= False,
 						   return_stacks=True,
+						   activation_protocol=[['gauss',2],['std',4]],
 						   show_progress_per_well = True,
 						   show_progress_per_pos = False,
 							)

{celldetective-1.1.0 → celldetective-1.1.1}/celldetective/gui/measurement_options.py

@@ -21,8 +21,7 @@ from fonticon_mdi6 import MDI6
 from celldetective.gui.thresholds_gui import ThresholdNormalisation, ThresholdSpot
 from celldetective.utils import extract_experiment_channels, get_software_location
 from celldetective.io import interpret_tracking_configuration, load_frames, auto_load_number_of_frames
-from celldetective.measure import compute_haralick_features, contour_of_instance_segmentation, correct_image, \
-    field_normalisation, normalise_by_cell
+from celldetective.measure import compute_haralick_features, contour_of_instance_segmentation, normalise_by_cell
 import numpy as np
 from tifffile import imread
 import json
@@ -736,6 +735,17 @@ class ConfigMeasurements(QMainWindow, Styles):
                 return None
         else:
             self.current_stack = movies[0]
+            self.stack_length = auto_load_number_of_frames(self.current_stack)
+            
+            if self.stack_length is None:
+                stack = imread(self.current_stack)
+                self.stack_length = len(stack)
+                del stack
+                gc.collect()
+            
+            self.mid_time = self.stack_length // 2
+            indices = self.mid_time + np.arange(len(self.channel_names))
+            self.test_frame = load_frames(list(indices.astype(int)),self.current_stack, normalize_input=False)
 
 
     def control_haralick_digitalization(self):
@@ -824,7 +834,7 @@ class ConfigMeasurements(QMainWindow, Styles):
         Load the first mask of the detected movie.
         """
 
-        labels_path = str(Path(self.stack0).parent_window.parent_window) + f'/labels_{self.mode}/'
+        labels_path = str(Path(self.current_stack).parent.parent) + os.sep+f'labels_{self.mode}'+os.sep
         masks = natsorted(glob(labels_path + '*.tif'))
         if len(masks) == 0:
             print('no mask found')
@@ -859,47 +869,6 @@ class ConfigMeasurements(QMainWindow, Styles):
         self.im_mask.set_alpha(value)
         self.fig_contour.canvas.draw_idle()
 
-    # def populate_normalisation_tabs(self):
-
-    #     """
-    #     Multi-tab options to perform background correction before measurements.
-    #     """
-
-    #     layout = QVBoxLayout(self.normalisation_frame)
-
-    #     self.normalisation_lbl = QLabel("BACKGROUND CORRECTION")
-    #     self.normalisation_lbl.setStyleSheet("""
-    #         font-weight: bold;
-    #         padding: 0px;
-    #         """)
-    #     layout.addWidget(self.normalisation_lbl, alignment=Qt.AlignCenter)
-
-
-    #     self.tabs = QTabWidget()
-    #     self.tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
-
-    #     self.tab1, self.tab2 = QWidget(), QWidget()
-    #     self.normalisation_list = QListWidget()
-    #     self.tabs.addTab(self.tab1, 'Local')
-    #     self.tabs.addTab(self.tab2, 'Field')
-    #     self.local_correction_layout = LocalCorrectionLayout(self, self.tab1)
-    #     self.fit_correction_layout = BackgroundFitCorrectionLayout(self, self.tab2)
-    #     layout.addWidget(self.tabs)
-
-    #     self.norm_list_lbl = QLabel('Background correction to perform:')
-    #     hbox = QHBoxLayout()
-    #     hbox.addWidget(self.norm_list_lbl)
-    #     self.del_norm_btn = QPushButton("")
-    #     self.del_norm_btn.setStyleSheet(self.button_select_all)
-    #     self.del_norm_btn.setIcon(icon(MDI6.trash_can, color="black"))
-    #     self.del_norm_btn.setToolTip("Remove background correction")
-    #     self.del_norm_btn.setIconSize(QSize(20, 20))
-    #     hbox.addWidget(self.del_norm_btn, alignment=Qt.AlignRight)
-    #     layout.addLayout(hbox)
-    #     self.del_norm_btn.clicked.connect(self.remove_item_from_list)
-    #     layout.addWidget(self.normalisation_list)
-
-
     def remove_item_from_list(self):
         current_item = self.normalisation_list.currentRow()
         if current_item > -1:
@@ -935,47 +904,6 @@ class ConfigMeasurements(QMainWindow, Styles):
     def fun(self, x, y):
         return x ** 2 + y
 
-    # def preview_normalisation(self):
-    #     plt.close('all')
-    #     plt.figure("Intensity Profiles",figsize=(10, 5))
-    #     self.locate_image()
-    #     diagonal_length = min(self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()].shape[0], self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()].shape[1])
-    #     if self.tab2_subtract.isChecked():
-    #         norm_operation='Subtract'
-    #     else:
-    #         norm_operation='Divide'
-    #     normalised, bg_fit = field_normalisation(self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()],
-    #                                              threshold=self.tab2_txt_threshold.text(),
-    #                                              normalisation_operation=norm_operation,
-    #                                              clip=self.tab2_clip.isChecked(),
-    #                                              mode=self.tab2_dropdown.currentText())
-    #     diagonal_original = [self.test_frame[:, :, self.tab2_channel_dropdown.currentIndex()][i, i] for i in
-    #                          range(diagonal_length)]
-    #     diagonal_corrected = [normalised[i, i] for i in range(diagonal_length)]
-    #     diagonal_indices = np.arange(diagonal_length)
-
-    #     plt.subplot(1, 2, 1)
-    #     plt.plot(diagonal_indices, diagonal_original, color='black', linewidth=0.2)  # Adjust linewidth here
-    #     plt.title('Original Image')
-    #     plt.xlabel('Pixel Index along Diagonal')
-    #     plt.ylabel('Intensity')
-
-    #     plt.subplot(1, 2, 2)
-    #     plt.plot(diagonal_indices, diagonal_corrected, color='black', linewidth=0.2)  # Adjust linewidth here
-    #     plt.title('Corrected Image')
-    #     plt.xlabel('Pixel Index along Diagonal')
-    #     plt.ylabel('Intensity')
-
-    #     plt.tight_layout()
-    #     plt.show()
-
-    #     self.fig, self.ax = plt.subplots()
-    #     self.normalised_img = FigureCanvas(self.fig, "Corrected background image preview")
-    #     self.ax.clear()
-    #     self.ax.imshow(normalised, cmap='gray')
-    #     self.normalised_img.canvas.draw()
-    #     self.normalised_img.show()
-
     def view_normalisation_contour(self):
 
         """
@@ -1061,30 +989,6 @@ class ConfigMeasurements(QMainWindow, Styles):
             if self.test_mask is not None:
                 self.spot_visual = ThresholdSpot(current_channel=self.spot_channel.currentIndex(), img=self.test_frame,
                                                  mask=self.test_mask, parent_window=self)
-        # for dictionary in self.background_correction:
-        #     if self.spot_channel.currentText() in dictionary['target channel']:
-        #         if dictionary['mode'] == 'field':
-        #             if dictionary['operation'] == 'Divide':
-        #                 normalised, bg_fit = field_normalisation(
-        #                     self.test_frame[:, :, self.spot_channel.currentIndex()],
-        #                     threshold=dictionary['threshold'],
-        #                     normalisation_operation=dictionary['operation'],
-        #                     clip=False,
-        #                     mode=dictionary['type'])
-        #             else:
-        #                 normalised, bg_fit = field_normalisation(
-        #                     self.test_frame[:, :, self.spot_channel.currentIndex()],
-        #                     threshold=dictionary['threshold'],
-        #                     normalisation_operation=dictionary['operation'],
-        #                     clip=dictionary['clip'],
-        #                     mode=dictionary['type'])
-        #             self.test_frame[:, :, self.spot_channel.currentIndex()] = normalised
-        #         if dictionary['mode'] == 'local':
-        #             normalised_image = normalise_by_cell(self.test_frame[:, :, self.spot_channel.currentIndex()].copy(), self.test_mask,
-        #                                                  distance=int(dictionary['distance']), mode=dictionary['type'],
-        #                                                  operation=dictionary['operation'])
-        #             self.test_frame[:, :, self.spot_channel.currentIndex()] = normalised_image
-
 
     def enable_spot_detection(self):
         if self.spot_check.isChecked():

{celldetective-1.1.0 → celldetective-1.1.1}/celldetective/gui/plot_signals_ui.py

@@ -32,6 +32,7 @@ from lifelines import KaplanMeierFitter
 from matplotlib.cm import viridis, tab10
 import math
 from celldetective.gui import Styles
+from matplotlib import colormaps
 
 
 

{celldetective-1.1.0 → celldetective-1.1.1}/celldetective/gui/process_block.py

@@ -1288,7 +1288,7 @@ class PreprocessingPanel(QFrame, Styles):
 				correct_background_model_free(self.exp_dir, 
 								   well_option=well_option,
 								   position_option=pos_option,
-								   export= True,
+								   export = True,
 								   return_stacks=False,
 								   show_progress_per_well = True,
 								   show_progress_per_pos = True,

{celldetective-1.1.0 → celldetective-1.1.1}/celldetective/gui/survival_ui.py

@@ -28,6 +28,7 @@ import matplotlib.cm as mcm
 import math
 from celldetective.events import switch_to_events
 from celldetective.gui import Styles
+from matplotlib import colormaps
 
 class ConfigSurvival(QWidget, Styles):
 	
@@ -124,7 +125,12 @@ class ConfigSurvival(QWidget, Styles):
 				self.cbs[i].addItems(self.cb_options[i])
 			choice_layout.addLayout(hbox)
 
-		self.cbs[-1].addColormaps(self.cb_options[-1])
+		for cm in list(colormaps):
+			try:
+				self.cbs[-1].addColormap(cm)
+			except:
+				pass
+
 		main_layout.addLayout(choice_layout)
 
 		self.cbs[0].setCurrentIndex(0)