scitex 2.3.0__py3-none-any.whl → 2.4.1__py3-none-any.whl

scitex/plt/ax/_plot/_plot_heatmap.py

@@ -1,277 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-05-02 22:21:41 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_plot/_plot_heatmap.py
-# ----------------------------------------
-import os
-
-__FILE__ = "./src/scitex/plt/ax/_plot/_plot_heatmap.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-
-
-def plot_heatmap(
-    ax,
-    data,
-    x_labels=None,
-    y_labels=None,
-    cmap="viridis",
-    cbar_label="ColorBar Label",
-    annot_format="{x:.1f}",
-    show_annot=True,
-    annot_color_lighter="black",
-    annot_color_darker="white",
-    **kwargs,
-):
-    """
-    Plot a heatmap on the given axes.
-
-    Parameters
-    ----------
-    ax : matplotlib.axes.Axes
-        The axes to plot on
-    data : array-like
-        The 2D data to display as heatmap
-    x_labels : list, optional
-        Labels for the x-axis
-    y_labels : list, optional
-        Labels for the y-axis
-    cmap : str or matplotlib colormap, optional
-        Colormap to use, default "viridis"
-    cbar_label : str, optional
-        Label for the colorbar, default "ColorBar Label"
-    show_annot : bool, optional
-        Whether to annotate the heatmap with values, default True
-    annot_format : str, optional
-        Format string for annotations, default "{x:.1f}"
-    annot_color_lighter : str, optional
-        Color for annotations on lighter background, default "black"
-    annot_color_darker : str, optional
-        Color for annotations on darker background, default "white"
-    **kwargs
-        Additional keyword arguments passed to matplotlib.axes.Axes.imshow()
-
-    Returns
-    -------
-    im : matplotlib.image.AxesImage
-        The image object created by imshow
-    cbar : matplotlib.colorbar.Colorbar
-        The colorbar object
-    """
-
-    im, cbar = _mpl_heatmap(
-        data,
-        x_labels,
-        y_labels,
-        ax=ax,
-        cmap=cmap,
-        cbarlabel=cbar_label,
-    )
-
-    if show_annot:
-        textcolors = _switch_annot_colors(cmap, annot_color_lighter, annot_color_darker)
-        texts = _mpl_annotate_heatmap(
-            im,
-            valfmt=annot_format,
-            textcolors=textcolors,
-        )
-
-    return ax, im, cbar
-
-
-def _switch_annot_colors(cmap, annot_color_lighter, annot_color_darker):
-    # Get colormap
-    cmap_obj = plt.cm.get_cmap(cmap)
-
-    # Sample the colormap at its extremes
-    dark_color = cmap_obj(0.1)  # Not using 0.0 to avoid edge effects
-    light_color = cmap_obj(0.9)  # Not using 1.0 to avoid edge effects
-
-    # Calculate perceived brightness
-    dark_brightness = (
-        0.2126 * dark_color[0] + 0.7152 * dark_color[1] + 0.0722 * dark_color[2]
-    )
-    light_brightness = (
-        0.2126 * light_color[0] + 0.7152 * light_color[1] + 0.0722 * light_color[2]
-    )
-
-    # Choose text colors based on background brightness
-    if dark_brightness < 0.5:
-        return (annot_color_lighter, annot_color_darker)
-    else:
-        return (annot_color_darker, annot_color_lighter)
-
-
-def _mpl_heatmap(
-    data, row_labels, col_labels, ax=None, cbar_kw=None, cbarlabel="", **kwargs
-):
-    """
-    A function to annotate a heatmap.
-
-    Parameters
-    ----------
-    im : matplotlib.image.AxesImage
-        The image to be annotated
-    data : array-like, optional
-        Data used to annotate. If None, the image's array is used
-    valfmt : str or matplotlib.ticker.Formatter, optional
-        Format of the annotations, default "{x:.2f}"
-    textcolors : tuple of str, optional
-        Colors for the annotations. The first is used for values below
-        threshold, the second for those above, default ("lightgray", "black")
-    threshold : float, optional
-        Value in normalized colormap space (0 to 1) above which the
-        second color is used. If None, 0.7*max(data) is used
-    **textkw
-        Additional keyword arguments passed to matplotlib.axes.Axes.text()
-
-    Returns
-    -------
-    texts : list of matplotlib.text.Text
-        The annotation text objects
-    """
-
-    if ax is None:
-        ax = plt.gca()
-
-    if cbar_kw is None:
-        cbar_kw = {}
-
-    # Plot the heatmap
-    im = ax.imshow(data, **kwargs)
-
-    # Create colorbar with proper formatting
-    cbar = ax.figure.colorbar(im, ax=ax, **cbar_kw)
-    cbar.ax.set_ylabel(cbarlabel, rotation=-90, va="bottom")
-
-    # Set colorbar border width to match axes spines
-    cbar.outline.set_linewidth(0.2 * 2.83465)  # 0.2mm in points
-
-    # Format colorbar ticks
-    from matplotlib.ticker import MaxNLocator
-    cbar.ax.yaxis.set_major_locator(MaxNLocator(nbins=4, min_n_ticks=3))
-    cbar.ax.tick_params(width=0.2 * 2.83465, length=0.8 * 2.83465)  # Match tick styling
-
-    # Show all ticks and label them with the respective list entries.
-    ax.set_xticks(
-        range(data.shape[1]),
-        labels=col_labels,
-        # rotation=45,
-        # ha="right",
-        # rotation_mode="anchor",
-    )
-    ax.set_yticks(range(data.shape[0]), labels=row_labels)
-
-    # Let the horizontal axes labeling appear on top.
-    ax.tick_params(top=False, bottom=True, labeltop=False, labelbottom=True)
-
-    # Show all 4 spines for heatmap
-    ax.spines[:].set_visible(True)
-
-    # Set aspect ratio to 'equal' for square cells (1:1)
-    ax.set_aspect('equal', adjustable='box')
-
-    ax.set_xticks(np.arange(data.shape[1] + 1) - 0.5, minor=True)
-    ax.set_yticks(np.arange(data.shape[0] + 1) - 0.5, minor=True)
-    ax.tick_params(which="minor", bottom=False, left=False)
-
-    return im, cbar
-
-
-def _mpl_annotate_heatmap(
-    im,
-    data=None,
-    valfmt="{x:.2f}",
-    textcolors=("lightgray", "black"),
-    threshold=None,
-    **textkw,
-):
-    """
-    A function to annotate a heatmap.
-
-    Parameters
-    ----------
-    im : matplotlib.image.AxesImage
-        The image to be annotated
-    data : array-like, optional
-        Data used to annotate. If None, the image's array is used
-    valfmt : str or matplotlib.ticker.Formatter, optional
-        Format of the annotations, default "{x:.2f}"
-    textcolors : tuple of str, optional
-        Colors for the annotations. The first is used for values below
-        threshold, the second for those above, default ("lightgray", "black")
-    threshold : float, optional
-        Value in normalized colormap space (0 to 1) above which the
-        second color is used. If None, 0.7*max(data) is used
-    **textkw
-        Additional keyword arguments passed to matplotlib.axes.Axes.text()
-
-    Returns
-    -------
-    texts : list of matplotlib.text.Text
-        The annotation text objects
-    """
-
-    if not isinstance(data, (list, np.ndarray)):
-        data = im.get_array()
-
-    # Normalize the threshold to the images color range.
-    if threshold is not None:
-        threshold = im.norm(threshold)
-    else:
-        # Use 0.7 instead of 0.5 for better visibility with most colormaps
-        threshold = im.norm(data.max()) * 0.7
-
-    # Set default alignment to center, but allow it to be
-    # overwritten by textkw.
-    kw = dict(horizontalalignment="center", verticalalignment="center")
-    kw.update(textkw)
-
-    # Get the formatter in case a string is supplied
-    if isinstance(valfmt, str):
-        valfmt = matplotlib.ticker.StrMethodFormatter(valfmt)
-
-    # Loop over the data and create a `Text` for each "pixel".
-    # Change the text's color depending on the data.
-    texts = []
-    for ii in range(data.shape[0]):
-        for jj in range(data.shape[1]):
-            kw.update(color=textcolors[int(im.norm(data[ii, jj]) > threshold)])
-            text = im.axes.text(jj, ii, valfmt(data[ii, jj], None), **kw)
-            texts.append(text)
-
-    return texts
-
-
-if __name__ == "__main__":
-    import matplotlib
-    import matplotlib as mpl
-    import matplotlib.pyplot as plt
-    import numpy as np
-
-    data = np.random.rand(5, 10)
-    x_labels = [f"X{ii+1}" for ii in range(5)]
-    y_labels = [f"Y{ii+1}" for ii in range(10)]
-
-    fig, ax = plt.subplots()
-
-    im, cbar = plot_heatmap(
-        ax,
-        data,
-        x_labels=x_labels,
-        y_labels=y_labels,
-        show_annot=True,
-        annot_color_lighter="white",
-        annot_color_darker="black",
-        cmap="Blues",
-    )
-
-    fig.tight_layout()
-    plt.show()
-    # EOF
-
-# EOF

scitex/plt/ax/_plot/_plot_joyplot.py

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-# Timestamp: "2025-05-02 09:03:23 (ywatanabe)"
-# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_plot/_plot_joyplot.py
-# ----------------------------------------
-import os
-
-__FILE__ = "./src/scitex/plt/ax/_plot/_plot_joyplot.py"
-__DIR__ = os.path.dirname(__FILE__)
-# ----------------------------------------
-
-import warnings
-
-from .._style._set_xyt import set_xyt as scitex_plt_set_xyt
-
-
-def plot_joyplot(ax, data, orientation="vertical", **kwargs):
-    """
-    Create a joyplot (ridgeline plot) with proper orientation handling.
-
-    Parameters
-    ----------
-    ax : matplotlib.axes.Axes
-        The axes to plot on
-    data : pandas.DataFrame or array-like
-        The data to plot
-    orientation : str, default "vertical"
-        Plot orientation. Either "vertical" or "horizontal"
-    **kwargs
-        Additional keyword arguments passed to joypy.joyplot()
-
-    Returns
-    -------
-    matplotlib.axes.Axes
-        The axes with the joyplot
-
-    Raises
-    ------
-    ValueError
-        If orientation is not "vertical" or "horizontal"
-    """
-    # Lazy import to avoid scipy circular import on startup
-    import joypy
-
-    if orientation not in ["vertical", "horizontal"]:
-        raise ValueError("orientation must be either 'vertical' or 'horizontal'")
-
-    # Handle orientation by setting appropriate joypy parameters
-    if orientation == "horizontal":
-        # For horizontal orientation, we need to transpose the data display
-        # joypy doesn't have direct horizontal support, so we work with the result
-        kwargs.setdefault("kind", "kde")  # Ensure we're using KDE plots
-
-    fig, axes = joypy.joyplot(
-        data=data,
-        **kwargs,
-    )
-
-    # Set appropriate labels based on orientation
-    if orientation == "vertical":
-        ax = scitex_plt_set_xyt(ax, None, "Density", "Joyplot")
-    elif orientation == "horizontal":
-        ax = scitex_plt_set_xyt(ax, "Density", None, "Joyplot")
-        # For horizontal plots, we might need additional transformations
-        # This is a limitation of joypy which primarily supports vertical plots
-
-    return ax
-
-
-# def plot_vertical_joyplot(ax, data, **kwargs):
-#     return _plot_joyplot(ax, data, "vertical", **kwargs)
-
-
-# def plot_horizontal_joyplot(ax, data, **kwargs):
-#     return _plot_joyplot(ax, data, "horizontal", **kwargs)
-
-# EOF

scitex/plt/ax/_plot/_plot_shaded_line.py

@@ -1,142 +0,0 @@
-#!/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 scitex.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