canns 0.13.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

canns/analyzer/data/__init__.py

@@ -1,5 +1,9 @@
 """Data analysis utilities for experimental and synthetic neural data."""
 
+from . import asa, cell_classification
 from .asa import *  # noqa: F401,F403
+from .cell_classification import *  # noqa: F401,F403
 
-__all__ = list(locals().get("__all__", []))
+__all__ = ["asa", "cell_classification"]
+__all__ += list(getattr(asa, "__all__", []))
+__all__ += list(getattr(cell_classification, "__all__", []))

canns/analyzer/data/asa/__init__.py

@@ -2,10 +2,14 @@ from __future__ import annotations
 
 # Coho-space analysis + visualization
 from .cohospace import (
-    compute_cohoscore,
-    plot_cohospace_neuron,
-    plot_cohospace_population,
-    plot_cohospace_trajectory,
+    compute_cohoscore_1d,
+    compute_cohoscore_2d,
+    plot_cohospace_neuron_1d,
+    plot_cohospace_neuron_2d,
+    plot_cohospace_population_1d,
+    plot_cohospace_population_2d,
+    plot_cohospace_trajectory_1d,
+    plot_cohospace_trajectory_2d,
 )
 from .config import (
     CANN2DError,
@@ -33,7 +37,11 @@ from .fr import (
 )
 
 # Path utilities
-from .path import align_coords_to_position, apply_angle_scale
+from .path import (
+    align_coords_to_position_1d,
+    align_coords_to_position_2d,
+    apply_angle_scale,
+)
 
 # Higher-level plotting helpers
 from .plotting import (
@@ -41,7 +49,8 @@ from .plotting import (
     plot_3d_bump_on_torus,
     plot_cohomap,
     plot_cohomap_multi,
-    plot_path_compare,
+    plot_path_compare_1d,
+    plot_path_compare_2d,
     plot_projection,
 )
 
@@ -61,7 +70,8 @@ __all__ = [
     "decode_circular_coordinates",
     "decode_circular_coordinates_multi",
     "plot_projection",
-    "plot_path_compare",
+    "plot_path_compare_1d",
+    "plot_path_compare_2d",
     "plot_cohomap",
     "plot_cohomap_multi",
     "plot_3d_bump_on_torus",
@@ -75,10 +85,15 @@ __all__ = [
     "FRMResult",
     "compute_frm",
     "plot_frm",
-    "plot_cohospace_trajectory",
-    "plot_cohospace_neuron",
-    "plot_cohospace_population",
-    "compute_cohoscore",
-    "align_coords_to_position",
+    "plot_cohospace_trajectory_1d",
+    "plot_cohospace_trajectory_2d",
+    "plot_cohospace_neuron_1d",
+    "plot_cohospace_neuron_2d",
+    "plot_cohospace_population_1d",
+    "plot_cohospace_population_2d",
+    "compute_cohoscore_1d",
+    "compute_cohoscore_2d",
+    "align_coords_to_position_1d",
+    "align_coords_to_position_2d",
     "apply_angle_scale",
 ]

canns/analyzer/data/asa/cohospace.py

@@ -91,7 +91,7 @@ def _align_activity_to_coords(
     return activity
 
 
-def plot_cohospace_trajectory(
+def plot_cohospace_trajectory_2d(
     coords: np.ndarray,
     times: np.ndarray | None = None,
     subsample: int = 1,
@@ -129,7 +129,7 @@ def plot_cohospace_trajectory(
 
     Examples
     --------
-    >>> fig = plot_cohospace_trajectory(coords, subsample=2, show=False)  # doctest: +SKIP
+    >>> fig = plot_cohospace_trajectory_2d(coords, subsample=2, show=False)  # doctest: +SKIP
     """
 
     try:
@@ -194,7 +194,106 @@ def plot_cohospace_trajectory(
     return ax
 
 
-def plot_cohospace_neuron(
+def plot_cohospace_trajectory_1d(
+    coords: np.ndarray,
+    times: np.ndarray | None = None,
+    subsample: int = 1,
+    figsize: tuple[int, int] = (6, 6),
+    cmap: str = "viridis",
+    save_path: str | None = None,
+    show: bool = False,
+    config: PlotConfig | None = None,
+) -> plt.Axes:
+    """
+    Plot a 1D cohomology trajectory on the unit circle.
+
+    Parameters
+    ----------
+    coords : ndarray, shape (T,) or (T, 1)
+        Decoded cohomology angles (theta). Values may be in radians or in [0, 1] "unit circle"
+        convention depending on upstream decoding; this function will plot on the unit circle.
+    times : ndarray, optional, shape (T,)
+        Optional time array used to color points. If None, uses arange(T).
+    subsample : int
+        Downsampling step (>1 reduces the number of plotted points).
+    figsize : tuple
+        Matplotlib figure size.
+    cmap : str
+        Matplotlib colormap name.
+    save_path : str, optional
+        If provided, saves the figure to this path.
+    show : bool
+        If True, calls plt.show(). If False, closes the figure and returns the Axes.
+    """
+    try:
+        subsample_i = int(subsample)
+    except Exception:
+        subsample_i = 1
+    if subsample_i < 1:
+        subsample_i = 1
+
+    coords = np.asarray(coords)
+    if coords.ndim == 2 and coords.shape[1] == 1:
+        coords = coords[:, 0]
+    if coords.ndim != 1:
+        raise ValueError(f"`coords` must have shape (T,) or (T, 1). Got {coords.shape}.")
+
+    if times is None:
+        times_vis = np.arange(coords.shape[0])
+    else:
+        times_vis = np.asarray(times)
+        if times_vis.shape[0] != coords.shape[0]:
+            raise ValueError(
+                f"`times` length must match coords length. Got times={times_vis.shape[0]}, coords={coords.shape[0]}."
+            )
+
+    if subsample_i > 1:
+        coords = coords[::subsample_i]
+        times_vis = times_vis[::subsample_i]
+
+    theta = coords % (2 * np.pi)
+    x = np.cos(theta)
+    y = np.sin(theta)
+
+    config = _ensure_plot_config(
+        config,
+        PlotConfig.for_static_plot,
+        title="CohoSpace trajectory (1D)",
+        xlabel="cos(theta)",
+        ylabel="sin(theta)",
+        figsize=figsize,
+        save_path=save_path,
+        show=show,
+    )
+
+    fig, ax = plt.subplots(figsize=config.figsize)
+    circle = np.linspace(0, 2 * np.pi, 200)
+    ax.plot(np.cos(circle), np.sin(circle), color="0.85", lw=1.0, zorder=0)
+    sc = ax.scatter(
+        x,
+        y,
+        c=times_vis,
+        cmap=cmap,
+        s=5,
+        alpha=0.8,
+    )
+    cbar = plt.colorbar(sc, ax=ax)
+    cbar.set_label("Time")
+
+    ax.set_xlim(-1.2, 1.2)
+    ax.set_ylim(-1.2, 1.2)
+    ax.set_xlabel(config.xlabel)
+    ax.set_ylabel(config.ylabel)
+    ax.set_title(config.title)
+    ax.set_aspect("equal", adjustable="box")
+    ax.grid(True, alpha=0.2)
+
+    _ensure_parent_dir(config.save_path)
+    finalize_figure(fig, config)
+    return ax
+
+
+def plot_cohospace_neuron_2d(
     coords: np.ndarray,
     activity: np.ndarray,
     neuron_id: int,
@@ -230,7 +329,7 @@ def plot_cohospace_neuron(
     mode : {"fr", "spike"}
     top_percent : float
         Used only when mode="fr". For example, 5.0 means "top 5%%" time points.
-    figsize, cmap, save_path, show : see `plot_cohospace_trajectory`.
+    figsize, cmap, save_path, show : see `plot_cohospace_trajectory_2d`.
 
     Returns
     -------
@@ -238,7 +337,7 @@ def plot_cohospace_neuron(
 
     Examples
     --------
-    >>> plot_cohospace_neuron(coords, spikes, neuron_id=0, show=False)  # doctest: +SKIP
+    >>> plot_cohospace_neuron_2d(coords, spikes, neuron_id=0, show=False)  # doctest: +SKIP
     """
     coords = np.asarray(coords)
     activity = _align_activity_to_coords(
@@ -300,7 +399,94 @@ def plot_cohospace_neuron(
     return fig
 
 
-def plot_cohospace_population(
+def plot_cohospace_neuron_1d(
+    coords: np.ndarray,
+    activity: np.ndarray,
+    neuron_id: int,
+    mode: str = "fr",
+    top_percent: float = 5.0,
+    times: np.ndarray | None = None,
+    auto_filter: bool = True,
+    figsize: tuple = (6, 6),
+    cmap: str = "hot",
+    save_path: str | None = None,
+    show: bool = True,
+    config: PlotConfig | None = None,
+) -> plt.Figure:
+    """
+    Overlay a single neuron's activity on the 1D cohomology trajectory (unit circle).
+    """
+    coords = np.asarray(coords)
+    if coords.ndim == 2 and coords.shape[1] == 1:
+        coords = coords[:, 0]
+    if coords.ndim != 1:
+        raise ValueError(f"coords must have shape (T,) or (T, 1), got {coords.shape}")
+
+    activity = _align_activity_to_coords(
+        coords[:, None], activity, times, label="activity", auto_filter=auto_filter
+    )
+
+    signal = activity[:, neuron_id]
+
+    if mode == "fr":
+        threshold = np.percentile(signal, 100 - top_percent)
+        idx = signal >= threshold
+        color = signal[idx]
+        title = f"Neuron {neuron_id} FR top {top_percent:.1f}% on coho-space (1D)"
+        use_cmap = cmap
+    elif mode == "spike":
+        idx = signal > 0
+        color = None
+        title = f"Neuron {neuron_id} spikes on coho-space (1D)"
+        use_cmap = None
+    else:
+        raise ValueError("mode must be 'fr' or 'spike'")
+
+    theta = coords % (2 * np.pi)
+    x = np.cos(theta)
+    y = np.sin(theta)
+
+    config = _ensure_plot_config(
+        config,
+        PlotConfig.for_static_plot,
+        title=title,
+        xlabel="cos(theta)",
+        ylabel="sin(theta)",
+        figsize=figsize,
+        save_path=save_path,
+        show=show,
+    )
+
+    fig, ax = plt.subplots(figsize=config.figsize)
+    circle = np.linspace(0, 2 * np.pi, 200)
+    ax.plot(np.cos(circle), np.sin(circle), color="0.85", lw=1.0, zorder=0)
+    sc = ax.scatter(
+        x[idx],
+        y[idx],
+        c=color if mode == "fr" else "red",
+        cmap=use_cmap,
+        s=8,
+        alpha=0.9,
+    )
+
+    if mode == "fr":
+        cbar = plt.colorbar(sc, ax=ax)
+        cbar.set_label("Firing rate")
+
+    ax.set_xlim(-1.2, 1.2)
+    ax.set_ylim(-1.2, 1.2)
+    ax.set_xlabel(config.xlabel)
+    ax.set_ylabel(config.ylabel)
+    ax.set_title(config.title)
+    ax.set_aspect("equal", adjustable="box")
+
+    _ensure_parent_dir(config.save_path)
+    finalize_figure(fig, config)
+
+    return fig
+
+
+def plot_cohospace_population_2d(
     coords: np.ndarray,
     activity: np.ndarray,
     neuron_ids: list[int] | np.ndarray,
@@ -338,7 +524,7 @@ def plot_cohospace_population(
     mode : {"fr", "spike"}
     top_percent : float
         Used only when mode="fr".
-    figsize, cmap, save_path, show : see `plot_cohospace_trajectory`.
+    figsize, cmap, save_path, show : see `plot_cohospace_trajectory_2d`.
 
     Returns
     -------
@@ -346,7 +532,7 @@ def plot_cohospace_population(
 
     Examples
     --------
-    >>> plot_cohospace_population(coords, spikes, neuron_ids=[0, 1, 2], show=False)  # doctest: +SKIP
+    >>> plot_cohospace_population_2d(coords, spikes, neuron_ids=[0, 1, 2], show=False)  # doctest: +SKIP
     """
     coords = np.asarray(coords)
     activity = _align_activity_to_coords(
@@ -411,7 +597,97 @@ def plot_cohospace_population(
     return fig
 
 
-def compute_cohoscore(
+def plot_cohospace_population_1d(
+    coords: np.ndarray,
+    activity: np.ndarray,
+    neuron_ids: list[int] | np.ndarray,
+    mode: str = "fr",
+    top_percent: float = 5.0,
+    times: np.ndarray | None = None,
+    auto_filter: bool = True,
+    figsize: tuple = (6, 6),
+    cmap: str = "hot",
+    save_path: str | None = None,
+    show: bool = True,
+    config: PlotConfig | None = None,
+) -> plt.Figure:
+    """
+    Plot aggregated activity from multiple neurons on the 1D cohomology trajectory.
+    """
+    coords = np.asarray(coords)
+    if coords.ndim == 2 and coords.shape[1] == 1:
+        coords = coords[:, 0]
+    if coords.ndim != 1:
+        raise ValueError(f"coords must have shape (T,) or (T, 1), got {coords.shape}")
+
+    activity = _align_activity_to_coords(
+        coords[:, None], activity, times, label="activity", auto_filter=auto_filter
+    )
+    neuron_ids = np.asarray(neuron_ids, dtype=int)
+
+    T = activity.shape[0]
+    mask = np.zeros(T, dtype=bool)
+    agg_color = np.zeros(T, dtype=float)
+
+    for n in neuron_ids:
+        signal = activity[:, n]
+
+        if mode == "fr":
+            threshold = np.percentile(signal, 100 - top_percent)
+            idx = signal >= threshold
+            agg_color[idx] += signal[idx]
+            mask |= idx
+        elif mode == "spike":
+            idx = signal > 0
+            agg_color[idx] += 1.0
+            mask |= idx
+        else:
+            raise ValueError("mode must be 'fr' or 'spike'")
+
+    theta = coords % (2 * np.pi)
+    x = np.cos(theta)
+    y = np.sin(theta)
+
+    config = _ensure_plot_config(
+        config,
+        PlotConfig.for_static_plot,
+        title=f"{len(neuron_ids)} neurons on coho-space (1D)",
+        xlabel="cos(theta)",
+        ylabel="sin(theta)",
+        figsize=figsize,
+        save_path=save_path,
+        show=show,
+    )
+
+    fig, ax = plt.subplots(figsize=config.figsize)
+    circle = np.linspace(0, 2 * np.pi, 200)
+    ax.plot(np.cos(circle), np.sin(circle), color="0.85", lw=1.0, zorder=0)
+    sc = ax.scatter(
+        x[mask],
+        y[mask],
+        c=agg_color[mask],
+        cmap=cmap,
+        s=6,
+        alpha=0.9,
+    )
+    cbar = plt.colorbar(sc, ax=ax)
+    label = "Aggregate FR" if mode == "fr" else "Spike count"
+    cbar.set_label(label)
+
+    ax.set_xlim(-1.2, 1.2)
+    ax.set_ylim(-1.2, 1.2)
+    ax.set_xlabel(config.xlabel)
+    ax.set_ylabel(config.ylabel)
+    ax.set_title(config.title)
+    ax.set_aspect("equal", adjustable="box")
+
+    _ensure_parent_dir(config.save_path)
+    finalize_figure(fig, config)
+
+    return fig
+
+
+def compute_cohoscore_2d(
     coords: np.ndarray,
     activity: np.ndarray,
     top_percent: float = 2.0,
@@ -451,7 +727,7 @@ def compute_cohoscore(
 
     Examples
     --------
-    >>> scores = compute_cohoscore(coords, spikes)  # doctest: +SKIP
+    >>> scores = compute_cohoscore_2d(coords, spikes)  # doctest: +SKIP
     >>> scores.shape[0]  # doctest: +SKIP
     """
     coords = np.asarray(coords)
@@ -487,6 +763,56 @@ def compute_cohoscore(
     return scores
 
 
+def compute_cohoscore_1d(
+    coords: np.ndarray,
+    activity: np.ndarray,
+    top_percent: float = 2.0,
+    times: np.ndarray | None = None,
+    auto_filter: bool = True,
+) -> np.ndarray:
+    """
+    Compute 1D cohomology-space selectivity score (CohoScore) for each neuron.
+
+    For each neuron:
+    - Select "active" time points:
+        - If top_percent is None: all time points with activity > 0
+        - Else: top `top_percent`%% time points by activity value
+    - Compute circular variance for theta on the selected points.
+    - CohoScore = var(theta)
+    """
+    coords = np.asarray(coords)
+    if coords.ndim == 2 and coords.shape[1] == 1:
+        coords = coords[:, 0]
+    if coords.ndim != 1:
+        raise ValueError(f"coords must have shape (T,) or (T, 1), got {coords.shape}")
+
+    activity = _align_activity_to_coords(
+        coords[:, None], activity, times, label="activity", auto_filter=auto_filter
+    )
+    _, n_neurons = activity.shape
+
+    theta = coords % (2 * np.pi)
+    scores = np.zeros(n_neurons, dtype=float)
+
+    for n in range(n_neurons):
+        signal = activity[:, n]
+
+        if top_percent is None:
+            idx = signal > 0
+        else:
+            threshold = np.percentile(signal, 100 - top_percent)
+            idx = signal >= threshold
+
+        if np.sum(idx) < 5:
+            scores[n] = np.nan
+            continue
+
+        var1 = circvar(theta[idx], high=2 * np.pi, low=0)
+        scores[n] = var1
+
+    return scores
+
+
 def skew_transform_torus(coords):
     """
     Convert torus angles (theta1, theta2) into coordinates in a skewed parallelogram fundamental domain.

canns/analyzer/data/asa/config.py

@@ -72,6 +72,8 @@ class TDAConfig:
         Number of shuffles for null distribution.
     progress_bar : bool
         Whether to show progress bars.
+    standardize : bool
+        Whether to standardize data before PCA (z-score).
 
     Examples
     --------
@@ -94,6 +96,7 @@ class TDAConfig:
     do_shuffle: bool = False
     num_shuffles: int = 1000
     progress_bar: bool = True
+    standardize: bool = True
 
 
 @dataclass

canns/analyzer/data/asa/embedding.py

@@ -59,11 +59,11 @@ def embed_spike_trains(spike_trains, config: SpikeEmbeddingConfig | None = None,
         # Step 1: Extract and filter spike data
         spikes_filtered = _extract_spike_data(spike_trains, config)
 
-        # Step 2: Create time bins
-        time_bins = _create_time_bins(spike_trains["t"], config)
+        # Step 2: Create time bins metadata
+        min_time, max_time, n_bins = _create_time_bins(spike_trains["t"], config)
 
         # Step 3: Bin spike data
-        spikes_bin = _bin_spike_data(spikes_filtered, time_bins, config)
+        spikes_bin = _bin_spike_data(spikes_filtered, min_time, max_time, n_bins, config)
 
         # Step 4: Apply temporal smoothing if requested
         if config.smooth:
@@ -73,7 +73,7 @@ def embed_spike_trains(spike_trains, config: SpikeEmbeddingConfig | None = None,
         if config.speed_filter:
             return _apply_speed_filtering(spikes_bin, spike_trains, config)
 
-        return spikes_bin, None, None, None
+        return spikes_bin, spike_trains["x"], spike_trains["y"], spike_trains["t"]
 
     except Exception as e:
         raise ProcessingError(f"Failed to embed spike trains: {e}") from e
@@ -132,36 +132,44 @@ def _extract_spike_data(
         raise ProcessingError(f"Error extracting spike data: {e}") from e
 
 
-def _create_time_bins(t: np.ndarray, config: SpikeEmbeddingConfig) -> np.ndarray:
-    """Create time bins for spike discretization."""
+def _create_time_bins(t: np.ndarray, config: SpikeEmbeddingConfig) -> tuple[int, int, int]:
+    """Create time-bin metadata for spike discretization."""
     min_time0 = np.min(t)
     max_time0 = np.max(t)
 
-    min_time = min_time0 * config.res
-    max_time = max_time0 * config.res
+    min_time = int(np.floor(min_time0 * config.res))
+    max_time = int(np.ceil(max_time0 * config.res)) + 1
+    n_bins = max(1, int(np.ceil((max_time - min_time) / config.dt)))
+    last_time = min_time + config.dt * (n_bins - 1)
 
-    return np.arange(np.floor(min_time), np.ceil(max_time) + 1, config.dt)
+    return min_time, last_time, n_bins
 
 
 def _bin_spike_data(
-    spikes: dict[int, np.ndarray], time_bins: np.ndarray, config: SpikeEmbeddingConfig
+    spikes: dict[int, np.ndarray],
+    min_time: int,
+    max_time: int,
+    n_bins: int,
+    config: SpikeEmbeddingConfig,
 ) -> np.ndarray:
     """Convert spike times to binned spike matrix."""
-    min_time = time_bins[0]
-    max_time = time_bins[-1]
-
-    spikes_bin = np.zeros((len(time_bins), len(spikes)), dtype=int)
+    spikes_bin = np.zeros((n_bins, len(spikes)), dtype=np.int32)
+    max_time_offset = max_time - min_time
 
     for n in spikes:
-        spike_times = np.array(spikes[n] * config.res - min_time, dtype=int)
+        spike_times = np.asarray(spikes[n])
+        if spike_times.size == 0:
+            continue
+        spike_times = (spike_times * config.res - min_time).astype(np.int64, copy=False)
         # Filter valid spike times
-        spike_times = spike_times[(spike_times < (max_time - min_time)) & (spike_times > 0)]
-        spike_times = np.array(spike_times / config.dt, int)
+        valid = (spike_times < max_time_offset) & (spike_times > 0)
+        if not np.any(valid):
+            continue
+        spike_times = spike_times[valid]
+        spike_bins = np.floor_divide(spike_times, config.dt).astype(np.int64, copy=False)
 
-        # Bin spikes
-        for j in spike_times:
-            if j < len(time_bins):
-                spikes_bin[j, n] += 1
+        # Bin spikes (vectorized)
+        np.add.at(spikes_bin[:, n], spike_bins, 1)
 
     return spikes_bin
 
@@ -171,21 +179,22 @@ def _apply_temporal_smoothing(spikes_bin: np.ndarray, config: SpikeEmbeddingConf
     # Calculate smoothing parameters (legacy implementation used custom kernel)
     # Current implementation uses scipy's gaussian_filter1d for better performance
 
-    # Apply smoothing (simplified version - could be further optimized)
-    smoothed = np.zeros((spikes_bin.shape[0], spikes_bin.shape[1]))
+    # Convert to float once to avoid holding both int and float arrays.
+    spikes_bin = spikes_bin.astype(np.float32, copy=False)
 
     # Use scipy's gaussian_filter1d for better performance
 
     sigma_bins = config.sigma / config.dt
 
     for n in range(spikes_bin.shape[1]):
-        smoothed[:, n] = gaussian_filter1d(
-            spikes_bin[:, n].astype(float), sigma=sigma_bins, mode="constant"
+        gaussian_filter1d(
+            spikes_bin[:, n], sigma=sigma_bins, mode="constant", output=spikes_bin[:, n]
         )
 
     # Normalize
     normalization_factor = 1 / np.sqrt(2 * np.pi * (config.sigma / config.res) ** 2)
-    return smoothed * normalization_factor
+    spikes_bin *= normalization_factor
+    return spikes_bin
 
 
 def _apply_speed_filtering(
@@ -240,25 +249,19 @@ def _load_pos(t, x, y, res=100000, dt=1000):
 
     tt = np.arange(np.floor(min_time), np.ceil(max_time) + 1, dt) / res
 
-    idt = np.concatenate(([0], np.digitize(t[1:-1], tt[:]) - 1, [len(tt) + 1]))
-    idtt = np.digitize(np.arange(len(tt)), idt) - 1
-
-    idx = np.concatenate((np.unique(idtt), [np.max(idtt) + 1]))
-    divisor = np.bincount(idtt)
-    steps = 1.0 / divisor[divisor > 0]
-    N = np.max(divisor)
-    ranges = np.multiply(np.arange(N)[np.newaxis, :], steps[:, np.newaxis])
-    ranges[ranges >= 1] = np.nan
-
-    rangesx = x[idx[:-1], np.newaxis] + np.multiply(
-        ranges, (x[idx[1:]] - x[idx[:-1]])[:, np.newaxis]
-    )
-    xx = rangesx[~np.isnan(ranges)]
-
-    rangesy = y[idx[:-1], np.newaxis] + np.multiply(
-        ranges, (y[idx[1:]] - y[idx[:-1]])[:, np.newaxis]
-    )
-    yy = rangesy[~np.isnan(ranges)]
+    if t.size == 0:
+        return np.array([]), np.array([]), tt, np.array([])
+
+    # Ensure monotonically increasing time for interpolation.
+    if t.size > 1 and np.any(np.diff(t) < 0):
+        order = np.argsort(t)
+        t = t[order]
+        x = x[order]
+        y = y[order]
+
+    # Interpolate positions onto the spike time bins.
+    xx = np.interp(tt, t, x)
+    yy = np.interp(tt, t, y)
 
     xxs = _gaussian_filter1d(xx - np.min(xx), sigma=100)
     yys = _gaussian_filter1d(yy - np.min(yy), sigma=100)