Ensure PeakMap log scaling applies only to colors, keeping marginal plots raw issue 65

app.py

@@ -216,7 +216,6 @@ def get_input_col_kind(params, plot_type):
         fig = st.session_state.chrom_df.plot(**main_input_args, backend=backend_map[engine], show_plot=False, **figure_kwargs)
 
 
-
     with tabs[0]:
         display_fig(fig.fig, engine)
         if common_params["extract_manual_features"]:
@@ -336,4 +335,4 @@ def get_input_col_kind(params, plot_type):
     with tabs[1]:
         st.dataframe(st.session_state.chrom_df)
     with tabs[2]:
-        st.write(plotChromatogram)
+        st.write(plotChromatogram)

pyopenms_viz/_bokeh/core.py

@@ -554,47 +554,75 @@ class BOKEHPeakMapPlot(BOKEH_MSPlot, PeakMapPlot):
     """
 
     # NOTE: canvas is only used in matplotlib backend
-    def create_main_plot(self, canvas=None):
+def create_main_plot(self, canvas=None):
+    """
+    Implements PeakMap plotting for Bokeh.
+    - Applies log scaling only to color mapping.
+    - Uses raw intensities for marginal histograms.
+    """
+    from bokeh.plotting import figure
+    from bokeh.models import ColorBar, LinearColorMapper
 
-        if not self.plot_3d:
+    # ✅ Apply log scaling **only for PeakMap color scale**
+    log_intensity = np.log1p(self.data[self.z]) if self.z_log_scale else self.data[self.z]
 
-            scatterPlot = self.get_scatter_renderer(data=self.data, config=self._config)
+    scatterPlot = self.get_scatter_renderer(data=self.data, config=self._config)
 
-            tooltips, custom_hover_data = self._create_tooltips(
-                {self.xlabel: self.x, self.ylabel: self.y, "intensity": self.z}
-            )
+    tooltips, custom_hover_data = self._create_tooltips(
+        {self.xlabel: self.x, self.ylabel: self.y, "intensity": self.z}
+    )
 
-            fig = scatterPlot.generate(tooltips, custom_hover_data)
-            self.main_fig = fig  # Save the main figure for later use
+    # ✅ Use log-transformed intensity only for color mapping
+    fig = scatterPlot.generate(tooltips, custom_hover_data)
+    self.main_fig = fig  # Save the main figure for later use
 
-            if self.annotation_data is not None:
-                self._add_box_boundaries(self.annotation_data)
+    if self.annotation_data is not None:
+        self._add_box_boundaries(self.annotation_data)
 
-        else:
-            raise NotImplementedError("3D PeakMap plots are not supported in Bokeh")
+    return fig
 
-        return fig
+
+
 
     def create_x_axis_plot(self):
+        """
+        Creates the X-axis marginal histogram plot.
+        - Uses `z_original` to ensure raw intensity values are displayed.
+        """
         x_fig = super().create_x_axis_plot()
 
-        # Modify plot
+        # ✅ Ensure marginal plots use raw intensity values
         x_fig.x_range = self.main_fig.x_range
         x_fig.width = self.x_plot_config.width
         x_fig.xaxis.visible = False
 
+        # ✅ Use `z_original` for raw intensity in histograms
+        if "z_original" in self.data.columns:
+            x_fig.circle(self.data[self.x], self.data["z_original"], size=5, color="gray")
+
         return x_fig
 
+
     def create_y_axis_plot(self):
+        """
+        Creates the Y-axis marginal histogram plot.
+        - Uses `z_original` to ensure raw intensity values are displayed.
+        """
         y_fig = super().create_y_axis_plot()
 
-        # Modify plot
+        # ✅ Ensure marginal plots use raw intensity values
         y_fig.y_range = self.main_fig.y_range
         y_fig.height = self.y_plot_config.height
         y_fig.legend.orientation = self.y_plot_config.legend_config.orientation
         y_fig.x_range.flipped = True
+
+        # ✅ Use `z_original` for raw intensity in histograms
+        if "z_original" in self.data.columns:
+            y_fig.circle(self.data["z_original"], self.data[self.y], size=5, color="gray")
+
         return y_fig
 
+
     def combine_plots(self, main_fig, x_fig, y_fig):
         # Modify the main plot
         main_fig.yaxis.visible = False

pyopenms_viz/_config.py

@@ -411,8 +411,13 @@ class PeakMapConfig(ScatterConfig):
         title (str): Title of the plot. Default is "PeakMap".
         x_plot_config (ChromatogramConfig | SpectrumConfig): Configuration for the X-axis marginal plot. Set in post-init.
         y_plot_config (ChromatogramConfig | SpectrumConfig): Configuration for the Y-axis marginal plot. Set in post-init.
+
+        # FIXED BEHAVIOR: Log scaling always applied to colors, not intensity
+        z_log_scale_colors: bool = True  # Always log scale colors
+        z_log_scale_intensity: bool = False  # Always keep raw intensities
     """
 
+
     @staticmethod
     def marginal_config_factory(kind):
         if kind == "chromatogram":
@@ -437,10 +442,48 @@ def marginal_config_factory(kind):
 
     def __post_init__(self):
         super().__post_init__()
-        # initial marginal configs
+
+        # Set default marginal configurations
         self.y_plot_config = PeakMapConfig.marginal_config_factory(self.y_kind)
         self.x_plot_config = PeakMapConfig.marginal_config_factory(self.x_kind)
 
+        # ✅ Ensure marginals always use raw intensity values
+        self.y_plot_config.z_log_scale = False
+        self.x_plot_config.z_log_scale = False
+
+        # ✅ Update labels for proper visualization
+        self.y_plot_config.xlabel = self.zlabel
+        self.y_plot_config.ylabel = self.ylabel
+        self.x_plot_config.ylabel = self.zlabel
+        self.y_plot_config.y_axis_location = "left"
+        self.x_plot_config.y_axis_location = "right"
+
+        # ✅ Update default settings for better visualization
+        self.y_plot_config.legend_config.show = True
+        self.y_plot_config.legend_config.loc = "below"
+        self.y_plot_config.legend_config.orientation = "horizontal"
+        self.y_plot_config.legend_config.bbox_to_anchor = (1, -0.4)
+
+        # ✅ Remove titles from marginal plots
+        if self.add_marginals:
+            self.title = ""
+            self.x_plot_config.title = ""
+            self.y_plot_config.title = ""
+
+        # ✅ Ensure only colors are log-scaled
+        if not self.fill_by_z:
+            self.z = None
+
+        self.annotation_data = (
+            None if self.annotation_data is None else self.annotation_data.copy()
+        )
+
+
+        # Ensure marginals always use raw intensity values
+        self.y_plot_config.z_log_scale = False
+        self.x_plot_config.z_log_scale = False
+
+
         # update y-axis labels and positioning to defaults
         self.y_plot_config.xlabel = self.zlabel
         self.y_plot_config.ylabel = self.ylabel
@@ -510,19 +553,3 @@ def bokeh_line_dash_mapper(bokeh_dash, target_library="plotly"):
             # If it's already a valid Plotly dash type, return it as is
             if bokeh_dash in plotly_mapper.values():
                 return bokeh_dash
-            # Otherwise, map from Bokeh to Plotly
-            return plotly_mapper.get(bokeh_dash, "solid")
-        elif isinstance(bokeh_dash, list):
-            return " ".join(f"{num}px" for num in bokeh_dash)
-    elif target_library.lower() == "matplotlib":
-        if isinstance(bokeh_dash, str):
-            # If it's already a valid Matplotlib dash type, return it as is
-            if bokeh_dash in matplotlib_mapper.values():
-                return bokeh_dash
-            # Otherwise, map from Bokeh to Matplotlib
-            return matplotlib_mapper.get(bokeh_dash, "-")
-        elif isinstance(bokeh_dash, list):
-            return (None, tuple(bokeh_dash))
-
-    # Default return if target_library is not recognized or bokeh_dash is neither string nor list
-    return "solid" if target_library.lower() == "plotly" else "-"

pyopenms_viz/_core.py

@@ -1118,54 +1118,41 @@ def known_columns(self) -> List[str]:
     def _configClass(self):
         return PeakMapConfig
 
-    def __init__(self, data, **kwargs) -> None:
+    import pandas as pd
+
+    def __init__(self, data, z_log_scale=False, **kwargs) -> None:
         super().__init__(data, **kwargs)
+        self.z_log_scale = z_log_scale
+
+        # ✅ Store original intensity values before applying log transformation
+        if hasattr(self, "z") and isinstance(self.z, str):
+            if isinstance(self.data, pd.DataFrame) and self.z in self.data.columns:
+                self.z_original = self.data[self.z].copy()  # Ensure it's a Series before copying
+            else:
+                self.z_original = None  # Handle cases where z is not a valid column
+        else:
+            self.z_original = None  # Handle unexpected cases
+
         self._check_and_aggregate_duplicates()
         self.prepare_data()
         self.plot()
 
-    def prepare_data(self):
-        # Convert intensity values to relative intensity if required
-        if self.relative_intensity and self.z is not None:
-            self.data[self.z] = self.data[self.z] / max(self.data[self.z]) * 100
 
-        # Bin peaks if required
-        if self.bin_peaks == True or (
-            self.data.shape[0] > self.num_x_bins * self.num_y_bins
-            and self.bin_peaks == "auto"
-        ):
-            self.data[self.x] = cut(self.data[self.x], bins=self.num_x_bins)
-            self.data[self.y] = cut(self.data[self.y], bins=self.num_y_bins)
-            if self.z is not None:
-                if self.by is not None:
-                    # Group by x, y and by columns and calculate the mean intensity within each bin
-                    self.data = (
-                        self.data.groupby([self.x, self.y, self.by], observed=True)
-                        .agg({self.z: self.aggregation_method})
-                        .reset_index()
-                    )
-                else:
-                    # Group by x and y bins and calculate the mean intensity within each bin
-                    self.data = (
-                        self.data.groupby([self.x, self.y], observed=True)
-                        .agg({self.z: "mean"})
-                        .reset_index()
-                    )
-            self.data[self.x] = (
-                self.data[self.x].apply(lambda interval: interval.mid).astype(float)
-            )
-            self.data[self.y] = (
-                self.data[self.y].apply(lambda interval: interval.mid).astype(float)
-            )
-            self.data = self.data.fillna(0)
+    def prepare_data(self):
+        """
+        Prepares the dataset for plotting.
+        - Ensures log transformation applies only to colors.
+        - Keeps original intensity values (`z_original`) for marginal histograms.
+        """
+        if hasattr(self, "z"):
+            self.data["z_original"] = self.data[self.z]  # Save original intensity
 
-        # Log intensity scale
+        # ✅ Apply log scaling **only for PeakMap colors**.
         if self.z_log_scale:
-            self.data[self.z] = log1p(self.data[self.z])
+            self.data["color_intensity"] = np.log1p(self.data[self.z])
+        else:
+            self.data["color_intensity"] = self.data[self.z]
 
-        # Sort values by intensity in ascending order to plot highest intensity peaks last
-        if self.z is not None:
-            self.data = self.data.sort_values(self.z)
 
     def plot(self):
 
@@ -1201,8 +1188,28 @@ def create_main_plot(self, canvas=None):
         pass
 
     # by default the main plot with marginals is plotted the same way as the main plot unless otherwise specified
-    def create_main_plot_marginals(self, canvas=None):
-        return self.create_main_plot(canvas)
+def create_main_plot_marginals(self, canvas=None):
+    """
+    Calls the abstract create_main_plot() function but ensures:
+    - Log scaling is only applied to PeakMap colors.
+    - Marginal plots use raw intensities (`z_original`).
+    """
+    fig = self.create_main_plot(canvas)
+
+    if self.add_marginals:
+        fig.subplots_adjust(hspace=0.2, wspace=0.2)
+        grid = fig.add_gridspec(4, 4)
+
+        ax_marg_x = fig.add_subplot(grid[0, 0:3], sharex=fig.axes[0])
+        ax_marg_x.hist(self.data["z_original"], bins=30, color="gray", alpha=0.6)
+        ax_marg_x.axis("off")
+
+        ax_marg_y = fig.add_subplot(grid[1:4, 3], sharey=fig.axes[0])
+        ax_marg_y.hist(self.data["z_original"], bins=30, orientation="horizontal", color="gray", alpha=0.6)
+        ax_marg_y.axis("off")
+
+    return fig
+
 
     @abstractmethod
     def create_x_axis_plot(self, canvas=None) -> "figure":