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

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...")

celldetective/gui/viewers.py

@@ -1,4 +1,3 @@
-import numpy as np
 from celldetective.io import auto_load_number_of_frames, load_frames
 from celldetective.filters import *
 from celldetective.segmentation import filter_image, threshold_image
@@ -11,17 +10,16 @@ from natsort import natsorted
 from glob import glob
 import os
 
-from PyQt5.QtWidgets import QHBoxLayout, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget, QShortcut
+from PyQt5.QtWidgets import QHBoxLayout, QMessageBox, QPushButton, QLabel, QComboBox, QLineEdit, QListWidget, QShortcut
 from PyQt5.QtCore import Qt, QSize
 from PyQt5.QtGui import QKeySequence, QDoubleValidator
-from celldetective.gui.gui_utils import FigureCanvas, center_window, QuickSliderLayout, QHSeperationLine, ThresholdLineEdit, PreprocessingLayout2
-from celldetective.gui import Styles, CelldetectiveWidget
+from celldetective.gui.gui_utils import FigureCanvas, QuickSliderLayout, QHSeperationLine, ThresholdLineEdit, PreprocessingLayout2
+from celldetective.gui import CelldetectiveWidget
 from superqt import QLabeledDoubleSlider, QLabeledSlider, QLabeledDoubleRangeSlider
 from superqt.fonticon import icon
 from fonticon_mdi6 import MDI6
 from matplotlib_scalebar.scalebar import ScaleBar
 import gc
-from celldetective.utils import mask_edges
 from scipy.ndimage import shift
 
 class StackVisualizer(CelldetectiveWidget):

celldetective/gui/workers.py

@@ -4,8 +4,6 @@ from PyQt5.QtCore import QRunnable, QObject, pyqtSignal, QThreadPool, QSize, Qt
 
 from celldetective.gui.base_components import CelldetectiveDialog
 from celldetective.gui.gui_utils import center_window
-from celldetective.gui import Styles
-import time
 import math
 
 class ProgressWindow(CelldetectiveDialog):

celldetective/io.py

@@ -24,13 +24,18 @@ from magicgui import magicgui
 from pathlib import Path, PurePath
 from shutil import copyfile, rmtree
 
-from celldetective.utils import _rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes,ConfigSectionMap, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, download_zenodo_file
-from celldetective.utils import interpolate_nan_multichannel, _estimate_scale_factor, _extract_channel_indices_from_config, _extract_channel_indices, _extract_nbr_channels_from_config, _get_img_num_per_channel, normalize_per_channel, get_config
+from celldetective.utils import _rearrange_multichannel_frame, _fix_no_contrast, zoom_multiframes, \
+	config_section_to_dict, extract_experiment_channels, _extract_labels_from_config, get_zenodo_files, \
+	download_zenodo_file
+from celldetective.utils import interpolate_nan_multichannel, get_config
 
 from stardist import fill_label_holes
 from skimage.transform import resize
 import re
 
+from typing import List, Tuple, Union
+import numbers
+
 def extract_experiment_from_well(well_path):
 
 	"""
@@ -202,6 +207,9 @@ def collect_experiment_metadata(pos_path=None, well_path=None):
 		if not well_path.endswith(os.sep):
 			well_path += os.sep
 		experiment = extract_experiment_from_well(well_path)
+	else:
+		print("Please provide a position or well path...")
+		return None
 		
 	wells = list(get_experiment_wells(experiment))
 	idx = wells.index(well_path)
@@ -211,7 +219,14 @@ def collect_experiment_metadata(pos_path=None, well_path=None):
 	else:
 		pos_name = 0
 
-	dico = {"pos_path": pos_path, "position": pos_path, "pos_name": pos_name, "well_path": well_path, "well_name": well_name, "well_nbr": well_nbr, "experiment": experiment}
+	dico = {"pos_path": pos_path,
+			"position": pos_path,
+			"pos_name": pos_name,
+			"well_path": well_path,
+			"well_name": well_name,
+			"well_nbr": well_nbr,
+			"experiment": experiment,
+			}
 
 	meta = get_experiment_metadata(experiment) # None or dict of metadata
 	if meta is not None:
@@ -306,9 +321,9 @@ def get_spatial_calibration(experiment):
 	"""
 
 	config = get_config(experiment)
-	PxToUm = float(ConfigSectionMap(config, "MovieSettings")["pxtoum"])
+	px_to_um = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
 
-	return PxToUm
+	return px_to_um
 
 
 def get_temporal_calibration(experiment):
@@ -351,14 +366,14 @@ def get_temporal_calibration(experiment):
 	"""
 
 	config = get_config(experiment)
-	FrameToMin = float(ConfigSectionMap(config, "MovieSettings")["frametomin"])
+	frame_to_min = float(config_section_to_dict(config, "MovieSettings")["frametomin"])
 
-	return FrameToMin
+	return frame_to_min
 
 def get_experiment_metadata(experiment):
 
 	config = get_config(experiment)
-	metadata = ConfigSectionMap(config, "Metadata")
+	metadata = config_section_to_dict(config, "Metadata")
 	return metadata
 
 def get_experiment_labels(experiment):
@@ -367,12 +382,12 @@ def get_experiment_labels(experiment):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	labels = ConfigSectionMap(config, "Labels")
+	labels = config_section_to_dict(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]):
+		if np.all(np.array([s.isnumeric() for s in values])):
 			values = [float(s) for s in values]
 		labels.update({k: values})
 
@@ -427,7 +442,7 @@ def get_experiment_concentrations(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	concentrations = ConfigSectionMap(config, "Labels")["concentrations"].split(",")
+	concentrations = config_section_to_dict(config, "Labels")["concentrations"].split(",")
 	if nbr_of_wells != len(concentrations):
 		concentrations = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
@@ -482,7 +497,7 @@ def get_experiment_cell_types(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	cell_types = ConfigSectionMap(config, "Labels")["cell_types"].split(",")
+	cell_types = config_section_to_dict(config, "Labels")["cell_types"].split(",")
 	if nbr_of_wells != len(cell_types):
 		cell_types = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
@@ -534,7 +549,7 @@ def get_experiment_antibodies(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	antibodies = ConfigSectionMap(config, "Labels")["antibodies"].split(",")
+	antibodies = config_section_to_dict(config, "Labels")["antibodies"].split(",")
 	if nbr_of_wells != len(antibodies):
 		antibodies = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
@@ -589,7 +604,7 @@ def get_experiment_pharmaceutical_agents(experiment, dtype=str):
 	wells = get_experiment_wells(experiment)
 	nbr_of_wells = len(wells)
 
-	pharmaceutical_agents = ConfigSectionMap(config, "Labels")["pharmaceutical_agents"].split(",")
+	pharmaceutical_agents = config_section_to_dict(config, "Labels")["pharmaceutical_agents"].split(",")
 	if nbr_of_wells != len(pharmaceutical_agents):
 		pharmaceutical_agents = [str(s) for s in np.linspace(0, nbr_of_wells - 1, nbr_of_wells)]
 
@@ -599,7 +614,7 @@ def get_experiment_pharmaceutical_agents(experiment, dtype=str):
 def get_experiment_populations(experiment, dtype=str):
 
 	config = get_config(experiment)
-	populations_str = ConfigSectionMap(config, "Populations")
+	populations_str = config_section_to_dict(config, "Populations")
 	if populations_str is not None:
 		populations = populations_str['populations'].split(',')
 	else:
@@ -607,7 +622,7 @@ def get_experiment_populations(experiment, dtype=str):
 	return list([dtype(c) for c in populations])
 
 
-def interpret_wells_and_positions(experiment, well_option, position_option):
+def interpret_wells_and_positions(experiment: str, well_option: Union[str,int,List[int]], position_option: Union[str,int,List[int]]) -> Union[Tuple[List[int], List[int]], None]:
 	"""
 	Interpret well and position options for a given experiment.
 
@@ -617,8 +632,8 @@ def interpret_wells_and_positions(experiment, well_option, position_option):
 
 	Parameters
 	----------
-	experiment : object
-		The experiment object containing well information.
+	experiment : str
+		The experiment path containing well information.
 	well_option : str, int, or list of int
 		The well selection option:
 		- '*' : Select all wells.
@@ -660,6 +675,9 @@ def interpret_wells_and_positions(experiment, well_option, position_option):
 		well_indices = [int(well_option)]
 	elif isinstance(well_option, list):
 		well_indices = well_option
+	else:
+		print("Well indices could not be interpreted...")
+		return None
 
 	if position_option == '*':
 		position_indices = None
@@ -667,6 +685,9 @@ def interpret_wells_and_positions(experiment, well_option, position_option):
 		position_indices = np.array([position_option], dtype=int)
 	elif isinstance(position_option, list):
 		position_indices = position_option
+	else:
+		print("Position indices could not be interpreted...")
+		return None
 
 	return well_indices, position_indices
 
@@ -795,7 +816,11 @@ def get_position_table(pos, population, return_path=False):
 		table = pos + os.sep.join(['output', 'tables', f'trajectories_{population}.csv'])
 
 	if os.path.exists(table):
-		df_pos = pd.read_csv(table, low_memory=False)
+		try:
+			df_pos = pd.read_csv(table, low_memory=False)
+		except Exception as e:
+			print(e)
+			df_pos = None
 	else:
 		df_pos = None
 	
@@ -970,7 +995,7 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 	config = get_config(experiment)
 	wells = get_experiment_wells(experiment)
 
-	movie_prefix = ConfigSectionMap(config, "MovieSettings")["movie_prefix"]
+	movie_prefix = config_section_to_dict(config, "MovieSettings")["movie_prefix"]
 
 	labels = get_experiment_labels(experiment)
 	metadata = get_experiment_metadata(experiment) # None or dict of metadata
@@ -1027,15 +1052,23 @@ def load_experiment_tables(experiment, population='targets', well_option='*', po
 
 				if metadata is not None:
 					keys = list(metadata.keys())
-					for k in keys:
-						df_pos[k] = metadata[k]
+					for key in keys:
+						df_pos[key] = metadata[key]
 
 				df.append(df_pos)
 				any_table = True
 
-				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}
+				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,
+							}
 
 				df_pos_info.append(pos_dict)
 
@@ -1098,7 +1131,9 @@ def locate_stack(position, prefix='Aligned'):
 		position += os.sep
 
 	stack_path = glob(position + os.sep.join(['movie', f'{prefix}*.tif']))
-	assert len(stack_path) > 0, f"No movie with prefix {prefix} found..."
+	if not stack_path:
+		raise FileNotFoundError(f"No movie with prefix {prefix} found...")
+
 	stack = imread(stack_path[0].replace('\\', '/'))
 	stack_length = auto_load_number_of_frames(stack_path[0])
 
@@ -1417,7 +1452,7 @@ def auto_load_number_of_frames(stack_path):
 
 	Handle invalid or missing paths gracefully:
 
-	>>> frames = auto_load_number_of_frames(None)
+	>>> frames = auto_load_number_of_frames("stack.tif")
 	>>> print(frames)
 	None
 
@@ -1520,7 +1555,7 @@ def parse_isotropic_radii(string):
 
 	"""
 
-	sections = re.split(',| ', string)
+	sections = re.split(r"[ ,]", string)
 	radii = []
 	for k, s in enumerate(sections):
 		if s.isdigit():
@@ -2344,7 +2379,7 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 	position : str
 		The path to the position or experiment directory.
 	prefix : str, optional
-		The prefix used to identify the the movie file. The default is "Aligned".
+		The prefix used to identify the movie file. The default is "Aligned".
 	population : str, optional
 		The population type to load, either "target" or "effector". The default is "target".
 
@@ -2396,7 +2431,7 @@ def load_napari_data(position, prefix="Aligned", population="target", return_sta
 	return data, properties, graph, labels, stack
 
 
-def auto_correct_masks(masks, bbox_factor = 1.75, min_area=9, fill_labels=False):
+def auto_correct_masks(masks, bbox_factor: float = 1.75, min_area: int = 9, fill_labels: bool = False):
 
 	"""
 	Correct segmentation masks to ensure consistency and remove anomalies.
@@ -2416,6 +2451,13 @@ def auto_correct_masks(masks, bbox_factor = 1.75, min_area=9, fill_labels=False)
 	masks : np.ndarray
 		A 2D array representing the segmented mask image with labeled regions. Each unique value 
 		in the array represents a different object or cell.
+	bbox_factor : float, optional
+		A factor on cell area that is compared directly to the bounding box area of the cell, to detect remote cells
+		sharing a same label value. The default is `1.75`.
+	min_area : int, optional
+		Discard cells that have an area smaller than this minimum area (px²). The default is `9` (3x3 pixels).
+	fill_labels : bool, optional
+		Fill holes within cell masks automatically. The default is `False`.
 
 	Returns
 	-------
@@ -2439,6 +2481,8 @@ def auto_correct_masks(masks, bbox_factor = 1.75, min_area=9, fill_labels=False)
 		   [0, 2, 2, 1],
 		   [0, 2, 0, 0]])
 	"""
+	
+	assert masks.ndim==2,"`masks` should be a 2D numpy array..."
 
 	# Avoid negative mask values
 	masks[masks<0] = np.abs(masks[masks<0])
@@ -2503,6 +2547,8 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 		The prefix used to identify the stack. The default is 'Aligned'.
 	population : str, optional
 		The population type for which the segmentation is performed. The default is 'target'.
+	flush_memory : bool, optional
+		Pop napari layers upon closing the viewer to empty the memory footprint. The default is `False`.
 
 	Notes
 	-----
@@ -2559,7 +2605,7 @@ def control_segmentation_napari(position, prefix='Aligned', population="target",
 			for k in keys:
 				info.update({k: metadata_info[k]})
 
-		spatial_calibration = float(ConfigSectionMap(config,"MovieSettings")["pxtoum"])
+		spatial_calibration = float(config_section_to_dict(config, "MovieSettings")["pxtoum"])
 		channel_names, channel_indices = extract_experiment_channels(expfolder)
 
 		annotation_folder = expfolder + os.sep + f'annotations_{population}' + os.sep
@@ -2727,6 +2773,12 @@ def correct_annotation(filename):
 	def save_widget():
 		return export_labels()
 
+	if filename.endswith("_labelled.tif"):
+		filename = filename.replace("_labelled.tif",".tif")
+	if filename.endswith(".json"):
+		filename = filename.replace('.json',".tif")
+	assert os.path.exists(filename),f"Image {filename} does not seem to exist..."
+	
 	img = imread(filename.replace('\\','/'))
 	if img.ndim==3:
 		img = np.moveaxis(img, 0, -1)
@@ -2791,7 +2843,7 @@ def _view_on_napari(tracks=None, stack=None, labels=None):
 	...                        'x': [10, 20, 30], 'y': [15, 25, 35]})
 	>>> stack = np.random.rand(100, 100, 3)
 	>>> labels = np.random.randint(0, 2, (100, 100))
-	>>> view_on_napari(tracks, stack=stack, labels=labels)
+	>>> _view_on_napari(tracks, stack=stack, labels=labels)
 	# Visualize tracks, stack, and labels using Napari.
 
 	"""
@@ -2864,22 +2916,6 @@ def get_segmentation_models_list(mode='targets', return_path=False):
 	else:
 		repository_models = get_zenodo_files(cat=os.sep.join(["models", f"segmentation_{mode}"]))
 
-	# if mode == 'targets':
-	# 	modelpath = os.sep.join(
-	# 		[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-	# 		 "segmentation_targets", os.sep])
-	# 	repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_targets"]))
-	# elif mode == 'effectors':
-	# 	modelpath = os.sep.join(
-	# 		[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-	# 		 "segmentation_effectors", os.sep])
-	# 	repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_effectors"]))
-	# elif mode == 'generic':
-	# 	modelpath = os.sep.join(
-	# 		[os.path.split(os.path.dirname(os.path.realpath(__file__)))[0], "celldetective", "models",
-	# 		 "segmentation_generic", os.sep])
-	# 	repository_models = get_zenodo_files(cat=os.sep.join(["models", "segmentation_generic"]))
-
 	available_models = natsorted(glob(modelpath + '*/'))
 	available_models = [m.replace('\\', '/').split('/')[-2] for m in available_models]
 
@@ -3199,7 +3235,7 @@ def normalize(frame, percentiles=(0.0,99.99), values=None, ignore_gray_value=0.,
 		subframe = frame.copy()
 
 	if values is not None:
-		mi = values[0];
+		mi = values[0]
 		ma = values[1]
 	else:
 		mi = np.nanpercentile(subframe.flatten(), percentiles[0], keepdims=True)
@@ -3220,9 +3256,14 @@ def normalize(frame, percentiles=(0.0,99.99), values=None, ignore_gray_value=0.,
 	return frame.copy().astype(dtype)
 
 
-def normalize_multichannel(multichannel_frame, percentiles=None,
-						   values=None, ignore_gray_value=0., clip=False,
-						   amplification=None, dtype=float):
+def normalize_multichannel(multichannel_frame: np.ndarray,
+						   percentiles=None,
+						   values=None,
+						   ignore_gray_value=0.,
+						   clip=False,
+						   amplification=None,
+						   dtype=float,
+						   ):
 	
 	"""
 	Normalizes a multichannel frame by adjusting the intensity values of each channel based on specified percentiles,
@@ -3271,13 +3312,11 @@ def normalize_multichannel(multichannel_frame, percentiles=None,
 	Examples
 	--------
 	>>> multichannel_frame = np.random.rand(100, 100, 3)  # Example multichannel frame
-	>>> normalized_frame = normalize_multichannel(multichannel_frame, percentiles=((1, 99), (2, 98), (0, 100)))
+	>>> normalized_frame = normalize_multichannel(multichannel_frame, percentiles=[(1, 99), (2, 98), (0, 100)])
 	# Normalizes each channel of the frame using specified percentile ranges.
 
 	"""
 
-
-
 	mf = multichannel_frame.copy().astype(float)
 	assert mf.ndim == 3, f'Wrong shape for the multichannel frame: {mf.shape}.'
 	if percentiles is None:
@@ -3371,6 +3410,10 @@ def load_frames(img_nums, stack_path, scale=None, normalize_input=True, dtype=np
 		print(
 			f'Error in loading the frame {img_nums} {e}. Please check that the experiment channel information is consistent with the movie being read.')
 		return None
+	try:
+		frames[np.isinf(frames)] = np.nan
+	except Exception as e:
+		print(e)
 
 	frames = _rearrange_multichannel_frame(frames)