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

scitex/plt/ax/_plot/_stx_shaded_line.py

@@ -0,0 +1,215 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 13:15:00 (ywatanabe)"
+# File: ./src/scitex/plt/ax/_plot/_plot_shaded_line.py
+
+"""Line plots with shaded uncertainty regions (e.g., confidence intervals)."""
+
+from typing import Any, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from matplotlib.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: Any,
+) -> Tuple[Union[Axes, "AxisWrapper"], pd.DataFrame]:
+    """Plot a single line with shaded area between y_lower and y_upper bounds.
+
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes or AxisWrapper
+        Axes to plot on.
+    xx : np.ndarray
+        X values.
+    y_lower : np.ndarray
+        Lower bound y values.
+    y_middle : np.ndarray
+        Middle (mean/median) y values.
+    y_upper : np.ndarray
+        Upper bound y values.
+    color : ColorLike, optional
+        Color for line and fill.
+    alpha : float, default 0.3
+        Transparency for shaded region.
+    **kwargs : dict
+        Additional keyword arguments passed to plot().
+
+    Returns
+    -------
+    axis : matplotlib.axes.Axes or AxisWrapper
+        The axes with the plot.
+    df : pd.DataFrame
+        DataFrame with x, y_lower, y_middle, y_upper columns.
+    """
+    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.pop("label", None)
+    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: Any,
+) -> Tuple[Union[Axes, "AxisWrapper"], List[pd.DataFrame]]:
+    """Plot multiple lines with shaded areas between ys_lower and ys_upper bounds.
+
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes or AxisWrapper
+        Axes to plot on.
+    xs : list of np.ndarray
+        List of x value arrays.
+    ys_lower : list of np.ndarray
+        List of lower bound y value arrays.
+    ys_middle : list of np.ndarray
+        List of middle y value arrays.
+    ys_upper : list of np.ndarray
+        List of upper bound y value arrays.
+    color : ColorLike or list of ColorLike, optional
+        Color(s) for lines and fills.
+    **kwargs : dict
+        Additional keyword arguments passed to plot().
+
+    Returns
+    -------
+    axis : matplotlib.axes.Axes or AxisWrapper
+        The axes with the plots.
+    results : list of pd.DataFrame
+        List of DataFrames with plot data.
+    """
+    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 stx_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: Any,
+) -> Tuple[Union[Axes, "AxisWrapper"], Union[pd.DataFrame, List[pd.DataFrame]]]:
+    """Plot line(s) with shaded uncertainty regions.
+
+    Automatically handles both single and multiple line cases. Useful for
+    plotting mean/median with confidence intervals or standard deviation bands.
+
+    Parameters
+    ----------
+    axis : matplotlib.axes.Axes or AxisWrapper
+        Axes to plot on.
+    xs : np.ndarray or list of np.ndarray
+        X values (single array or list of arrays for multiple lines).
+    ys_lower : np.ndarray or list of np.ndarray
+        Lower bound y values.
+    ys_middle : np.ndarray or list of np.ndarray
+        Middle (mean/median) y values.
+    ys_upper : np.ndarray or list of np.ndarray
+        Upper bound y values.
+    color : ColorLike or list of ColorLike, optional
+        Color(s) for lines and shaded regions.
+    **kwargs : dict
+        Additional keyword arguments passed to plot().
+
+    Returns
+    -------
+    axis : matplotlib.axes.Axes or AxisWrapper
+        The axes with the plot(s).
+    data : pd.DataFrame or list of pd.DataFrame
+        DataFrame(s) containing plot data with columns:
+        x, y_lower, y_middle, y_upper.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import scitex as stx
+    >>> x = np.linspace(0, 10, 100)
+    >>> y_mean = np.sin(x)
+    >>> y_std = 0.2
+    >>> fig, ax = stx.plt.subplots()
+    >>> ax, df = stx.plt.ax.stx_shaded_line(
+    ...     ax, x, y_mean - y_std, y_mean, y_mean + y_std,
+    ...     color='blue', alpha=0.3
+    ... )
+    """
+    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

scitex/plt/ax/_plot/{_plot_violin.py → _stx_violin.py}

@@ -17,9 +17,9 @@ import seaborn as sns
 from ....plt.utils import assert_valid_axis
 
 
-def plot_violin(
+def stx_violin(
     ax,
-    data_list,
+    values_list,
     labels=None,
     colors=None,
     half=False,
@@ -32,10 +32,10 @@ def plot_violin(
     ----------
     ax : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
         The axes to plot on
-    data_list : list
-        List of arrays to plot as violins
+    values_list : list of array-like, shape (n_groups,) where each element is (n_samples,)
+        List of 1D arrays to plot as violins, one per group
     labels : list, optional
-        Labels for each array in data_list
+        Labels for each array in values_list
     colors : list, optional
         Colors for each violin
     half : bool, optional
@@ -48,11 +48,18 @@ def plot_violin(
     ax : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
         The axes object with the plot
     """
+    # Add sample size to label if provided (show range if variable)
+    if kwargs.get("label"):
+        n_per_group = [len(g) for g in values_list]
+        n_min, n_max = min(n_per_group), max(n_per_group)
+        n_str = str(n_min) if n_min == n_max else f"{n_min}-{n_max}"
+        kwargs["label"] = f"{kwargs['label']} ($n$={n_str})"
+
     # Convert list-style data to DataFrame
     all_values = []
     all_groups = []
 
-    for idx, values in enumerate(data_list):
+    for idx, values in enumerate(values_list):
         all_values.extend(values)
         group_label = labels[idx] if labels and idx < len(labels) else f"x {idx}"
         all_groups.extend([group_label] * len(values))

scitex/plt/ax/_style/__init__.py

@@ -35,5 +35,8 @@ from ._share_axes import (
     set_ylims,
 )
 from ._shift import shift
+from ._show_spines import show_spines
+from ._style_boxplot import style_boxplot
+from ._style_violinplot import style_violinplot
 
 # EOF

scitex/plt/ax/_style/_style_barplot.py

@@ -1,18 +1,25 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-11-19 14:52:00 (ywatanabe)"
+# Timestamp: "2025-12-01 20:00:00 (ywatanabe)"
 # File: ./src/scitex/plt/ax/_style/_style_barplot.py
 
 """
 Style bar plot elements with millimeter-based control.
+
+Default values are loaded from SCITEX_STYLE.yaml via presets.py.
 """
 
 from typing import Optional, Union, List
 
+from scitex.plt.styles.presets import SCITEX_STYLE
+
+# Get defaults from centralized config
+_DEFAULT_EDGE_THICKNESS_MM = SCITEX_STYLE.get("bar_edge_thickness_mm", 0.2)
+
 
 def style_barplot(
     bar_container,
-    edge_thickness_mm: float = 0.2,
+    edge_thickness_mm: float = None,
     edgecolor: Optional[Union[str, List[str]]] = 'black',
 ):
     """
@@ -40,6 +47,10 @@ def style_barplot(
     """
     from scitex.plt.utils import mm_to_pt
 
+    # Use centralized default if not specified
+    if edge_thickness_mm is None:
+        edge_thickness_mm = _DEFAULT_EDGE_THICKNESS_MM
+
     # Convert mm to points
     lw_pt = mm_to_pt(edge_thickness_mm)
 

scitex/plt/ax/_style/_style_boxplot.py

@@ -1,77 +1,123 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-11-19 14:30:00 (ywatanabe)"
+# Timestamp: "2025-12-01 20:00:00 (ywatanabe)"
 # File: ./src/scitex/plt/ax/_style/_style_boxplot.py
 
 """
 Style boxplot elements with millimeter-based control.
+
+Default values are loaded from SCITEX_STYLE.yaml via presets.py.
 """
 
 from typing import Dict, Optional
 import matplotlib.pyplot as plt
 
+from scitex.plt.styles.presets import SCITEX_STYLE
+
+# Get defaults from centralized config
+_DEFAULT_LINEWIDTH_MM = SCITEX_STYLE.get("trace_thickness_mm", 0.2)
+_DEFAULT_FLIER_SIZE_MM = SCITEX_STYLE.get("marker_size_mm", 0.8)
+
 
 def style_boxplot(
     boxplot_dict,
-    linewidth_mm: float = 0.8,
+    linewidth_mm: float = None,
+    flier_size_mm: float = None,
+    median_color: str = "black",
+    edge_color: str = "black",
     colors: Optional[list] = None,
     add_legend: bool = False,
     labels: Optional[list] = None,
 ):
-    """
-    Apply consistent styling to matplotlib boxplot elements.
+    """Apply publication-quality styling to matplotlib boxplot elements.
+
+    This function modifies boxplots to:
+    - Set consistent line widths for all elements
+    - Set median line to black for visibility
+    - Set edge colors to black
+    - Apply consistent outlier marker styling
+    - Use scitex color palette by default for box fills
 
     Parameters
     ----------
     boxplot_dict : dict
-        Dictionary returned by ax.boxplot()
-    linewidth_mm : float, optional
-        Line width in millimeters (default: 0.8mm for balanced appearance)
+        Dictionary returned by ax.boxplot().
+    linewidth_mm : float, default 0.2
+        Line width in millimeters for all elements.
+    flier_size_mm : float, default 0.8
+        Outlier (flier) marker size in millimeters.
+    median_color : str, default "black"
+        Color for the median line inside boxes.
+    edge_color : str, default "black"
+        Color for box edges, whiskers, and caps.
     colors : list, optional
-        List of colors for each box. If None, uses default matplotlib colors.
-    add_legend : bool, optional
-        Whether to add a legend (default: False)
+        List of colors for each box fill. If None, uses scitex color palette.
+    add_legend : bool, default False
+        Whether to add a legend.
     labels : list, optional
-        Labels for legend entries (required if add_legend=True)
+        Labels for legend entries (required if add_legend=True).
 
     Returns
     -------
     boxplot_dict : dict
-        The styled boxplot dictionary
+        The styled boxplot dictionary.
 
     Examples
     --------
-    >>> fig, ax = stx.plt.subplots(**stx.plt.presets.NATURE_STYLE)
+    >>> import scitex as stx
+    >>> import numpy as np
+    >>> fig, ax = stx.plt.subplots()
     >>> box_data = [np.random.normal(0, 1, 100) for _ in range(4)]
-    >>> bp = ax.boxplot(box_data)
-    >>> stx.ax.style_boxplot(bp, linewidth_mm=0.8, colors=['blue', 'red', 'green', 'orange'])
+    >>> bp = ax.boxplot(box_data, patch_artist=True)
+    >>> stx.plt.ax.style_boxplot(bp, median_color="black")
     """
     from scitex.plt.utils import mm_to_pt
+    from scitex.plt.color._PARAMS import HEX
+
+    # Use centralized defaults if not specified
+    if linewidth_mm is None:
+        linewidth_mm = _DEFAULT_LINEWIDTH_MM
+    if flier_size_mm is None:
+        flier_size_mm = _DEFAULT_FLIER_SIZE_MM
 
     # Convert mm to points
     lw_pt = mm_to_pt(linewidth_mm)
+    flier_size_pt = mm_to_pt(flier_size_mm)
+
+    # Use scitex color palette by default
+    if colors is None:
+        colors = [
+            HEX["blue"], HEX["red"], HEX["green"], HEX["yellow"],
+            HEX["purple"], HEX["orange"], HEX["lightblue"], HEX["pink"],
+        ]
 
-    # Style box elements
-    for element_name in ['boxes', 'whiskers', 'caps', 'medians', 'fliers']:
+    # Style box elements with line width
+    for element_name in ['boxes', 'whiskers', 'caps']:
         if element_name in boxplot_dict:
             for element in boxplot_dict[element_name]:
                 element.set_linewidth(lw_pt)
+                element.set_color(edge_color)
+
+    # Style medians with specified color
+    if 'medians' in boxplot_dict:
+        for median in boxplot_dict['medians']:
+            median.set_linewidth(lw_pt)
+            median.set_color(median_color)
+
+    # Style fliers (outliers) with marker size
+    if 'fliers' in boxplot_dict:
+        for flier in boxplot_dict['fliers']:
+            flier.set_markersize(flier_size_pt)
+            flier.set_markeredgewidth(lw_pt)
+            flier.set_markeredgecolor(edge_color)
+            flier.set_markerfacecolor('none')  # Open circles
 
-    # Apply colors if provided
-    if colors is not None:
-        n_boxes = len(boxplot_dict.get('boxes', []))
-        for i, box in enumerate(boxplot_dict.get('boxes', [])):
-            color = colors[i % len(colors)]
-            box.set_edgecolor(color)
-            # Also color the associated whiskers, caps, and median
-            if 'whiskers' in boxplot_dict:
-                boxplot_dict['whiskers'][i*2].set_color(color)
-                boxplot_dict['whiskers'][i*2+1].set_color(color)
-            if 'caps' in boxplot_dict:
-                boxplot_dict['caps'][i*2].set_color(color)
-                boxplot_dict['caps'][i*2+1].set_color(color)
-            if 'medians' in boxplot_dict and i < len(boxplot_dict['medians']):
-                boxplot_dict['medians'][i].set_color(color)
+    # Apply fill colors to boxes
+    for i, box in enumerate(boxplot_dict.get('boxes', [])):
+        color = colors[i % len(colors)]
+        if hasattr(box, 'set_facecolor'):
+            box.set_facecolor(color)
+        box.set_edgecolor(edge_color)
 
     # Add legend if requested
     if add_legend and labels is not None:

scitex/plt/ax/_style/_style_errorbar.py

@@ -1,19 +1,27 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-11-19 14:50:00 (ywatanabe)"
+# Timestamp: "2025-12-01 20:00:00 (ywatanabe)"
 # File: ./src/scitex/plt/ax/_style/_style_errorbar.py
 
 """
 Style error bar elements with millimeter-based control.
+
+Default values are loaded from SCITEX_STYLE.yaml via presets.py.
 """
 
 from typing import Optional
 
+from scitex.plt.styles.presets import SCITEX_STYLE
+
+# Get defaults from centralized config
+_DEFAULT_THICKNESS_MM = SCITEX_STYLE.get("trace_thickness_mm", 0.2)
+_DEFAULT_CAP_WIDTH_MM = SCITEX_STYLE.get("errorbar_cap_width_mm", 0.8)
+
 
 def style_errorbar(
     errorbar_container,
-    thickness_mm: float = 0.2,
-    cap_width_mm: float = 0.8,
+    thickness_mm: float = None,
+    cap_width_mm: float = None,
 ):
     """
     Apply consistent styling to matplotlib errorbar elements.
@@ -40,6 +48,12 @@ def style_errorbar(
     """
     from scitex.plt.utils import mm_to_pt
 
+    # Use centralized defaults if not specified
+    if thickness_mm is None:
+        thickness_mm = _DEFAULT_THICKNESS_MM
+    if cap_width_mm is None:
+        cap_width_mm = _DEFAULT_CAP_WIDTH_MM
+
     # Convert mm to points
     lw_pt = mm_to_pt(thickness_mm)
     cap_width_pt = mm_to_pt(cap_width_mm)

scitex/plt/ax/_style/_style_scatter.py

@@ -1,19 +1,27 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Timestamp: "2025-11-19 15:00:00 (ywatanabe)"
+# Timestamp: "2025-12-01 20:00:00 (ywatanabe)"
 # File: ./src/scitex/plt/ax/_style/_style_scatter.py
 
 """
 Style scatter plot elements with millimeter-based control.
+
+Default values are loaded from SCITEX_STYLE.yaml via presets.py.
 """
 
 from typing import Optional
 
+from scitex.plt.styles.presets import SCITEX_STYLE
+
+# Get defaults from centralized config
+_DEFAULT_SIZE_MM = SCITEX_STYLE.get("scatter_size_mm", 0.8)
+_DEFAULT_EDGE_THICKNESS_MM = SCITEX_STYLE.get("marker_edge_width_mm", 0.0)
+
 
 def style_scatter(
     path_collection,
-    size_mm: float = 0.8,
-    edge_thickness_mm: float = 0.0,
+    size_mm: float = None,
+    edge_thickness_mm: float = None,
 ):
     """
     Apply consistent styling to matplotlib scatter plot elements.
@@ -46,6 +54,12 @@ def style_scatter(
     """
     from scitex.plt.utils import mm_to_pt
 
+    # Use centralized defaults if not specified
+    if size_mm is None:
+        size_mm = _DEFAULT_SIZE_MM
+    if edge_thickness_mm is None:
+        edge_thickness_mm = _DEFAULT_EDGE_THICKNESS_MM
+
     # Convert mm to points
     size_pt = mm_to_pt(size_mm)
 

scitex/plt/ax/_style/_style_violinplot.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 20:00:00 (ywatanabe)"
+# File: ./src/scitex/plt/ax/_style/_style_violinplot.py
+
+"""Style violin plot elements with millimeter-based control.
+
+Default values are loaded from SCITEX_STYLE.yaml via presets.py.
+"""
+
+from typing import Optional, Union
+
+from matplotlib.axes import Axes
+
+from scitex.plt.styles.presets import SCITEX_STYLE
+
+# Get defaults from centralized config
+_DEFAULT_LINEWIDTH_MM = SCITEX_STYLE.get("trace_thickness_mm", 0.2)
+
+
+def style_violinplot(
+    ax: Union[Axes, "AxisWrapper"],
+    linewidth_mm: float = None,
+    edge_color: str = "black",
+    median_color: str = "black",
+    remove_caps: bool = True,
+) -> Union[Axes, "AxisWrapper"]:
+    """Apply publication-quality styling to seaborn violin plots.
+
+    This function modifies violin plots created by seaborn.violinplot() to:
+    - Add borders to the KDE (violin body) edges
+    - Remove caps from the internal boxplot whiskers
+    - Set median line to black for better visibility
+    - Apply consistent line widths
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes or AxisWrapper
+        The axes containing the violin plot.
+    linewidth_mm : float, default 0.2
+        Line width in millimeters for violin edges and boxplot elements.
+    edge_color : str, default "black"
+        Color for the violin body edges.
+    median_color : str, default "black"
+        Color for the median line inside the boxplot.
+    remove_caps : bool, default True
+        Whether to remove the caps (horizontal lines) from boxplot whiskers.
+
+    Returns
+    -------
+    ax : matplotlib.axes.Axes or AxisWrapper
+        The axes with styled violin plot.
+
+    Examples
+    --------
+    >>> import seaborn as sns
+    >>> import scitex as stx
+    >>> fig, ax = stx.plt.subplots()
+    >>> sns.violinplot(data=df, x="group", y="value", ax=ax)
+    >>> stx.plt.ax.style_violinplot(ax)
+    """
+    from scitex.plt.utils import mm_to_pt
+
+    # Use centralized default if not specified
+    if linewidth_mm is None:
+        linewidth_mm = _DEFAULT_LINEWIDTH_MM
+
+    lw_pt = mm_to_pt(linewidth_mm)
+
+    # Style violin bodies (PolyCollection)
+    for collection in ax.collections:
+        # Check if it's a violin body (PolyCollection with filled area)
+        if hasattr(collection, 'set_edgecolor'):
+            collection.set_edgecolor(edge_color)
+            collection.set_linewidth(lw_pt)
+
+    # Style internal boxplot elements (Line2D objects)
+    # Seaborn violin plot lines: whiskers (vertical), caps (horizontal), median (short horizontal)
+    lines = list(ax.lines)
+    n_violins = len([c for c in ax.collections if hasattr(c, 'get_paths') and len(c.get_paths()) > 0])
+
+    for line in lines:
+        # Get line data to identify element type
+        xdata = line.get_xdata()
+        ydata = line.get_ydata()
+
+        if len(ydata) != 2:
+            continue
+
+        # Caps are horizontal lines (same y-value for both points) with wider x-span
+        is_horizontal = ydata[0] == ydata[1]
+        x_span = abs(xdata[1] - xdata[0]) if len(xdata) == 2 else 0
+
+        if is_horizontal:
+            if remove_caps and x_span > 0.05:
+                # This is likely a cap (wider horizontal line at whisker ends)
+                line.set_visible(False)
+            else:
+                # This is likely a median line (short horizontal line)
+                line.set_color(median_color)
+                line.set_linewidth(lw_pt)
+        else:
+            # Vertical lines (whiskers)
+            line.set_linewidth(lw_pt)
+
+    return ax
+
+
+# EOF

scitex/plt/color/_vizualize_colors.py

@@ -28,18 +28,18 @@ def vizualize_colors(colors):
         xx, yy, ss = gen_rand_sample()
 
         # # Box color plot
-        # ax.plot_rectangle(
+        # ax.stx_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)
+        ax.stx_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)
+        # axes[3].stx_kde(yy, color=rgba, label=color_str)
 
     # for ax in axes.flat:
     #     # ax.axis("off")