celldetective 1.4.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

celldetective/gui/processes/measure_cells.py

@@ -6,7 +6,7 @@ import json
 from pathlib import Path, PurePath
 
 from celldetective.io import auto_load_number_of_frames, load_frames, locate_labels
-from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel
+from celldetective.utils import extract_experiment_channels, config_section_to_dict, _get_img_num_per_channel
 from celldetective.utils import remove_trajectory_measurements, _extract_coordinates_from_features, _remove_invalid_cols
 from celldetective.measure import drop_tonal_features, measure_features, measure_isotropic_intensity, measure_radial_distance_to_center, center_of_mass_to_abs_coordinates
 
@@ -17,9 +17,14 @@ import concurrent.futures
 import pandas as pd
 from natsort import natsorted
 from art import tprint
+from typing import Optional, Union
 
 
 class MeasurementProcess(Process):
+	
+	pos: Optional[Union[str,Path]] = None
+	mode: Optional[str] = None
+	n_threads: int = 1
 
 	def __init__(self, queue=None, process_args=None):
 		
@@ -173,12 +178,12 @@ class MeasurementProcess(Process):
 
 	def extract_experiment_parameters(self):
 
-		self.movie_prefix = ConfigSectionMap(self.config,"MovieSettings")["movie_prefix"]
-		self.spatial_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["pxtoum"])
-		self.time_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["frametomin"])
-		self.len_movie = float(ConfigSectionMap(self.config,"MovieSettings")["len_movie"])
-		self.shape_x = int(ConfigSectionMap(self.config,"MovieSettings")["shape_x"])
-		self.shape_y = int(ConfigSectionMap(self.config,"MovieSettings")["shape_y"])
+		self.movie_prefix = config_section_to_dict(self.config, "MovieSettings")["movie_prefix"]
+		self.spatial_calibration = float(config_section_to_dict(self.config, "MovieSettings")["pxtoum"])
+		self.time_calibration = float(config_section_to_dict(self.config, "MovieSettings")["frametomin"])
+		self.len_movie = float(config_section_to_dict(self.config, "MovieSettings")["len_movie"])
+		self.shape_x = int(config_section_to_dict(self.config, "MovieSettings")["shape_x"])
+		self.shape_y = int(config_section_to_dict(self.config, "MovieSettings")["shape_y"])
 
 		self.channel_names, self.channel_indices = extract_experiment_channels(self.exp_dir)
 		self.nbr_channels = len(self.channel_names)
@@ -331,7 +336,8 @@ class MeasurementProcess(Process):
 
 			df = df.reset_index(drop=True)
 			df = _remove_invalid_cols(df)
-			
+			df = df.replace([np.inf, -np.inf], np.nan)
+
 			df.to_csv(self.pos+os.sep.join(["output", "tables", self.table_name]), index=False)
 			print(f'Measurement table successfully exported in  {os.sep.join(["output", "tables"])}...')
 			print('Done.')

celldetective/gui/processes/segment_cells.py

@@ -5,7 +5,7 @@ import os
 import json
 import numpy as np
 from celldetective.io import extract_position_name, locate_segmentation_model, auto_load_number_of_frames, load_frames, _check_label_dims, _load_frames_to_segment
-from celldetective.utils import _rescale_labels, _segment_image_with_stardist_model, _segment_image_with_cellpose_model, _prep_stardist_model, _prep_cellpose_model, _get_normalize_kwargs_from_config, extract_experiment_channels, _estimate_scale_factor, _extract_channel_indices_from_config, ConfigSectionMap, _extract_nbr_channels_from_config, _get_img_num_per_channel
+from celldetective.utils import _rescale_labels, _segment_image_with_stardist_model, _segment_image_with_cellpose_model, _prep_stardist_model, _prep_cellpose_model, _get_normalize_kwargs_from_config, extract_experiment_channels, _estimate_scale_factor, _extract_channel_indices_from_config, config_section_to_dict, _extract_nbr_channels_from_config, _get_img_num_per_channel
 
 from pathlib import Path, PurePath
 from glob import glob
@@ -39,10 +39,25 @@ class BaseSegmentProcess(Process):
 		print(f"Position: {extract_position_name(self.pos)}...")
 		print("Configuration file: ",self.config)
 		print(f"Population: {self.mode}...")
-
+		self.instruction_file = os.sep.join(["configs", f"segmentation_instructions_{self.mode}.json"])
+		
+		self.read_instructions()
 		self.extract_experiment_parameters()
 		self.detect_movie_length()
 		self.write_folders()
+	
+	def read_instructions(self):
+		print('Looking for instruction file...')
+		instr_path = PurePath(self.exp_dir,Path(f"{self.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...")
+				print(f"Instructions: {_instructions}...")
+			self.flip = _instructions.get("flip", False)
+		else:
+			self.flip = False
+
 
 	def write_folders(self):
 
@@ -58,9 +73,9 @@ class BaseSegmentProcess(Process):
 
 	def extract_experiment_parameters(self):
 
-		self.spatial_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["pxtoum"])
-		self.len_movie = float(ConfigSectionMap(self.config,"MovieSettings")["len_movie"])
-		self.movie_prefix = ConfigSectionMap(self.config,"MovieSettings")["movie_prefix"]
+		self.spatial_calibration = float(config_section_to_dict(self.config, "MovieSettings")["pxtoum"])
+		self.len_movie = float(config_section_to_dict(self.config, "MovieSettings")["len_movie"])
+		self.movie_prefix = config_section_to_dict(self.config, "MovieSettings")["movie_prefix"]
 		self.nbr_channels = _extract_nbr_channels_from_config(self.config)
 		self.channel_names, self.channel_indices = extract_experiment_channels(self.exp_dir)
 
@@ -357,7 +372,7 @@ class SegmentCellThresholdProcess(BaseSegmentProcess):
 
 		self.indices = list(range(self.img_num_channels.shape[1]))
 		if self.flip:
-			self.indices = reversed(self.indices)
+			self.indices = np.array(list(reversed(self.indices)))
 		
 		chunks = np.array_split(self.indices, self.n_threads)
 

celldetective/gui/processes/track_cells.py

@@ -1,10 +1,8 @@
 from multiprocessing import Process
 import time
-import datetime
-import os
-import json
 from celldetective.io import auto_load_number_of_frames, _load_frames_to_measure, locate_labels
-from celldetective.utils import extract_experiment_channels, ConfigSectionMap, _get_img_num_per_channel, _mask_intensity_measurements
+from celldetective.utils import config_section_to_dict, _get_img_num_per_channel, \
+	_mask_intensity_measurements, remove_file_if_exists
 from pathlib import Path, PurePath
 from glob import glob
 from tqdm import tqdm
@@ -155,12 +153,12 @@ class TrackingProcess(Process):
 
 	def extract_experiment_parameters(self):
 
-		self.movie_prefix = ConfigSectionMap(self.config,"MovieSettings")["movie_prefix"]
-		self.spatial_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["pxtoum"])
-		self.time_calibration = float(ConfigSectionMap(self.config,"MovieSettings")["frametomin"])
-		self.len_movie = float(ConfigSectionMap(self.config,"MovieSettings")["len_movie"])
-		self.shape_x = int(ConfigSectionMap(self.config,"MovieSettings")["shape_x"])
-		self.shape_y = int(ConfigSectionMap(self.config,"MovieSettings")["shape_y"])
+		self.movie_prefix = config_section_to_dict(self.config, "MovieSettings")["movie_prefix"]
+		self.spatial_calibration = float(config_section_to_dict(self.config, "MovieSettings")["pxtoum"])
+		self.time_calibration = float(config_section_to_dict(self.config, "MovieSettings")["frametomin"])
+		self.len_movie = float(config_section_to_dict(self.config, "MovieSettings")["len_movie"])
+		self.shape_x = int(config_section_to_dict(self.config, "MovieSettings")["shape_x"])
+		self.shape_y = int(config_section_to_dict(self.config, "MovieSettings")["shape_y"])
 
 		self.channel_names, self.channel_indices = extract_experiment_channels(self.exp_dir)
 		self.nbr_channels = len(self.channel_names)
@@ -246,7 +244,9 @@ class TrackingProcess(Process):
 
 		print('Features successfully measured...')
 
-		df = pd.concat(self.timestep_dataframes)	
+		df = pd.concat(self.timestep_dataframes)
+		df = df.replace([np.inf, -np.inf], np.nan)
+
 		df.reset_index(inplace=True, drop=True)
 		df = _mask_intensity_measurements(df, self.mask_channels)
 
@@ -280,8 +280,7 @@ class TrackingProcess(Process):
 		trajectories.to_csv(self.pos+os.sep.join(['output', 'tables', self.table_name]), index=False)
 		print(f"Trajectory table successfully exported in {os.sep.join(['output', 'tables'])}...")
 
-		if os.path.exists(self.pos+os.sep.join(['output', 'tables', self.table_name.replace('.csv','.pkl')])):
-			os.remove(self.pos+os.sep.join(['output', 'tables', self.table_name.replace('.csv','.pkl')]))
+		remove_file_if_exists(self.pos+os.sep.join(['output', 'tables', self.table_name.replace('.csv','.pkl')]))
 
 		del trajectories; del napari_data;
 		gc.collect()		

celldetective/gui/settings/__init__.py

@@ -0,0 +1,7 @@
+from ._settings_measurements import SettingsMeasurements
+from ._settings_segmentation import SettingsSegmentation
+from ._settings_tracking import SettingsTracking
+from ._settings_segmentation_model_training import SettingsSegmentationModelTraining
+from ._settings_event_model_training import SettingsEventDetectionModelTraining
+from ._settings_signal_annotator import SettingsSignalAnnotator
+from ._settings_neighborhood import SettingsNeighborhood

celldetective/gui/settings/_settings_base.py

@@ -0,0 +1,70 @@
+from abc import abstractmethod
+from PyQt5.QtWidgets import QApplication, QScrollArea, QSizePolicy, QVBoxLayout, QPushButton
+from PyQt5.QtCore import Qt
+from celldetective.utils import get_software_location
+from celldetective.gui.gui_utils import center_window
+from celldetective.gui import CelldetectiveMainWindow, CelldetectiveWidget
+from PyQt5.QtGui import QDoubleValidator, QIntValidator
+
+class CelldetectiveSettingsPanel(CelldetectiveMainWindow):
+	
+	def __init__(self, title=""):
+		
+		super().__init__()
+		self.setWindowTitle(title)
+		
+		self._get_screen_height()
+		#self.setMinimumWidth(500)
+		self.setMaximumHeight(int(0.8 * self._screen_height))
+		self._scroll_area = QScrollArea(self)
+		self._floatValidator = QDoubleValidator()
+		self._intValidator = QIntValidator()
+		self._software_path = get_software_location()
+
+		self._create_widgets()
+		self._build_layouts()
+		self.center_window()
+	
+	def _create_widgets(self):
+		self.submit_btn: QPushButton = QPushButton("Save")
+		self.submit_btn.setStyleSheet(self.button_style_sheet)
+		self.submit_btn.clicked.connect(self._write_instructions)
+	
+	def center_window(self):
+		return center_window(self)
+	
+	def _get_screen_height(self):
+		app = QApplication.instance()
+		screen = app.primaryScreen()
+		geometry = screen.availableGeometry()
+		self._screen_width, self._screen_height = geometry.getRect()[-2:]
+	
+	def _adjustSize(self):
+		self._widget.adjustSize()
+		self._scroll_area.adjustSize()
+		self.adjustSize()
+	
+	def _build_layouts(self):
+		
+		self._layout: QVBoxLayout = QVBoxLayout()
+		self._widget: CelldetectiveWidget = CelldetectiveWidget()
+		self._widget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
+		
+		# Create button widget and layout
+		self._widget.setLayout(self._layout)
+		self._layout.setContentsMargins(30, 30, 30, 30)
+		
+		self._scroll_area.setAlignment(Qt.AlignCenter)
+		self._scroll_area.setWidget(self._widget)
+		self._scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+		self._scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
+		self._scroll_area.setWidgetResizable(True)
+		self.setCentralWidget(self._scroll_area)
+		
+		QApplication.processEvents()
+	
+	@abstractmethod
+	def _load_previous_instructions(self): pass
+	
+	@abstractmethod
+	def _write_instructions(self): pass

celldetective/gui/{retrain_signal_model_options.py → settings/_settings_event_model_training.py}

@@ -1,12 +1,9 @@
-from PyQt5.QtWidgets import QApplication, QDialog, QMessageBox, QScrollArea, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QMessageBox, QComboBox, QFrame, QCheckBox, QFileDialog, QGridLayout, QLineEdit, QVBoxLayout, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt, QSize
-from PyQt5.QtGui import QDoubleValidator, QIntValidator, QIcon
-from celldetective.gui.gui_utils import center_window
 from celldetective.gui.layouts import ChannelNormGenerator
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QSearchableComboBox
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
-from celldetective.utils import get_software_location
 from celldetective.io import locate_signal_dataset, get_signal_datasets_list, load_experiment_tables
 from celldetective.signals import train_signal_model
 import numpy as np
@@ -14,12 +11,12 @@ import json
 import os
 from glob import glob
 from datetime import datetime
-from celldetective.gui import CelldetectiveMainWindow, CelldetectiveWidget
 from pandas.api.types import is_numeric_dtype
 from celldetective.gui.processes.train_signal_model import TrainSignalModelProcess
 from celldetective.gui.workers import ProgressWindow
+from celldetective.gui.settings._settings_base import CelldetectiveSettingsPanel
 
-class ConfigSignalModelTraining(CelldetectiveMainWindow):
+class SettingsEventDetectionModelTraining(CelldetectiveSettingsPanel):
 	
 	"""
 	UI to set measurement instructions.
@@ -28,87 +25,62 @@ class ConfigSignalModelTraining(CelldetectiveMainWindow):
 
 	def __init__(self, parent_window=None, signal_mode='single-cells'):
 		
-		super().__init__()
 		self.parent_window = parent_window
-		self.setWindowTitle("Train signal model")
 		self.mode = self.parent_window.mode
 		self.exp_dir = self.parent_window.exp_dir
-		self.soft_path = get_software_location()
-		self.pretrained_model = None 
+		self.pretrained_model = None
 		self.dataset_folder = None
 		self.current_neighborhood = None
 		self.reference_population = None
 		self.neighbor_population = None
 		self.signal_mode = signal_mode
+		
+		super().__init__(title="Train event detection model")
 
 		if self.signal_mode=='single-cells':
-			self.signal_models_dir = self.soft_path+os.sep+os.sep.join(['celldetective','models','signal_detection'])
+			self.signal_models_dir = self._software_path+os.sep+os.sep.join(['celldetective','models','signal_detection'])
 		elif self.signal_mode=='pairs':
-			self.signal_models_dir = self.soft_path+os.sep+os.sep.join(['celldetective','models','pair_signal_detection'])
+			self.signal_models_dir = self._software_path+os.sep+os.sep.join(['celldetective','models','pair_signal_detection'])
 			self.mode = 'pairs'
+		
+		self._add_to_layout()
+		self._load_previous_instructions()
+		
+		self._adjustSize()
+		new_width = int(self.width()*1.2)
+		self.resize(new_width, int(self._screen_height * 0.8))
+		self.setMinimumWidth(new_width)
+	
+	def _add_to_layout(self):
+		self._layout.addWidget(self.model_frame)
+		self._layout.addWidget(self.data_frame)
+		self._layout.addWidget(self.hyper_frame)
+		self._layout.addWidget(self.submit_btn)
 
-		self.onlyFloat = QDoubleValidator()
-		self.onlyInt = QIntValidator()
-
-		self.screen_height = self.parent_window.parent_window.parent_window.screen_height
-		center_window(self)
-
-		self.setMinimumWidth(500)
-		self.setMinimumHeight(int(0.3*self.screen_height))
-		self.setMaximumHeight(int(0.8*self.screen_height))
-		self.populate_widget()
-		#self.load_previous_measurement_instructions()
-
-	def populate_widget(self):
+	def _create_widgets(self):
 
 		"""
 		Create the multibox design.
 
 		"""
+		super()._create_widgets()
 		
-		# Create button widget and layout
-		self.scroll_area = QScrollArea(self)
-		self.button_widget = CelldetectiveWidget()
-		self.main_layout = QVBoxLayout()
-		self.button_widget.setLayout(self.main_layout)
-		self.main_layout.setContentsMargins(30,30,30,30)
-
 		# first frame for FEATURES
 		self.model_frame = QFrame()
 		self.model_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_model_frame()
-		self.main_layout.addWidget(self.model_frame)
 
 		self.data_frame = QFrame()
 		self.data_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_data_frame()
-		self.main_layout.addWidget(self.data_frame)
 
 		self.hyper_frame = QFrame()
 		self.hyper_frame.setFrameStyle(QFrame.StyledPanel | QFrame.Raised)
 		self.populate_hyper_frame()
-		self.main_layout.addWidget(self.hyper_frame)
 
-		self.submit_btn = QPushButton('Train')
-		self.submit_btn.setStyleSheet(self.button_style_sheet)
-		self.submit_btn.clicked.connect(self.prep_model)
-		self.main_layout.addWidget(self.submit_btn)
 		self.submit_btn.setEnabled(False)
+		self.submit_btn.setText("Train")
 
-		#self.populate_left_panel()
-		#grid.addLayout(self.left_side, 0, 0, 1, 1)
-		self.button_widget.adjustSize()
-
-		self.scroll_area.setAlignment(Qt.AlignCenter)
-		self.scroll_area.setWidget(self.button_widget)
-		self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-		self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
-		self.scroll_area.setWidgetResizable(True)
-		self.setCentralWidget(self.scroll_area)
-		self.show()
-
-		QApplication.processEvents()
-		self.adjustScrollArea()
 
 	def populate_hyper_frame(self):
 
@@ -138,14 +110,14 @@ class ConfigSignalModelTraining(CelldetectiveMainWindow):
 		lr_layout = QHBoxLayout()
 		lr_layout.addWidget(QLabel('learning rate: '),30)
 		self.lr_le = QLineEdit('0,01')
-		self.lr_le.setValidator(self.onlyFloat)
+		self.lr_le.setValidator(self._floatValidator)
 		lr_layout.addWidget(self.lr_le, 70)
 		layout.addLayout(lr_layout)
 
 		bs_layout = QHBoxLayout()
 		bs_layout.addWidget(QLabel('batch size: '),30)
 		self.bs_le = QLineEdit('64')
-		self.bs_le.setValidator(self.onlyInt)
+		self.bs_le.setValidator(self._intValidator)
 		bs_layout.addWidget(self.bs_le, 70)
 		layout.addLayout(bs_layout)
 
@@ -378,42 +350,11 @@ class ConfigSignalModelTraining(CelldetectiveMainWindow):
 		self.dataframes = {}
 		self.neighborhood_cols = []
 		for population in self.parent_window.parent_window.populations:
-			df_pop = load_experiment_tables(self.parent_window.exp_dir, population=pop, load_pickle=True)
-			self.dataframes.update({pop: df_pop})
+			df_pop = load_experiment_tables(self.parent_window.exp_dir, population=population, load_pickle=True)
+			self.dataframes.update({population: df_pop})
 			if df_pop is not None:
 				self.neighborhood_cols.extend(
-					[f'{pop}_ref_' + c for c in list(df_pop.columns) if c.startswith('neighborhood')])
-
-		# df_targets = load_experiment_tables(self.parent_window.exp_dir, population='targets', load_pickle=True)
-		# df_effectors = load_experiment_tables(self.parent_window.exp_dir, population='effectors', load_pickle=True)
-		#
-		# self.dataframes = {
-		# 	'targets': df_targets,
-		# 	'effectors': df_effectors,
-		# }
-		#
-		# self.neighborhood_cols = []
-		# self.reference_populations = []
-		# self.neighbor_populations = []
-		# if df_targets is not None:
-		# 	self.neighborhood_cols.extend(['target_ref_'+c for c in list(df_targets.columns) if c.startswith('neighborhood')])
-		# 	self.reference_populations.extend(['targets' for c in list(df_targets.columns) if c.startswith('neighborhood')])
-		# 	for c in list(df_targets.columns):
-		# 		if c.startswith('neighborhood') and '_2_' in c:
-		# 			self.neighbor_populations.append('effectors')
-		# 		elif c.startswith('neighborhood') and 'self' in c:
-		# 			self.neighbor_populations.append('targets')
-		#
-		# if df_effectors is not None:
-		# 	self.neighborhood_cols.extend(['effector_ref_'+c for c in list(df_effectors.columns) if c.startswith('neighborhood')])
-		# 	self.reference_populations.extend(['effectors' for c in list(df_effectors.columns) if c.startswith('neighborhood')])
-		# 	for c in list(df_effectors.columns):
-		# 		if c.startswith('neighborhood') and '_2_' in c:
-		# 			self.neighbor_populations.append('targets')
-		# 		elif c.startswith('neighborhood') and 'self' in c:
-		# 			self.neighbor_populations.append('effectors')
-		#
-		# print(f"The following neighborhoods were detected: {self.neighborhood_cols=} {self.reference_populations=} {self.neighbor_populations=}")
+					[f'{population}_ref_' + c for c in list(df_pop.columns) if c.startswith('neighborhood')])
 
 		self.neighborhood_choice_cb.addItems(self.neighborhood_cols)
 
@@ -519,7 +460,7 @@ class ConfigSignalModelTraining(CelldetectiveMainWindow):
 		while self.scroll_area.verticalScrollBar().isVisible() and self.height() < self.maximumHeight():
 			self.resize(self.width(), self.height() + step)
 
-	def prep_model(self):
+	def _write_instructions(self):
 
 		model_name = self.modelname_le.text()
 		pretrained_model = self.pretrained_model
@@ -597,4 +538,7 @@ class ConfigSignalModelTraining(CelldetectiveMainWindow):
 		# 	return None	
 
 		train_signal_model(model_folder+"training_instructions.json")
-		self.parent_window.refresh_signal_models()
+		self.parent_window.refresh_signal_models()
+	
+	def _load_previous_instructions(self):
+		pass