scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/color/_get_colors_from_cmap.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 17:53:27 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/color/_get_from_cmap.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/color/_get_from_cmap.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from typing import List, Optional, Tuple, Union
+
+import matplotlib
+import numpy as np
+
+# class ColorGetter:
+#     # https://stackoverflow.com/questions/26108436/how-can-i-get-the-matplotlib-rgb-color-given-the-colormap-name-boundrynorm-an
+#     def __init__(self, cmap_name, start_val, stop_val):
+#         self.cmap_name = cmap_name
+#         self.cmap = plt.get_cmap(cmap_name)
+#         self.norm = mpl.colors.Normalize(vmin=start_val, vmax=stop_val)
+#         self.scalarMap = cm.ScalarMappable(norm=self.norm, cmap=self.cmap)
+
+#     def get_rgb(self, val):
+#         return self.scalarMap.to_rgba(val)
+
+
+def get_color_from_cmap(
+    cmap_name: str,
+    value: float,
+    value_range: Optional[Tuple[float, float]] = None,
+    alpha: float = 1.0,
+) -> Tuple[float, float, float, float]:
+    """Get a color from a colormap at a specific value.
+
+    Parameters
+    ----------
+    cmap_name : str
+        Name of the colormap (e.g., 'viridis', 'plasma', 'Blues')
+    value : float
+        Value to map to a color in the colormap
+    value_range : tuple of (float, float), optional
+        Range of values to map to the colormap. If None, uses (0, 1)
+    alpha : float, optional
+        Alpha value for the color (0.0 to 1.0), by default 1.0
+
+    Returns
+    -------
+    tuple
+        RGBA color tuple with values from 0 to 1
+    """
+    # Get the colormap using the recommended approach
+    cmap = matplotlib.colormaps[cmap_name]
+
+    # Normalize the value
+    if value_range is None:
+        norm_value = value
+    else:
+        min_val, max_val = value_range
+        norm_value = (value - min_val) / (max_val - min_val)
+
+    # Clip to ensure within range
+    norm_value = np.clip(norm_value, 0.0, 1.0)
+
+    # Get the color
+    rgba_color = list(cmap(norm_value))
+
+    # Set alpha
+    rgba_color[3] = alpha
+
+    return tuple(rgba_color)
+
+
+def get_colors_from_cmap(
+    cmap_name: str,
+    n_colors: int,
+    value_range: Optional[Tuple[float, float]] = None,
+    alpha: float = 1.0,
+) -> List[Tuple[float, float, float, float]]:
+    """Get a list of evenly spaced colors from a colormap.
+
+    Parameters
+    ----------
+    cmap_name : str
+        Name of the colormap (e.g., 'viridis', 'plasma', 'Blues')
+    n_colors : int
+        Number of colors to sample from the colormap
+    value_range : tuple of (float, float), optional
+        Range of values to map to the colormap. If None, uses (0, 1)
+    alpha : float, optional
+        Alpha value for the colors (0.0 to 1.0), by default 1.0
+
+    Returns
+    -------
+    list
+        List of RGBA color tuples with values from 0 to 1
+    """
+    if value_range is None:
+        values = np.linspace(0, 1, n_colors)
+    else:
+        values = np.linspace(value_range[0], value_range[1], n_colors)
+
+    return [get_color_from_cmap(cmap_name, val, value_range, alpha) for val in values]
+
+
+def get_categorical_colors_from_cmap(
+    cmap_name: str, categories: Union[List, np.ndarray], alpha: float = 1.0
+) -> dict:
+    """Map categorical values to colors from a colormap.
+
+    Parameters
+    ----------
+    cmap_name : str
+        Name of the colormap (e.g., 'viridis', 'plasma', 'Blues')
+    categories : list or np.ndarray
+        List of categories to map to colors
+    alpha : float, optional
+        Alpha value for the colors (0.0 to 1.0), by default 1.0
+
+    Returns
+    -------
+    dict
+        Dictionary mapping categories to RGBA color tuples
+    """
+    unique_categories = np.unique(categories)
+    n_categories = len(unique_categories)
+
+    colors = get_colors_from_cmap(cmap_name, n_categories, alpha=alpha)
+
+    return {cat: colors[idx] for idx, cat in enumerate(unique_categories)}
+
+
+# EOF

scitex/plt/color/_interpolate.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-03 00:51:06 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/color/_interp_colors.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/color/_interp_colors.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib.colors as mcolors
+import numpy as np
+from scitex.decorators import deprecated
+
+
+def gen_interpolate(color_start, color_end, num_points, round=3):
+    color_start_rgba = np.array(mcolors.to_rgba(color_start))
+    color_end_rgba = np.array(mcolors.to_rgba(color_end))
+    rgba_values = np.linspace(color_start_rgba, color_end_rgba, num_points).round(round)
+    return [list(color) for color in rgba_values]
+
+
+@deprecated("Use gen_interpolate instead")
+def interpolate(color_start, color_end, num_points, round=3):
+    return gen_interpolate(color_start, color_end, num_points, round=round)
+
+
+# EOF

scitex/plt/color/_vizualize_colors.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-03 00:53:43 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/color/_vizualize_colors.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/color/_vizualize_colors.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+
+
+def vizualize_colors(colors):
+
+    def gen_rand_sample(size=100):
+        x = np.linspace(-1, 1, size)
+        y = np.random.normal(size=size)
+        s = np.random.randn(size)
+        return x, y, s
+
+    from .. import subplots as scitex_plt_subplots
+
+    fig, ax = scitex_plt_subplots()
+
+    for ii, (color_str, rgba) in enumerate(colors.items()):
+        xx, yy, ss = gen_rand_sample()
+
+        # # Box color plot
+        # ax.plot_rectangle(
+        #     xx=ii, yy=0, width=1, height=1, color=rgba, label=color_str
+        # )
+
+        # Line plot
+        ax.plot_shaded_line(xx, yy - ss, yy, yy + ss, color=rgba, label=color_str)
+
+        # # Scatter plot
+        # axes[2].scatter(xx, yy, color=rgba, label=color_str)
+
+        # # KDE plot
+        # axes[3].plot_kde(yy, color=rgba, label=color_str)
+
+    # for ax in axes.flat:
+    #     # ax.axis("off")
+    #     ax.legend()
+
+    ax.legend()
+    # plt.tight_layout()
+    # plt.show()
+    return fig, ax
+
+
+# EOF

scitex/plt/utils/__init__.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Scitex utils module."""
+
+from ._calc_bacc_from_conf_mat import calc_bacc_from_conf_mat
+from ._calc_nice_ticks import calc_nice_ticks
+from ._close import close
+from ._colorbar import add_shared_colorbar, colorbar
+from ._configure_mpl import configure_mpl
+from ._histogram_utils import HistogramBinManager, histogram_bin_manager
+from ._im2grid import im2grid
+from ._is_valid_axis import assert_valid_axis, is_valid_axis
+from ._mk_colorbar import mk_colorbar
+from ._mk_patches import mk_patches
+from ._scientific_captions import ScientificCaption, add_figure_caption, add_panel_captions, caption_manager, create_figure_list, cross_ref, enhance_scitex_save_with_captions, export_captions, quick_caption, save_with_caption
+from ._scitex_config import SciTeXConfig, configure_scitex_ecosystem, get_scitex_config
+
+__all__ = [
+    "HistogramBinManager",
+    "SciTeXConfig",
+    "ScientificCaption",
+    "add_figure_caption",
+    "add_panel_captions",
+    "add_shared_colorbar",
+    "assert_valid_axis",
+    "calc_bacc_from_conf_mat",
+    "calc_nice_ticks",
+    "caption_manager",
+    "close",
+    "colorbar",
+    "configure_mpl",
+    "configure_scitex_ecosystem",
+    "create_figure_list",
+    "cross_ref",
+    "enhance_scitex_save_with_captions",
+    "export_captions",
+    "get_scitex_config",
+    "histogram_bin_manager",
+    "im2grid",
+    "is_valid_axis",
+    "mk_colorbar",
+    "mk_patches",
+    "quick_caption",
+    "save_with_caption",
+]

scitex/plt/utils/_calc_bacc_from_conf_mat.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 10:09:35 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/utils/_calc_bacc_from_conf_mat.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/utils/_calc_bacc_from_conf_mat.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+
+from ...context import suppress_output
+
+
+def calc_bacc_from_conf_mat(confusion_matrix: np.ndarray, n_round=3) -> float:
+    """Calculates balanced accuracy from confusion matrix.
+
+    Parameters
+    ----------
+    confusion_matrix : np.ndarray
+        Confusion matrix array
+
+    Returns
+    -------
+    float
+        Balanced accuracy score
+
+    Example
+    -------
+    >>> cm = np.array([[10, 2, 0], [1, 15, 3], [0, 2, 20]])
+    >>> bacc = calc_bacc_from_conf_mat(cm, n_round=3)
+    >>> print(f"Balanced Accuracy: bacc")
+    Balanced Accuracy: 0.889
+    """
+    with suppress_output():
+        try:
+            per_class = np.diag(confusion_matrix) / np.nansum(confusion_matrix, axis=1)
+            bacc = np.nanmean(per_class)
+        except:
+            bacc = np.nan
+        return round(bacc, n_round)
+
+
+# EOF

scitex/plt/utils/_calc_nice_ticks.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-01 13:40:19 (ywatanabe)"
+# File: /home/ywatanabe/proj/_scitex_repo/src/scitex/plt/_calc_nice_ticks.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_calc_nice_ticks.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib.ticker as mticker
+import numpy as np
+
+
+def calc_nice_ticks(
+    min_val,
+    max_val,
+    allow_edge_min=True,
+    allow_edge_max=False,
+    pad_perc=5,
+    num_ticks=4,
+    prefer_integer=True,
+):
+    """
+    Calculate nice tick values for axes based on data range.
+    Parameters:
+    -----------
+    min_val : float
+        Minimum data value
+    max_val : float
+        Maximum data value
+    allow_edge_min : bool, optional
+        Whether to allow a tick at the min value, defaults to True
+    allow_edge_max : bool, optional
+        Whether to allow a tick at the max value, defaults to False
+    pad_perc : float, optional
+        Percentage of data range to pad, defaults to 5%
+    num_ticks : int, optional
+        Target number of ticks to display, defaults to 4
+    prefer_integer : bool, optional
+        If True, convert ticks to integers when possible, defaults to True
+    Returns:
+    --------
+    list
+        List of nicely spaced tick positions
+    """
+    # Handle edge cases
+    if min_val == max_val:
+        if min_val == 0:
+            return [0, 1, 2, 3]
+        else:
+            # Create a small range around the single value
+            margin = abs(min_val) * 0.1
+            min_val -= margin
+            max_val += margin
+
+    # Store original values before padding
+    original_min = min_val
+    original_max = max_val
+
+    # Apply padding if needed
+    range_size = max_val - min_val
+    if not allow_edge_min:
+        min_val -= range_size * pad_perc / 100
+    if not allow_edge_max:
+        max_val += range_size * pad_perc / 100
+
+    # Use matplotlib's MaxNLocator to get nice tick locations
+    locator = mticker.MaxNLocator(
+        nbins=num_ticks,
+        steps=[1, 2, 5, 10],
+        integer=False,
+        symmetric=False,
+        prune=None,
+        min_n_ticks=3,
+    )
+
+    # Get tick locations
+    tick_locations = locator.tick_values(min_val, max_val)
+
+    # If we got too many ticks, try to reduce them
+    if len(tick_locations) > num_ticks + 1:
+        locator = mticker.MaxNLocator(nbins=num_ticks - 1)
+        tick_locations = locator.tick_values(min_val, max_val)
+
+    # Filter out ticks outside the original data range if needed
+    if not allow_edge_min:
+        tick_locations = [tick for tick in tick_locations if tick >= original_min]
+    if not allow_edge_max:
+        tick_locations = [tick for tick in tick_locations if tick <= original_max]
+
+    # Convert to integers if all values can be represented as integers
+    if prefer_integer and all(float(int(tick)) == tick for tick in tick_locations):
+        tick_locations = [int(tick) for tick in tick_locations]
+
+    # Convert to simple list
+    return np.array(tick_locations).tolist()
+
+
+# EOF

scitex/plt/utils/_close.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-29 20:41:30 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_close.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_close.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib
+import matplotlib.pyplot as plt
+import scitex.plt as scitex_plt
+
+
+def close(obj):
+    """Close a matplotlib figure or SciTeX FigWrapper object.
+
+    Properly closes matplotlib figures to free memory, handling both
+    standard matplotlib Figure objects and SciTeX FigWrapper objects.
+    This is important for preventing memory leaks when creating many plots.
+
+    Parameters
+    ----------
+    obj : matplotlib.figure.Figure or scitex.plt.FigWrapper
+        The figure object to close. Can be either a matplotlib Figure
+        or an SciTeX FigWrapper instance.
+
+    Raises
+    ------
+    TypeError
+        If obj is neither a Figure nor FigWrapper object.
+
+    Examples
+    --------
+    >>> # Close a matplotlib figure
+    >>> fig, ax = plt.subplots()
+    >>> ax.plot([1, 2, 3], [1, 4, 9])
+    >>> close(fig)
+
+    >>> # Close an SciTeX FigWrapper
+    >>> fig, axes = scitex.plt.subplots(2, 2)
+    >>> close(fig)
+
+    >>> # Prevents memory leaks in loops
+    >>> for i in range(100):
+    ...     fig, ax = plt.subplots()
+    ...     ax.plot(data[i])
+    ...     plt.savefig(f'plot_{i}.png')
+    ...     close(fig)  # Important!
+
+    See Also
+    --------
+    matplotlib.pyplot.close : Standard matplotlib close function
+    scitex.plt.subplots : Creates FigWrapper objects
+    """
+    if isinstance(obj, matplotlib.figure.Figure):
+        plt.close(obj)
+    elif isinstance(obj, scitex_plt._subplots._FigWrapper.FigWrapper):
+        plt.close(obj.figure)
+    else:
+        raise TypeError(
+            f"Cannot close object of type {type(obj).__name__}. Expected FigWrapper or Figure object."
+        )
+
+
+# EOF

scitex/plt/utils/_colorbar.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-06-08 11:15:00 (ywatanabe)"
+# File: /src/scitex/plt/utils/_colorbar.py
+# ----------------------------------------
+
+"""Enhanced colorbar utilities for better placement with scitex.plt"""
+
+import matplotlib.pyplot as plt
+from matplotlib.cm import ScalarMappable
+from matplotlib.colors import Normalize
+
+
+def colorbar(mappable, ax=None, **kwargs):
+    """Enhanced colorbar function that ensures proper spacing.
+    
+    This function wraps matplotlib.pyplot.colorbar with better defaults
+    to prevent overlap with axes when using constrained_layout.
+    
+    Parameters
+    ----------
+    mappable : matplotlib.cm.ScalarMappable
+        The mappable whose colorbar is to be made (e.g., from imshow, scatter)
+    ax : matplotlib.axes.Axes or list of Axes, optional
+        Parent axes from which space for a new colorbar axes will be stolen.
+    **kwargs : dict
+        Additional keyword arguments passed to matplotlib.pyplot.colorbar
+        
+    Returns
+    -------
+    colorbar : matplotlib.colorbar.Colorbar
+        The colorbar instance
+    """
+    # Set better defaults for colorbar placement
+    defaults = {
+        'fraction': 0.046,  # Fraction of axes to use for colorbar
+        'pad': 0.04,        # Padding between axes and colorbar
+        'aspect': 20,       # Aspect ratio of colorbar
+    }
+    
+    # Update defaults with any user-provided kwargs
+    for key, value in defaults.items():
+        if key not in kwargs:
+            kwargs[key] = value
+    
+    # Create the colorbar
+    cbar = plt.colorbar(mappable, ax=ax, **kwargs)
+    
+    # If using constrained_layout, ensure the figure updates
+    if ax is not None:
+        fig = ax.figure if hasattr(ax, 'figure') else ax[0].figure
+        if hasattr(fig, 'get_constrained_layout') and fig.get_constrained_layout():
+            # Force a layout update
+            fig.canvas.draw_idle()
+    
+    return cbar
+
+
+def add_shared_colorbar(fig, axes, mappable, location='right', **kwargs):
+    """Add a single colorbar shared by multiple axes.
+    
+    Parameters
+    ----------
+    fig : matplotlib.figure.Figure
+        The figure containing the axes
+    axes : array-like of Axes
+        The axes that will share the colorbar
+    mappable : matplotlib.cm.ScalarMappable
+        The mappable whose colorbar is to be made
+    location : {'right', 'bottom', 'left', 'top'}, optional
+        Where to place the colorbar (default: 'right')
+    **kwargs : dict
+        Additional keyword arguments passed to fig.colorbar
+        
+    Returns
+    -------
+    colorbar : matplotlib.colorbar.Colorbar
+        The colorbar instance
+    """
+    defaults = {
+        'shrink': 0.8,      # Shrink colorbar to match axes height
+        'aspect': 30,       # Make it thinner for shared colorbars
+    }
+    
+    # Update defaults with any user-provided kwargs
+    for key, value in defaults.items():
+        if key not in kwargs:
+            kwargs[key] = value
+    
+    # Create the shared colorbar
+    cbar = fig.colorbar(mappable, ax=axes, location=location, **kwargs)
+    
+    return cbar
+
+
+# EOF