scitex 2.0.0__py2.py3-none-any.whl

scitex/plt/ax/_style/_hide_spines.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-06-07 15:45:36 (ywatanabe)"
+# File: /ssh:ywatanabe@sp:/home/ywatanabe/proj/.claude-worktree/scitex_repo/src/scitex/plt/ax/_style/_hide_spines.py
+# ----------------------------------------
+import os
+__FILE__ = (
+    "./src/scitex/plt/ax/_style/_hide_spines.py"
+)
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+# Time-stamp: "2024-04-26 20:03:45 (ywatanabe)"
+
+import matplotlib
+from ....plt.utils import assert_valid_axis
+
+
+def hide_spines(
+    axis,
+    top=True,
+    bottom=False,
+    left=False,
+    right=True,
+    ticks=False,
+    labels=False,
+):
+    """
+    Hides the specified spines of a matplotlib Axes object or scitex axis wrapper and optionally removes the ticks and labels.
+
+    This function is designed to work with matplotlib Axes objects or scitex axis wrappers. It allows for a cleaner, more minimalist
+    presentation of plots by hiding the spines (the lines denoting the boundaries of the plot area) and optionally
+    removing the ticks and labels from the axes.
+
+    Arguments:
+        ax (matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper): The axis for which the spines will be hidden.
+        top (bool, optional): If True, hides the top spine. Defaults to True.
+        bottom (bool, optional): If True, hides the bottom spine. Defaults to False.
+        left (bool, optional): If True, hides the left spine. Defaults to False.
+        right (bool, optional): If True, hides the right spine. Defaults to True.
+        ticks (bool, optional): If True, removes the ticks from the hidden spines' axes. Defaults to False.
+        labels (bool, optional): If True, removes the labels from the hidden spines' axes. Defaults to False.
+
+    Returns:
+        matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper: The modified axis with the specified spines hidden.
+
+    Example:
+        >>> fig, ax = plt.subplots()
+        >>> hide_spines(ax)
+        >>> plt.show()
+    """
+    assert_valid_axis(axis, "First argument must be a matplotlib axis or scitex axis wrapper")
+
+    tgts = []
+    if top:
+        tgts.append("top")
+    if bottom:
+        tgts.append("bottom")
+    if left:
+        tgts.append("left")
+    if right:
+        tgts.append("right")
+
+    for tgt in tgts:
+        # Spines
+        axis.spines[tgt].set_visible(False)
+
+        # Ticks
+        if ticks:
+            if tgt == "bottom":
+                axis.xaxis.set_ticks_position("none")
+            elif tgt == "left":
+                axis.yaxis.set_ticks_position("none")
+
+        # Labels
+        if labels:
+            if tgt == "bottom":
+                axis.set_xticklabels([])
+            elif tgt == "left":
+                axis.set_yticklabels([])
+
+    return axis
+
+# EOF

scitex/plt/ax/_style/_map_ticks.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 09:00:56 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_style/_map_ticks.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_style/_map_ticks.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+
+from ....plt.utils import assert_valid_axis
+
+
+def map_ticks(ax, src, tgt, axis="x"):
+    """
+    Maps source tick positions or labels to new target labels on a matplotlib Axes object.
+    Supports both numeric positions and string labels for source ticks ('src'), enabling the mapping
+    to new target labels ('tgt'). This ensures only the specified target ticks are displayed on the
+    final axis, enhancing the clarity and readability of plots.
+
+    Parameters:
+    - ax (matplotlib.axes.Axes or scitex.plt._subplots._AxisWrapper.AxisWrapper): The Axes object to modify.
+    - src (list of str or numeric): Source positions (if numeric) or labels (if str) to map from.
+      When using string labels, ensure they match the current tick labels on the axis.
+    - tgt (list of str): New target labels to apply to the axis. Must have the same length as 'src'.
+    - axis (str): Specifies which axis to apply the tick modifications ('x' or 'y').
+
+    Returns:
+    - ax (matplotlib.axes.Axes or scitex.plt._subplots._AxisWrapper.AxisWrapper): The modified Axes object with adjusted tick labels.
+
+    Examples:
+    --------
+    Numeric Example:
+        fig, ax = plt.subplots()
+        x = np.linspace(0, 2 * np.pi, 100)
+        y = np.sin(x)
+        ax.plot(x, y)  # Plot a sine wave
+        src = [0, np.pi/2, np.pi, 3*np.pi/2, 2*np.pi]  # Numeric src positions
+        tgt = ['0', 'π/2', 'π', '3π/2', '2π']  # Corresponding target labels
+        map_ticks(ax, src, tgt, axis="x")  # Map src to tgt on the x-axis
+        plt.show()
+
+    String Example:
+        fig, ax = plt.subplots()
+        categories = ['A', 'B', 'C', 'D', 'E']  # Initial categories
+        values = [1, 3, 2, 5, 4]
+        ax.bar(categories, values)  # Bar plot with string labels
+        src = ['A', 'B', 'C', 'D', 'E']  # Source labels to map from
+        tgt = ['Alpha', 'Beta', 'Gamma', 'Delta', 'Epsilon']  # New target labels
+        map_ticks(ax, src, tgt, axis="x")  # Apply the mapping
+        plt.show()
+    """
+    assert_valid_axis(ax, "First argument must be a matplotlib axis or scitex axis wrapper")
+
+    if len(src) != len(tgt):
+        raise ValueError(
+            "Source ('src') and target ('tgt') must have the same number of elements."
+        )
+
+    # Determine tick positions if src is string data
+    if all(isinstance(item, str) for item in src):
+        if axis == "x":
+            all_labels = [label.get_text() for label in ax.get_xticklabels()]
+        else:
+            all_labels = [label.get_text() for label in ax.get_yticklabels()]
+
+        # Find positions of src labels
+        src_positions = [all_labels.index(s) for s in src if s in all_labels]
+    else:
+        # Use src as positions directly if numeric
+        src_positions = src
+
+    # Set the ticks and labels based on the specified axis
+    if axis == "x":
+        ax.set_xticks(src_positions)
+        ax.set_xticklabels(tgt)
+    elif axis == "y":
+        ax.set_yticks(src_positions)
+        ax.set_yticklabels(tgt)
+    else:
+        raise ValueError("Invalid axis argument. Use 'x' or 'y'.")
+
+    return ax
+
+
+def numeric_example():
+    """Example demonstrating numeric tick mapping.
+
+    Shows how to replace numeric tick positions with custom labels,
+    such as replacing radian values with pi notation in trigonometric plots.
+
+    Returns
+    -------
+    matplotlib.figure.Figure
+        Figure with two subplots showing before and after tick mapping.
+
+    Examples
+    --------
+    >>> fig = numeric_example()
+    >>> plt.show()
+
+    Notes
+    -----
+    The top subplot shows original numeric labels, while the bottom
+    subplot shows the same data with custom pi notation labels.
+    """
+    fig, axs = plt.subplots(2, 1, figsize=(10, 6))  # Two rows, one column
+
+    # Original plot
+    x = np.linspace(0, 2 * np.pi, 100)
+    y = np.sin(x)
+    axs[0].plot(x, y)  # Plot a sine wave on the first row
+    axs[0].set_title("Original Numeric Labels")
+
+    # Numeric src positions for ticks (e.g., multiples of pi) and target labels
+    src = [0, np.pi / 2, np.pi, 3 * np.pi / 2, 2 * np.pi]
+    tgt = ["0", "π/2", "π", "3π/2", "2π"]
+
+    # Plot with mapped ticks
+    axs[1].plot(x, y)  # Plot again on the second row for mapped labels
+    map_ticks(axs[1], src, tgt, axis="x")
+    axs[1].set_title("Mapped Numeric Labels")
+
+    return fig
+
+
+def string_example():
+    """Example demonstrating string tick mapping.
+
+    Shows how to replace categorical string labels with more descriptive
+    alternatives, useful for improving plot readability.
+
+    Returns
+    -------
+    matplotlib.figure.Figure
+        Figure with two subplots showing before and after tick mapping.
+
+    Examples
+    --------
+    >>> fig = string_example()
+    >>> plt.show()
+
+    Notes
+    -----
+    The top subplot shows original short category labels (A, B, C...),
+    while the bottom subplot shows the same data with descriptive Greek
+    letter names.
+    """
+    fig, axs = plt.subplots(2, 1, figsize=(10, 6))  # Two rows, one column
+
+    # Original plot with categorical string labels
+    categories = ["A", "B", "C", "D", "E"]
+    values = [1, 3, 2, 5, 4]
+    axs[0].bar(categories, values)
+    axs[0].set_title("Original String Labels")
+
+    # src as the existing labels to change and target labels
+    src = categories
+    tgt = ["Alpha", "Beta", "Gamma", "Delta", "Epsilon"]
+
+    # Plot with mapped string labels
+    axs[1].bar(categories, values)  # Bar plot again on the second row for mapped labels
+    map_ticks(axs[1], src, tgt, axis="x")
+    axs[1].set_title("Mapped String Labels")
+
+    return fig
+
+
+# Execute examples
+if __name__ == "__main__":
+    fig_numeric = numeric_example()
+    fig_string = string_example()
+
+    plt.tight_layout()
+    plt.show()
+
+# EOF

scitex/plt/ax/_style/_rotate_labels.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-10-27 13:24:32 (ywatanabe)"
+# /home/ywatanabe/proj/_scitex_repo_openhands/src/scitex/plt/ax/_rotate_labels.py
+
+"""This script does XYZ."""
+
+"""Imports"""
+import numpy as np
+
+
+def rotate_labels(ax, x=45, y=45, x_ha=None, y_ha=None, x_va=None, y_va=None, 
+                 auto_adjust=True, scientific_convention=True):
+    """
+    Rotate x and y axis labels of a matplotlib Axes object with automatic positioning.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        The Axes object to modify.
+    x : float, optional
+        Rotation angle for x-axis labels in degrees. Default is 45.
+    y : float, optional
+        Rotation angle for y-axis labels in degrees. Default is 45.
+    x_ha : str, optional
+        Horizontal alignment for x-axis labels. If None, automatically determined.
+    y_ha : str, optional
+        Horizontal alignment for y-axis labels. If None, automatically determined.
+    x_va : str, optional
+        Vertical alignment for x-axis labels. If None, automatically determined.
+    y_va : str, optional
+        Vertical alignment for y-axis labels. If None, automatically determined.
+    auto_adjust : bool, optional
+        Whether to automatically adjust alignment based on rotation angle. Default is True.
+    scientific_convention : bool, optional
+        Whether to follow scientific plotting conventions. Default is True.
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The modified Axes object.
+
+    Example
+    -------
+    fig, ax = plt.subplots()
+    ax.plot([1, 2, 3], [1, 2, 3])
+    rotate_labels(ax)
+    plt.show()
+    
+    Notes
+    -----
+    Scientific conventions for label rotation:
+    - X-axis labels: For angles 0-90°, use 'right' alignment; for 90-180°, use 'left'
+    - Y-axis labels: For angles 0-90°, use 'center' alignment; adjust vertical as needed
+    - Optimal readability maintained through automatic positioning
+    """
+    # Get current tick positions
+    xticks = ax.get_xticks()
+    yticks = ax.get_yticks()
+
+    # Set ticks explicitly
+    ax.set_xticks(xticks)
+    ax.set_yticks(yticks)
+
+    # Auto-adjust alignment based on rotation angle and scientific conventions
+    if auto_adjust:
+        x_ha, x_va = _get_optimal_alignment('x', x, x_ha, x_va, scientific_convention)
+        y_ha, y_va = _get_optimal_alignment('y', y, y_ha, y_va, scientific_convention)
+    
+    # Apply defaults if not auto-adjusting
+    if x_ha is None:
+        x_ha = "center"
+    if y_ha is None:
+        y_ha = "center"
+    if x_va is None:
+        x_va = "center"
+    if y_va is None:
+        y_va = "center"
+
+    # Set labels with rotation and proper alignment
+    ax.set_xticklabels(ax.get_xticklabels(), rotation=x, ha=x_ha, va=x_va)
+    ax.set_yticklabels(ax.get_yticklabels(), rotation=y, ha=y_ha, va=y_va)
+    
+    # Auto-adjust subplot parameters for better layout if needed
+    if auto_adjust and scientific_convention:
+        _adjust_subplot_params(ax, x, y)
+    
+    return ax
+
+
+def _get_optimal_alignment(axis, angle, ha, va, scientific_convention):
+    """
+    Determine optimal alignment based on rotation angle and scientific conventions.
+    
+    Parameters
+    ----------
+    axis : str
+        'x' or 'y' axis
+    angle : float
+        Rotation angle in degrees
+    ha : str or None
+        Current horizontal alignment
+    va : str or None  
+        Current vertical alignment
+    scientific_convention : bool
+        Whether to follow scientific conventions
+        
+    Returns
+    -------
+    tuple
+        (horizontal_alignment, vertical_alignment)
+    """
+    # Normalize angle to 0-360 range
+    angle = angle % 360
+    
+    if axis == 'x':
+        if scientific_convention:
+            # Scientific convention for x-axis labels
+            if 0 <= angle <= 30:
+                ha = ha or 'center'
+                va = va or 'top'
+            elif 30 < angle <= 60:
+                ha = ha or 'right'
+                va = va or 'top'
+            elif 60 < angle <= 120:
+                ha = ha or 'right'
+                va = va or 'center'
+            elif 120 < angle <= 150:
+                ha = ha or 'right'
+                va = va or 'bottom'
+            elif 150 < angle <= 210:
+                ha = ha or 'center'
+                va = va or 'bottom'
+            elif 210 < angle <= 240:
+                ha = ha or 'left'
+                va = va or 'bottom'
+            elif 240 < angle <= 300:
+                ha = ha or 'left'
+                va = va or 'center'
+            else:  # 300-360
+                ha = ha or 'left'
+                va = va or 'top'
+        else:
+            ha = ha or 'center'
+            va = va or 'top'
+            
+    else:  # y-axis
+        if scientific_convention:
+            # Scientific convention for y-axis labels
+            if 0 <= angle <= 30:
+                ha = ha or 'right'
+                va = va or 'center'
+            elif 30 < angle <= 60:
+                ha = ha or 'right'
+                va = va or 'bottom'
+            elif 60 < angle <= 120:
+                ha = ha or 'center'
+                va = va or 'bottom'
+            elif 120 < angle <= 150:
+                ha = ha or 'left'
+                va = va or 'bottom'
+            elif 150 < angle <= 210:
+                ha = ha or 'left'
+                va = va or 'center'
+            elif 210 < angle <= 240:
+                ha = ha or 'left'
+                va = va or 'top'
+            elif 240 < angle <= 300:
+                ha = ha or 'center'
+                va = va or 'top'
+            else:  # 300-360
+                ha = ha or 'right'
+                va = va or 'top'
+        else:
+            ha = ha or 'center'
+            va = va or 'center'
+    
+    return ha, va
+
+
+def _adjust_subplot_params(ax, x_angle, y_angle):
+    """
+    Automatically adjust subplot parameters to accommodate rotated labels.
+    
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        The axes object
+    x_angle : float
+        X-axis rotation angle
+    y_angle : float
+        Y-axis rotation angle
+    """
+    fig = ax.get_figure()
+    
+    # Calculate required margins based on rotation angles
+    x_margin_factor = abs(np.sin(np.radians(x_angle))) * 0.1
+    y_margin_factor = abs(np.sin(np.radians(y_angle))) * 0.15
+    
+    # Get current subplot parameters
+    try:
+        subplotpars = fig.subplotpars
+        current_bottom = subplotpars.bottom
+        current_left = subplotpars.left
+        
+        # Adjust margins if they need to be increased
+        new_bottom = max(current_bottom, 0.1 + x_margin_factor)
+        new_left = max(current_left, 0.1 + y_margin_factor)
+        
+        # Only adjust if we're increasing the margins significantly
+        if new_bottom > current_bottom + 0.05 or new_left > current_left + 0.05:
+            fig.subplots_adjust(bottom=new_bottom, left=new_left)
+    except Exception:
+        # Skip adjustment if there are issues
+        pass