scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/utils/_configure_mpl.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-19 08:49:35 (ywatanabe)"
+# File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/scitex_repo/src/scitex/plt/utils/_configure_mpl.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/utils/_configure_mpl.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from typing import Any, Dict, Tuple, Union
+
+import matplotlib.pyplot as plt
+import scitex
+import numpy as np
+
+
+def configure_mpl(
+    plt,
+    fig_size_mm=(160, 100),
+    fig_scale=1.0,
+    dpi_display=100,
+    dpi_save=300,
+    fontsize="medium",
+    autolayout=True,
+    n_ticks=4,
+    hide_top_right_spines=True,
+    line_width=1.0,  # Increased from 0.5 for better visibility
+    alpha=0.85,  # Adjusted for better contrast
+    enable_latex=True,  # Enable LaTeX rendering by default
+    latex_preamble=None,  # Custom LaTeX preamble
+    verbose=False,
+    **kwargs,
+) -> Tuple[Any, Dict]:
+    """Configures Matplotlib settings for publication-quality plots.
+
+    Parameters
+    ----------
+    plt : matplotlib.pyplot
+        Matplotlib pyplot module
+    fig_size_mm : tuple of int, optional
+        Figure width and height in millimeters, by default (160, 100)
+    fig_scale : float, optional
+        Scaling factor for figure size, by default 1.0
+    dpi_display : int, optional
+        Display resolution in DPI, by default 100
+    dpi_save : int, optional
+        Saving resolution in DPI, by default 300
+    fontsize : Union[str, int, float], optional
+        Base font size ('xx-small' to 'xx-large' or points), by default 'medium'
+        Other sizes are derived from this:
+        - Title: 125% of base
+        - Labels: 100% of base
+        - Ticks/Legend: 85% of base
+    autolayout : bool, optional
+        Whether to enable automatic tight layout, by default True
+    hide_top_right_spines : bool, optional
+        Whether to hide top and right spines, by default True
+    line_width : float, optional
+        Default line width, by default 1.0
+    alpha : float, optional
+        Color transparency, by default 0.85
+    n_ticks : int, optional
+        Number of ticks on each axis, by default 4
+    verbose : bool, optional
+        Whether to print configuration details, by default False
+
+    Returns
+    -------
+    tuple
+        (plt, dict of RGBA colors)
+    """
+    # Convert base font size
+    base_size = _convert_font_size(fontsize)
+
+    # Ensure minimum sizes for different elements with better proportions
+    title_size = max(base_size * 1.25, 10.0)  # Increased for better hierarchy
+    label_size = max(base_size * 1.0, 9.0)  # Minimum 9pt for good readability
+    small_size = max(base_size * 0.85, 8.0)  # Increased ratio for better legibility
+
+    # Colors
+    RGBA = {
+        k: scitex.plt.color.update_alpha(v, alpha)
+        for k, v in scitex.plt.color.PARAMS["RGBA"].items()
+    }
+
+    RGBA_NORM = {
+        k: tuple(scitex.plt.color.update_alpha(v, alpha))
+        for k, v in scitex.plt.color.PARAMS["RGBA_NORM"].items()
+    }
+
+    RGBA_NORM_FOR_CYCLE = {
+        k: tuple(scitex.plt.color.update_alpha(v, alpha))
+        for k, v in scitex.plt.color.PARAMS["RGBA_NORM_FOR_CYCLE"].items()
+    }
+
+    # Normalize figure size from mm to inches
+    figsize_inch = (
+        fig_size_mm[0] / 25.4 * fig_scale,
+        fig_size_mm[1] / 25.4 * fig_scale,
+    )
+
+    # Prepare matplotlib configuration
+    mpl_config = {
+        # Resolution
+        "figure.dpi": dpi_display,
+        "savefig.dpi": dpi_save,
+        # Figure Size
+        "figure.figsize": figsize_inch,
+        # Font Sizes
+        "font.size": base_size,
+        "axes.titlesize": title_size,
+        "axes.labelsize": label_size,
+        "xtick.labelsize": small_size,
+        "ytick.labelsize": small_size,
+        "legend.fontsize": small_size,
+        # Auto Layout
+        "figure.autolayout": autolayout,
+        # Top and Right Axes
+        "axes.spines.top": not hide_top_right_spines,
+        "axes.spines.right": not hide_top_right_spines,
+        # Spine width
+        "axes.linewidth": 0.8,  # Slightly thicker axes lines
+        # Custom color cycle
+        "axes.prop_cycle": plt.cycler(color=list(RGBA_NORM_FOR_CYCLE.values())),
+        # Line
+        "lines.linewidth": line_width,
+        "lines.markersize": 6.0,  # Better default marker size
+        # Grid (if used)
+        "grid.linewidth": 0.6,
+        "grid.alpha": 0.3,
+    }
+    
+    # Configure LaTeX rendering if enabled with enhanced fallback
+    if enable_latex:
+        latex_success = False
+        try:
+            # Try to enable LaTeX rendering
+            test_config = {
+                "text.usetex": True,
+                "text.latex.preamble": latex_preamble or r"\usepackage{amsmath}\usepackage{amssymb}",
+                "font.family": "serif",
+                "font.serif": ["Computer Modern Roman"],
+                "mathtext.fontset": "cm",
+            }
+            
+            # Test LaTeX capability before applying
+            with plt.rc_context(test_config):
+                try:
+                    # Create a test figure to verify LaTeX works
+                    fig, ax = plt.subplots(figsize=(1, 1))
+                    ax.text(0.5, 0.5, r'$x^2 + y^2 = r^2$', usetex=True)
+                    fig.canvas.draw()  # Force rendering
+                    plt.close(fig)
+                    latex_success = True
+                except Exception as latex_error:
+                    plt.close(fig)
+                    if verbose:
+                        print(f"⚠️  LaTeX test render failed: {latex_error}")
+                    raise latex_error
+            
+            if latex_success:
+                mpl_config.update(test_config)
+                if verbose:
+                    print("✅ LaTeX rendering enabled and tested")
+                    
+        except Exception as e:
+            if verbose:
+                print(f"⚠️  LaTeX rendering failed, falling back to mathtext: {e}")
+                print("    This may be due to missing LaTeX fonts or Node.js conflicts")
+            
+            # Enhanced fallback to mathtext with better configuration
+            mpl_config.update({
+                "text.usetex": False,
+                "mathtext.default": "regular",
+                "font.family": "serif",
+                "mathtext.fontset": "cm",
+                "mathtext.fallback": "cm",  # Fallback font for missing symbols
+            })
+            
+            # Enable LaTeX fallback mode in the str module
+            try:
+                from scitex.str._latex_fallback import set_fallback_mode
+                set_fallback_mode("force_mathtext")
+                if verbose:
+                    print("📝 Enabled automatic LaTeX fallback mode")
+            except ImportError:
+                if verbose:
+                    print("⚠️  LaTeX fallback module not available")
+                    
+    else:
+        # Use mathtext only with enhanced configuration
+        mpl_config.update({
+            "text.usetex": False,
+            "mathtext.default": "regular",
+            "mathtext.fontset": "cm",
+            "mathtext.fallback": "cm",
+        })
+        
+        # Set fallback mode to mathtext
+        try:
+            from scitex.str._latex_fallback import set_fallback_mode
+            set_fallback_mode("force_mathtext")
+        except ImportError:
+            pass
+
+    # Update Matplotlib configuration
+    plt.rcParams.update(mpl_config)
+
+    if verbose:
+        print("\n" + "-" * 40)
+        print("Matplotlib has been configured as follows:\n")
+        print(f"Figure DPI (Display): {dpi_display} DPI")
+        print(f"Figure DPI (Save): {dpi_save} DPI")
+        print(
+            f"Figure Size (Not the Axis Size): "
+            f"{fig_size_mm[0] * fig_scale:.1f} x "
+            f"{fig_size_mm[1] * fig_scale:.1f} mm (width x height)"
+        )
+        print("\nFont Sizes:")
+        print(f"  Base Size: {base_size:.1f}pt")
+        print(f"  Title: {title_size:.1f}pt (125% of base, min 10pt)")
+        print(f"  Axis Labels: {label_size:.1f}pt (100% of base, min 9pt)")
+        print(f"  Tick Labels: {small_size:.1f}pt (85% of base, min 8pt)")
+        print(f"  Legend: {small_size:.1f}pt (85% of base, min 8pt)")
+        print(f"\nHide Top and Right Axes: {hide_top_right_spines}")
+        print(f"Line Width: {line_width}")
+        # print(f"Number of Ticks: {n_ticks}")
+        print(f"\nCustom Colors (RGBA):")
+        for color_str, rgba in RGBA.items():
+            print(f"  {color_str}: {rgba}")
+        print("-" * 40)
+
+    # Store n_ticks for later use
+    plt._n_ticks = n_ticks
+
+    # Add a utility function to plt
+    def set_n_ticks(ax, n=None):
+        if n is None:
+            n = plt._n_ticks
+        ax.xaxis.set_major_locator(plt.MaxNLocator(n))
+        ax.yaxis.set_major_locator(plt.MaxNLocator(n))
+
+    plt.set_n_ticks = set_n_ticks
+
+    return plt, RGBA_NORM
+
+
+def _convert_font_size(size: Union[str, int, float]) -> float:
+    """Converts various font size specifications to numerical values.
+
+    Parameters
+    ----------
+    size : Union[str, int, float]
+        Font size specification. Can be:
+        - String: 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large', 'xx-large'
+        - Numeric: direct point size value
+
+    Returns
+    -------
+    float
+        Font size in points
+    """
+    if isinstance(size, str):
+        size_map = {
+            "xx-small": 9,
+            "x-small": 11,
+            "small": 13,
+            "medium": 15,
+            "large": 18,
+            "x-large": 22,
+            "xx-large": 26,
+        }
+        return size_map.get(size.lower(), 15)
+    elif isinstance(size, (int, float)):
+        return max(float(size), 9.0)  # Ensure minimum size of 9
+    else:
+        raise ValueError(f"Unsupported font size type: {type(size)}")
+
+
+if __name__ == "__main__":
+    plt, CC = configure_mpl(plt)
+    fig, axes = plt.subplots(nrows=2, sharex=True, sharey=True)
+    x = np.linspace(0, 10, 100)
+    for idx_cc, cc_str in enumerate(CC):
+        phase_shift = idx_cc * np.pi / len(CC)
+        y = np.sin(x + phase_shift)
+        axes[0].plot(x, y, label="Default color cycle")
+        axes[1].plot(x, y, color=CC[cc_str], label=f"{cc_str}")
+    axes[0].legend()
+    axes[1].legend()
+    plt.show()
+
+# EOF

scitex/plt/utils/_histogram_utils.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 18:14:26 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/utils/_histogram_utils.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/utils/_histogram_utils.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+from typing import List, Tuple, Union, Optional, Dict
+
+class HistogramBinManager:
+    """
+    Utility class to manage histogram bin alignment across multiple histograms.
+    
+    This class maintains a registry of histograms and their bin configurations
+    for each axis, allowing histograms on the same axis to use consistent binning.
+    
+    Attributes:
+        _axis_registry (Dict): Registry of bin configurations by axis ID
+    """
+    
+    def __init__(self):
+        self._axis_registry = {}
+        
+    def register_histogram(self, 
+                          axis_id: str, 
+                          hist_id: str, 
+                          data: np.ndarray, 
+                          bins: Union[int, str, np.ndarray] = 10,
+                          range: Optional[Tuple[float, float]] = None):
+        """
+        Register a histogram with the bin manager.
+        
+        Args:
+            axis_id (str): Identifier for the axis
+            hist_id (str): Identifier for the histogram
+            data (np.ndarray): The data array for the histogram
+            bins (Union[int, str, np.ndarray]): Number of bins or bin edges
+            range (Optional[Tuple[float, float]]): Range of the histogram
+        
+        Returns:
+            Tuple[int, Tuple[float, float]]: Consistent bins and range for the axis
+        """
+        # Initialize registry for this axis if needed
+        if axis_id not in self._axis_registry:
+            self._axis_registry[axis_id] = {
+                'histograms': {},
+                'common_config': None
+            }
+        
+        # Calculate data range if not provided
+        if range is None:
+            range = (np.min(data), np.max(data))
+        
+        # Store histogram info in registry
+        self._axis_registry[axis_id]['histograms'][hist_id] = {
+            'data': data,
+            'bins': bins,
+            'range': range
+        }
+        
+        # Calculate common configuration if needed
+        if self._axis_registry[axis_id]['common_config'] is None:
+            self._update_common_config(axis_id)
+        
+        return self._axis_registry[axis_id]['common_config']
+    
+    def _update_common_config(self, axis_id: str):
+        """
+        Update the common bin configuration for an axis.
+        
+        Args:
+            axis_id (str): Identifier for the axis
+        """
+        histograms = self._axis_registry[axis_id]['histograms']
+        
+        if not histograms:
+            return
+        
+        # Find common range across all histograms on this axis
+        min_val = min(hist['range'][0] for hist in histograms.values())
+        max_val = max(hist['range'][1] for hist in histograms.values())
+        
+        # Use maximum number of bins from all histograms
+        # (if any histogram uses a string or array for bins, this gets more complex)
+        bins_values = [hist['bins'] for hist in histograms.values() 
+                     if isinstance(hist['bins'], int)]
+        
+        # Default to 10 bins if no integer bin counts
+        n_bins = max(bins_values) if bins_values else 10
+        
+        # Set common configuration
+        self._axis_registry[axis_id]['common_config'] = (n_bins, (min_val, max_val))
+        
+    def get_common_config(self, axis_id: str) -> Tuple[int, Tuple[float, float]]:
+        """
+        Get the common bin configuration for an axis.
+        
+        Args:
+            axis_id (str): Identifier for the axis
+            
+        Returns:
+            Tuple[int, Tuple[float, float]]: Common bins and range for the axis
+        """
+        if axis_id in self._axis_registry:
+            return self._axis_registry[axis_id]['common_config']
+        
+        # Default if axis not registered
+        return (10, (0, 1))
+        
+    def clear_axis(self, axis_id: str):
+        """
+        Clear registry for a specific axis.
+        
+        Args:
+            axis_id (str): Identifier for the axis to clear
+        """
+        if axis_id in self._axis_registry:
+            del self._axis_registry[axis_id]
+            
+    def clear_all(self):
+        """Clear the entire registry."""
+        self._axis_registry = {}
+
+
+# Global instance
+histogram_bin_manager = HistogramBinManager()

scitex/plt/utils/_im2grid.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-01 23:21:22 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_im2grid.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_im2grid.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+from PIL import Image
+
+
+def im2grid(image_paths, default_color=(255, 255, 255)):
+    """
+    Create a grid of images from a 2D NumPy array of image paths.
+    Skips positions where image_paths is None.
+
+    Args:
+    image_paths (2D numpy array of str or None): Array of image file paths or None for empty slots
+    default_color (tuple): RGB color tuple for empty spaces
+
+    Returns:
+    PIL.Image: A new image consisting of the grid of images
+    """
+    from scitex.io import load as scitex_io_load
+
+    nrows, ncols = image_paths.shape
+
+    # Load images, skip None paths
+    images = []
+    for row in image_paths:
+        row_images = []
+        for path in row:
+            if path is not None:
+                # img = Image.open(path)
+                img = scitex_io_load(path)
+            else:
+                img = None
+            row_images.append(img)
+        images.append(row_images)
+
+    # Assuming all images are the same size, use the first non-None image to determine size
+    for row in images:
+        for img in row:
+            if img is not None:
+                img_width, img_height = img.size
+                break
+        else:
+            continue
+        break
+    else:
+        raise ValueError("All image paths are None.")
+
+    # Create a new image with the total size
+    grid_width = img_width * ncols
+    grid_height = img_height * nrows
+    grid_image = Image.new("RGB", (grid_width, grid_height), default_color)
+
+    # Paste images into the grid
+    for y, row in enumerate(images):
+        for x, img in enumerate(row):
+            if img is not None:
+                grid_image.paste(img, (x * img_width, y * img_height))
+
+    return grid_image
+
+
+# EOF

scitex/plt/utils/_is_valid_axis.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-18 15:12:10 (ywatanabe)"
+# File: /data/gpfs/projects/punim2354/ywatanabe/scitex_repo/src/scitex/plt/utils/_is_valid_axis.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/utils/_is_valid_axis.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import inspect
+import matplotlib
+
+def is_valid_axis(axis):
+    """
+    Check if the provided object is a valid axis (matplotlib Axes or scitex AxisWrapper).
+    
+    Parameters
+    ----------
+    axis : object
+        The object to check
+        
+    Returns
+    -------
+    bool
+        True if the object is a valid axis, False otherwise
+        
+    Examples
+    --------
+    >>> import matplotlib.pyplot as plt
+    >>> import scitex
+    >>> fig, ax = plt.subplots()
+    >>> is_valid_axis(ax)
+    True
+    >>> mfig, max = scitex.plt.subplots()
+    >>> is_valid_axis(max)
+    True
+    """
+    # Check if it's a matplotlib Axes directly
+    if isinstance(axis, matplotlib.axes._axes.Axes):
+        return True
+    
+    # Check if it's an AxisWrapper from scitex
+    # This checks the class hierarchy to see if it has an AxisWrapper in its inheritance chain
+    for cls in inspect.getmro(type(axis)):
+        if cls.__name__ == 'AxisWrapper':
+            return True
+            
+    # Check if it has common axis methods (fallback check)
+    axis_methods = ['plot', 'scatter', 'set_xlabel', 'set_ylabel', 'get_figure']
+    has_methods = all(hasattr(axis, method) for method in axis_methods)
+    
+    return has_methods
+
+def assert_valid_axis(axis, error_message=None):
+    """
+    Assert that the provided object is a valid axis (matplotlib Axes or scitex AxisWrapper).
+    
+    Parameters
+    ----------
+    axis : object
+        The object to check
+    error_message : str, optional
+        Custom error message if assertion fails
+        
+    Raises
+    ------
+    AssertionError
+        If the provided object is not a valid axis
+    """
+    if error_message is None:
+        error_message = "First argument must be a matplotlib axis or scitex axis wrapper"
+        
+    assert is_valid_axis(axis), error_message
+
+# EOF

scitex/plt/utils/_mk_colorbar.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-03 01:09:23 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/utils/_mk_colorbar.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/utils/_mk_colorbar.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+# def mk_colorbar(start="white", end="blue"):
+#     xx = np.linspace(0, 1, 256)
+
+#     start = np.array(scitex.plt.colors.RGB[start])
+#     end = np.array(scitex.plt.colors.RGB[end])
+#     colors = (end - start)[:, np.newaxis] * xx
+
+#     colors -= colors.min()
+#     colors /= colors.max()
+
+#     fig, ax = plt.subplots()
+#     [ax.axvline(_xx, color=colors[:, i_xx]) for i_xx, _xx in enumerate(xx)]
+#     ax.xaxis.set_ticks_position("none")
+#     ax.yaxis.set_ticks_position("none")
+#     ax.set_aspect(0.2)
+#     return fig
+
+
+def mk_colorbar(start="white", end="blue"):
+    """Create a colorbar gradient between two colors.
+
+    Args:
+        start (str): Starting color name
+        end (str): Ending color name
+
+    Returns:
+        matplotlib.figure.Figure: Figure with colorbar
+    """
+    import matplotlib.colors as mcolors
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    # import scitex
+    from scitex.plt.color._PARAMS import RGB
+
+    # Get RGB values for start and end colors
+    start_rgb = RGB[start]
+    end_rgb = RGB[end]
+
+    # Create a colormap
+    colors = [start_rgb, end_rgb]
+    cmap = mcolors.LinearSegmentedColormap.from_list("custom_cmap", colors, N=256)
+
+    # Create the figure and plot the colorbar
+    fig, ax = plt.subplots(figsize=(6, 1))
+    gradient = np.linspace(0, 1, 256).reshape(1, -1)
+    ax.imshow(gradient, aspect="auto", cmap=cmap)
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+    return fig
+
+
+# EOF

scitex/plt/utils/_mk_patches.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-04-30 21:18:45 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/_mk_patches.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/_mk_patches.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib.patches as mpatches
+
+
+def mk_patches(colors, labels):
+    """
+    colors = ["red", "blue"]
+    labels = ["label_1", "label_2"]
+    ax.legend(handles=scitex.plt.mk_patches(colors, labels))
+    """
+
+    patches = [mpatches.Patch(color=c, label=l) for c, l in zip(colors, labels)]
+    return patches
+
+
+# EOF