celldetective 1.3.9.post5__py3-none-any.whl → 1.4.1__py3-none-any.whl

celldetective/gui/survival_ui.py

@@ -1,7 +1,7 @@
-from PyQt5.QtWidgets import QMessageBox, QComboBox, QLineEdit, QVBoxLayout, QWidget, QLabel, QHBoxLayout, QPushButton
+from PyQt5.QtWidgets import QComboBox, QLineEdit, QVBoxLayout, QLabel, QHBoxLayout, QPushButton
 from PyQt5.QtCore import Qt
 from PyQt5.QtGui import QDoubleValidator
-from celldetective.gui.gui_utils import center_window
+from celldetective.gui.gui_utils import center_window, generic_message
 from superqt import QColormapComboBox
 from celldetective.gui.generic_signal_plot import SurvivalPlotWidget
 from celldetective.utils import get_software_location, _extract_labels_from_config, extract_cols_from_table_list
@@ -11,14 +11,14 @@ import os
 import matplotlib.pyplot as plt
 plt.rcParams['svg.fonttype'] = 'none'
 from glob import glob
-from celldetective.gui import Styles
+from celldetective.gui import Styles, CelldetectiveWidget
 from matplotlib import colormaps
 from celldetective.events import compute_survival
 from celldetective.relative_measurements import expand_pair_table
 import matplotlib.cm
 from celldetective.neighborhood import extract_neighborhood_in_pair_table
 
-class ConfigSurvival(QWidget, Styles):
+class ConfigSurvival(CelldetectiveWidget):
 	
 	"""
 	UI to set survival instructions.
@@ -30,7 +30,6 @@ class ConfigSurvival(QWidget, Styles):
 		super().__init__()
 		self.parent_window = parent_window
 		self.setWindowTitle("Configure survival")
-		self.setWindowIcon(self.celldetective_icon)
 
 		self.exp_dir = self.parent_window.exp_dir
 		self.soft_path = get_software_location()		
@@ -53,8 +52,6 @@ class ConfigSurvival(QWidget, Styles):
 		self.populate_widget()
 		if self.auto_close:
 			self.close()
-		
-		self.setAttribute(Qt.WA_DeleteOnClose)
 
 	def interpret_pos_location(self):
 		
@@ -91,51 +88,27 @@ class ConfigSurvival(QWidget, Styles):
 
 
 		pops = []
-		for population in ['effectors','targets','pairs']:
+		self.cols_per_pop = {}
+		for population in self.parent_window.parent_window.populations:
 			tables = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_{population}.csv']))
 			if len(tables)>0:
 				pops.append(population)
-
-		tables_targets = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_targets.csv']))
-		self.cols_targets = extract_cols_from_table_list(tables_targets)
-		tables_effectors = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_effectors.csv']))
-		self.cols_effectors = extract_cols_from_table_list(tables_effectors)
-
-		# Smart reading of existing neighborhoods (without loading tables in memory)
-		if 'pairs' in pops and not 'targets' in pops:
-			# must be effector-effector
-			effector_neighs = [c[16:] for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood')]
-			if len(effector_neighs)>0:
-				pops.pop(pops.index('pairs'))
-				pops.append('effectors-effectors')
-		elif 'pairs' in pops and not 'effectors' in pops:
-			# must be target-target
-			target_neighs = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood')]
-			if len(target_neighs)>0:
-				pops.pop(pops.index('pairs'))
-				pops.append('targets-targets')
-		elif 'pairs' in pops:
-			# either effector-target or target-effector
-			target_neighs_cross = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
-			if len(target_neighs_cross)>0:
-				pops.append('targets-effectors')
-			effector_neighs_cross = [c for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
-			if len(effector_neighs_cross)>0:
-				pops.append('effectors-targets')
-			target_neighs = [c for c in self.cols_targets if c.startswith('inclusive_count_neighborhood') and 'self' in c]
-			if len(target_neighs)>0:
-				pops.append('targets-targets')
-			effector_neighs = [c for c in self.cols_effectors if c.startswith('inclusive_count_neighborhood') and 'self' in c]
-			if len(effector_neighs)>0:
-				pops.append('effectors-effectors')
-			pops.pop(pops.index('pairs'))
-		else:
-			pass
-
+				cols = extract_cols_from_table_list(tables)
+				
+				# check for neighbor pairs
+				neigh_cols = [c for c in cols if c.startswith('inclusive_count_neighborhood')]
+				neigh_pairs = [c.split('_(')[-1].split(')_')[0].split('-') for c in neigh_cols]
+				neigh_pairs = ['-'.join(c) for c in neigh_pairs]
+				for k in range(len(neigh_pairs)):
+					if "_self_" in neigh_pairs[k]:
+						neigh_pairs[k] = '-'.join([population, population])
+				pops.extend(neigh_pairs)
+
+				self.cols_per_pop.update({population: cols})
 
 		labels = [QLabel('population: '), QLabel('time of\nreference: '), QLabel('time of\ninterest: '), QLabel('cmap: ')] #QLabel('class: '),
 		self.cb_options = [pops, ['0'], [], []] #['class'],
-		self.cbs = [QComboBox() for i in range(len(labels))]
+		self.cbs = [QComboBox() for _ in range(len(labels))]
 
 		self.cbs[-1] = QColormapComboBox()
 		self.cbs[0].currentIndexChanged.connect(self.set_classes_and_times)
@@ -155,12 +128,8 @@ class ConfigSurvival(QWidget, Styles):
 			if hasattr(matplotlib.cm, str(cm).lower()):
 				try:
 					self.cbs[-1].addColormap(cm.lower())
-				except:
+				except Exception as _:
 					pass
-			#try:
-			# 	self.cbs[-1].addColormap(cm)
-			# except:
-			# 	pass
 
 		main_layout.addLayout(choice_layout)
 
@@ -213,18 +182,16 @@ class ConfigSurvival(QWidget, Styles):
 
 			self.population = 'pairs'
 			tables_pairs = glob(self.exp_dir+os.sep.join(['W*','*','output','tables',f'trajectories_pairs.csv']))
+			if not tables_pairs:
+				print('No pair table found... please compute the pair measurements...')
+				return None
 			self.cols_pairs = extract_cols_from_table_list(tables_pairs)
 
 			self.population_reference = pop_split[0]
 			self.population_neigh = pop_split[1]
-			if self.population_reference=='targets':
-				cols_ref = self.cols_targets
-			else:
-				cols_ref = self.cols_effectors
-			if self.population_neigh=='targets':
-				cols_neigh = self.cols_targets
-			else:
-				cols_neigh = self.cols_effectors
+
+			cols_ref = self.cols_per_pop[self.population_reference]
+			cols_neigh = self.cols_per_pop[self.population_neigh]
 
 			time_cols_ref = np.array([s.startswith('t_') or s=='t0' for s in cols_ref])
 			if len(time_cols_ref)>0:
@@ -237,9 +204,11 @@ class ConfigSurvival(QWidget, Styles):
 				time_cols_neigh = ['neighbor_'+t for t in time_cols_neigh]
 
 			if self.population_reference!=self.population_neigh:
-				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and '_2_' in c]
+				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and str(self.population_neigh) in c]
 			else:
-				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and 'self' in c]
+				self.neighborhood_keys = [c[16:] for c in cols_ref if c.startswith('inclusive_count_neighborhood') and str(self.population_neigh) not in c]
+
+			print(f"{self.neighborhood_keys=}")
 
 			time_idx = np.array([s.startswith('t_') or s.startswith('t0') for s in self.cols_pairs])
 			time_cols_pairs = list(self.cols_pairs[time_idx])
@@ -247,10 +216,7 @@ class ConfigSurvival(QWidget, Styles):
 			time_columns = time_cols_ref + time_cols_neigh + time_cols_pairs
 
 		else:
-			if self.population=='targets':
-				self.all_columns = self.cols_targets
-			else:
-				self.all_columns = self.cols_effectors
+			self.all_columns = self.cols_per_pop[self.population]
 			time_idx = np.array([s.startswith('t_') or s=='t0' for s in self.all_columns])
 
 			try:
@@ -274,6 +240,8 @@ class ConfigSurvival(QWidget, Styles):
 		self.time_of_interest = self.cbs[2].currentText()
 		if self.time_of_interest=="t0":
 			self.class_of_interest = "class"
+		elif self.time_of_interest.startswith('t0'):
+			self.class_of_interest = self.time_of_interest.replace('t0_','class_')
 		else:
 			self.class_of_interest = self.time_of_interest.replace('t_','class_')
 
@@ -290,29 +258,19 @@ class ConfigSurvival(QWidget, Styles):
 				print(e, ' The query is misunderstood and will not be applied...')
 			
 			self.interpret_pos_location()
+
 			if self.class_of_interest in list(self.df.columns) and self.cbs[2].currentText() in list(self.df.columns):
 				self.compute_survival_functions()
 			else:
-				msgBox = QMessageBox()
-				msgBox.setIcon(QMessageBox.Warning)
-				msgBox.setText("The class and/or event time of interest is not found in the dataframe...")
-				msgBox.setWindowTitle("Warning")
-				msgBox.setStandardButtons(QMessageBox.Ok)
-				returnValue = msgBox.exec()
-				if returnValue == QMessageBox.Ok:
-					return None
+				generic_message("The class and/or event time of interest is not found in the dataframe...")
+				return None
+
 			if 'survival_fit' in list(self.df_pos_info.columns):
 				self.plot_window = SurvivalPlotWidget(parent_window=self, df=self.df, df_pos_info = self.df_pos_info, df_well_info = self.df_well_info, title='plot survivals')
 				self.plot_window.show()
 			else:
-				msgBox = QMessageBox()
-				msgBox.setIcon(QMessageBox.Warning)
-				msgBox.setText("No survival function was successfully computed...\nCheck your parameter choice.")
-				msgBox.setWindowTitle("Warning")
-				msgBox.setStandardButtons(QMessageBox.Ok)
-				returnValue = msgBox.exec()
-				if returnValue == QMessageBox.Ok:
-					return None	
+				generic_message("No survival function was successfully computed...\nCheck your parameter choice.")
+				return None
 
 	def load_available_tables_local(self):
 
@@ -327,32 +285,26 @@ class ConfigSurvival(QWidget, Styles):
 		self.df, self.df_pos_info = load_experiment_tables(self.exp_dir, well_option=self.well_option, position_option=self.position_option, population=self.population, return_pos_info=True)
 
 		if self.df is None:
-			msgBox = QMessageBox()
-			msgBox.setIcon(QMessageBox.Warning)
-			msgBox.setText("No table could be found.. Abort.")
-			msgBox.setWindowTitle("Warning")
-			msgBox.setStandardButtons(QMessageBox.Ok)
-			returnValue = msgBox.exec()
-			if returnValue == QMessageBox.Ok:
-				return None		
+			generic_message("No table could be found.. Abort.")
+			return None
 		else:
 			self.df_well_info = self.df_pos_info.loc[:,['well_path', 'well_index', 'well_name', 'well_number', 'well_alias']].drop_duplicates()
-			#print(f"{self.df_well_info=}")
 
 		if self.population=='pairs':
 			self.df = expand_pair_table(self.df)
 			self.df = extract_neighborhood_in_pair_table(self.df, reference_population=self.population_reference, neighbor_population=self.population_neigh, neighborhood_key=self.neighborhood_keys[0], contact_only=True)
 
-
 	def compute_survival_functions(self):
 
 		cut_observation_time = None
 		try:
-			cut_observation_time = float(self.query_time_cut.text().replace(',','.')) / self.FrameToMin
-			if not 0<cut_observation_time<=(self.df['FRAME'].max()):
-				print('Invalid cut time (larger than movie length)... Not applied.')
-				cut_observation_time = None		
+			if self.query_time_cut.text()!='':
+				cut_observation_time = float(self.query_time_cut.text().replace(',','.')) / self.FrameToMin
+				if not 0<cut_observation_time<=(self.df['FRAME'].max()):
+					print('Invalid cut time (larger than movie length)... Not applied.')
+					cut_observation_time = None		
 		except Exception as e:
+			print(f"{e=}")
 			pass
 
 		pairs = False
@@ -361,7 +313,9 @@ class ConfigSurvival(QWidget, Styles):
 
 		# Per position survival
 		for block,movie_group in self.df.groupby(['well','position']):
+			print(f"{block=}")
 			ks = compute_survival(movie_group, self.class_of_interest, self.cbs[2].currentText(), t_reference=self.cbs[1].currentText(), FrameToMin=self.FrameToMin, cut_observation_time=cut_observation_time, pairs=pairs)
+			print(f"{ks=}")
 			if ks is not None:
 				self.df_pos_info.loc[self.df_pos_info['pos_path']==block[1],'survival_fit'] = ks
 

celldetective/gui/tableUI.py

@@ -1,8 +1,11 @@
-from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QMainWindow, QTableView, QAction, QMenu,QFileDialog, QLineEdit, QHBoxLayout, QWidget, QPushButton, QVBoxLayout, QComboBox, QLabel, QCheckBox, QMessageBox
+from PyQt5.QtWidgets import QRadioButton, QButtonGroup, QTableView, QAction, QMenu,QFileDialog, QLineEdit, QHBoxLayout, QPushButton, QVBoxLayout, QComboBox, QLabel, QCheckBox, QMessageBox
 from PyQt5.QtCore import Qt
 from PyQt5.QtGui import QBrush, QColor, QDoubleValidator
 import pandas as pd
 import matplotlib.pyplot as plt
+
+from celldetective.gui.table_ops.merge_groups import MergeGroupWidget
+
 plt.rcParams['svg.fonttype'] = 'none'
 from celldetective.gui.gui_utils import FigureCanvas, center_window, QHSeperationLine, GenericOpColWidget, PandasModel
 from celldetective.utils import differentiate_per_track, collapse_trajectories_by_status, test_2samp_generic, safe_log
@@ -12,7 +15,7 @@ import numpy as np
 import seaborn as sns
 import matplotlib.cm as mcm
 import os
-from celldetective.gui import Styles
+from celldetective.gui import CelldetectiveWidget, CelldetectiveMainWindow
 from superqt import QColormapComboBox, QLabeledSlider, QSearchableComboBox
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
@@ -22,12 +25,13 @@ from matplotlib import colormaps
 import matplotlib.cm
 
 
-class QueryWidget(QWidget):
+class QueryWidget(CelldetectiveWidget):
 
 	def __init__(self, parent_window):
 
 		super().__init__()
 		self.parent_window = parent_window
+
 		self.setWindowTitle("Filter table")
 		# Create the QComboBox and add some items
 
@@ -39,7 +43,6 @@ class QueryWidget(QWidget):
 		self.submit_btn = QPushButton('submit')
 		self.submit_btn.clicked.connect(self.filter_table)
 		layout.addWidget(self.submit_btn, 30)
-		self.setAttribute(Qt.WA_DeleteOnClose)
 		center_window(self)
 
 	def filter_table(self):
@@ -54,7 +57,7 @@ class QueryWidget(QWidget):
 			return None
 
 
-class MergeOneHotWidget(QWidget, Styles):
+class MergeOneHotWidget(CelldetectiveWidget):
 
 	def __init__(self, parent_window, selected_columns=None):
 
@@ -139,7 +142,7 @@ class MergeOneHotWidget(QWidget, Styles):
 			self.submit_btn.setEnabled(True)
 
 
-class DifferentiateColWidget(QWidget, Styles):
+class DifferentiateColWidget(CelldetectiveWidget):
 
 	def __init__(self, parent_window, column=None):
 
@@ -217,7 +220,7 @@ class DifferentiateColWidget(QWidget, Styles):
 
 
 
-class OperationOnColsWidget(QWidget, Styles):
+class OperationOnColsWidget(CelldetectiveWidget):
 
 	def __init__(self, parent_window, column1=None, column2=None, operation='divide'):
 
@@ -394,7 +397,7 @@ class LogColWidget(GenericOpColWidget):
 		self.parent_window.data['log10('+self.measurements_cb.currentText()+')'] = safe_log(self.parent_window.data[self.measurements_cb.currentText()].values)
 
 
-class RenameColWidget(QWidget):
+class RenameColWidget(CelldetectiveWidget):
 
 	def __init__(self, parent_window, column=None):
 
@@ -429,11 +432,11 @@ class RenameColWidget(QWidget):
 		self.parent_window.table_view.setModel(self.parent_window.model)
 		self.close()
 
-class PivotTableUI(QWidget):
+class PivotTableUI(CelldetectiveWidget):
 
 	def __init__(self, data, title="", mode=None, *args, **kwargs):
 
-		QWidget.__init__(self, *args, **kwargs)
+		CelldetectiveWidget.__init__(self, *args, **kwargs)
 		
 		self.data = data
 		self.title = title
@@ -535,11 +538,11 @@ class PivotTableUI(QWidget):
 		"""
 		self.information_label.setText(html_caption)
 
-class TableUI(QMainWindow, Styles):
+class TableUI(CelldetectiveMainWindow):
 
 	def __init__(self, data, title, population='targets',plot_mode="plot_track_signals", save_inplace_option=False, collapse_tracks_option=True, *args, **kwargs):
 
-		QMainWindow.__init__(self, *args, **kwargs)
+		CelldetectiveMainWindow.__init__(self, *args, **kwargs)
 
 		self.setWindowTitle(title)
 		self.setGeometry(100,100,1000,400)
@@ -574,7 +577,6 @@ class TableUI(QMainWindow, Styles):
 		self.model = PandasModel(data)
 		self.table_view.setModel(self.model)
 		self.table_view.resizeColumnsToContents()
-		self.setAttribute(Qt.WA_DeleteOnClose)
 
 	def resizeEvent(self, event):
 
@@ -651,11 +653,17 @@ class TableUI(QMainWindow, Styles):
 		self.calibrate_action.triggered.connect(self.calibrate_selected_feature)
 		self.calibrate_action.setShortcut("Ctrl+C")
 		self.mathMenu.addAction(self.calibrate_action)
+		
+		self.merge_classification_action = QAction('&Merge states...', self)
+		self.merge_classification_action.triggered.connect(self.merge_classification_features)
+		self.mathMenu.addAction(self.merge_classification_action)
 
 		self.derivative_action = QAction('&Differentiate...', self)
 		self.derivative_action.triggered.connect(self.differenciate_selected_feature)
 		self.derivative_action.setShortcut("Ctrl+D")
 		self.mathMenu.addAction(self.derivative_action)
+		if not self.tracks:
+			self.derivative_action.setEnabled(False)
 
 		self.abs_action = QAction('&Absolute value...', self)
 		self.abs_action.triggered.connect(self.take_abs_of_selected_feature)
@@ -696,7 +704,7 @@ class TableUI(QMainWindow, Styles):
 
 	def collapse_pairs_in_neigh(self):
 
-		self.selectNeighWidget = QWidget()
+		self.selectNeighWidget = CelldetectiveWidget()
 		self.selectNeighWidget.setMinimumWidth(480)
 		self.selectNeighWidget.setWindowTitle('Set neighborhood of interest')
 		
@@ -757,14 +765,20 @@ class TableUI(QMainWindow, Styles):
 		ref_pop = self.reference_pop_cb.currentText()
 		neighborhood = self.neigh_cb.currentText()
 		status_neigh = 'status_'+neighborhood
+
 		if 'self' in neighborhood:
 			neighbor_pop = ref_pop
-		elif ref_pop=='targets':
-			neighbor_pop = 'effectors'
-		elif ref_pop=='effectors':
-			neighbor_pop = "targets"
 
-		data = extract_neighborhood_in_pair_table(self.data, neighborhood_key=neighborhood, contact_only=self.contact_only_check.isChecked())
+		neigh_col = neighborhood.replace('status_','')
+		if '_(' in neigh_col and ')_' in neigh_col:
+			neighbor_pop = neigh_col.split('_(')[-1].split(')_')[0].split('-')[-1]
+		else:
+			if ref_pop=='targets':
+				neighbor_pop = 'effectors'
+			if ref_pop=='effectors':
+				neighbor_pop = "targets"
+
+		data = extract_neighborhood_in_pair_table(self.data, neighborhood_key=neighborhood, contact_only=self.contact_only_check.isChecked(), reference_population=ref_pop)
 
 		if self.groupby_pair_rb.isChecked():
 			self.groupby_cols = ['position', 'REFERENCE_ID', 'NEIGHBOR_ID']
@@ -774,6 +788,7 @@ class TableUI(QMainWindow, Styles):
 		self.current_data = data
 		skip_projection = False
 		if 'reference_tracked' in list(self.current_data.columns):
+			print(f"{self.current_data['reference_tracked']=} {(self.current_data['reference_tracked']==False)=} {np.all(self.current_data['reference_tracked']==False)=}")
 			if np.all(self.current_data['reference_tracked'].astype(bool)==False):
 				# reference not tracked
 				if self.groupby_reference_rb.isChecked():
@@ -987,6 +1002,22 @@ class TableUI(QMainWindow, Styles):
 
 		self.LogWidget = LogColWidget(self, selected_col)
 		self.LogWidget.show()
+		
+	def merge_classification_features(self):
+		
+		x = self.table_view.selectedIndexes()
+		col_idx = np.unique(np.array([l.column() for l in x]))
+		
+		col_selection = []
+		if isinstance(col_idx, (list, np.ndarray)):
+			cols = np.array(list(self.data.columns))
+			if len(col_idx) > 0:
+				selected_cols = cols[col_idx]
+				col_selection.extend(selected_cols)
+		
+		self.merge_classification_widget = MergeGroupWidget(self, columns = col_selection)
+		self.merge_classification_widget.show()
+
 
 	def calibrate_selected_feature(self):
 		
@@ -1030,14 +1061,11 @@ class TableUI(QMainWindow, Styles):
 
 		x = self.table_view.selectedIndexes()
 		col_idx = np.unique(np.array([l.column() for l in x]))
+		selected_cols = None
 		if isinstance(col_idx, (list, np.ndarray)):
 			cols = np.array(list(self.data.columns))
 			if len(col_idx)>0:
 				selected_col = str(cols[col_idx[0]])
-			else:
-				selected_col = None
-		else:
-			selected_col = None
 
 		self.mergewidget = MergeOneHotWidget(self, selected_columns=selected_cols)
 		self.mergewidget.show()
@@ -1091,7 +1119,7 @@ class TableUI(QMainWindow, Styles):
 		
 		self.current_data = self.data
 
-		self.projectionWidget = QWidget()
+		self.projectionWidget = CelldetectiveWidget()
 		self.projectionWidget.setMinimumWidth(500)
 		self.projectionWidget.setWindowTitle('Set projection mode')
 		
@@ -1191,7 +1219,7 @@ class TableUI(QMainWindow, Styles):
 
 	def set_1D_plot_params(self):
 
-		self.plot1Dparams = QWidget()
+		self.plot1Dparams = CelldetectiveWidget()
 		self.plot1Dparams.setWindowTitle('Set 1D plot parameters')
 		
 		layout = QVBoxLayout()

celldetective/gui/table_ops/merge_groups.py

@@ -0,0 +1,118 @@
+from typing import List
+
+import numpy as np
+from PyQt5.QtCore import QSize, Qt
+from PyQt5.QtWidgets import QComboBox, QHBoxLayout, QLabel, QLineEdit, QPushButton, QVBoxLayout
+from fonticon_mdi6 import MDI6
+from superqt.fonticon import icon
+
+from celldetective.gui import CelldetectiveWidget
+from celldetective.gui.gui_utils import PandasModel, center_window
+
+
+class MergeGroupWidget(CelldetectiveWidget):
+	def __init__(self, parent_window, columns: List[str] = [], n_cols_init: int = 3):
+		
+		super().__init__()
+		self.parent_window = parent_window
+
+		self.setWindowTitle("Merge classifications")
+		self.group_cols = [c for c in list(self.parent_window.data.columns) if c.startswith("group_") or c.startswith("status_")]
+		self.group_cols.insert(0, "--")
+		if len(columns) > n_cols_init:
+			n_cols_init = len(columns)
+		
+		center_window(self)
+		
+		layout = QVBoxLayout(self)
+		layout.setContentsMargins(30, 10, 30, 30)
+		
+		label = QLabel(
+			"Merge several binary or multi-label classification features into a multi-label classification feature where each state is one of the possible combinations.\n")
+		
+		label.setWordWrap(True)  # enables automatic line breaking
+		label.setTextInteractionFlags(Qt.TextSelectableByMouse)  # optional, to allow copy
+		label.setStyleSheet("color: gray;")  # optional style
+		
+		layout.addWidget(label)
+		
+		
+		self.name_le = QLineEdit("group_multilabel")
+		name_layout = QHBoxLayout()
+		name_layout.addWidget(QLabel("name: "), 25)
+		name_layout.addWidget(self.name_le, 75)
+		layout.addLayout(name_layout)
+		
+		self.cbs_layout = QVBoxLayout()
+		self.cbs_layout.setContentsMargins(0,10,0,0)
+		
+		self.cbs = []
+		for i in range(n_cols_init):
+			cb_i = QComboBox()
+			cb_i.addItems(self.group_cols)
+			if i < len(columns):
+				selection = columns[i]
+				idx = cb_i.findText(selection)
+				if idx>=0:
+					cb_i.setCurrentIndex(idx)
+				else:
+					cb_i.setCurrentIndex(0)
+			self.cbs.append(cb_i)
+			
+			col_layout = QHBoxLayout()
+			col_layout.addWidget(QLabel(f'state {i}: '), 25)
+			col_layout.addWidget(cb_i, 75)
+			self.cbs_layout.addLayout(col_layout)
+		
+		layout.addLayout(self.cbs_layout)
+		
+		self.add_feature_btn = QPushButton()
+		self.add_feature_btn.setIcon(icon(MDI6.plus, color=self.help_color))
+		self.add_feature_btn.setIconSize(QSize(20, 20))
+		self.add_feature_btn.clicked.connect(self.add_col)
+		self.add_feature_btn.setStyleSheet(self.button_select_all)
+		layout.addWidget(self.add_feature_btn, alignment=Qt.AlignRight)
+		
+		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 add_col(self):
+		cb_i = QComboBox()
+		cb_i.addItems(self.group_cols)
+		self.cbs.append(cb_i)
+	
+		col_layout = QHBoxLayout()
+		col_layout.addWidget(QLabel(f'state {len(self.cbs)}: '), 25)
+		col_layout.addWidget(cb_i, 75)
+	
+		self.cbs_layout.addLayout(col_layout)
+	
+	def compute(self):
+		
+		cols_to_merge = [cb_i.currentText() for cb_i in self.cbs if cb_i.currentText() != "--"]
+		name = self.name_le.text()
+		if " " in name:
+			name.replace(" ","_")
+		if name == '':
+			name = "multilabel"
+		if not name.startswith("group_"):
+			name = "group_" + name
+		
+		if len(cols_to_merge) > 1:
+			print("Computing a multi-label classification from the classification feature sources...")
+			bases = [int(self.parent_window.data[c].max()) + 1 for c in cols_to_merge]
+			multipliers = np.concatenate(([1], np.cumprod(bases[:-1])))
+			self.parent_window.data[name] = (self.parent_window.data[cols_to_merge] * multipliers).sum(axis=1)
+			self.parent_window.data.loc[self.parent_window.data[cols_to_merge].isna().any(axis=1), name] = np.nan
+	
+			self.parent_window.model = PandasModel(self.parent_window.data)
+			self.parent_window.table_view.setModel(self.parent_window.model)
+			self.close()
+		elif len(cols_to_merge) == 1:
+			print("Only one classification feature was selected, nothing to merge...")
+		else:
+			print("No classification feature was selected...")