canns 0.14.2__py3-none-any.whl → 0.15.0__py3-none-any.whl

canns/analyzer/data/asa/embedding.py

@@ -31,10 +31,9 @@ def embed_spike_trains(spike_trains, config: SpikeEmbeddingConfig | None = None,
     Returns
     -------
     tuple
-        ``(spikes_bin, xx, yy, tt)`` where:
-        - ``spikes_bin`` is a (T, N) binned spike matrix.
-        - ``xx``, ``yy``, ``tt`` are position/time arrays when ``speed_filter=True``,
-          otherwise ``None``.
+        ``(spikes_bin, xx, yy, tt)``. ``spikes_bin`` is a (T, N) binned spike matrix.
+        ``xx``, ``yy``, ``tt`` are position/time arrays when ``speed_filter=True``,
+        otherwise ``None``.
 
     Examples
     --------

canns/analyzer/data/asa/plotting.py

@@ -403,7 +403,7 @@ def plot_path_compare_1d(
     return fig, axes
 
 
-def plot_cohomap(
+def plot_cohomap_scatter(
     decoding_result: dict[str, Any],
     position_data: dict[str, Any],
     config: PlotConfig | None = None,
@@ -453,7 +453,7 @@ def plot_cohomap(
         >>> # Decode coordinates
         >>> decoding = decode_circular_coordinates(persistence_result, spike_data)
         >>> # Visualize with trajectory data
-        >>> fig = plot_cohomap(
+        >>> fig = plot_cohomap_scatter(
         ...     decoding,
         ...     position_data={'x': xx, 'y': yy},
         ...     save_path='cohomap.png',
@@ -518,7 +518,7 @@ def plot_cohomap(
     return fig
 
 
-def plot_cohomap_multi(
+def plot_cohomap_scatter_multi(
     decoding_result: dict,
     position_data: dict,
     config: PlotConfig | None = None,
@@ -560,7 +560,7 @@ def plot_cohomap_multi(
 
     Examples
     --------
-    >>> fig = plot_cohomap_multi(decoding, {"x": xx, "y": yy}, show=False)  # doctest: +SKIP
+    >>> fig = plot_cohomap_scatter_multi(decoding, {"x": xx, "y": yy}, show=False)  # doctest: +SKIP
     """
     config = _ensure_plot_config(
         config,

canns/analyzer/data/cell_classification/__init__.py

@@ -11,6 +11,9 @@ Vollan, Gardner, Moser & Moser (Nature, 2025)
 __version__ = "0.1.0"
 
 from .core import (  # noqa: F401
+    BTNAnalyzer,
+    BTNConfig,
+    BTNResult,
     GridnessAnalyzer,
     GridnessResult,
     HDCellResult,
@@ -46,6 +49,8 @@ from .utils import (  # noqa: F401
 )
 from .visualization import (  # noqa: F401
     plot_autocorrelogram,
+    plot_btn_autocorr_summary,
+    plot_btn_distance_matrix,
     plot_grid_score_histogram,
     plot_gridness_analysis,
     plot_hd_analysis,
@@ -57,6 +62,9 @@ from .visualization import (  # noqa: F401
 __all__ = [
     "GridnessAnalyzer",
     "GridnessResult",
+    "BTNAnalyzer",
+    "BTNConfig",
+    "BTNResult",
     "HeadDirectionAnalyzer",
     "HDCellResult",
     "compute_2d_autocorrelation",
@@ -94,4 +102,6 @@ __all__ = [
     "plot_polar_tuning",
     "plot_temporal_autocorr",
     "plot_hd_analysis",
+    "plot_btn_autocorr_summary",
+    "plot_btn_distance_matrix",
 ]

canns/analyzer/data/cell_classification/core/__init__.py

@@ -1,5 +1,6 @@
 """Core analysis modules."""
 
+from .btn import BTNAnalyzer, BTNConfig, BTNResult
 from .grid_cells import GridnessAnalyzer, GridnessResult, compute_2d_autocorrelation
 from .grid_modules_leiden import identify_grid_modules_and_stats
 from .head_direction import HDCellResult, HeadDirectionAnalyzer
@@ -15,6 +16,9 @@ __all__ = [
     "GridnessAnalyzer",
     "compute_2d_autocorrelation",
     "GridnessResult",
+    "BTNAnalyzer",
+    "BTNConfig",
+    "BTNResult",
     "HeadDirectionAnalyzer",
     "HDCellResult",
     "compute_rate_map",

canns/analyzer/data/cell_classification/core/btn.py

@@ -0,0 +1,272 @@
+"""
+BTN (Bursty/Theta/Non-bursty) classification.
+
+Workflow:
+1) Compute ISI autocorrelograms from spike times.
+2) Normalize and smooth each autocorr curve.
+3) Compute cosine distance between curves.
+4) Cluster with Tomato using a manual kNN graph and density weights.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+from scipy.ndimage import gaussian_filter1d
+from scipy.spatial.distance import pdist, squareform
+
+try:
+    from gudhi.clustering.tomato import Tomato
+except Exception as exc:  # pragma: no cover - optional dependency
+    Tomato = None
+    _TOMATO_IMPORT_ERROR = exc
+else:
+    _TOMATO_IMPORT_ERROR = None
+
+
+@dataclass
+class BTNConfig:
+    """Configuration for BTN clustering."""
+
+    maxt: float = 0.2
+    res: float = 1e-3
+    smooth_sigma: float = 4.0
+    nbs: int = 80
+    n_clusters: int = 4
+    metric: str = "cosine"
+    b_one: bool = True
+    b_log: bool = False
+
+
+@dataclass
+class BTNResult:
+    """Result container for BTN clustering."""
+
+    labels: np.ndarray
+    n_clusters: int
+    cluster_sizes: np.ndarray
+    btn_labels: np.ndarray | None
+    mapping: dict[int, str] | None
+    intermediates: dict[str, np.ndarray] | None
+
+
+class BTNAnalyzer:
+    """Analyzer that clusters neurons into BTN groups using Tomato."""
+
+    def __init__(self, config: BTNConfig | None = None):
+        self.config = config or BTNConfig()
+
+    def classify_btn(
+        self,
+        spike_data: dict[str, Any],
+        *,
+        mapping: dict[int, str] | None = None,
+        return_intermediates: bool = False,
+        plot_diagram: bool = False,
+    ) -> BTNResult:
+        """Cluster neurons into BTN classes using ISI autocorr + Tomato.
+
+        Parameters
+        ----------
+        spike_data : dict
+            ASA-style dict with keys ``spike`` and ``t`` (and optionally x/y).
+        mapping : dict, optional
+            Optional mapping from cluster id to BTN label string.
+        return_intermediates : bool
+            If True, include intermediate arrays in the result.
+        plot_diagram : bool
+            If True, call Tomato.plot_diagram() for visual inspection.
+        """
+        _require_tomato()
+        spikes = _extract_spike_times(spike_data)
+        acorr, bin_times = _isi_autocorr(
+            spikes,
+            maxt=self.config.maxt,
+            res=self.config.res,
+            b_one=self.config.b_one,
+            b_log=self.config.b_log,
+        )
+        acorr_norm = _normalize_autocorr(acorr)
+        acorr_smooth = gaussian_filter1d(acorr_norm, sigma=self.config.smooth_sigma, axis=1)
+
+        dist = squareform(pdist(acorr_smooth, metric=self.config.metric))
+        num_nodes = dist.shape[0]
+        order = np.argsort(dist, axis=1)
+        if num_nodes > 1:
+            nbs_max = num_nodes - 1
+            nbs = max(1, min(int(self.config.nbs), nbs_max))
+            knn_indices = order[:, 1 : nbs + 1]
+        else:
+            nbs = 1
+            knn_indices = order[:, :1]
+        knn_dists = dist[np.arange(dist.shape[0])[:, None], knn_indices]
+        weights = np.sum(np.exp(-knn_dists), axis=1)
+
+        t = Tomato(graph_type="manual", density_type="manual", metric="precomputed")
+        t.fit(knn_indices, weights=weights)
+        if plot_diagram:
+            t.plot_diagram()
+        if self.config.n_clusters is not None:
+            t.n_clusters_ = int(self.config.n_clusters)
+        labels = np.asarray(t.labels_, dtype=int)
+        if labels.size:
+            if np.any(labels < 0):
+                valid = labels[labels >= 0]
+                cluster_sizes = np.bincount(valid) if valid.size else np.array([])
+            else:
+                cluster_sizes = np.bincount(labels)
+        else:
+            cluster_sizes = np.array([])
+
+        btn_labels = None
+        if mapping is not None:
+            btn_labels = np.array([mapping.get(int(c), "unknown") for c in labels], dtype=object)
+
+        intermediates = None
+        if return_intermediates:
+            intermediates = {
+                "acorr": acorr,
+                "acorr_norm": acorr_norm,
+                "acorr_smooth": acorr_smooth,
+                "distance_matrix": dist,
+                "knn_indices": knn_indices,
+                "knn_dists": knn_dists,
+                "density_weights": weights,
+                "bin_times": bin_times,
+            }
+
+        if self.config.n_clusters is not None:
+            n_clusters = int(self.config.n_clusters)
+        else:
+            if labels.size:
+                valid_labels = labels[labels >= 0]
+                n_clusters = int(np.unique(valid_labels).size)
+            else:
+                n_clusters = 0
+
+        return BTNResult(
+            labels=labels,
+            n_clusters=n_clusters,
+            cluster_sizes=cluster_sizes,
+            btn_labels=btn_labels,
+            mapping=mapping,
+            intermediates=intermediates,
+        )
+
+
+def _require_tomato() -> None:
+    if Tomato is None:
+        raise ImportError(
+            "Tomato clustering requires gudhi. Install with: pip install gudhi"
+        ) from _TOMATO_IMPORT_ERROR
+
+
+def _extract_spike_times(spike_data: dict[str, Any]) -> dict[int, np.ndarray]:
+    if not isinstance(spike_data, dict) or "spike" not in spike_data or "t" not in spike_data:
+        raise ValueError("spike_data must be a dict with keys 'spike' and 't'")
+
+    spike_raw = spike_data["spike"]
+    t = np.asarray(spike_data["t"])
+    if (
+        isinstance(spike_raw, np.ndarray)
+        and spike_raw.ndim == 2
+        and spike_raw.shape[0] == t.shape[0]
+    ):
+        raise ValueError(
+            "BTN expects spike times per neuron, but got a binned spike matrix (T x N)."
+        )
+    if (
+        hasattr(spike_raw, "item")
+        and callable(spike_raw.item)
+        and np.asarray(spike_raw).shape == ()
+    ):
+        spikes_all = spike_raw[()]
+    elif isinstance(spike_raw, dict):
+        spikes_all = spike_raw
+    elif isinstance(spike_raw, (list, np.ndarray)):
+        spikes_all = spike_raw
+    else:
+        spikes_all = spike_raw
+
+    min_time0 = np.min(t)
+    max_time0 = np.max(t)
+
+    spikes: dict[int, np.ndarray] = {}
+    if isinstance(spikes_all, dict):
+        for i, key in enumerate(spikes_all.keys()):
+            s = np.asarray(spikes_all[key])
+            spikes[i] = s[(s >= min_time0) & (s < max_time0)]
+    else:
+        cell_inds = np.arange(len(spikes_all))
+        for i, m in enumerate(cell_inds):
+            s = np.asarray(spikes_all[m]) if len(spikes_all[m]) > 0 else np.array([])
+            if s.size > 0:
+                spikes[i] = s[(s >= min_time0) & (s < max_time0)]
+            else:
+                spikes[i] = np.array([])
+
+    return spikes
+
+
+def _isi_autocorr(
+    spk: dict[int, np.ndarray],
+    *,
+    maxt: float = 0.2,
+    res: float = 1e-3,
+    b_one: bool = True,
+    b_log: bool = False,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Compute ISI autocorrelogram for each neuron.
+
+    Returns
+    -------
+    acorr : ndarray
+        Shape (N, num_bins).
+    bin_times : ndarray
+        Bin edges used for histogramming.
+    """
+    if b_log:
+        num_bins = 100
+        bin_times = np.ones(num_bins + 1) * 10
+        bin_times = np.power(bin_times, np.linspace(np.log10(0.005), np.log10(maxt), num_bins + 1))
+        bin_times = np.unique(np.concatenate((-bin_times, bin_times)))
+        num_bins = len(bin_times)
+    elif b_one:
+        num_bins = int(maxt / res) + 1
+        bin_times = np.linspace(0, maxt, num_bins)
+    else:
+        num_bins = int(2 * maxt / res) + 1
+        bin_times = np.linspace(-maxt, maxt, num_bins)
+
+    num_neurons = len(spk)
+    acorr = np.zeros((num_neurons, len(bin_times) - 1), dtype=int)
+
+    maxt = maxt - 1e-5
+    mint = -maxt
+    if b_one:
+        mint = -1e-5
+
+    for i, n in enumerate(spk):
+        spike_times = np.asarray(spk[n])
+        for ss in spike_times:
+            stemp = spike_times[(spike_times < ss + maxt) & (spike_times > ss + mint)]
+            dd = stemp - ss
+            if b_one:
+                dd = dd[dd >= 0]
+            bins = np.digitize(dd, bin_times) - 1
+            bins = bins[(bins >= 0) & (bins < num_bins - 1)]
+            if bins.size:
+                acorr[i, :] += np.bincount(bins, minlength=num_bins)[:-1]
+
+    return acorr, bin_times
+
+
+def _normalize_autocorr(acorr: np.ndarray) -> np.ndarray:
+    acorr = acorr.astype(float, copy=True)
+    denom = acorr[:, 0].copy()
+    valid = denom > 0
+    acorr[valid, :] = acorr[valid, :] / denom[valid, None]
+    acorr[:, 0] = 0.0
+    return acorr

canns/analyzer/data/cell_classification/visualization/__init__.py

@@ -1,5 +1,6 @@
 """Visualization modules."""
 
+from .btn_plots import plot_btn_autocorr_summary, plot_btn_distance_matrix
 from .grid_plots import (
     plot_autocorrelogram,
     plot_grid_score_histogram,
@@ -16,4 +17,6 @@ __all__ = [
     "plot_polar_tuning",
     "plot_temporal_autocorr",
     "plot_hd_analysis",
+    "plot_btn_distance_matrix",
+    "plot_btn_autocorr_summary",
 ]

canns/analyzer/data/cell_classification/visualization/btn_plots.py

@@ -0,0 +1,258 @@
+"""BTN visualization utilities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+from matplotlib import pyplot as plt
+from scipy.ndimage import gaussian_filter1d
+
+from canns.analyzer.visualization.core.config import PlotConfig, finalize_figure
+
+_DEFAULT_BTN_COLORS = {
+    "B": "#1f77b4",
+    "T": "#000000",
+    "N": "#2ca02c",
+}
+
+
+def _ensure_plot_config(
+    config: PlotConfig | None,
+    factory,
+    *,
+    kwargs: dict[str, Any] | None = None,
+    **defaults: Any,
+) -> PlotConfig:
+    if config is None:
+        defaults.update({"kwargs": kwargs or {}})
+        return factory(**defaults)
+
+    if kwargs:
+        config_kwargs = config.kwargs or {}
+        config_kwargs.update(kwargs)
+        config.kwargs = config_kwargs
+    return config
+
+
+def _canonical_label(label: str) -> str:
+    lab = label.strip().lower()
+    if lab in ("b", "bursty"):
+        return "B"
+    if lab in ("t", "theta", "theta-modulated", "theta_modulated", "theta modulated"):
+        return "T"
+    if lab in ("n", "nonbursty", "non-bursty", "non_bursty"):
+        return "N"
+    return label
+
+
+def _cluster_order(labels: np.ndarray, mapping: dict[int, str] | None) -> list[int]:
+    cids = [int(c) for c in np.unique(labels)]
+    if mapping is None:
+        return sorted(cids)
+
+    def _key(cid: int) -> tuple[int, str]:
+        lab = _canonical_label(mapping.get(int(cid), str(cid)))
+        order = {"B": 0, "T": 1, "N": 2}.get(lab, 999)
+        return (order, str(lab))
+
+    return sorted(cids, key=_key)
+
+
+def _label_color(
+    label: str,
+    colors: dict[str, str] | None,
+    fallback_idx: int,
+) -> str:
+    if colors and label in colors:
+        return colors[label]
+    if label in _DEFAULT_BTN_COLORS:
+        return _DEFAULT_BTN_COLORS[label]
+    cmap = plt.get_cmap("tab10")
+    return cmap(fallback_idx % 10)
+
+
+def _normalize_rows(acorr: np.ndarray, mode: str | None) -> np.ndarray:
+    if mode is None or mode == "none":
+        return acorr
+    if mode == "probability":
+        denom = acorr.sum(axis=1, keepdims=True)
+    elif mode == "peak":
+        denom = acorr.max(axis=1, keepdims=True)
+    elif mode == "first":
+        denom = acorr[:, :1]
+    else:
+        raise ValueError(f"Unknown normalize mode: {mode!r}")
+    denom = np.where(denom == 0, 1.0, denom)
+    return acorr / denom
+
+
+def plot_btn_distance_matrix(
+    *,
+    dist: np.ndarray | None = None,
+    labels: np.ndarray | None = None,
+    mapping: dict[int, str] | None = None,
+    sort_by_label: bool = True,
+    title: str = "BTN distance matrix",
+    cmap: str = "afmhot",
+    figsize: tuple[int, int] = (5, 5),
+    save_path: str | None = None,
+    show: bool = True,
+    ax: plt.Axes | None = None,
+    config: PlotConfig | None = None,
+) -> tuple[plt.Figure, plt.Axes, np.ndarray]:
+    """Plot a distance matrix heatmap sorted by BTN cluster labels."""
+    if dist is None or labels is None:
+        raise ValueError("dist and labels are required.")
+
+    labels = np.asarray(labels).astype(int)
+
+    if sort_by_label:
+        cids = _cluster_order(labels, mapping)
+        order = np.concatenate([np.where(labels == c)[0] for c in cids])
+    else:
+        order = np.arange(len(labels))
+
+    dist_sorted = dist[np.ix_(order, order)]
+
+    config = _ensure_plot_config(
+        config,
+        PlotConfig.for_static_plot,
+        title=title,
+        figsize=figsize,
+        save_path=save_path,
+        show=show,
+        kwargs={},
+    )
+
+    created_fig = False
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, figsize=config.figsize)
+        created_fig = True
+    else:
+        fig = ax.figure
+
+    im = ax.imshow(dist_sorted, cmap=cmap, origin="lower", interpolation="nearest")
+    fig.colorbar(im, ax=ax, label="Cosine distance")
+    ax.set_title(config.title)
+    ax.set_xlabel("Neuron")
+    ax.set_ylabel("Neuron")
+
+    if sort_by_label:
+        sizes = [np.sum(labels == c) for c in cids]
+        boundaries = np.cumsum(sizes)[:-1]
+        for b in boundaries:
+            ax.axhline(b - 0.5, color="w", linewidth=0.6, alpha=0.7)
+            ax.axvline(b - 0.5, color="w", linewidth=0.6, alpha=0.7)
+
+    if created_fig:
+        fig.tight_layout()
+        finalize_figure(fig, config, rasterize_artists=[im] if config.rasterized else None)
+
+    return fig, ax, order
+
+
+def plot_btn_autocorr_summary(
+    *,
+    acorr: np.ndarray | None = None,
+    labels: np.ndarray | None = None,
+    bin_times: np.ndarray | None = None,
+    res: float | None = None,
+    mapping: dict[int, str] | None = None,
+    colors: dict[str, str] | None = None,
+    normalize: str | None = "probability",
+    smooth_sigma: float | None = None,
+    long_max_ms: float | None = 200.0,
+    short_max_ms: float | None = None,
+    title: str = "BTN temporal autocorr",
+    figsize: tuple[int, int] = (8, 3),
+    save_path: str | None = None,
+    show: bool = True,
+    config: PlotConfig | None = None,
+) -> plt.Figure:
+    """Plot class-averaged ISI autocorr curves (mean +/- SEM)."""
+    if acorr is None or labels is None:
+        raise ValueError("acorr and labels are required.")
+
+    labels = np.asarray(labels).astype(int)
+    acorr = np.asarray(acorr)
+    acorr_plot = _normalize_rows(acorr.astype(float, copy=False), normalize)
+    if smooth_sigma is not None:
+        acorr_plot = gaussian_filter1d(acorr_plot, sigma=float(smooth_sigma), axis=1)
+
+    if bin_times is not None:
+        bin_times = np.asarray(bin_times)
+        x = 0.5 * (bin_times[:-1] + bin_times[1:])
+    elif res is not None:
+        x = np.arange(acorr.shape[1]) * float(res)
+    else:
+        raise ValueError("Provide bin_times or res to define lag axis.")
+
+    x_ms = x * 1000.0
+
+    cids = _cluster_order(labels, mapping)
+    label_strings = []
+    for c in cids:
+        if mapping is not None:
+            label_strings.append(_canonical_label(mapping.get(int(c), str(c))))
+        else:
+            label_strings.append(str(c))
+
+    show_short = short_max_ms is not None
+    ncols = 2 if show_short else 1
+
+    config = _ensure_plot_config(
+        config,
+        PlotConfig.for_static_plot,
+        title=title,
+        figsize=figsize if ncols == 1 else (figsize[0] * 1.6, figsize[1]),
+        save_path=save_path,
+        show=show,
+        kwargs={},
+    )
+
+    fig, axes = plt.subplots(1, ncols, figsize=config.figsize)
+    if ncols == 1:
+        axes = [axes]
+
+    def _plot_panel(ax: plt.Axes, max_ms: float | None, panel_title: str):
+        if max_ms is None:
+            mask = np.ones_like(x_ms, dtype=bool)
+        else:
+            mask = x_ms <= max_ms
+
+        for idx, (cid, label_str) in enumerate(zip(cids, label_strings, strict=False)):
+            rows = acorr_plot[labels == cid]
+            if rows.size == 0:
+                continue
+            mean = rows.mean(axis=0)
+            sem = rows.std(axis=0) / np.sqrt(rows.shape[0])
+            color = _label_color(label_str, colors, idx)
+            ax.plot(x_ms[mask], mean[mask], color=color, lw=2, label=label_str)
+            ax.fill_between(
+                x_ms[mask],
+                (mean - sem)[mask],
+                (mean + sem)[mask],
+                color=color,
+                alpha=0.25,
+                linewidth=0,
+            )
+
+        ax.set_xlabel("Lag (ms)")
+        ax.set_title(panel_title)
+        ax.grid(False)
+
+    _plot_panel(axes[0], long_max_ms, "Long lag")
+    ylabel = "Probability" if normalize == "probability" else "Autocorr (norm)"
+    axes[0].set_ylabel(ylabel)
+
+    if show_short:
+        _plot_panel(axes[1], float(short_max_ms), "Short lag")
+
+    for ax in axes:
+        ax.legend(frameon=False)
+
+    fig.suptitle(config.title)
+    fig.tight_layout()
+    finalize_figure(fig, config)
+    return fig

canns/analyzer/visualization/__init__.py

@@ -34,6 +34,7 @@ from .theta_sweep_plots import (
     create_theta_sweep_grid_cell_animation,
     create_theta_sweep_place_cell_animation,
     plot_grid_cell_manifold,
+    plot_internal_position_trajectory,
     plot_population_activity_with_theta,
 )
 from .tuning_plots import tuning_curve
@@ -70,5 +71,6 @@ __all__ = [
     "create_theta_sweep_grid_cell_animation",
     "create_theta_sweep_place_cell_animation",
     "plot_grid_cell_manifold",
+    "plot_internal_position_trajectory",
     "plot_population_activity_with_theta",
 ]

canns/analyzer/visualization/core/config.py

@@ -469,6 +469,26 @@ class PlotConfigs:
         defaults.update(kwargs)
         return PlotConfig.for_static_plot(**defaults)
 
+    @staticmethod
+    def internal_position_trajectory_static(**kwargs: Any) -> PlotConfig:
+        defaults: dict[str, Any] = {
+            "title": "Internal Position vs. Real Trajectory",
+            "figsize": (6, 4),
+        }
+        plot_kwargs: dict[str, Any] = {
+            "cmap": "cool",
+            "add_colorbar": True,
+            "colorbar": {"label": "Max GC activity"},
+            "trajectory_color": "black",
+            "trajectory_linewidth": 1.0,
+            "scatter_size": 4,
+            "scatter_alpha": 0.9,
+        }
+        plot_kwargs.update(kwargs.pop("kwargs", {}))
+        defaults["kwargs"] = plot_kwargs
+        defaults.update(kwargs)
+        return PlotConfig.for_static_plot(**defaults)
+
     @staticmethod
     def direction_cell_polar(**kwargs: Any) -> PlotConfig:
         """Configuration for direction cell polar plot visualization.