FlowCyPy 0.7.0__tar.gz → 0.7.1__tar.gz

{flowcypy-0.7.0 → flowcypy-0.7.1}/FlowCyPy/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.7.0'
-__version_tuple__ = version_tuple = (0, 7, 0)
+__version__ = version = '0.7.1'
+__version_tuple__ = version_tuple = (0, 7, 1)

{flowcypy-0.7.0 → flowcypy-0.7.1}/FlowCyPy/acquisition.py

@@ -10,6 +10,7 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 from tabulate import tabulate
 import warnings
+from FlowCyPy import helper
 
 class DataAccessor:
     def __init__(self, outer):
@@ -110,13 +111,36 @@ class Acquisition:
         )
 
     def _get_trigger_indices(
-            self,
-            threshold: units.Quantity,
-            trigger_detector_name: str = None,
-            pre_buffer: int = 64,
-            post_buffer: int = 64) -> tuple[np.ndarray, np.ndarray]:
+        self,
+        threshold: units.Quantity,
+        trigger_detector_name: str = None,
+        pre_buffer: int = 64,
+        post_buffer: int = 64
+    ) -> tuple[np.ndarray, np.ndarray]:
         """
-        Calculate start and end indices for triggered segments.
+        Calculate start and end indices for triggered segments, ensuring no retriggering
+        occurs during an active buffer period.
+
+        Parameters
+        ----------
+        threshold : units.Quantity
+            The threshold value for triggering.
+        trigger_detector_name : str, optional
+            The name of the detector to use for the triggering signal.
+        pre_buffer : int, optional
+            Number of samples to include before the trigger point.
+        post_buffer : int, optional
+            Number of samples to include after the trigger point.
+
+        Returns
+        -------
+        tuple[np.ndarray, np.ndarray]
+            The start and end indices of non-overlapping triggered segments.
+
+        Raises
+        ------
+        ValueError
+            If the specified detector is not found in the data.
         """
         if trigger_detector_name not in self.data.continuous.index.get_level_values('Detector').unique():
             raise ValueError(f"Detector '{trigger_detector_name}' not found.")
@@ -128,7 +152,18 @@ class Acquisition:
         start_indices = np.clip(crossings - pre_buffer, 0, len(trigger_signal) - 1)
         end_indices = np.clip(crossings + post_buffer, 0, len(trigger_signal) - 1)
 
-        return start_indices, end_indices
+        # Suppress retriggering within an active buffer period
+        suppressed_start_indices = []
+        suppressed_end_indices = []
+
+        last_end = -1
+        for start, end in zip(start_indices, end_indices):
+            if start > last_end:  # Ensure no overlap with the last active buffer
+                suppressed_start_indices.append(start)
+                suppressed_end_indices.append(end)
+                last_end = end  # Update the end of the current active buffer
+
+        return np.array(suppressed_start_indices), np.array(suppressed_end_indices)
 
     def run_triggering(self,
             threshold: units.Quantity,
@@ -191,6 +226,16 @@ class Acquisition:
 
         self.detect_peaks()
 
+    def classify_dataset(self, classifier: object, features: List[str], detectors: list[str]) -> None:
+        self.data.peaks = self.data.peaks.unstack('Detector')
+        self.classifier = classifier
+
+        self.classifier.run(
+            dataframe=self.data.peaks,
+            features=features,
+            detectors=detectors
+        )
+
     class LoggerInterface:
         """
         A nested class for logging statistical information about the experiment.
@@ -443,7 +488,8 @@ class Acquisition:
 
             ax.legend()
 
-        def coupling_distribution(self, x_detector: str, y_detector: str, log_scale: bool = False, show: bool = True, equal_limits: bool = False, save_path: str = None) -> None:
+        @helper.plot_sns
+        def coupling_distribution(self, x_detector: str, y_detector: str, equal_limits: bool = False) -> None:
             """
             Plots the density distribution of optical coupling between two detector channels.
 
@@ -466,31 +512,17 @@ class Acquisition:
             y = df[y_detector].pint.to(y_units)
 
             with plt.style.context(mps):
-                joint_plot = sns.jointplot(data=df, x=x, y=y, hue="Population", alpha=0.8)
-
-            if log_scale:
-                joint_plot.ax_joint.set_xscale("log")
-                joint_plot.ax_joint.set_yscale("log")
+                grid = sns.jointplot(data=df, x=x, y=y, hue="Population", alpha=0.8)
 
-            if equal_limits:
-                min_limit = min(x.min(), y.min())
-                max_limit = max(x.max(), y.max())
-                joint_plot.ax_joint.set_xlim(min_limit, max_limit)
-                joint_plot.ax_joint.set_ylim(min_limit, max_limit)
+            grid.ax_joint.set_xlabel(f"Signal {x_detector} [{x_units}]")
+            grid.ax_joint.set_ylabel(f"Signal {y_detector} [{y_units}]")
 
-            joint_plot.ax_joint.set_xlabel(f"Signal {x_detector} [{x_units}]")
-            joint_plot.ax_joint.set_ylabel(f"Signal {y_detector} [{y_units}]")
+            grid.figure.suptitle("Theoretical coupling distribution")
 
-            plt.tight_layout()
+            return grid
 
-            if save_path:
-                joint_plot.figure.savefig(save_path, dpi=300, bbox_inches="tight")
-                logging.info(f"Plot saved to {save_path}")
-
-            if show:
-                plt.show()
-
-        def scatterer(self, show: bool = True, alpha: float = 0.8, bandwidth_adjust: float = 1, log_scale: bool = False, color_palette: Optional[Union[str, dict]] = None) -> None:
+        @helper.plot_sns
+        def scatterer(self, alpha: float = 0.8, bandwidth_adjust: float = 1, log_scale: bool = False, color_palette: Optional[Union[str, dict]] = None) -> None:
             """
             Visualizes the joint distribution of scatterer sizes and refractive indices using a Seaborn jointplot.
 
@@ -504,8 +536,6 @@ class Acquisition:
                 Transparency level for the scatter plot points, ranging from 0 (fully transparent) to 1 (fully opaque). Default is 0.8.
             bandwidth_adjust : float, optional
                 Bandwidth adjustment factor for the kernel density estimate of the marginal distributions. Higher values produce smoother density estimates. Default is 1.
-            log_scale : bool, optional
-                If `True`, applies a logarithmic scale to both axes of the joint plot and their marginal distributions. Default is `False`.
             color_palette : str or dict, optional
                 The color palette to use for the hue in the scatterplot. Can be a seaborn palette name
                 (e.g., 'viridis', 'coolwarm') or a dictionary mapping hue levels to specific colors. Default is None.
@@ -540,19 +570,13 @@ class Acquisition:
                     marginal_kws=dict(bw_adjust=bandwidth_adjust)
                 )
 
-            grid.ax_joint.set_xlabel(f"Size [{x_unit}]")
-
-            if log_scale:
-                grid.ax_joint.set_xscale('log')
-                grid.ax_joint.set_yscale('log')
-                grid.ax_marg_x.set_xscale('log')
-                grid.ax_marg_y.set_yscale('log')
+            grid.figure.suptitle("Scatterer sampling distribution")
 
-            plt.tight_layout()
+            grid.ax_joint.set_xlabel(f"Size [{x_unit}]")
 
-            if show:
-                plt.show()
+            return grid
 
+        @helper.plot_sns
         def peaks(self, x_detector: str, y_detector: str, signal: str = 'Height', bandwidth_adjust: float = 0.8) -> None:
             """
             Plot the joint KDE distribution of the specified signal between two detectors using seaborn,
@@ -582,11 +606,12 @@ class Acquisition:
                     joint_kws={'bw_adjust': bandwidth_adjust, 'alpha': 0.7}
                 )
 
+            grid.figure.suptitle("Peaks properties")
             grid.ax_joint.scatter(x_data, y_data, color='C1', alpha=0.6)
 
             grid.set_axis_labels(f"{signal} ({x_detector}) [{x_units}]", f"{signal} ({y_detector}) [{y_units}]", fontsize=12)
-            plt.tight_layout()
-            plt.show()
+
+            return grid
 
         def trigger(self, show: bool = True) -> None:
             """Plot detected peaks on signal segments."""
@@ -646,6 +671,47 @@ class Acquisition:
             if show:
                 plt.show()
 
+        @helper.plot_sns
+        def classifier(self, feature: str, x_detector: str, y_detector: str) -> None:
+            """
+            Visualize the classification of peaks using a scatter plot.
+
+            Parameters
+            ----------
+            feature : str
+                The feature to classify (e.g., 'Height', 'Width', 'Area').
+            x_detector : str
+                The detector to use for the x-axis.
+            y_detector : str
+                The detector to use for the y-axis.
+
+            Raises
+            ------
+            ValueError
+                If the 'Label' column is missing in the data, suggesting that
+                the `classify_dataset` method must be called first.
+            """
+            # Check if 'Label' exists in the dataset
+            if 'Label' not in self.acquisition.data.peaks.columns:
+                raise ValueError(
+                    "The 'Label' column is missing. Ensure the dataset has been classified "
+                    "by calling the `classify_dataset` method before using `classifier`."
+                )
+
+            # Set the plotting style
+            with plt.style.context(mps):
+                # Generate a scatter plot using seaborn's jointplot
+                grid = sns.jointplot(
+                    data=self.acquisition.data.peaks,
+                    x=(feature, x_detector),
+                    y=(feature, y_detector),
+                    hue='Label',
+                )
+
+            grid.figure.suptitle('Event classification')
+
+            return grid
+
         def get_detector(self, name: str):
             for detector in self.acquisition.cytometer.detectors:
                 if detector.name == name:

{flowcypy-0.7.0 → flowcypy-0.7.1}/FlowCyPy/classifier.py

@@ -7,7 +7,7 @@ import matplotlib.pyplot as plt
 from MPSPlots.styles import mps
 
 class BaseClassifier:
-    def filter_dataframe(self, features: list, detectors: list = None) -> object:
+    def filter_dataframe(self, dataframe: pd.DataFrame, features: list, detectors: list = None) -> object:
         """
         Filter the DataFrame based on the selected features and detectors.
 
@@ -31,13 +31,13 @@ class BaseClassifier:
         # Determine detectors to use
 
         if detectors is None:
-            detectors = self.dataframe.columns.get_level_values(0).unique().tolist()
+            detectors = dataframe.columns.get_level_values(0).unique().tolist()
 
-        return self.dataframe.loc[detectors, features]
+        return dataframe.loc[:, (features, detectors)]
 
 
 class KmeansClassifier(BaseClassifier):
-    def __init__(self, dataframe: object) -> None:
+    def __init__(self, number_of_cluster: int) -> None:
         """
         Initialize the Classifier.
 
@@ -46,42 +46,44 @@ class KmeansClassifier(BaseClassifier):
         dataframe : DataFrame
             The input dataframe with multi-index columns.
         """
-        self.dataframe = dataframe
-        self.dataframe['Label'] = 0  # Initialize labels as 0
+        self.number_of_cluster = number_of_cluster
+        # self.dataframe = dataframe
+        # self.dataframe['Label'] = 0  # Initialize labels as 0
 
-    def run(self, number_of_cluster: int, features: list = ['Height'], detectors: list = None, random_state: int = 42) -> None:
+    def run(self, dataframe: pd.DataFrame, features: list = ['Height'], detectors: list = None, random_state: int = 42) -> pd.DataFrame:
         """
         Run KMeans clustering on the selected features and detectors.
 
         Parameters
         ----------
-        number_of_cluster : int
-            Number of clusters for KMeans.
+        dataframe : pd.DataFrame
+            The input DataFrame with multi-index (e.g., by 'Detector').
         features : list
-            List of features to use for clustering. Options include 'Heights', 'Widths', 'Areas'.
+            List of features to use for clustering. Options include 'Height', 'Width', 'Area'.
         detectors : list, optional
             List of detectors to use. If None, use all detectors.
         random_state : int, optional
             Random state for KMeans, by default 42.
+
+        Returns
+        -------
+        pd.DataFrame
+            DataFrame with clustering labels added.
         """
         # Filter the DataFrame
-        sub_dataframe = self.filter_dataframe(features=features, detectors=detectors)
-        sub_dataframe = sub_dataframe.unstack('Detector')
+        sub_dataframe = self.filter_dataframe(dataframe=dataframe, features=features, detectors=detectors)
 
         # Ensure data is dequantified if it uses Pint quantities
         if hasattr(sub_dataframe, 'pint'):
             sub_dataframe = sub_dataframe.pint.dequantify().droplevel('unit', axis=1)
 
-        sub_dataframe = sub_dataframe.droplevel(0, axis=1)
-
         # Run KMeans
-        kmeans = KMeans(n_clusters=number_of_cluster, random_state=random_state)
+        kmeans = KMeans(n_clusters=self.number_of_cluster, random_state=random_state)
+        labels = kmeans.fit_predict(sub_dataframe)
 
-        sub_dataframe['Label'] = kmeans.fit_predict(sub_dataframe)
+        dataframe['Label'] = labels
 
-        self.sub_dataframe = sub_dataframe
-
-        return sub_dataframe
+        return labels
 
     def plot(self, x_detector: str, y_detector: str) -> None:
         with plt.style.context(mps):

{flowcypy-0.7.0 → flowcypy-0.7.1}/FlowCyPy/distribution/particle_size_distribution.py

@@ -64,7 +64,7 @@ class RosinRammler(Base):
         # Apply inverse CDF of Rosin-Rammler distribution
         return d * (-np.log(1 - u))**(1 / self.spread)
 
-    def _generate_default_x(self, x_min: float, x_max: float, n_samples: int = 20) -> np.ndarray:
+    def _generate_default_x(self, x_min: float, x_max: float, n_samples: int = 100) -> np.ndarray:
         """
         Generates a default range for x-values based on the characteristic size
         and spread of the Rosin-Rammler distribution.
@@ -93,7 +93,7 @@ class RosinRammler(Base):
         x_max = d * x_max  # Scale x_max by characteristic size
         return np.linspace(x_min, x_max, n_samples) * self._units
 
-    def get_pdf(self, x_min: float = 0.01, x_max: float = 2, n_samples: int = 20) -> Tuple[np.ndarray, np.ndarray]:
+    def get_pdf(self, x_min: float = 0.01, x_max: float = 4, n_samples: int = 100) -> Tuple[np.ndarray, np.ndarray]:
         r"""
         Returns the x-values and the scaled PDF values for the particle size distribution.
 
@@ -119,12 +119,13 @@ class RosinRammler(Base):
         # Generate x-values based on user-defined or default parameters
         x = self._generate_default_x(x_min=x_min, x_max=x_max, n_samples=n_samples)
 
-        common_units = x.units
-        d = self.characteristic_size.to(common_units).magnitude
+        x = x.to(self._units)
+        _x = x.magnitude
+        d = self.characteristic_size.to(self._units).magnitude
         k = self.spread
 
         # Rosin-Rammler PDF formula
-        pdf = (k / d) * (x.magnitude / d)**(k - 1) * np.exp(-(x.magnitude / d)**k)
+        pdf = (k / d) * (_x / d)**(k - 1) * np.exp(-(_x / d)**k)
 
         return x, pdf
 

{flowcypy-0.7.0 → flowcypy-0.7.1}/FlowCyPy/flow_cell.py

@@ -174,7 +174,6 @@ class FlowCell(object):
 
         # Step 2: Calculate the expected number of particles over the entire experiment
         expected_particles = particle_flux * run_time
-        # expected_particles = population.n_events
 
         # Step 3: Generate inter-arrival times (exponentially distributed)
         inter_arrival_times = numpy.random.exponential(

flowcypy-0.7.1/FlowCyPy/helper.py

@@ -0,0 +1,166 @@
+from typing import Callable
+import matplotlib.pyplot as plt
+from MPSPlots.styles import mps
+
+
+
+def plot_sns(function: Callable) -> Callable:
+    """
+    A decorator that helps in plotting by wrapping a plotting function with additional functionality
+    such as handling axes creation, setting the figure style, managing legends, and saving figures.
+
+    Parameters
+    ----------
+    function : Callable
+        The plotting function that is decorated. It should accept `self`, `ax`, and `mode_of_interest`
+        as parameters.
+
+    Returns
+    -------
+    Callable
+        A wrapper function that adds the specified plotting functionalities.
+
+    Notes
+    -----
+    This decorator expects the decorated function to have the following signature:
+    `function(self, ax=None, mode_of_interest='all', **kwargs)`.
+    """
+    def wrapper(self, show: bool = True, equal_limits: bool = False, save_filename: str = None, log_scale: bool = False, **kwargs) -> plt.Figure:
+        """
+        A wrapped version of the plotting function that provides additional functionality for creating
+        and managing plots.
+
+        Parameters
+        ----------
+        self : object
+            The instance of the class calling this method.
+        ax : plt.Axes, optional
+            A matplotlib Axes object to draw the plot on. If None, a new figure and axes are created.
+            Default is None.
+        show : bool, optional
+            Whether to display the plot. If False, the plot will not be shown but can still be saved
+            or returned. Default is True.
+        log_scale : bool, optional
+            If `True`, applies a logarithmic scale to both axes of the joint plot and their marginal distributions. Default is `False`.
+        save_filename : str, optional
+            A file path to save the figure. If None, the figure will not be saved. Default is None.
+        equal_limits : bool, optional
+            Ensures equal axis limits if True (default: False).
+        **kwargs : dict
+            Additional keyword arguments passed to the decorated function.
+
+        Returns
+        -------
+        plt.Figure
+            The matplotlib Figure object created or used for the plot.
+
+        Notes
+        -----
+        - If no `ax` is provided, a new figure and axes are created using the style context `mps`.
+        - The legend is only added if there are labels to display.
+        - If `save_filename` is specified, the figure is saved to the given path.
+        - The plot is shown if `show` is set to True.
+        """
+        grid = function(self, **kwargs)
+
+        grid.figure.tight_layout()
+
+        if equal_limits:
+            min_limit = min(x.min(), y.min())
+            max_limit = max(x.max(), y.max())
+            grid.ax_joint.set_xlim(min_limit, max_limit)
+            grid.ax_joint.set_ylim(min_limit, max_limit)
+
+        if log_scale:
+            grid.ax_joint.set_xscale('log')
+            grid.ax_joint.set_yscale('log')
+            grid.ax_marg_x.set_xscale('log')
+            grid.ax_marg_y.set_yscale('log')
+
+        if save_filename:
+            grid.figure.savefig(save_filename)
+
+        if show:
+            plt.show()
+
+        return grid
+
+    return wrapper
+
+
+def plot_helper(function: Callable) -> Callable:
+    """
+    A decorator that helps in plotting by wrapping a plotting function with additional functionality
+    such as handling axes creation, setting the figure style, managing legends, and saving figures.
+
+    Parameters
+    ----------
+    function : Callable
+        The plotting function that is decorated. It should accept `self`, `ax`, and `mode_of_interest`
+        as parameters.
+
+    Returns
+    -------
+    Callable
+        A wrapper function that adds the specified plotting functionalities.
+
+    Notes
+    -----
+    This decorator expects the decorated function to have the following signature:
+    `function(self, ax=None, mode_of_interest='all', **kwargs)`.
+    """
+    def wrapper(self, ax: plt.Axes = None, show: bool = True, save_filename: str = None, figure_size: tuple = None, **kwargs) -> plt.Figure:
+        """
+        A wrapped version of the plotting function that provides additional functionality for creating
+        and managing plots.
+
+        Parameters
+        ----------
+        self : object
+            The instance of the class calling this method.
+        ax : plt.Axes, optional
+            A matplotlib Axes object to draw the plot on. If None, a new figure and axes are created.
+            Default is None.
+        show : bool, optional
+            Whether to display the plot. If False, the plot will not be shown but can still be saved
+            or returned. Default is True.
+        mode_of_interest : str, optional
+            Specifies the mode of interest for the plot. If 'all', all available modes will be plotted.
+            This parameter is interpreted using the `interpret_mode_of_interest` function. Default is 'all'.
+        save_filename : str, optional
+            A file path to save the figure. If None, the figure will not be saved. Default is None.
+        **kwargs : dict
+            Additional keyword arguments passed to the decorated function.
+
+        Returns
+        -------
+        plt.Figure
+            The matplotlib Figure object created or used for the plot.
+
+        Notes
+        -----
+        - If no `ax` is provided, a new figure and axes are created using the style context `mps`.
+        - The legend is only added if there are labels to display.
+        - If `save_filename` is specified, the figure is saved to the given path.
+        - The plot is shown if `show` is set to True.
+        """
+        if ax is None:
+            with plt.style.context(mps):
+                figure, ax = plt.subplots(1, 1, figsize=figure_size)
+
+        else:
+            figure = ax.get_figure()
+
+        output = function(self, ax=ax, **kwargs)
+
+        _, labels = ax.get_legend_handles_labels()
+
+        if save_filename:
+            figure.savefig(save_filename)
+
+        if show:
+            plt.show()
+
+        return output
+
+    return wrapper

{flowcypy-0.7.0 → flowcypy-0.7.1}/FlowCyPy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: FlowCyPy
-Version: 0.7.0
+Version: 0.7.1
 Summary: A package for flow-cytometry simulations.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License: MIT License

{flowcypy-0.7.0 → flowcypy-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: FlowCyPy
-Version: 0.7.0
+Version: 0.7.1
 Summary: A package for flow-cytometry simulations.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License: MIT License