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

scitex/plt/utils/_collect_figure_metadata.py

@@ -168,16 +168,25 @@ def collect_figure_metadata(fig, ax=None, plot_id=None) -> Dict:
     if ax is not None and hasattr(ax, "_scitex_metadata"):
         scitex_meta = ax._scitex_metadata
 
+        # Extract stats separately for top-level access
+        if 'stats' in scitex_meta:
+            metadata['stats'] = scitex_meta['stats']
+
         # Merge into scitex section
         for key, value in scitex_meta.items():
-            if key not in metadata["scitex"]:
+            if key not in metadata["scitex"] and key != 'stats':  # Don't duplicate stats
                 metadata["scitex"][key] = value
 
     # Alternative: check figure for metadata (for multi-axes cases)
     elif hasattr(fig, "_scitex_metadata"):
         scitex_meta = fig._scitex_metadata
+
+        # Extract stats separately for top-level access
+        if 'stats' in scitex_meta:
+            metadata['stats'] = scitex_meta['stats']
+
         for key, value in scitex_meta.items():
-            if key not in metadata["scitex"]:
+            if key not in metadata["scitex"] and key != 'stats':  # Don't duplicate stats
                 metadata["scitex"][key] = value
 
     # Add actual font information
@@ -228,6 +237,7 @@ def collect_figure_metadata(fig, ax=None, plot_id=None) -> Dict:
                 "label": x_label,
                 "unit": x_unit,
                 "scale": ax.get_xscale(),
+                "lim": list(ax.get_xlim()),
             }
 
             # Y-axis
@@ -237,6 +247,7 @@ def collect_figure_metadata(fig, ax=None, plot_id=None) -> Dict:
                 "label": y_label,
                 "unit": y_unit,
                 "scale": ax.get_yscale(),
+                "lim": list(ax.get_ylim()),
             }
 
             # Add n_ticks if available from style
@@ -248,6 +259,11 @@ def collect_figure_metadata(fig, ax=None, plot_id=None) -> Dict:
 
             metadata["axes"] = axes_info
 
+            # Extract title
+            title = ax.get_title()
+            if title:
+                metadata["title"] = title
+
             # Detect plot type and method from axes history or lines
             plot_type, method = _detect_plot_type(ax)
             if plot_type:
@@ -261,6 +277,16 @@ def collect_figure_metadata(fig, ax=None, plot_id=None) -> Dict:
             elif hasattr(fig, "_scitex_metadata") and "style_preset" in fig._scitex_metadata:
                 metadata["style_preset"] = fig._scitex_metadata["style_preset"]
 
+            # Phase 2: Extract traces (lines) with their properties and CSV column mapping
+            traces = _extract_traces(ax)
+            if traces:
+                metadata["traces"] = traces
+
+            # Phase 2: Extract legend info
+            legend_info = _extract_legend_info(ax)
+            if legend_info:
+                metadata["legend"] = legend_info
+
         except Exception as e:
             # If Phase 1 extraction fails, continue without it
             import warnings
@@ -307,6 +333,122 @@ def _parse_label_unit(label_text: str) -> tuple:
     return label_text.strip(), ""
 
 
+def _extract_traces(ax) -> list:
+    """
+    Extract trace (line) information including properties and CSV column mapping.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        The axes to extract traces from
+
+    Returns
+    -------
+    list
+        List of trace dictionaries with id, label, color, linestyle, linewidth,
+        and csv_columns mapping
+    """
+    import matplotlib.colors as mcolors
+
+    traces = []
+
+    # Get axes position for CSV column naming
+    ax_pos = "00"  # Default for single axes
+    if hasattr(ax, '_scitex_metadata') and 'position_in_grid' in ax._scitex_metadata:
+        pos = ax._scitex_metadata['position_in_grid']
+        ax_pos = f"{pos[0]}{pos[1]}"
+
+    for i, line in enumerate(ax.lines):
+        trace = {}
+
+        # Get ID from _scitex_id attribute (set by scitex plotting functions)
+        # This matches the id= kwarg passed to ax.plot()
+        scitex_id = getattr(line, '_scitex_id', None)
+
+        # Get label for legend
+        label = line.get_label()
+
+        # Determine trace_id for CSV column matching
+        if scitex_id:
+            trace_id = scitex_id
+        elif not label.startswith('_'):
+            trace_id = label
+        else:
+            trace_id = f"line_{i}"
+
+        trace["id"] = trace_id
+
+        # Label (for legend) - use label if not internal
+        if not label.startswith('_'):
+            trace["label"] = label
+
+        # Color - always convert to hex for consistent JSON storage
+        color = line.get_color()
+        try:
+            # mcolors.to_hex handles strings, RGB tuples, RGBA tuples
+            color_hex = mcolors.to_hex(color, keep_alpha=False)
+            trace["color"] = color_hex
+        except (ValueError, TypeError):
+            # Fallback: store as-is
+            trace["color"] = color
+
+        # Line style
+        trace["linestyle"] = line.get_linestyle()
+
+        # Line width
+        trace["linewidth"] = line.get_linewidth()
+
+        # Marker
+        marker = line.get_marker()
+        if marker and marker != 'None':
+            trace["marker"] = marker
+            trace["markersize"] = line.get_markersize()
+
+        # CSV column mapping - this is how we'll reconstruct from CSV
+        # Format matches what _export_as_csv generates: ax_{row}{col}_{id}_plot_x/y
+        # The id should match the id= kwarg passed to ax.plot()
+        trace["csv_columns"] = {
+            "x": f"ax_{ax_pos}_{trace_id}_plot_x",
+            "y": f"ax_{ax_pos}_{trace_id}_plot_y",
+        }
+
+        traces.append(trace)
+
+    return traces
+
+
+def _extract_legend_info(ax) -> Optional[dict]:
+    """
+    Extract legend information from axes.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        The axes to extract legend from
+
+    Returns
+    -------
+    dict or None
+        Legend info dictionary or None if no legend
+    """
+    legend = ax.get_legend()
+    if legend is None:
+        return None
+
+    legend_info = {
+        "visible": legend.get_visible(),
+        "loc": legend._loc if hasattr(legend, '_loc') else "best",
+        "frameon": legend.get_frame_on() if hasattr(legend, 'get_frame_on') else True,
+    }
+
+    # Extract legend entries (labels)
+    texts = legend.get_texts()
+    if texts:
+        legend_info["labels"] = [t.get_text() for t in texts]
+
+    return legend_info
+
+
 def _detect_plot_type(ax) -> tuple:
     """
     Detect the primary plot type and method from axes content.
@@ -337,24 +479,24 @@ def _detect_plot_type(ax) -> tuple:
     if hasattr(ax, 'history') and len(ax.history) > 0:
         # Get the first plotting command
         first_cmd = ax.history[0].get('command', '')
-        if 'plot_heatmap' in first_cmd:
-            return "heatmap", "plot_heatmap"
-        elif 'plot_kde' in first_cmd:
-            return "kde", "plot_kde"
-        elif 'plot_ecdf' in first_cmd:
-            return "ecdf", "plot_ecdf"
-        elif 'plot_violin' in first_cmd:
-            return "violin", "plot_violin"
-        elif 'plot_box' in first_cmd or 'boxplot' in first_cmd:
-            return "boxplot", "plot_box"
-        elif 'plot_line' in first_cmd:
-            return "line", "plot_line"
+        if 'stx_heatmap' in first_cmd:
+            return "heatmap", "stx_heatmap"
+        elif 'stx_kde' in first_cmd:
+            return "kde", "stx_kde"
+        elif 'stx_ecdf' in first_cmd:
+            return "ecdf", "stx_ecdf"
+        elif 'stx_violin' in first_cmd:
+            return "violin", "stx_violin"
+        elif 'stx_box' in first_cmd or 'boxplot' in first_cmd:
+            return "boxplot", "stx_box"
+        elif 'stx_line' in first_cmd:
+            return "line", "stx_line"
         elif 'plot_scatter' in first_cmd:
             return "scatter", "plot_scatter"
-        elif 'plot_mean_std' in first_cmd:
-            return "line", "plot_mean_std"
-        elif 'plot_shaded_line' in first_cmd:
-            return "line", "plot_shaded_line"
+        elif 'stx_mean_std' in first_cmd:
+            return "line", "stx_mean_std"
+        elif 'stx_shaded_line' in first_cmd:
+            return "line", "stx_shaded_line"
         elif 'sns_boxplot' in first_cmd:
             return "boxplot", "sns_boxplot"
         elif 'sns_violinplot' in first_cmd:

scitex/plt/utils/_colorbar.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-06-08 11:15:00 (ywatanabe)"
+# Timestamp: "2025-12-01 10:00:00 (ywatanabe)"
 # File: /src/scitex/plt/utils/_colorbar.py
 # ----------------------------------------
 
@@ -10,49 +10,108 @@ import matplotlib.pyplot as plt
 from matplotlib.cm import ScalarMappable
 from matplotlib.colors import Normalize
 
+from ._units import mm_to_pt
 
-def colorbar(mappable, ax=None, **kwargs):
+
+# ============================================================================
+# Constants for colorbar styling
+# ============================================================================
+COLORBAR_LINE_WIDTH_MM = 0.2
+COLORBAR_TICK_LENGTH_MM = 0.8
+COLORBAR_TICK_FONTSIZE = 6  # pt
+
+
+def style_colorbar(cbar):
+    """Apply publication-quality styling to a colorbar.
+
+    Applies:
+    - 0.2mm outline thickness
+    - 0.8mm tick length
+    - 6pt tick labels
+
+    Parameters
+    ----------
+    cbar : matplotlib.colorbar.Colorbar
+        The colorbar to style
+
+    Returns
+    -------
+    cbar : matplotlib.colorbar.Colorbar
+        The styled colorbar
+    """
+    line_width = mm_to_pt(COLORBAR_LINE_WIDTH_MM)
+    tick_length = mm_to_pt(COLORBAR_TICK_LENGTH_MM)
+
+    # Style the colorbar outline
+    cbar.outline.set_linewidth(line_width)
+
+    # Style the ticks
+    cbar.ax.tick_params(
+        width=line_width,
+        length=tick_length,
+        labelsize=COLORBAR_TICK_FONTSIZE
+    )
+
+    # Style the colorbar axis spines
+    for spine in cbar.ax.spines.values():
+        spine.set_linewidth(line_width)
+
+    return cbar
+
+
+def colorbar(mappable, ax=None, n_ticks=4, **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.
+    n_ticks : int, optional
+        Number of ticks on the colorbar. Default is 4 to match main axes style.
     **kwargs : dict
         Additional keyword arguments passed to matplotlib.pyplot.colorbar
-        
+
     Returns
     -------
     colorbar : matplotlib.colorbar.Colorbar
         The colorbar instance
     """
+    from matplotlib.ticker import MaxNLocator
+
     # 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)
-    
+
+    # Limit number of ticks to match main axes style (3-4 ticks)
+    cbar.locator = MaxNLocator(nbins=n_ticks, min_n_ticks=2, prune='both')
+    cbar.update_ticks()
+
+    # Apply publication-quality styling
+    style_colorbar(cbar)
+
     # 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
 
 
@@ -89,7 +148,10 @@ def add_shared_colorbar(fig, axes, mappable, location='right', **kwargs):
     
     # Create the shared colorbar
     cbar = fig.colorbar(mappable, ax=axes, location=location, **kwargs)
-    
+
+    # Apply publication-quality styling
+    style_colorbar(cbar)
+
     return cbar
 
 

scitex/plt/utils/_configure_mpl.py

@@ -1,11 +1,12 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-11-19 12:01:10 (ywatanabe)"
+# Timestamp: "2025-12-02 12:00:00 (ywatanabe)"
 # File: /home/ywatanabe/proj/scitex-code/src/scitex/plt/utils/_configure_mpl.py
 
 
 from typing import Any
 from typing import Dict
+from typing import Optional
 from typing import Tuple
 
 import matplotlib.pyplot as plt
@@ -16,51 +17,48 @@ from scitex.dict import DotDict
 
 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=False,  # Disable LaTeX, use Arial font instead
-    latex_preamble=None,  # Custom LaTeX preamble
-    verbose=False,
+    fig_size_mm: Optional[Tuple[float, float]] = None,
+    fig_scale: float = 1.0,
+    dpi_display: Optional[int] = None,
+    dpi_save: Optional[int] = None,
+    autolayout: bool = True,
+    n_ticks: Optional[int] = None,
+    hide_top_right_spines: Optional[bool] = None,
+    line_width: Optional[float] = None,
+    alpha: float = 1.0,
+    enable_latex: bool = False,
+    latex_preamble: Optional[str] = None,
+    verbose: bool = False,
     **kwargs,
 ) -> Tuple[Any, Dict]:
     """Configures Matplotlib settings for publication-quality plots.
 
+    All default values are loaded from SCITEX_STYLE.yaml. Parameters passed
+    directly to this function override the YAML values.
+
     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_size_mm : tuple of float, optional
+        Figure width and height in millimeters. If None, calculated from
+        YAML axes dimensions + margins.
     fig_scale : float, optional
         Scaling factor for figure size, by default 1.0
     dpi_display : int, optional
-        Display resolution in DPI, by default 100
+        Display resolution in DPI. If None, uses YAML output.dpi / 3.
     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
+        Saving resolution in DPI. If None, uses YAML output.dpi.
     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
+        Whether to hide top and right spines. If None, uses YAML behavior settings.
     line_width : float, optional
-        Default line width, by default 1.0
+        Default line width in points. If None, converts YAML lines.trace_mm to pt.
     alpha : float, optional
-        Color transparency, by default 0.85
+        Color transparency, by default 1.0
     n_ticks : int, optional
-        Number of ticks on each axis, by default 4
+        Number of ticks on each axis. If None, uses YAML ticks.n_ticks.
     verbose : bool, optional
         Whether to print configuration details, by default False
 
@@ -68,14 +66,72 @@ def configure_mpl(
     -------
     tuple
         (plt, DotDict of RGBA colors) - Access as COLORS.blue or COLORS['blue']
-    """
-    # # 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
+    Notes
+    -----
+    Style values are resolved from SCITEX_STYLE.yaml located at:
+    scitex/plt/styles/SCITEX_STYLE.yaml
+
+    The YAML file contains all default values for:
+    - Axes dimensions (width_mm, height_mm, thickness_mm)
+    - Margins and spacing
+    - Font sizes (axis_label_pt, tick_label_pt, title_pt, legend_pt)
+    - Line thicknesses (trace_mm, errorbar_mm, etc.)
+    - Tick settings (length_mm, thickness_mm, direction, n_ticks)
+    - Output settings (dpi, transparent)
+    - Behavior flags (hide_top_spine, hide_right_spine, grid)
+    """
+    # Load style from YAML
+    from scitex.plt.styles import load_style, resolve_style_value
+
+    style = load_style()
+
+    # mm to pt conversion factor
+    mm_to_pt = 2.83465
+
+    # Resolve values with priority: direct → env → yaml → default
+    # If parameter is None, use YAML value; otherwise use the passed value
+
+    # Figure size: calculate from axes + margins if not specified
+    if fig_size_mm is None:
+        axes_w = resolve_style_value("axes.width_mm", None, 40)
+        axes_h = resolve_style_value("axes.height_mm", None, 28)
+        margin_l = resolve_style_value("margins.left_mm", None, 20)
+        margin_r = resolve_style_value("margins.right_mm", None, 20)
+        margin_b = resolve_style_value("margins.bottom_mm", None, 20)
+        margin_t = resolve_style_value("margins.top_mm", None, 20)
+        fig_size_mm = (axes_w + margin_l + margin_r, axes_h + margin_b + margin_t)
+
+    # DPI
+    yaml_dpi = int(resolve_style_value("output.dpi", None, 300))
+    if dpi_save is None:
+        dpi_save = yaml_dpi
+    if dpi_display is None:
+        dpi_display = max(100, yaml_dpi // 3)  # Lower DPI for display
+
+    # Line width: convert from mm to pt if using YAML value
+    if line_width is None:
+        trace_mm = resolve_style_value("lines.trace_mm", None, 0.2)
+        line_width = trace_mm * mm_to_pt
+
+    # Ticks
+    if n_ticks is None:
+        n_ticks = int(resolve_style_value("ticks.n_ticks", None, 4))
+
+    # Spines
+    if hide_top_right_spines is None:
+        hide_top = resolve_style_value("behavior.hide_top_spine", None, True, bool)
+        hide_right = resolve_style_value("behavior.hide_right_spine", None, True, bool)
+        hide_top_right_spines = hide_top and hide_right
+
+    # Font sizes from YAML
+    font_size = resolve_style_value("fonts.axis_label_pt", None, 7)
+    title_size = resolve_style_value("fonts.title_pt", None, 8)
+    tick_size = resolve_style_value("fonts.tick_label_pt", None, 7)
+    legend_size = resolve_style_value("fonts.legend_pt", None, 6)
+
+    # Axis thickness from YAML
+    axes_linewidth = resolve_style_value("axes.thickness_mm", None, 0.2) * mm_to_pt
 
     # Colors
     RGBA = {
@@ -99,39 +155,39 @@ def configure_mpl(
         fig_size_mm[1] / 25.4 * fig_scale,
     )
 
-    # Prepare matplotlib configuration
+    # Prepare matplotlib configuration using YAML-derived values
     mpl_config = {
         # Resolution
         "figure.dpi": dpi_display,
         "savefig.dpi": dpi_save,
         # Figure Size
         "figure.figsize": figsize_inch,
-        # Font Sizes (7pt for titles/labels, 6pt for legend)
-        "font.size": 7,  # Base font size
-        "axes.titlesize": 7,  # Title size (prevent "large" default)
-        "axes.labelsize": 7,  # Axis label size
-        "xtick.labelsize": 7,  # Tick label size
-        "ytick.labelsize": 7,  # Tick label size
-        # Legend configuration
-        "legend.fontsize": 6,  # 6pt for legend labels
-        "legend.frameon": False,  # No frame by default
-        "legend.loc": "best",  # Auto-position to avoid overlap
+        # Font Sizes from YAML
+        "font.size": font_size,
+        "axes.titlesize": title_size,
+        "axes.labelsize": font_size,
+        "xtick.labelsize": tick_size,
+        "ytick.labelsize": tick_size,
+        # Legend configuration from YAML
+        "legend.fontsize": legend_size,
+        "legend.frameon": False,
+        "legend.loc": "best",
         # Auto Layout
         "figure.autolayout": autolayout,
-        # Top and Right Axes
+        # Top and Right Axes from YAML
         "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
+        # Spine width from YAML (converted from mm to pt)
+        "axes.linewidth": axes_linewidth,
         # Custom color cycle
         "axes.prop_cycle": plt.cycler(
             color=list(RGBA_NORM_FOR_CYCLE.values())
         ),
-        # Line
+        # Line width from YAML (converted from mm to pt)
         "lines.linewidth": line_width,
-        "lines.markersize": 6.0,  # Better default marker size
+        "lines.markersize": 6.0,
         # Grid (if used)
-        "grid.linewidth": 0.6,
+        "grid.linewidth": axes_linewidth,
         "grid.alpha": 0.3,
     }
 

scitex/plt/utils/_crop.py

@@ -42,21 +42,35 @@ def find_content_area(image_path: str) -> Tuple[int, int, int, int]:
     img_array = np.array(img)
 
     # Check if image has alpha channel (RGBA)
-    if img_array.shape[2] == 4:
+    if len(img_array.shape) == 3 and img_array.shape[2] == 4:
         # Use alpha channel to find content (non-transparent pixels)
         alpha = img_array[:, :, 3]
         # Find non-transparent pixels
         rows = np.any(alpha > 0, axis=1)
         cols = np.any(alpha > 0, axis=0)
     else:
-        # For RGB images, find non-white pixels
-        # Consider pixels as content if they differ from white background
+        # For RGB images, detect background color from corners and find non-background pixels
         if len(img_array.shape) == 3:
-            # Check if pixel is not white (255, 255, 255)
-            is_content = np.any(img_array < 250, axis=2)
+            # Sample background color from corners (more robust than assuming white)
+            h, w = img_array.shape[:2]
+            corners = [
+                img_array[0, 0],           # top-left
+                img_array[0, w-1],         # top-right
+                img_array[h-1, 0],         # bottom-left
+                img_array[h-1, w-1],       # bottom-right
+            ]
+            # Use median of corners as background color (robust to one corner having content)
+            bg_color = np.median(corners, axis=0).astype(np.uint8)
+
+            # Find pixels that differ significantly from background (threshold: 10 per channel)
+            diff = np.abs(img_array.astype(np.int16) - bg_color.astype(np.int16))
+            is_content = np.any(diff > 10, axis=2)
         else:
-            # Grayscale: check if not white
-            is_content = img_array < 250
+            # Grayscale: detect background from corners
+            h, w = img_array.shape
+            corners = [img_array[0, 0], img_array[0, w-1], img_array[h-1, 0], img_array[h-1, w-1]]
+            bg_value = np.median(corners)
+            is_content = np.abs(img_array.astype(np.int16) - bg_value) > 10
 
         rows = np.any(is_content, axis=1)
         cols = np.any(is_content, axis=0)