scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/ax/_plot/_plot_scatter_hist.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 18:14:56 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_plot/_plot_scatter_hist.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_plot/_plot_scatter_hist.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+
+
+def plot_scatter_hist(
+    ax,
+    x,
+    y,
+    fig=None,
+    hist_bins: int = 20,
+    scatter_alpha: float = 0.6,
+    scatter_size: float = 20,
+    scatter_color: str = "blue",
+    hist_color_x: str = "blue",
+    hist_color_y: str = "red",
+    hist_alpha: float = 0.5,
+    scatter_ratio: float = 0.8,
+    **kwargs,
+):
+    """
+    Plot a scatter plot with histograms on the x and y axes.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        The main scatter plot axes
+    x : array-like
+        x data for scatter plot and histogram
+    y : array-like
+        y data for scatter plot and histogram
+    fig : matplotlib.figure.Figure, optional
+        Figure to create axes in. If None, uses ax.figure
+    hist_bins : int, optional
+        Number of bins for histograms, default 20
+    scatter_alpha : float, optional
+        Alpha value for scatter points, default 0.6
+    scatter_size : float, optional
+        Size of scatter points, default 20
+    scatter_color : str, optional
+        Color of scatter points, default "blue"
+    hist_color_x : str, optional
+        Color of x-axis histogram, default "blue"
+    hist_color_y : str, optional
+        Color of y-axis histogram, default "red"
+    hist_alpha : float, optional
+        Alpha value for histograms, default 0.5
+    scatter_ratio : float, optional
+        Ratio of main plot to histograms, default 0.8
+    **kwargs
+        Additional keyword arguments passed to scatter and hist functions
+
+    Returns
+    -------
+    tuple
+        (ax, ax_histx, ax_histy, hist_data) - All axes objects and histogram data
+        hist_data is a dictionary containing histogram counts and bin edges
+    """
+    # Get the current figure if not provided
+    if fig is None:
+        fig = ax.figure
+
+    # Calculate the positions based on scatter_ratio
+    margin = 0.1 * (1 - scatter_ratio)
+    hist_size = 0.2 * scatter_ratio
+
+    # Create the histogram axes
+    ax_histx = fig.add_axes(
+        [
+            ax.get_position().x0,
+            ax.get_position().y1 + margin,
+            ax.get_position().width * scatter_ratio,
+            hist_size,
+        ]
+    )
+    ax_histy = fig.add_axes(
+        [
+            ax.get_position().x1 + margin,
+            ax.get_position().y0,
+            hist_size,
+            ax.get_position().height * scatter_ratio,
+        ]
+    )
+
+    # No labels for histograms
+    ax_histx.tick_params(axis="x", labelbottom=False)
+    ax_histy.tick_params(axis="y", labelleft=False)
+
+    # The scatter plot
+    ax.scatter(
+        x,
+        y,
+        alpha=scatter_alpha,
+        s=scatter_size,
+        color=scatter_color,
+        **kwargs,
+    )
+
+    # Calculate histogram data
+    hist_x, bin_edges_x = np.histogram(x, bins=hist_bins)
+    hist_y, bin_edges_y = np.histogram(y, bins=hist_bins)
+
+    # Plot histograms
+    ax_histx.hist(x, bins=hist_bins, color=hist_color_x, alpha=hist_alpha)
+    ax_histy.hist(
+        y,
+        bins=hist_bins,
+        orientation="horizontal",
+        color=hist_color_y,
+        alpha=hist_alpha,
+    )
+
+    # Create return data structure
+    hist_data = {
+        "hist_x": hist_x,
+        "hist_y": hist_y,
+        "bin_edges_x": bin_edges_x,
+        "bin_edges_y": bin_edges_y,
+    }
+
+    return ax, ax_histx, ax_histy, hist_data
+
+
+# EOF

scitex/plt/ax/_plot/_plot_shaded_line.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 23:28:32 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_plot/_plot_shaded_line.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_plot/_plot_shaded_line.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from typing import List, Optional, Tuple, Union
+
+import matplotlib
+import numpy as np
+import pandas as pd
+from matplotlib.axes._axes import Axes
+
+from ....types import ColorLike
+from ....plt.utils import assert_valid_axis
+
+
+def _plot_single_shaded_line(
+    axis: Union[Axes, 'AxisWrapper'],
+    xx: np.ndarray,
+    y_lower: np.ndarray,
+    y_middle: np.ndarray,
+    y_upper: np.ndarray,
+    color: Optional[ColorLike] = None,
+    alpha: float = 0.3,
+    **kwargs
+) -> Tuple[Union[Axes, 'AxisWrapper'], pd.DataFrame]:
+    """Plot a line with shaded area between y_lower and y_upper bounds."""
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+    assert (
+        len(xx) == len(y_middle) == len(y_lower) == len(y_upper)
+    ), "All arrays must have the same length"
+
+    label = kwargs.get("label")
+    if kwargs.get("label"):
+        del kwargs["label"]
+    axis.plot(xx, y_middle, color=color, alpha=alpha, label=label, **kwargs)
+    kwargs["linewidth"] = 0
+    kwargs["edgecolor"] = "none"  # Remove edge line
+    axis.fill_between(xx, y_lower, y_upper, alpha=alpha, color=color, **kwargs)
+
+    return axis, pd.DataFrame(
+        {"x": xx, "y_lower": y_lower, "y_middle": y_middle, "y_upper": y_upper}
+    )
+
+
+def _plot_shaded_line(
+    axis: Union[Axes, 'AxisWrapper'],
+    xs: List[np.ndarray],
+    ys_lower: List[np.ndarray],
+    ys_middle: List[np.ndarray],
+    ys_upper: List[np.ndarray],
+    color: Optional[Union[List[ColorLike], ColorLike]] = None,
+    **kwargs
+) -> Tuple[Union[Axes, 'AxisWrapper'], List[pd.DataFrame]]:
+    """Plot multiple lines with shaded areas between ys_lower and ys_upper bounds."""
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+    assert (
+        len(xs) == len(ys_lower) == len(ys_middle) == len(ys_upper)
+    ), "All input lists must have the same length"
+
+    results = []
+    colors = color
+    color_list = colors
+
+    if colors is not None:
+        if not isinstance(colors, list):
+            color_list = [colors] * len(xs)
+        else:
+            assert len(colors) == len(xs), "Number of colors must match number of lines"
+            color_list = colors
+
+        for idx, (xx, y_lower, y_middle, y_upper) in enumerate(
+            zip(xs, ys_lower, ys_middle, ys_upper)
+        ):
+            this_kwargs = kwargs.copy()
+            this_kwargs["color"] = color_list[idx]
+            _, result_df = _plot_single_shaded_line(
+                axis, xx, y_lower, y_middle, y_upper, **this_kwargs
+            )
+            results.append(result_df)
+    else:
+        for xx, y_lower, y_middle, y_upper in zip(xs, ys_lower, ys_middle, ys_upper):
+            _, result_df = _plot_single_shaded_line(
+                axis, xx, y_lower, y_middle, y_upper, **kwargs
+            )
+            results.append(result_df)
+
+    return axis, results
+
+
+def plot_shaded_line(
+    axis: Union[Axes, 'AxisWrapper'],
+    xs: Union[np.ndarray, List[np.ndarray]],
+    ys_lower: Union[np.ndarray, List[np.ndarray]],
+    ys_middle: Union[np.ndarray, List[np.ndarray]],
+    ys_upper: Union[np.ndarray, List[np.ndarray]],
+    color: Optional[Union[ColorLike, List[ColorLike]]] = None,
+    **kwargs
+) -> Tuple[Union[Axes, 'AxisWrapper'], Union[pd.DataFrame, List[pd.DataFrame]]]:
+    """
+    Plot a line with shaded area, automatically switching between single and multiple line versions.
+
+    Args:
+        axis: matplotlib axis or scitex axis wrapper
+        xs: x values (single array or list of arrays)
+        ys_lower: lower bound y values (single array or list of arrays)
+        ys_middle: middle y values (single array or list of arrays)
+        ys_upper: upper bound y values (single array or list of arrays)
+        color: color or list of colors for the lines
+        **kwargs: additional plotting parameters
+
+    Returns:
+        tuple: (axis, DataFrame or list of DataFrames with plot data)
+    """
+    is_single = not (
+        isinstance(xs, list)
+        and isinstance(ys_lower, list)
+        and isinstance(ys_middle, list)
+        and isinstance(ys_upper, list)
+    )
+
+    if is_single:
+        assert (
+            len(xs) == len(ys_lower) == len(ys_middle) == len(ys_upper)
+        ), "All arrays must have the same length for single line plot"
+
+        return _plot_single_shaded_line(
+            axis, xs, ys_lower, ys_middle, ys_upper, color=color, **kwargs
+        )
+    else:
+        return _plot_shaded_line(
+            axis, xs, ys_lower, ys_middle, ys_upper, color=color, **kwargs
+        )
+
+
+# EOF

scitex/plt/ax/_plot/_plot_statistical_shaded_line.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-30 20:50:45 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_plot_statistical_shaded_line.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_plot_statistical_shaded_line.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib
+import numpy as np
+import pandas as pd
+from ....plt.utils import assert_valid_axis
+
+from ._plot_shaded_line import plot_shaded_line as scitex_plt_plot_shaded_line
+
+
+def plot_line(axis, data, xx=None, **kwargs):
+    """
+    Plot a simple line.
+    
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis to plot on
+    data : array-like
+        Data to plot
+    xx : array-like, optional
+        X coordinates for the data. If None, will use np.arange(len(data))
+    **kwargs
+        Additional keyword arguments passed to axis.plot()
+        
+    Returns
+    -------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis with the plot
+    df : pandas.DataFrame
+        DataFrame with x and y values
+    """
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+    data = np.asarray(data)
+    assert data.ndim <= 2, f"Data must be 1D or 2D, got {data.ndim}D"
+    if xx is None:
+        xx = np.arange(len(data))
+    else:
+        xx = np.asarray(xx)
+    assert len(xx) == len(
+        data
+    ), f"xx length ({len(xx)}) must match data length ({len(data)})"
+    axis.plot(xx, data, **kwargs)
+    return axis, pd.DataFrame({"x": xx, "y": data})
+
+
+def plot_mean_std(axis, data, xx=None, sd=1, **kwargs):
+    """
+    Plot mean line with standard deviation shading.
+    
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis to plot on
+    data : array-like
+        Data to plot, can be 1D or 2D. If 2D, mean and std are calculated across the first dimension
+    xx : array-like, optional
+        X coordinates for the data. If None, will use np.arange(len(data))
+    sd : float, optional
+        Number of standard deviations for the shaded region. Default is 1
+    **kwargs
+        Additional keyword arguments passed to plot_shaded_line()
+        
+    Returns
+    -------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis with the plot
+    """
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+    assert isinstance(sd, (int, float)), f"sd must be a number, got {type(sd)}"
+    assert sd >= 0, f"sd must be non-negative, got {sd}"
+    data = np.asarray(data)
+    assert data.ndim <= 2, f"Data must be 1D or 2D, got {data.ndim}D"
+    if xx is None:
+        xx = np.arange(data.shape[1] if data.ndim > 1 else len(data))
+    else:
+        xx = np.asarray(xx)
+    expected_len = data.shape[1] if data.ndim > 1 else len(data)
+    assert (
+        len(xx) == expected_len
+    ), f"xx length ({len(xx)}) must match data length ({expected_len})"
+
+    if data.ndim == 1:
+        central = data
+        error = np.zeros_like(central)
+    else:
+        central = np.nanmean(data, axis=0)
+        error = np.nanstd(data, axis=0) * sd
+
+    y_lower = central - error
+    y_upper = central + error
+    n_samples = data.shape[0] if data.ndim > 1 else 1
+
+    if "label" in kwargs and kwargs["label"]:
+        kwargs["label"] = f"{kwargs['label']} (n={n_samples})"
+
+    return scitex_plt_plot_shaded_line(axis, xx, y_lower, central, y_upper, **kwargs)
+
+
+def plot_mean_ci(axis, data, xx=None, perc=95, **kwargs):
+    """
+    Plot mean line with confidence interval shading.
+    
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis to plot on
+    data : array-like
+        Data to plot, can be 1D or 2D. If 2D, mean and percentiles are calculated across the first dimension
+    xx : array-like, optional
+        X coordinates for the data. If None, will use np.arange(len(data))
+    perc : float, optional
+        Confidence interval percentage (0-100). Default is 95
+    **kwargs
+        Additional keyword arguments passed to plot_shaded_line()
+        
+    Returns
+    -------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis with the plot
+    """
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+    assert isinstance(
+        perc, (int, float)
+    ), f"perc must be a number, got {type(perc)}"
+    assert 0 <= perc <= 100, f"perc must be between 0 and 100, got {perc}"
+    data = np.asarray(data)
+    assert data.ndim <= 2, f"Data must be 1D or 2D, got {data.ndim}D"
+
+    if xx is None:
+        xx = np.arange(data.shape[1] if data.ndim > 1 else len(data))
+    else:
+        xx = np.asarray(xx)
+
+    expected_len = data.shape[1] if data.ndim > 1 else len(data)
+    assert (
+        len(xx) == expected_len
+    ), f"xx length ({len(xx)}) must match data length ({expected_len})"
+
+    if data.ndim == 1:
+        central = data
+        y_lower = central
+        y_upper = central
+    else:
+        central = np.nanmean(data, axis=0)
+        # Calculate CI bounds
+        alpha = 1 - perc / 100
+        y_lower_perc = alpha / 2 * 100
+        y_upper_perc = (1 - alpha / 2) * 100
+        y_lower = np.nanpercentile(data, y_lower_perc, axis=0)
+        y_upper = np.nanpercentile(data, y_upper_perc, axis=0)
+
+    n_samples = data.shape[0] if data.ndim > 1 else 1
+
+    if "label" in kwargs and kwargs["label"]:
+        kwargs["label"] = f"{kwargs['label']} (n={n_samples}, CI={perc}%)"
+
+    return scitex_plt_plot_shaded_line(axis, xx, y_lower, central, y_upper, **kwargs)
+
+
+def plot_median_iqr(axis, data, xx=None, **kwargs):
+    """
+    Plot median line with interquartile range shading.
+    
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis to plot on
+    data : array-like
+        Data to plot, can be 1D or 2D. If 2D, median and IQR are calculated across the first dimension
+    xx : array-like, optional
+        X coordinates for the data. If None, will use np.arange(len(data))
+    **kwargs
+        Additional keyword arguments passed to plot_shaded_line()
+        
+    Returns
+    -------
+    axis : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
+        The axis with the plot
+    """
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+    data = np.asarray(data)
+    assert data.ndim <= 2, f"Data must be 1D or 2D, got {data.ndim}D"
+
+    if xx is None:
+        xx = np.arange(data.shape[1] if data.ndim > 1 else len(data))
+    else:
+        xx = np.asarray(xx)
+
+    expected_len = data.shape[1] if data.ndim > 1 else len(data)
+    assert (
+        len(xx) == expected_len
+    ), f"xx length ({len(xx)}) must match data length ({expected_len})"
+
+    if data.ndim == 1:
+        central = data
+        y_lower = central
+        y_upper = central
+    else:
+        central = np.nanmedian(data, axis=0)
+        y_lower = np.nanpercentile(data, 25, axis=0)
+        y_upper = np.nanpercentile(data, 75, axis=0)
+
+    n_samples = data.shape[0] if data.ndim > 1 else 1
+
+    if "label" in kwargs and kwargs["label"]:
+        kwargs["label"] = f"{kwargs['label']} (n={n_samples}, IQR)"
+
+    return scitex_plt_plot_shaded_line(axis, xx, y_lower, central, y_upper, **kwargs)
+
+
+# EOF