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

scitex/plt/ax/_plot/_stx_heatmap.py

@@ -0,0 +1,366 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-12-01 13:00:00 (ywatanabe)"
+# File: ./src/scitex/plt/ax/_plot/_plot_heatmap.py
+
+"""Heatmap plotting with automatic annotation color switching."""
+
+from typing import Any, List, Optional, Tuple, Union
+
+import matplotlib
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.axes import Axes
+from matplotlib.colorbar import Colorbar
+from matplotlib.image import AxesImage
+
+
+def stx_heatmap(
+    ax: Union[Axes, "AxisWrapper"],
+    values_2d: np.ndarray,
+    x_labels: Optional[List[str]] = None,
+    y_labels: Optional[List[str]] = None,
+    cmap: str = "viridis",
+    cbar_label: str = "ColorBar Label",
+    annot_format: str = "{x:.1f}",
+    show_annot: bool = True,
+    annot_color_lighter: str = "black",
+    annot_color_darker: str = "white",
+    **kwargs: Any,
+) -> Tuple[Union[Axes, "AxisWrapper"], AxesImage, Colorbar]:
+    """Plot a heatmap on the given axes with automatic annotation colors.
+
+    Creates a heatmap visualization with optional cell annotations. Annotation
+    text colors are automatically switched based on background brightness for
+    optimal readability.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes or AxisWrapper
+        The axes to plot on.
+    values_2d : np.ndarray, shape (n_rows, n_cols)
+        2D array of data to display as heatmap.
+    x_labels : list of str, optional
+        Labels for the x-axis (columns).
+    y_labels : list of str, optional
+        Labels for the y-axis (rows).
+    cmap : str, default "viridis"
+        Colormap name to use.
+    cbar_label : str, default "ColorBar Label"
+        Label for the colorbar.
+    annot_format : str, default "{x:.1f}"
+        Format string for cell annotations.
+    show_annot : bool, default True
+        Whether to annotate the heatmap with values.
+    annot_color_lighter : str, default "black"
+        Text color for annotations on lighter backgrounds.
+    annot_color_darker : str, default "white"
+        Text color for annotations on darker backgrounds.
+    **kwargs : dict
+        Additional keyword arguments passed to imshow().
+
+    Returns
+    -------
+    ax : matplotlib.axes.Axes or AxisWrapper
+        The axes with the heatmap.
+    im : matplotlib.image.AxesImage
+        The image object created by imshow.
+    cbar : matplotlib.colorbar.Colorbar
+        The colorbar object.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import scitex as stx
+    >>> data = np.random.rand(5, 10)
+    >>> fig, ax = stx.plt.subplots()
+    >>> ax, im, cbar = stx.plt.ax.stx_heatmap(
+    ...     ax, data,
+    ...     x_labels=[f"X{i}" for i in range(10)],
+    ...     y_labels=[f"Y{i}" for i in range(5)],
+    ...     cmap="Blues"
+    ... )
+    """
+
+    im, cbar = _mpl_heatmap(
+        values_2d,
+        x_labels,
+        y_labels,
+        ax=ax,
+        cmap=cmap,
+        cbarlabel=cbar_label,
+    )
+
+    if show_annot:
+        textcolors = _switch_annot_colors(cmap, annot_color_lighter, annot_color_darker)
+        texts = _mpl_annotate_heatmap(
+            im,
+            valfmt=annot_format,
+            textcolors=textcolors,
+        )
+
+    return ax, im, cbar
+
+
+def _switch_annot_colors(
+    cmap: str,
+    annot_color_lighter: str,
+    annot_color_darker: str,
+) -> Tuple[str, str]:
+    """Determine annotation text colors based on colormap brightness.
+
+    Uses perceived brightness (ITU-R BT.709) to select appropriate text
+    colors for light vs dark backgrounds in the colormap.
+
+    Parameters
+    ----------
+    cmap : str
+        Colormap name.
+    annot_color_lighter : str
+        Color to use on lighter backgrounds.
+    annot_color_darker : str
+        Color to use on darker backgrounds.
+
+    Returns
+    -------
+    tuple of str
+        (color_for_dark_bg, color_for_light_bg) text colors.
+    """
+    cmap_obj = plt.cm.get_cmap(cmap)
+
+    # Sample colormap at extremes (avoiding edge effects)
+    dark_color = cmap_obj(0.1)
+    light_color = cmap_obj(0.9)
+
+    # Calculate perceived brightness using ITU-R BT.709 coefficients
+    dark_brightness = (
+        0.2126 * dark_color[0] + 0.7152 * dark_color[1] + 0.0722 * dark_color[2]
+    )
+
+    # Choose text colors based on background brightness
+    if dark_brightness < 0.5:
+        return (annot_color_lighter, annot_color_darker)
+    else:
+        return (annot_color_darker, annot_color_lighter)
+
+
+def _mpl_heatmap(
+    data: np.ndarray,
+    row_labels: Optional[List[str]],
+    col_labels: Optional[List[str]],
+    ax: Optional[Axes] = None,
+    cbar_kw: Optional[dict] = None,
+    cbarlabel: str = "",
+    **kwargs: Any,
+) -> Tuple[AxesImage, Colorbar]:
+    """Create a heatmap with imshow and add a colorbar.
+
+    Parameters
+    ----------
+    data : np.ndarray
+        2D array of data to display.
+    row_labels : list of str or None
+        Labels for the rows (y-axis).
+    col_labels : list of str or None
+        Labels for the columns (x-axis).
+    ax : matplotlib.axes.Axes, optional
+        Axes to plot on. If None, uses current axes.
+    cbar_kw : dict, optional
+        Keyword arguments for colorbar creation.
+    cbarlabel : str, default ""
+        Label for the colorbar.
+    **kwargs : dict
+        Additional keyword arguments passed to imshow().
+
+    Returns
+    -------
+    im : matplotlib.image.AxesImage
+        The image object.
+    cbar : matplotlib.colorbar.Colorbar
+        The colorbar object.
+    """
+
+    if ax is None:
+        ax = plt.gca()
+
+    if cbar_kw is None:
+        cbar_kw = {}
+
+    # Plot the heatmap
+    im = ax.imshow(data, **kwargs)
+
+    # Create colorbar with proper formatting
+    cbar = ax.figure.colorbar(im, ax=ax, **cbar_kw)
+    cbar.ax.set_ylabel(cbarlabel, rotation=-90, va="bottom")
+
+    # Set colorbar border width to match axes spines
+    cbar.outline.set_linewidth(0.2 * 2.83465)  # 0.2mm in points
+
+    # Format colorbar ticks
+    from matplotlib.ticker import MaxNLocator
+    cbar.ax.yaxis.set_major_locator(MaxNLocator(nbins=4, min_n_ticks=3))
+    cbar.ax.tick_params(width=0.2 * 2.83465, length=0.8 * 2.83465)  # Match tick styling
+
+    # Show all ticks and label them with the respective list entries.
+    ax.set_xticks(
+        range(data.shape[1]),
+        labels=col_labels,
+        # rotation=45,
+        # ha="right",
+        # rotation_mode="anchor",
+    )
+    ax.set_yticks(range(data.shape[0]), labels=row_labels)
+
+    # Let the horizontal axes labeling appear on top.
+    ax.tick_params(top=False, bottom=True, labeltop=False, labelbottom=True)
+
+    # Show all 4 spines for heatmap
+    ax.spines[:].set_visible(True)
+
+    # Set aspect ratio to 'equal' for square cells (1:1)
+    ax.set_aspect('equal', adjustable='box')
+
+    ax.set_xticks(np.arange(data.shape[1] + 1) - 0.5, minor=True)
+    ax.set_yticks(np.arange(data.shape[0] + 1) - 0.5, minor=True)
+    ax.tick_params(which="minor", bottom=False, left=False)
+
+    return im, cbar
+
+
+def _calc_annot_fontsize(n_rows: int, n_cols: int) -> float:
+    """Calculate dynamic annotation font size based on cell count.
+
+    Uses a base size of 6pt for small heatmaps and scales down for larger ones.
+
+    Parameters
+    ----------
+    n_rows : int
+        Number of rows in the heatmap.
+    n_cols : int
+        Number of columns in the heatmap.
+
+    Returns
+    -------
+    float
+        Font size in points.
+    """
+    # Base font size for small heatmaps (e.g., 5x5)
+    BASE_FONTSIZE = 6.0
+    BASE_CELLS = 5  # Reference dimension
+
+    # Use the larger dimension to scale
+    max_dim = max(n_rows, n_cols)
+
+    if max_dim <= BASE_CELLS:
+        return BASE_FONTSIZE
+    elif max_dim <= 10:
+        # Linear interpolation: 6pt at 5 cells, 5pt at 10 cells
+        return BASE_FONTSIZE - (max_dim - BASE_CELLS) * 0.2
+    elif max_dim <= 20:
+        # 5pt at 10 cells, 4pt at 20 cells
+        return 5.0 - (max_dim - 10) * 0.1
+    else:
+        # Minimum 3pt for very large heatmaps
+        return max(3.0, 4.0 - (max_dim - 20) * 0.05)
+
+
+def _mpl_annotate_heatmap(
+    im: AxesImage,
+    data: Optional[np.ndarray] = None,
+    valfmt: str = "{x:.2f}",
+    textcolors: Tuple[str, str] = ("lightgray", "black"),
+    threshold: Optional[float] = None,
+    fontsize: Optional[float] = None,
+    **textkw: Any,
+) -> List:
+    """Annotate a heatmap with cell values.
+
+    Parameters
+    ----------
+    im : matplotlib.image.AxesImage
+        The image to be annotated.
+    data : np.ndarray, optional
+        Data used to annotate. If None, uses the image's array.
+    valfmt : str, default "{x:.2f}"
+        Format string for the annotations.
+    textcolors : tuple of str, default ("lightgray", "black")
+        Colors for annotations. First color for values below threshold,
+        second for values above.
+    threshold : float, optional
+        Value in normalized colormap space (0 to 1) above which the
+        second color is used. If None, uses 0.7 * max(data).
+    fontsize : float, optional
+        Font size in points. If None, dynamically calculated based on
+        cell count (6pt base, scaling down for larger heatmaps).
+    **textkw : dict
+        Additional keyword arguments passed to ax.text().
+
+    Returns
+    -------
+    texts : list of matplotlib.text.Text
+        The annotation text objects.
+    """
+
+    if not isinstance(data, (list, np.ndarray)):
+        data = im.get_array()
+
+    # Calculate dynamic font size if not specified
+    if fontsize is None:
+        fontsize = _calc_annot_fontsize(data.shape[0], data.shape[1])
+
+    # Normalize the threshold to the images color range.
+    if threshold is not None:
+        threshold = im.norm(threshold)
+    else:
+        # Use 0.7 instead of 0.5 for better visibility with most colormaps
+        threshold = im.norm(data.max()) * 0.7
+
+    # Set default alignment to center, but allow it to be
+    # overwritten by textkw.
+    kw = dict(horizontalalignment="center", verticalalignment="center", fontsize=fontsize)
+    kw.update(textkw)
+
+    # Get the formatter in case a string is supplied
+    if isinstance(valfmt, str):
+        valfmt = matplotlib.ticker.StrMethodFormatter(valfmt)
+
+    # Loop over the data and create a `Text` for each "pixel".
+    # Change the text's color depending on the data.
+    texts = []
+    for ii in range(data.shape[0]):
+        for jj in range(data.shape[1]):
+            kw.update(color=textcolors[int(im.norm(data[ii, jj]) > threshold)])
+            text = im.axes.text(jj, ii, valfmt(data[ii, jj], None), **kw)
+            texts.append(text)
+
+    return texts
+
+
+if __name__ == "__main__":
+    import matplotlib
+    import matplotlib as mpl
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    data = np.random.rand(5, 10)
+    x_labels = [f"X{ii+1}" for ii in range(5)]
+    y_labels = [f"Y{ii+1}" for ii in range(10)]
+
+    fig, ax = plt.subplots()
+
+    im, cbar = stx_heatmap(
+        ax,
+        data,
+        x_labels=x_labels,
+        y_labels=y_labels,
+        show_annot=True,
+        annot_color_lighter="white",
+        annot_color_darker="black",
+        cmap="Blues",
+    )
+
+    fig.tight_layout()
+    plt.show()
+    # EOF
+
+# EOF

scitex/plt/ax/_plot/{_plot_image.py → _stx_image.py}

@@ -13,7 +13,7 @@ import matplotlib
 from scitex.plt.utils import assert_valid_axis
 
 
-def plot_image(
+def stx_image(
     ax,
     arr_2d,
     cbar=True,

scitex/plt/ax/_plot/_stx_joyplot.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Timestamp: "2025-05-02 09:03:23 (ywatanabe)"
+# File: /home/ywatanabe/proj/scitex_repo/src/scitex/plt/ax/_plot/_plot_joyplot.py
+# ----------------------------------------
+import os
+
+__FILE__ = "./src/scitex/plt/ax/_plot/_plot_joyplot.py"
+__DIR__ = os.path.dirname(__FILE__)
+# ----------------------------------------
+
+import numpy as np
+from scipy import stats
+
+from ....plt.utils import assert_valid_axis
+
+
+def stx_joyplot(ax, arrays, overlap=0.5, fill_alpha=0.7, line_alpha=1.0,
+                 colors=None, **kwargs):
+    """
+    Create a joyplot (ridgeline plot) on the provided axes.
+
+    Parameters
+    ----------
+    ax : matplotlib.axes.Axes
+        The axes to plot on
+    arrays : list of array-like
+        List of 1D arrays for each ridge
+    overlap : float, default 0.5
+        Amount of overlap between ridges (0 = no overlap, 1 = full overlap)
+    fill_alpha : float, default 0.7
+        Alpha for the filled KDE area
+    line_alpha : float, default 1.0
+        Alpha for the KDE line
+    colors : list, optional
+        Colors for each ridge. If None, uses scitex palette.
+    **kwargs
+        Additional keyword arguments
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The axes with the joyplot
+    """
+    assert_valid_axis(ax, "First argument must be a matplotlib axis or scitex axis wrapper")
+
+    # Add sample size per distribution to label if provided (show range if variable)
+    if kwargs.get("label"):
+        n_per_dist = [len(arr) for arr in arrays]
+        n_min, n_max = min(n_per_dist), max(n_per_dist)
+        n_str = str(n_min) if n_min == n_max else f"{n_min}-{n_max}"
+        kwargs["label"] = f"{kwargs['label']} ($n$={n_str})"
+
+    # Import scitex colors
+    from scitex.plt.color._PARAMS import HEX
+
+    # Default colors from scitex palette
+    if colors is None:
+        colors = [
+            HEX["blue"], HEX["red"], HEX["green"], HEX["yellow"],
+            HEX["purple"], HEX["orange"], HEX["lightblue"], HEX["pink"],
+        ]
+
+    n_ridges = len(arrays)
+
+    # Calculate global x range
+    all_data = np.concatenate([np.asarray(arr) for arr in arrays])
+    x_min, x_max = np.min(all_data), np.max(all_data)
+    x_range = x_max - x_min
+    x_padding = x_range * 0.1
+    x = np.linspace(x_min - x_padding, x_max + x_padding, 200)
+
+    # Calculate KDEs and find max density for scaling
+    kdes = []
+    max_density = 0
+    for arr in arrays:
+        arr = np.asarray(arr)
+        if len(arr) > 1:
+            kde = stats.gaussian_kde(arr)
+            density = kde(x)
+            kdes.append(density)
+            max_density = max(max_density, np.max(density))
+        else:
+            kdes.append(np.zeros_like(x))
+
+    # Scale factor for ridge height
+    ridge_height = 1.0 / (1.0 - overlap * 0.5) if overlap < 1 else 2.0
+
+    # Plot each ridge from back to front
+    for i in range(n_ridges - 1, -1, -1):
+        color = colors[i % len(colors)]
+        baseline = i * (1.0 - overlap)
+
+        # Scale density to fit nicely
+        scaled_density = kdes[i] / max_density * ridge_height if max_density > 0 else kdes[i]
+
+        # Fill
+        ax.fill_between(x, baseline, baseline + scaled_density,
+                       facecolor=color, edgecolor='none', alpha=fill_alpha)
+        # Line on top
+        ax.plot(x, baseline + scaled_density, color=color, alpha=line_alpha,
+               linewidth=1.0)
+
+    # Set y limits
+    ax.set_ylim(-0.1, n_ridges * (1.0 - overlap) + ridge_height)
+
+    # Hide y-axis ticks for cleaner look (joyplots typically don't show y values)
+    ax.set_yticks([])
+
+    return ax
+
+
+# EOF

scitex/plt/ax/_plot/{_plot_raster.py → _stx_raster.py}

@@ -18,15 +18,16 @@ import pandas as pd
 from ....plt.utils import assert_valid_axis
 
 
-def plot_raster(
+def stx_raster(
     ax,
-    event_times,
+    spike_times_list,
     time=None,
     labels=None,
     colors=None,
     orientation="horizontal",
     y_offset=None,
     lineoffsets=None,
+    linelengths=None,
     apply_set_n_ticks=True,
     n_xticks=4,
     n_yticks=None,
@@ -39,8 +40,8 @@ def plot_raster(
     ----------
     ax : matplotlib.axes.Axes or scitex.plt._subplots.AxisWrapper
         The axes on which to draw the raster plot.
-    event_times : Array-like or list of lists
-        Time points of events by channels/trials
+    spike_times_list : list of array-like, shape (n_trials,) where each element is (n_spikes,)
+        List of spike/event time arrays, one per trial/channel
     time : array-like, optional
         The time indices for the events (default: np.linspace(0, max(event_times))).
     labels : list, optional
@@ -50,9 +51,11 @@ def plot_raster(
     orientation: str, optional
         Orientation of raster plot (default: horizontal).
     y_offset : float, optional
-        Vertical spacing between trials/channels.
+        Vertical spacing between trials/channels (default: 1.0).
     lineoffsets : array-like, optional
         Y-positions for each trial/channel (overrides automatic positioning).
+    linelengths : float, optional
+        Height of each spike mark (default: 0.8, slightly less than y_offset to prevent overlap).
     apply_set_n_ticks : bool, optional
         Whether to apply set_n_ticks for cleaner axis (default: True).
     n_xticks : int, optional
@@ -71,37 +74,46 @@ def plot_raster(
     """
     assert_valid_axis(ax, "First argument must be a matplotlib axis or scitex axis wrapper")
 
-    # Format event_times data
-    event_times_list = _ensure_list(event_times)
+    # Format spike_times_list data
+    spike_times_list = _ensure_list(spike_times_list)
+
+    # Add sample size (number of trials) to label if provided
+    if kwargs.get("label"):
+        n_trials = len(spike_times_list)
+        kwargs["label"] = f"{kwargs['label']} ($n$={n_trials})"
 
     # Handle colors and labels
-    colors = _handle_colors(colors, event_times_list)
-    
+    colors = _handle_colors(colors, spike_times_list)
+
     # Handle lineoffsets for positioning between trials/channels
+    if y_offset is None:
+        y_offset = 1.0  # Default spacing
     if lineoffsets is None:
-        if y_offset is None:
-            y_offset = 1.0  # Default spacing
-        lineoffsets = np.arange(len(event_times_list)) * y_offset
-    
-    # Ensure lineoffsets is iterable and matches event_times_list length
+        lineoffsets = np.arange(len(spike_times_list)) * y_offset
+
+    # Set linelengths to prevent overlap (80% of y_offset by default)
+    if linelengths is None:
+        linelengths = y_offset * 0.8
+
+    # Ensure lineoffsets is iterable and matches spike_times_list length
     if np.isscalar(lineoffsets):
         lineoffsets = [lineoffsets]
-    if len(lineoffsets) < len(event_times_list):
-        lineoffsets = list(lineoffsets) + list(range(len(lineoffsets), len(event_times_list)))
+    if len(lineoffsets) < len(spike_times_list):
+        lineoffsets = list(lineoffsets) + list(range(len(lineoffsets), len(spike_times_list)))
 
-    # Plotting as eventplot using event_times_list with proper positioning
-    for ii, (pos, color, offset) in enumerate(zip(event_times_list, colors, lineoffsets)):
+    # Plotting as eventplot using spike_times_list with proper positioning
+    for ii, (pos, color, offset) in enumerate(zip(spike_times_list, colors, lineoffsets)):
         label = _define_label(labels, ii)
-        ax.eventplot(pos, lineoffsets=offset, orientation=orientation, 
-                    colors=color, label=label, **kwargs)
+        ax.eventplot(pos, lineoffsets=offset, linelengths=linelengths,
+                    orientation=orientation, colors=color, label=label, **kwargs)
 
     # Apply set_n_ticks for cleaner axes if requested
     if apply_set_n_ticks:
         from scitex.plt.ax._style._set_n_ticks import set_n_ticks
-        
+
         # For categorical y-axis (trials/channels), use appropriate tick count
         if n_yticks is None:
-            n_yticks = min(len(event_times_list), 8)  # Max 8 ticks for readability
+            n_yticks = min(len(spike_times_list), 8)  # Max 8 ticks for readability
         
         # Only apply if we have reasonable numeric ranges
         try:
@@ -124,10 +136,10 @@ def plot_raster(
     if labels is not None:
         ax.legend()
 
-    # Return event_times in a useful format
-    event_times_digital_df = _event_times_to_digital_df(event_times_list, time, lineoffsets)
+    # Return spike_times in a useful format
+    spike_times_digital_df = _event_times_to_digital_df(spike_times_list, time, lineoffsets)
 
-    return ax, event_times_digital_df
+    return ax, spike_times_digital_df
 
 
 def _ensure_list(event_times):

scitex/plt/ax/_plot/{_plot_rectangle.py → _stx_rectangle.py}

@@ -12,11 +12,12 @@ __DIR__ = os.path.dirname(__FILE__)
 from matplotlib.patches import Rectangle
 
 
-def plot_rectangle(ax, xx, yy, ww, hh, **kwargs):
+def stx_rectangle(ax, xx, yy, ww, hh, **kwargs):
     """Add a rectangle patch to an axes.
 
     Convenience function for adding rectangular patches to plots, useful for
     highlighting regions, creating box annotations, or drawing geometric shapes.
+    By default, rectangles have no edge (border) for cleaner publication figures.
 
     Parameters
     ----------
@@ -34,7 +35,7 @@ def plot_rectangle(ax, xx, yy, ww, hh, **kwargs):
         Additional keyword arguments passed to matplotlib.patches.Rectangle.
         Common options include:
         - facecolor/fc : fill color
-        - edgecolor/ec : edge color
+        - edgecolor/ec : edge color (default: 'none')
         - linewidth/lw : edge line width
         - alpha : transparency (0-1)
         - linestyle/ls : edge line style
@@ -48,20 +49,20 @@ def plot_rectangle(ax, xx, yy, ww, hh, **kwargs):
     --------
     >>> fig, ax = plt.subplots()
     >>> ax.plot([0, 10], [0, 10])
-    >>> # Highlight a region
-    >>> plot_rectangle(ax, 2, 3, 4, 3, facecolor='yellow', alpha=0.3)
+    >>> # Highlight a region (no border by default)
+    >>> stx_rectangle(ax, 2, 3, 4, 3, facecolor='yellow', alpha=0.3)
 
-    >>> # Draw a box annotation
-    >>> plot_rectangle(ax, 5, 5, 2, 2, facecolor='none', edgecolor='red', linewidth=2)
-
-    >>> # Create a filled rectangle
-    >>> plot_rectangle(ax, 0, 0, 1, 1, facecolor='blue', edgecolor='black')
+    >>> # Draw a box with explicit edge
+    >>> stx_rectangle(ax, 5, 5, 2, 2, facecolor='none', edgecolor='red', linewidth=2)
 
     See Also
     --------
     matplotlib.patches.Rectangle : The underlying Rectangle class
     matplotlib.axes.Axes.add_patch : Method used to add the patch
     """
+    # Default to no edge for cleaner publication figures
+    if 'edgecolor' not in kwargs and 'ec' not in kwargs:
+        kwargs['edgecolor'] = 'none'
     ax.add_patch(Rectangle((xx, yy), ww, hh, **kwargs))
     return ax
 

scitex/plt/ax/_plot/{_plot_scatter_hist.py → _stx_scatter_hist.py}

@@ -12,7 +12,7 @@ __DIR__ = os.path.dirname(__FILE__)
 import numpy as np
 
 
-def plot_scatter_hist(
+def stx_scatter_hist(
     ax,
     x,
     y,