scitex 2.0.0__py2.py3-none-any.whl

scitex/dsp/__init__.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Scitex dsp module."""
+
+import warnings
+
+# Core imports that should always work
+from ._crop import crop
+from ._demo_sig import demo_sig
+from ._detect_ripples import detect_ripples, _preprocess, _find_events, _drop_ripples_at_edges, _calc_relative_peak_position, _sort_columns
+from ._ensure_3d import ensure_3d
+from ._hilbert import hilbert
+from ._modulation_index import modulation_index, _reshape
+from ._pac import pac
+from ._psd import band_powers, psd
+from ._resample import resample
+from ._time import time
+from ._transform import to_segments, to_sktime_df
+from ._wavelet import wavelet
+
+# Import example and params modules as submodules
+from . import example
+from . import params
+
+# Try to import audio-related functions that require PortAudio
+try:
+    from ._listen import list_and_select_device
+    _audio_available = True
+except (ImportError, OSError) as e:
+    warnings.warn(
+        "Audio functionality unavailable: PortAudio library not found. "
+        "Install PortAudio to use audio features (e.g., sudo apt-get install portaudio19-dev)",
+        ImportWarning
+    )
+    list_and_select_device = None
+    _audio_available = False
+
+# Try to import MNE-related functions
+try:
+    from ._mne import get_eeg_pos
+    _mne_available = True
+except ImportError:
+    warnings.warn(
+        "MNE functionality unavailable. Install MNE-Python to use EEG position features.",
+        ImportWarning
+    )
+    get_eeg_pos = None
+    _mne_available = False
+
+__all__ = [
+    "_calc_relative_peak_position",
+    "_drop_ripples_at_edges",
+    "_find_events",
+    "_preprocess",
+    "_reshape",
+    "_sort_columns",
+    "band_powers",
+    "crop",
+    "demo_sig",
+    "detect_ripples",
+    "ensure_3d",
+    "get_eeg_pos",
+    "hilbert",
+    "list_and_select_device",
+    "modulation_index",
+    "pac",
+    "psd",
+    "resample",
+    "time",
+    "to_segments",
+    "to_sktime_df",
+    "wavelet",
+]

scitex/dsp/_crop.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "ywatanabe (2024-11-02 22:50:46)"
+# File: ./scitex_repo/src/scitex/dsp/_crop.py
+
+import numpy as np
+
+
+def crop(sig_2d, window_length, overlap_factor=0.0, axis=-1, time=None):
+    """
+    Crops the input signal into overlapping windows of a specified length,
+    allowing for an arbitrary axis and considering a time vector.
+
+    Parameters:
+    - sig_2d (numpy.ndarray): The input sig_2d array to be cropped. Can be multi-dimensional.
+    - window_length (int): The length of each window to crop the sig_2d into.
+    - overlap_factor (float): The fraction of the window that consecutive windows overlap. For example, an overlap_factor of 0.5 means 50% overlap.
+    - axis (int): The time axis along which to crop the sig_2d.
+        - time (numpy.ndarray): The time vector associated with the signal. Its length should match the signal's length along the cropping axis.
+
+    Returns:
+    - cropped_windows (numpy.ndarray): The cropped signal windows. The shape depends on the input shape and the specified axis.
+    """
+    # Ensure axis is in a valid range
+    if axis < 0:
+        axis += sig_2d.ndim
+    if axis >= sig_2d.ndim or axis < 0:
+        raise ValueError("Invalid axis. Axis out of range for sig_2d dimensions.")
+
+    if time is not None:
+        # Validate the length of the time vector against the signal's dimension
+        if sig_2d.shape[axis] != len(time):
+            raise ValueError(
+                "Length of time vector does not match signal's dimension along the specified axis."
+            )
+
+    # Move the target axis to the last position
+    axes = np.arange(sig_2d.ndim)
+    axes[axis], axes[-1] = axes[-1], axes[axis]
+    sig_2d_permuted = np.transpose(sig_2d, axes)
+
+    # Compute the number of windows and the step size
+    seq_len = sig_2d_permuted.shape[-1]
+    step = int(window_length * (1 - overlap_factor))
+    n_windows = max(
+        1, ((seq_len - window_length) // step + 1)
+    )  # Ensure at least 1 window
+
+    # Crop the sig_2d into windows
+    cropped_windows = []
+    cropped_times = []
+    for i in range(n_windows):
+        start = i * step
+        end = start + window_length
+        cropped_windows.append(sig_2d_permuted[..., start:end])
+        if time is not None:
+            cropped_times.append(time[start:end])
+
+    # Convert list of windows back to numpy array
+    cropped_windows = np.array(cropped_windows)
+    cropped_times = np.array(cropped_times)
+
+    # Move the last axis back to its original position if necessary
+    if axis != sig_2d.ndim - 1:
+        # Compute the inverse permutation
+        inv_axes = np.argsort(axes)
+        cropped_windows = np.transpose(cropped_windows, axes=inv_axes)
+
+    if time is None:
+        return cropped_windows
+    else:
+        return cropped_windows, cropped_times
+
+
+def main():
+    import random
+
+    FS = 128
+    N_CHS = 19
+    RECORD_S = 13
+    WINDOW_S = 2
+    FACTOR = 0.5
+
+    # To pts
+    record_pts = int(RECORD_S * FS)
+    window_pts = int(WINDOW_S * FS)
+
+    # Demo signal
+    sig2d = np.random.rand(N_CHS, record_pts)
+    time = np.arange(record_pts) / FS
+
+    # Main
+    xx, tt = crop(sig2d, window_pts, overlap_factor=FACTOR, time=time)
+
+    print(f"sig2d.shape: {sig2d.shape}")
+    print(f"xx.shape: {xx.shape}")
+
+    # Validation
+    i_seg = random.randint(0, len(xx) - 1)
+    start = int(i_seg * window_pts * FACTOR)
+    end = start + window_pts
+    assert np.allclose(sig2d[:, start:end], xx[i_seg])
+
+
+if __name__ == "__main__":
+    # parser = argparse.ArgumentParser(description='')
+    # import argparse
+    # # Argument Parser
+    import sys
+
+    import matplotlib.pyplot as plt
+    import scitex
+
+    # parser.add_argument('--var', '-v', type=int, default=1, help='')
+    # parser.add_argument('--flag', '-f', action='store_true', default=False, help='')
+    # args = parser.parse_args()
+    # Main
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt, verbose=False)
+    main()
+    scitex.gen.close(CONFIG, verbose=False, notify=False)
+
+# EOF

scitex/dsp/_demo_sig.py

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Time-stamp: "2024-11-06 01:45:32 (ywatanabe)"
+# File: ./scitex_repo/src/scitex/dsp/_demo_sig.py
+
+import random
+import sys
+import warnings
+
+import matplotlib.pyplot as plt
+import mne
+import numpy as np
+from mne.datasets import sample
+from ripple_detection.simulate import simulate_LFP, simulate_time
+from scipy.signal import chirp
+from tensorpac.signals import pac_signals_wavelet
+
+from ..io._load_configs import load_configs
+
+# Config
+CONFIG = load_configs(verbose=False)
+
+
+# Functions
+def demo_sig(
+    sig_type="periodic",
+    batch_size=8,
+    n_chs=19,
+    n_segments=20,
+    t_sec=4,
+    fs=512,
+    freqs_hz=None,
+    verbose=False,
+):
+    """
+    Generate demo signals for various signal types.
+
+    Parameters:
+    -----------
+    sig_type : str, optional
+        Type of signal to generate. Options are "uniform", "gauss", "periodic", "chirp", "ripple", "meg", "tensorpac", "pac".
+        Default is "periodic".
+    batch_size : int, optional
+        Number of batches to generate. Default is 8.
+    n_chs : int, optional
+        Number of channels. Default is 19.
+    n_segments : int, optional
+        Number of segments for tensorpac and pac signals. Default is 20.
+    t_sec : float, optional
+        Duration of the signal in seconds. Default is 4.
+    fs : int, optional
+        Sampling frequency in Hz. Default is 512.
+    freqs_hz : list or None, optional
+        List of frequencies in Hz for periodic signals. If None, random frequencies will be used.
+    verbose : bool, optional
+        If True, print additional information. Default is False.
+
+    Returns:
+    --------
+    tuple
+        A tuple containing:
+        - np.ndarray: Generated signal(s) with shape (batch_size, n_chs, time_samples) or (batch_size, n_chs, n_segments, time_samples) for tensorpac and pac signals.
+        - np.ndarray: Time array.
+        - int: Sampling frequency.
+    """
+    assert sig_type in [
+        "uniform",
+        "gauss",
+        "periodic",
+        "chirp",
+        "ripple",
+        "meg",
+        "tensorpac",
+        "pac",
+    ]
+    tt = np.linspace(0, t_sec, int(t_sec * fs), endpoint=False)
+
+    if sig_type == "uniform":
+        return (
+            np.random.uniform(low=-0.5, high=0.5, size=(batch_size, n_chs, len(tt))),
+            tt,
+            fs,
+        )
+
+    elif sig_type == "gauss":
+        return np.random.randn(batch_size, n_chs, len(tt)), tt, fs
+
+    elif sig_type == "meg":
+        return (
+            _demo_sig_meg(
+                batch_size=batch_size,
+                n_chs=n_chs,
+                t_sec=t_sec,
+                fs=fs,
+                verbose=verbose,
+            ).astype(np.float32)[..., : len(tt)],
+            tt,
+            fs,
+        )
+
+    elif sig_type == "tensorpac":
+        xx, tt = _demo_sig_tensorpac(
+            batch_size=batch_size,
+            n_chs=n_chs,
+            n_segments=n_segments,
+            t_sec=t_sec,
+            fs=fs,
+        )
+        return xx.astype(np.float32)[..., : len(tt)], tt, fs
+
+    elif sig_type == "pac":
+        xx = _demo_sig_pac(
+            batch_size=batch_size,
+            n_chs=n_chs,
+            n_segments=n_segments,
+            t_sec=t_sec,
+            fs=fs,
+        )
+        return xx.astype(np.float32)[..., : len(tt)], tt, fs
+
+    else:
+        fn_1d = {
+            "periodic": _demo_sig_periodic_1d,
+            "chirp": _demo_sig_chirp_1d,
+            "ripple": _demo_sig_ripple_1d,
+        }.get(sig_type)
+
+        return (
+            (
+                np.array(
+                    [
+                        fn_1d(
+                            t_sec=t_sec,
+                            fs=fs,
+                            freqs_hz=freqs_hz,
+                            verbose=verbose,
+                        )
+                        for _ in range(int(batch_size * n_chs))
+                    ]
+                )
+                .reshape(batch_size, n_chs, -1)
+                .astype(np.float32)[..., : len(tt)]
+            ),
+            tt,
+            fs,
+        )
+
+
+def _demo_sig_pac(
+    batch_size=8,
+    n_chs=19,
+    t_sec=4,
+    fs=512,
+    f_pha=10,
+    f_amp=100,
+    noise=0.8,
+    n_segments=20,
+    verbose=False,
+):
+    """
+    Generate a demo signal with phase-amplitude coupling.
+    Parameters:
+        batch_size (int): Number of batches.
+        n_chs (int): Number of channels.
+        t_sec (int): Duration of the signal in seconds.
+        fs (int): Sampling frequency.
+        f_pha (float): Frequency of the phase-modulating signal.
+        f_amp (float): Frequency of the amplitude-modulated signal.
+        noise (float): Noise level added to the signal.
+        n_segments (int): Number of segments.
+        verbose (bool): If True, print additional information.
+    Returns:
+        np.array: Generated signals with shape (batch_size, n_chs, n_segments, seq_len).
+    """
+    seq_len = t_sec * fs
+    t = np.arange(seq_len) / fs
+    if verbose:
+        print(f"Generating signal with length: {seq_len}")
+
+    # Create empty array to store the signals
+    signals = np.zeros((batch_size, n_chs, n_segments, seq_len))
+
+    for b in range(batch_size):
+        for ch in range(n_chs):
+            for seg in range(n_segments):
+                # Phase signal
+                theta = np.sin(2 * np.pi * f_pha * t)
+                # Amplitude envelope
+                amplitude_env = 1 + np.sin(2 * np.pi * f_amp * t)
+                # Combine phase and amplitude modulation
+                signal = theta * amplitude_env
+                # Add Gaussian noise
+                signal += noise * np.random.randn(seq_len)
+                signals[b, ch, seg, :] = signal
+
+    return signals
+
+
+def _demo_sig_tensorpac(
+    batch_size=8,
+    n_chs=19,
+    t_sec=4,
+    fs=512,
+    f_pha=10,
+    f_amp=100,
+    noise=0.8,
+    n_segments=20,
+    verbose=False,
+):
+    n_times = int(t_sec * fs)
+    x_2d, tt = pac_signals_wavelet(
+        sf=fs,
+        f_pha=f_pha,
+        f_amp=f_amp,
+        noise=noise,
+        n_epochs=n_segments,
+        n_times=n_times,
+    )
+    x_3d = np.stack([x_2d for _ in range(batch_size)], axis=0)
+    x_4d = np.stack([x_3d for _ in range(n_chs)], axis=1)
+    return x_4d, tt
+
+
+def _demo_sig_meg(batch_size=8, n_chs=19, t_sec=10, fs=512, verbose=False, **kwargs):
+    data_path = sample.data_path()
+    meg_path = data_path / "MEG" / "sample"
+    raw_fname = meg_path / "sample_audvis_raw.fif"
+    fwd_fname = meg_path / "sample_audvis-meg-eeg-oct-6-fwd.fif"
+
+    # Load real data as the template
+    raw = mne.io.read_raw_fif(raw_fname, verbose=verbose)
+    raw = raw.crop(tmax=t_sec, verbose=verbose)
+    raw = raw.resample(fs, verbose=verbose)
+    raw.set_eeg_reference(projection=True, verbose=verbose)
+
+    return raw.get_data(
+        picks=raw.ch_names[: batch_size * n_chs], verbose=verbose
+    ).reshape(batch_size, n_chs, -1)
+
+
+def _demo_sig_periodic_1d(t_sec=10, fs=512, freqs_hz=None, verbose=False, **kwargs):
+    """Returns a demo signal with the shape (t_sec*fs,)."""
+
+    if freqs_hz is None:
+        n_freqs = random.randint(1, 5)
+        freqs_hz = np.random.permutation(np.arange(fs))[:n_freqs]
+        if verbose:
+            print(f"freqs_hz was randomly determined as {freqs_hz}")
+
+    n = int(t_sec * fs)
+    t = np.linspace(0, t_sec, n, endpoint=False)
+
+    summed = np.array(
+        [
+            np.random.rand() * np.sin((f_hz * t + np.random.rand()) * (2 * np.pi))
+            for f_hz in freqs_hz
+        ]
+    ).sum(axis=0)
+    return summed
+
+
+def _demo_sig_chirp_1d(
+    t_sec=10, fs=512, low_hz=None, high_hz=None, verbose=False, **kwargs
+):
+    if low_hz is None:
+        low_hz = random.randint(1, 20)
+        if verbose:
+            warnings.warn(f"low_hz was randomly determined as {low_hz}.")
+
+    if high_hz is None:
+        high_hz = random.randint(100, 1000)
+        if verbose:
+            warnings.warn(f"high_hz was randomly determined as {high_hz}.")
+
+    n = int(t_sec * fs)
+    t = np.linspace(0, t_sec, n, endpoint=False)
+    x = chirp(t, low_hz, t[-1], high_hz)
+    x *= 1.0 + 0.5 * np.sin(2.0 * np.pi * 3.0 * t)
+    return x
+
+
+def _demo_sig_ripple_1d(t_sec=10, fs=512, **kwargs):
+    n_samples = t_sec * fs
+    t = simulate_time(n_samples, fs)
+    n_ripples = random.randint(1, 5)
+    mid_time = np.random.permutation(t)[:n_ripples]
+    return simulate_LFP(t, mid_time, noise_amplitude=1.2, ripple_amplitude=5)
+
+
+if __name__ == "__main__":
+    import scitex
+
+    # Start
+    CONFIG, sys.stdout, sys.stderr, plt, CC = scitex.gen.start(sys, plt)
+    import scitex
+
+    SIG_TYPES = [
+        "uniform",
+        "gauss",
+        "periodic",
+        "chirp",
+        "meg",
+        "ripple",
+        "tensorpac",
+        "pac",
+    ]
+
+    i_batch, i_ch, i_segment = 0, 0, 0
+    fig, axes = scitex.plt.subplots(nrows=len(SIG_TYPES))
+    for ax, (i_sig_type, sig_type) in zip(axes, enumerate(SIG_TYPES)):
+        xx, tt, fs = demo_sig(sig_type=sig_type)
+        if sig_type not in ["tensorpac", "pac"]:
+            ax.plot(tt, xx[i_batch, i_ch], label=sig_type)
+        else:
+            ax.plot(tt, xx[i_batch, i_ch, i_segment], label=sig_type)
+        ax.legend(loc="upper left")
+    fig.suptitle("Demo signals")
+    fig.supxlabel("Time [s]")
+    fig.supylabel("Amplitude [?V]")
+    scitex.io.save(fig, "traces.png")
+
+    # Close
+    scitex.gen.close(CONFIG)
+
+# EOF
+
+"""
+/home/ywatanabe/proj/entrance/scitex/dsp/_demo_sig.py
+"""
+
+# EOF