Simplifying MultiPlot Interface #83

Author: Nishantrde

docs/gallery_scripts_template/plot_spyogenes_subplots_ms_matplotlib.py

@@ -1,21 +1,22 @@
 """
-Plot Spyogenes subplots ms_matplotlib
-=======================================
+Plot Spyogenes subplots ms_matplotlib using tile_by
+====================================================
 
-Here we show how we can plot multiple chromatograms across runs together
+This script downloads the Spyogenes data and uses the new tile_by parameter to create subplots automatically.
 """
 
 import pandas as pd
 import requests
 import zipfile
-import numpy as np
 import matplotlib.pyplot as plt
+import sys
 
+# Append the local module path
+
+# Set the plotting backend
 pd.options.plotting.backend = "ms_matplotlib"
 
 ###### Load Data #######
-
-# URL of the zip file
 url = "https://github.com/OpenMS/pyopenms_viz/releases/download/v0.1.3/spyogenes.zip"
 zip_filename = "spyogenes.zip"
 
@@ -24,73 +25,47 @@
     print(f"Downloading {zip_filename}...")
     response = requests.get(url)
     response.raise_for_status()  # Check for any HTTP errors
-
-    # Save the zip file to the current directory
     with open(zip_filename, "wb") as out:
         out.write(response.content)
     print(f"Downloaded {zip_filename} successfully.")
-except requests.RequestException as e:
+except Exception as e:
     print(f"Error downloading zip file: {e}")
-except IOError as e:
-    print(f"Error writing zip file: {e}")
 
-# Unzipping the file
+# Unzip the file
 try:
     with zipfile.ZipFile(zip_filename, "r") as zip_ref:
-        # Extract all files to the current directory
         zip_ref.extractall()
         print("Unzipped files successfully.")
-except zipfile.BadZipFile as e:
+except Exception as e:
     print(f"Error unzipping file: {e}")
 
-annotation_bounds = pd.read_csv(
-    "spyogenes/AADGQTVSGGSILYR3_manual_annotations.tsv", sep="\t"
-)  # contain annotations across all runs
-chrom_df = pd.read_csv(
-    "spyogenes/chroms_AADGQTVSGGSILYR3.tsv", sep="\t"
-)  # contains chromatogram for precursor across all runs
-
-##### Set Plotting Variables #####
-pd.options.plotting.backend = "ms_matplotlib"
-RUN_NAMES = [
-    "Run #0 Spyogenes 0% human plasma",
-    "Run #1 Spyogenes 0% human plasma",
-    "Run #2 Spyogenes 0% human plasma",
-    "Run #3 Spyogenes 10% human plasma",
-    "Run #4 Spyogenes 10% human plasma",
-    "Run #5 Spyogenes 10% human plasma",
-]
-
-fig, axs = plt.subplots(len(np.unique(chrom_df["run"])), 1, figsize=(10, 15))
-
-# plt.close ### required for running in jupyter notebook setting
-
-# For each run fill in the axs object with the corresponding chromatogram
-plot_list = []
-for i, run in enumerate(RUN_NAMES):
-    run_df = chrom_df[chrom_df["run_name"] == run]
-    current_bounds = annotation_bounds[annotation_bounds["run"] == run]
+# Load the data
+annotation_bounds = pd.read_csv("spyogenes/AADGQTVSGGSILYR3_manual_annotations.tsv", sep="\t")
+chrom_df = pd.read_csv("spyogenes/chroms_AADGQTVSGGSILYR3.tsv", sep="\t")
 
-    run_df.plot(
-        kind="chromatogram",
-        x="rt",
-        y="int",
-        grid=False,
-        by="ion_annotation",
-        title=run_df.iloc[0]["run_name"],
-        title_font_size=16,
-        xaxis_label_font_size=14,
-        yaxis_label_font_size=14,
-        xaxis_tick_font_size=12,
-        yaxis_tick_font_size=12,
-        canvas=axs[i],
-        relative_intensity=True,
-        annotation_data=current_bounds,
-        xlabel="Retention Time (sec)",
-        ylabel="Relative\nIntensity",
-        annotation_legend_config=dict(show=False),
-        legend_config={"show": False},
-    )
+##### Plotting Using Tile By #####
+# Instead of pre-creating subplots and looping over RUN_NAMES,
+# we call the plot method once and provide a tile_by parameter.
+fig = chrom_df.plot(
+    kind="chromatogram",
+    x="rt",
+    y="int",
+    tile_by="run_name",         # Automatically groups data by run_name and creates subplots
+    tile_columns=1,             # Layout: 1 column (one subplot per row)
+    grid=False,
+    by="ion_annotation",
+    title_font_size=16,
+    xaxis_label_font_size=14,
+    yaxis_label_font_size=14,
+    xaxis_tick_font_size=12,
+    yaxis_tick_font_size=12,
+    relative_intensity=True,
+    annotation_data=annotation_bounds,
+    xlabel="Retention Time (sec)",
+    ylabel="Relative\nIntensity",
+    annotation_legend_config={"show": False},
+    legend_config={"show": False},
+)
 
 fig.tight_layout()
 fig

pyopenms_viz/_config.py

@@ -205,6 +205,10 @@ def default_legend_factory():
     legend_config: LegendConfig | dict = field(default_factory=default_legend_factory)
     opacity: float = 1.0
 
+    tile_by: str | None = None  # Name of the column to tile the plot by.
+    tile_columns: int = 1       # How many columns in the subplot grid.
+    tile_figsize: Tuple[int, int] = (10, 15)  # Overall figure size for tiled plots.
+
     def __post_init__(self):
         # if legend_config is a dictionary, update it to LegendConfig object
         if isinstance(self.legend_config, dict):

pyopenms_viz/_core.py

@@ -14,6 +14,10 @@
 from pandas.util._decorators import Appender
 import re
 
+import matplotlib.pyplot as plt
+from math import ceil
+import numpy as np
+
 from numpy import ceil, log1p, log2, nan, mean, repeat, concatenate
 from ._config import (
     LegendConfig,
@@ -539,7 +543,6 @@ def _create_tooltips(self, entries: dict, index: bool = True):
 
 
 class ChromatogramPlot(BaseMSPlot, ABC):
-
     _config: ChromatogramConfig = None
 
     @property
@@ -560,9 +563,7 @@ def load_config(self, **kwargs):
 
     def __init__(self, data, config: ChromatogramConfig = None, **kwargs) -> None:
         super().__init__(data, config, **kwargs)
-
         self.label_suffix = self.x  # set label suffix for bounding box
-
         self._check_and_aggregate_duplicates()
 
         # sort data by x so in order
@@ -579,45 +580,89 @@ def __init__(self, data, config: ChromatogramConfig = None, **kwargs) -> None:
 
     def plot(self):
         """
-        Create the plot
+        Create the plot. If the configuration includes a valid tile_by column,
+        the data will be split into subplots based on unique values in that column.
         """
-        tooltip_entries = {"retention time": self.x, "intensity": self.y}
-        if "Annotation" in self.data.columns:
-            tooltip_entries["annotation"] = "Annotation"
-        if "product_mz" in self.data.columns:
-            tooltip_entries["product m/z"] = "product_mz"
-        tooltips, custom_hover_data = self._create_tooltips(
-            tooltip_entries, index=False
-        )
-
-        linePlot = self.get_line_renderer(data=self.data, config=self._config)
-
-        self.canvas = linePlot.generate(tooltips, custom_hover_data)
-        self._modify_y_range((0, self.data[self.y].max()), (0, 0.1))
-
-        if self._interactive:
-            self.manual_boundary_renderer = self._add_bounding_vertical_drawer()
-
-        if self.annotation_data is not None:
-            self._add_peak_boundaries(self.annotation_data)
+        # Check for tiling functionality
+        tile_by = self._config.tile_by if hasattr(self._config, "tile_by") else None
+
+        if tile_by and tile_by in self.data.columns:
+            # Group the data by the tile_by column
+            grouped = self.data.groupby(tile_by)
+            num_groups = len(grouped)
+            
+            # Get tiling options from config
+            tile_columns = self._config.tile_columns if hasattr(self._config, "tile_columns") else 1
+            tile_rows = int(ceil(num_groups / tile_columns))
+            figsize = self._config.tile_figsize if hasattr(self._config, "tile_figsize") else (10, 15)
+
+            # Create a figure with a grid of subplots
+            fig, axes = plt.subplots(tile_rows, tile_columns, figsize=figsize, squeeze=False)
+            axes = axes.flatten()  # Easier indexing for a 1D list
+
+            # Loop through each group and plot on its own axis
+            for i, (group_val, group_df) in enumerate(grouped):
+                ax = axes[i]
+                
+                # Prepare tooltips for this group (if applicable)
+                tooltip_entries = {"retention time": self.x, "intensity": self.y}
+                if "Annotation" in group_df.columns:
+                    tooltip_entries["annotation"] = "Annotation"
+                if "product_mz" in group_df.columns:
+                    tooltip_entries["product m/z"] = "product_mz"
+                tooltips, custom_hover_data = self._create_tooltips(tooltip_entries, index=False)
+                
+                # Get a line renderer instance and generate the plot for the current group,
+                # passing the current axis (canvas) using a parameter like `canvas` or `ax`.
+                linePlot = self.get_line_renderer(data=group_df, config=self._config)
+                # Here, we assume that your renderer can accept the axis to plot on:
+                linePlot.canvas = ax
+                linePlot.generate(tooltips, custom_hover_data)
+
+                
+                # Set the title of this subplot based on the group value
+                ax.set_title(f"{tile_by}: {group_val}", fontsize=14)
+                # Optionally adjust the y-axis limits for the subplot
+                ax.set_ylim(0, group_df[self.y].max())
+                
+                # If you have annotations that should be split, filter them too
+                if self.annotation_data is not None and tile_by in self.annotation_data.columns:
+                    group_annotations = self.annotation_data[self.annotation_data[tile_by] == group_val]
+                    self._add_peak_boundaries(group_annotations)
+            
+            # Remove any extra axes if the grid size is larger than the number of groups
+            for j in range(i + 1, len(axes)):
+                fig.delaxes(axes[j])
+            
+            fig.tight_layout()
+            self.canvas = fig
+        else:
+            # Fallback: plot on a single canvas if no valid tiling is specified
+            tooltip_entries = {"retention time": self.x, "intensity": self.y}
+            if "Annotation" in self.data.columns:
+                tooltip_entries["annotation"] = "Annotation"
+            if "product_mz" in self.data.columns:
+                tooltip_entries["product m/z"] = "product_mz"
+            tooltips, custom_hover_data = self._create_tooltips(tooltip_entries, index=False)
+            linePlot = self.get_line_renderer(data=self.data, config=self._config)
+            self.canvas = linePlot.generate(tooltips, custom_hover_data)
+            self._modify_y_range((0, self.data[self.y].max()), (0, 0.1))
+            
+            if self._interactive:
+                self.manual_boundary_renderer = self._add_bounding_vertical_drawer()
+            if self.annotation_data is not None:
+                self._add_peak_boundaries(self.annotation_data)
 
     def _add_peak_boundaries(self, annotation_data):
         """
         Prepare data for adding peak boundaries to the plot.
-        This is not a complete method should be overridden by subclasses.
-
-        Args:
-            annotation_data (DataFrame): The feature data containing the peak boundaries.
-
-        Returns:
-            None
+        (Override this method if needed.)
         """
-        # compute the apex intensity
         self.compute_apex_intensity(annotation_data)
 
     def compute_apex_intensity(self, annotation_data):
         """
-        Compute the apex intensity of the peak group based on the peak boundaries
+        Compute the apex intensity of the peak group based on the peak boundaries.
         """
         for idx, feature in annotation_data.iterrows():
             annotation_data.loc[idx, "apexIntensity"] = self.data.loc[