Exemplo n.º 1
0
    def set_data(self, data, sf=1., method='fourier', nperseg=256, f_min=1.,
                 f_max=160., f_step=1., baseline=None, norm=None,
                 n_window=None, overlap=0., window=None, c_parameter=20,
                 clim=None, cmap='viridis', vmin=None, under=None, vmax=None,
                 over=None):
        """Compute TF and set data to the ImageObj."""
        # ======================= CHECKING =======================
        assert isinstance(data, np.ndarray) and data.ndim == 1
        assert isinstance(sf, (int, float))
        assert method in ('fourier', 'wavelet', 'multitaper')
        if not isinstance(window, str):
            window = 'hamming' if method is 'fourier' else 'flat'
        assert 0. <= overlap < 1.
        # Wavelet args :
        assert isinstance(f_min, (int, float))
        assert isinstance(f_max, (int, float))
        assert isinstance(f_step, (int, float))
        # Spectrogram and Multi-taper args :
        noverlap = int(round(overlap * nperseg))
        assert isinstance(nperseg, int)
        assert isinstance(c_parameter, int)

        # Update color arguments :
        self._update_cbar_args(cmap, clim, vmin, vmax, under, over)
        logger.info("    Compute time-frequency decomposition using the"
                    " %s method" % method)

        if method == 'fourier':
            freqs, time, tf = spectrogram(data, sf, nperseg=nperseg,
                                          noverlap=noverlap, window=window)
        if method == 'wavelet':
            n_pts = len(data)
            freqs = np.arange(f_min, f_max, f_step)
            time = np.arange(n_pts) / sf
            tf = np.zeros((len(freqs), n_pts), dtype=data.dtype)
            # Compute TF and inplace normalization :
            logger.info("    Compute the time-frequency map ("
                        "normalization=%r)" % norm)
            for i, k in enumerate(freqs):
                tf[i, :] = np.square(np.abs(morlet(data, sf, k)))
            normalization(tf, norm=norm, baseline=baseline, axis=1)

            # Averaging :
            if isinstance(n_window, int):
                logger.info("    Averaging time-frequency map using windows of"
                            " size %i with a %f overlap" % (n_window, overlap))
                kw = dict(overlap=overlap, window=window)
                tf = averaging(tf, n_window, axis=1, **kw)
                time = averaging(time, n_window, **kw)
        elif method == 'multitaper':
            is_lspopt_installed(raise_error=True)
            from lspopt import spectrogram_lspopt
            freqs, time, tf = spectrogram_lspopt(data, sf, nperseg=nperseg,
                                                 noverlap=noverlap,
                                                 c_parameter=c_parameter)

        # Set data to the image object :
        ImageObj.set_data(self, tf, xaxis=time, yaxis=freqs,
                          **self.to_kwargs())
Exemplo n.º 2
0
    def set_data(self, data, sf=1., method='fourier', nperseg=256, f_min=1.,
                 f_max=160., f_step=1., baseline=None, norm=None,
                 n_window=None, overlap=0., window=None, c_parameter=20,
                 clim=None, cmap='viridis', vmin=None, under=None, vmax=None,
                 over=None):
        """Compute TF and set data to the ImageObj."""
        # ======================= CHECKING =======================
        assert isinstance(data, np.ndarray) and data.ndim == 1
        assert isinstance(sf, (int, float))
        assert method in ('fourier', 'wavelet', 'multitaper')
        if not isinstance(window, str):
            window = 'hamming' if method is 'fourier' else 'flat'
        assert 0. <= overlap < 1.
        # Wavelet args :
        assert isinstance(f_min, (int, float))
        assert isinstance(f_max, (int, float))
        assert isinstance(f_step, (int, float))
        # Spectrogram and Multi-taper args :
        noverlap = int(round(overlap * nperseg))
        assert isinstance(nperseg, int)
        assert isinstance(c_parameter, int)

        # Update color arguments :
        self._update_cbar_args(cmap, clim, vmin, vmax, under, over)
        logger.info("Compute time-frequency decomposition using the"
                    " %s method" % method)

        if method == 'fourier':
            freqs, time, tf = spectrogram(data, sf, nperseg=nperseg,
                                          noverlap=noverlap, window=window)
        if method == 'wavelet':
            n_pts = len(data)
            freqs = np.arange(f_min, f_max, f_step)
            time = np.arange(n_pts) / sf
            tf = np.zeros((len(freqs), n_pts), dtype=data.dtype)
            # Compute TF and inplace normalization :
            logger.info("Compute the time-frequency map ("
                        "normalization=%r)" % norm)
            for i, k in enumerate(freqs):
                tf[i, :] = np.square(np.abs(morlet(data, sf, k)))
            normalization(tf, norm=norm, baseline=baseline, axis=1)

            # Averaging :
            if isinstance(n_window, int):
                logger.info("Averaging time-frequency map using windows of "
                            "size %i with a %f overlap" % (n_window, overlap))
                kw = dict(overlap=overlap, window=window)
                tf = averaging(tf, n_window, axis=1, **kw)
                time = averaging(time, n_window, **kw)
        elif method == 'multitaper':
            is_lspopt_installed(raise_error=True)
            from lspopt import spectrogram_lspopt
            freqs, time, tf = spectrogram_lspopt(data, sf, nperseg=nperseg,
                                                 noverlap=noverlap,
                                                 c_parameter=c_parameter)

        # Set data to the image object :
        ImageObj.set_data(self, tf, xaxis=time, yaxis=freqs,
                          **self.to_kwargs())
Exemplo n.º 3
0
def test_spectrogram_method():
    """Test the spectrogram method's functionality."""
    fs = 10e3
    N = 1e5
    amp = 2 * np.sqrt(2)
    noise_power = 0.001 * fs / 2
    time = np.arange(N) / fs
    freq = np.linspace(1e3, 2e3, N)
    x = amp * chirp(time, 1e3, 2.0, 6e3, method='quadratic') + \
        np.random.normal(scale=np.sqrt(noise_power), size=time.shape)

    f, t, Sxx = spectrogram_lspopt(x, fs, c_parameter=20.0)
    f_sp, t_sp, Sxx_sp = spectrogram(x, fs)

    assert True
Exemplo n.º 4
0
 def transform(self, x):
     psg = x[:, 0, :]
     #psg = x
     padding = self.window // 2 - self.stride // 2
     psg = np.pad(psg, pad_width=((0, 0), (padding, padding)), mode='edge')
     from lspopt import spectrogram_lspopt
     f, t, sxx = spectrogram_lspopt(
         psg,
         self.sampling_rate,
         c_parameter=5.0,
         nperseg=self.window,
         noverlap=self.window - self.stride,
     )
     # [num_epochs, 1, nfreqbins, time_domain]
     sxx = sxx[:, np.newaxis, :, :]
     return sxx
Exemplo n.º 5
0
def plot_spectrogram(data, sf, hypno=None, win_sec=30, fmin=0.5, fmax=25,
                     trimperc=2.5, cmap='RdBu_r'):
    """
    Plot a full-night multi-taper spectrogram, optionally with the hypnogram
    on top.

    For more details, please refer to the `Jupyter notebook
    <https://github.com/raphaelvallat/yasa/blob/master/notebooks/10_spectrogram.ipynb>`_

    .. versionadded:: 0.1.8

    Parameters
    ----------
    data : :py:class:`numpy.ndarray`
        Single-channel EEG data. Must be a 1D NumPy array.
    sf : float
        The sampling frequency of data AND the hypnogram.
    hypno : array_like
        Sleep stage (hypnogram), optional.

        The hypnogram must have the exact same number of samples as ``data``.
        To upsample your hypnogram, please refer to
        :py:func:`yasa.hypno_upsample_to_data`.

        .. note::
            The default hypnogram format in YASA is a 1D integer
            vector where:

            - -2 = Unscored
            - -1 = Artefact / Movement
            - 0 = Wake
            - 1 = N1 sleep
            - 2 = N2 sleep
            - 3 = N3 sleep
            - 4 = REM sleep
    win_sec : int or float
        The length of the sliding window, in seconds, used for multitaper PSD
        calculation. Default is 30 seconds. Note that ``data`` must be at least
        twice longer than ``win_sec`` (e.g. 60 seconds).
    fmin, fmax : int or float
        The lower and upper frequency of the spectrogram. Default 0.5 to 25 Hz.
    trimperc : int or float
        The amount of data to trim on both ends of the distribution when
        normalizing the colormap. This parameter directly impacts the
        contrast of the spectrogram plot (higher values = higher contrast).
        Default is 2.5, meaning that the min and max of the colormap
        are defined as the 2.5 and 97.5 percentiles of the spectrogram.
    cmap : str
        Colormap. Default to 'RdBu_r'.


    Returns
    -------
    fig : :py:class:`matplotlib.figure.Figure`
        Matplotlib Figure

    Examples
    --------
    1. Full-night multitaper spectrogram on Cz, no hypnogram

    .. plot::

        >>> import yasa
        >>> import numpy as np
        >>> # In the next 5 lines, we're loading the data from GitHub.
        >>> import requests
        >>> from io import BytesIO
        >>> r = requests.get('https://github.com/raphaelvallat/yasa/raw/master/notebooks/data_full_6hrs_100Hz_Cz%2BFz%2BPz.npz', stream=True)
        >>> npz = np.load(BytesIO(r.raw.read()))
        >>> data = npz.get('data')[0, :]
        >>> sf = 100
        >>> fig = yasa.plot_spectrogram(data, sf)

    2. Full-night multitaper spectrogram on Cz with the hypnogram on top

    .. plot::

        >>> import yasa
        >>> import numpy as np
        >>> # In the next lines, we're loading the data from GitHub.
        >>> import requests
        >>> from io import BytesIO
        >>> r = requests.get('https://github.com/raphaelvallat/yasa/raw/master/notebooks/data_full_6hrs_100Hz_Cz%2BFz%2BPz.npz', stream=True)
        >>> npz = np.load(BytesIO(r.raw.read()))
        >>> data = npz.get('data')[0, :]
        >>> sf = 100
        >>> # Load the 30-sec hypnogram and upsample to data
        >>> hypno = np.loadtxt('https://raw.githubusercontent.com/raphaelvallat/yasa/master/notebooks/data_full_6hrs_100Hz_hypno_30s.txt')
        >>> hypno = yasa.hypno_upsample_to_data(hypno, 1/30, data, sf)
        >>> fig = yasa.plot_spectrogram(data, sf, hypno, cmap='Spectral_r')
    """
    # Increase font size while preserving original
    old_fontsize = plt.rcParams['font.size']
    plt.rcParams.update({'font.size': 18})

    # Safety checks
    assert isinstance(data, np.ndarray), 'Data must be a 1D NumPy array.'
    assert isinstance(sf, (int, float)), 'sf must be int or float.'
    assert data.ndim == 1, 'Data must be a 1D (single-channel) NumPy array.'
    assert isinstance(win_sec, (int, float)), 'win_sec must be int or float.'
    assert isinstance(fmin, (int, float)), 'fmin must be int or float.'
    assert isinstance(fmax, (int, float)), 'fmax must be int or float.'
    assert fmin < fmax, 'fmin must be strictly inferior to fmax.'
    assert fmax < sf / 2, 'fmax must be less than Nyquist (sf / 2).'

    # Calculate multi-taper spectrogram
    nperseg = int(win_sec * sf)
    assert data.size > 2 * nperseg, 'Data length must be at least 2 * win_sec.'
    f, t, Sxx = spectrogram_lspopt(data, sf, nperseg=nperseg, noverlap=0)
    Sxx = 10 * np.log10(Sxx)  # Convert uV^2 / Hz --> dB / Hz

    # Select only relevant frequencies (up to 30 Hz)
    good_freqs = np.logical_and(f >= fmin, f <= fmax)
    Sxx = Sxx[good_freqs, :]
    f = f[good_freqs]
    t /= 3600  # Convert t to hours

    # Normalization
    vmin, vmax = np.percentile(Sxx, [0 + trimperc, 100 - trimperc])
    norm = Normalize(vmin=vmin, vmax=vmax)

    if hypno is None:
        fig, ax = plt.subplots(nrows=1, figsize=(12, 4))
        im = ax.pcolormesh(t, f, Sxx, norm=norm, cmap=cmap, antialiased=True,
                           shading="auto")
        ax.set_xlim(0, t.max())
        ax.set_ylabel('Frequency [Hz]')
        ax.set_xlabel('Time [hrs]')

        # Add colorbar
        cbar = fig.colorbar(im, ax=ax, shrink=0.95, fraction=0.1, aspect=25)
        cbar.ax.set_ylabel('Log Power (dB / Hz)', rotation=270, labelpad=20)
        return fig
    else:
        hypno = np.asarray(hypno).astype(int)
        assert hypno.ndim == 1, 'Hypno must be 1D.'
        assert hypno.size == data.size, 'Hypno must have the same sf as data.'
        t_hyp = np.arange(hypno.size) / (sf * 3600)
        # Make sure that REM is displayed after Wake
        hypno = pd.Series(hypno).map({-2: -2, -1: -1, 0: 0, 1: 2,
                                      2: 3, 3: 4, 4: 1}).values
        hypno_rem = np.ma.masked_not_equal(hypno, 1)

        fig, (ax0, ax1) = plt.subplots(nrows=2, figsize=(12, 6),
                                       gridspec_kw={'height_ratios': [1, 2]})
        plt.subplots_adjust(hspace=0.1)

        # Hypnogram (top axis)
        ax0.step(t_hyp, -1 * hypno, color='k')
        ax0.step(t_hyp, -1 * hypno_rem, color='r')
        if -2 in hypno and -1 in hypno:
            # Both Unscored and Artefacts are present
            ax0.set_yticks([2, 1, 0, -1, -2, -3, -4])
            ax0.set_yticklabels(['Uns', 'Art', 'W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 2.5)
        elif -2 in hypno and -1 not in hypno:
            # Only Unscored are present
            ax0.set_yticks([2, 0, -1, -2, -3, -4])
            ax0.set_yticklabels(['Uns', 'W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 2.5)

        elif -2 not in hypno and -1 in hypno:
            # Only Artefacts are present
            ax0.set_yticks([1, 0, -1, -2, -3, -4])
            ax0.set_yticklabels(['Art', 'W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 1.5)
        else:
            # No artefacts or Unscored
            ax0.set_yticks([0, -1, -2, -3, -4])
            ax0.set_yticklabels(['W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 0.5)
        ax0.set_xlim(0, t_hyp.max())
        ax0.set_ylabel('Stage')
        ax0.xaxis.set_visible(False)
        ax0.spines['right'].set_visible(False)
        ax0.spines['top'].set_visible(False)

        # Spectrogram (bottom axis)
        im = ax1.pcolormesh(t, f, Sxx, norm=norm, cmap=cmap, antialiased=True,
                            shading="auto")
        ax1.set_xlim(0, t.max())
        ax1.set_ylabel('Frequency [Hz]')
        ax1.set_xlabel('Time [hrs]')

        # Revert font-size
        plt.rcParams.update({'font.size': old_fontsize})
        return fig
Exemplo n.º 6
0
    def set_data(self,
                 sf,
                 data,
                 time,
                 method='Fourier transform',
                 cmap='rainbow',
                 nfft=30.,
                 overlap=0.,
                 fstart=.5,
                 fend=20.,
                 contrast=.5,
                 interp='nearest',
                 norm=0):
        """Set data to the spectrogram.

        Use this method to change data, colormap, spectrogram settings, the
        starting and ending frequencies.

        Parameters
        ----------
        sf: float
            The sampling frequency.
        data: array_like
            The data to use for the spectrogram. Must be a row vector.
        time: array_like
            The time vector.
        method: string | 'Fourier transform'
            Computation method.
        cmap : string | 'viridis'
            The matplotlib colormap to use.
        nfft : float | 30.
            Number of fft points for the spectrogram (in seconds).
        overlap : float | .5
            Ovelap proprotion (0 <= overlap <1).
        fstart : float | .5
            Frequency from which the spectrogram have to start.
        fend : float | 20.
            Frequency from which the spectrogram have to finish.
        contrast : float | .5
            Contrast of the colormap.
        interp : string | 'nearest'
            Interpolation method.
        norm : int | 0
            Normalization method for TF.
        """
        # =================== PREPARE DATA ===================
        # Prepare data (only if needed)
        if self:
            data = self._prepare_data(sf, data.copy(), time)

        nperseg = int(round(nfft * sf))

        # =================== TF // SPECTRO ===================
        if method == 'Wavelet':
            self.tf.set_data(data,
                             sf,
                             f_min=fstart,
                             f_max=fend,
                             cmap=cmap,
                             contrast=contrast,
                             n_window=nperseg,
                             overlap=overlap,
                             window='hamming',
                             norm=norm)
            self.tf._image.interpolation = interp
            self.rect = self.tf.rect
            self.freq = self.tf.freqs
        else:
            # =================== CONVERSION ===================
            overlap = int(round(overlap * nperseg))

            if method == 'Multitaper':
                from lspopt import spectrogram_lspopt
                freq, _, mesh = spectrogram_lspopt(data,
                                                   fs=sf,
                                                   nperseg=nperseg,
                                                   c_parameter=20,
                                                   noverlap=overlap)
            elif method == 'Fourier transform':
                freq, _, mesh = scpsig.spectrogram(data,
                                                   fs=sf,
                                                   nperseg=nperseg,
                                                   noverlap=overlap,
                                                   window='hamming')
            mesh = 20 * np.log10(mesh)

            # =================== FREQUENCY SELECTION ===================
            # Find where freq is [fstart, fend] :
            f = [0., 0.]
            f[0] = np.abs(freq - fstart).argmin() if fstart else 0
            f[1] = np.abs(freq - fend).argmin() if fend else len(freq)
            # Build slicing and select frequency vector :
            sls = slice(f[0], f[1] + 1)
            freq = freq[sls]
            self._fstart, self._fend = freq[0], freq[-1]

            # =================== COLOR ===================
            # Get clim :
            _mesh = mesh[sls, :]
            contrast = 1. if contrast is None else contrast
            clim = (contrast * _mesh.min(), contrast * _mesh.max())
            # Turn mesh into color array for selected frequencies:
            self.mesh.set_data(_mesh)
            _min, _max = _mesh.min(), _mesh.max()
            _cmap = cmap_to_glsl(limits=(_min, _max), clim=clim, cmap=cmap)
            self.mesh.cmap = _cmap
            self.mesh.clim = 'auto'
            self.mesh.interpolation = interp

            # =================== TRANSFORM ===================
            tm, th = time.min(), time.max()
            # Re-scale the mesh for fitting in time / frequency :
            fact = (freq.max() - freq.min()) / len(freq)
            sc = (th / mesh.shape[1], fact, 1)
            tr = [0., freq.min(), 0.]
            self.mesh.transform.translate = tr
            self.mesh.transform.scale = sc
            # Update object :
            self.mesh.update()
            # Get camera rectangle :
            self.rect = (tm, freq.min(), th - tm, freq.max() - freq.min())
            self.freq = freq
        # Visibility :
        self.mesh.visible = 0 if method == 'Wavelet' else 1
        self.tf.visible = 1 if method == 'Wavelet' else 0
Exemplo n.º 7
0
def specgram_multitaper(data,
                        sfreq,
                        sperseg=30,
                        perc_overlap=1 / 3,
                        lfreq=0,
                        ufreq=40,
                        show_plot=True,
                        title='',
                        ax=None):
    """
    Display EEG spectogram using a multitaper from 0-30 Hz

    :param data: the data to visualize, should be of rank 1
    :param sfreq: the sampling frequency of the data
    :param sperseg: number of seconds to use per FFT
    :param noverlap: percentage of overlap between segments
    :param lfreq: Lower frequency to display
    :param ufreq: Upper frequency to display
    :param show_plot: If false, only the mesh is returned, but not Figure opened
    :param ax: An axis where to plot. Else will create a new Figure
    :returns: the resulting mesh as it would be plotted
    """

    if ax is None:
        plt.figure()
        ax = plt.subplot(1, 1, 1)

    assert isinstance(show_plot, bool), 'show_plot must be boolean'
    nperseg = int(round(sperseg * sfreq))
    overlap = int(round(perc_overlap * nperseg))

    f_range = [lfreq, ufreq]

    freq, xy, mesh = spectrogram_lspopt(data,
                                        sfreq,
                                        nperseg=nperseg,
                                        noverlap=overlap,
                                        c_parameter=20.)
    if mesh.ndim == 3: mesh = mesh.squeeze().T
    mesh = 20 * np.log10(mesh + 0.0000001)
    idx_notfinite = np.isfinite(mesh) == False
    mesh[idx_notfinite] = np.min(mesh[~idx_notfinite])

    f_range[1] = np.abs(freq - ufreq).argmin()
    sls = slice(f_range[0], f_range[1] + 1)
    freq = freq[sls]

    mesh = mesh[sls, :]
    mesh = mesh - mesh.min()
    mesh = mesh / mesh.max()
    if show_plot:
        ax.imshow(np.flipud(mesh), aspect='auto')
        formatter = matplotlib.ticker.FuncFormatter(lambda s, x: time.strftime(
            '%H:%M', time.gmtime(int(s * (sperseg - overlap / sfreq)))))
        ax.xaxis.set_major_formatter(formatter)
        if xy[-1] < 3600 * 7:  # 7 hours is half hourly
            tick_distance = max(np.argmax(xy > sperseg * 60),
                                5)  #plot per half hour
        else:  # more than 7 hours hourly ticks
            tick_distance = np.argmax(
                xy > sperseg * 60) * 2  #plot per half hour
        two_hz_pos = np.argmax(freq > 1.99999999)
        ytick_pos = np.arange(0, len(freq), two_hz_pos)
        ax.set_xticks(np.arange(0, mesh.shape[1], tick_distance))
        ax.set_yticks(ytick_pos)
        ax.set_yticklabels(np.arange(ufreq, lfreq - 1, -2))
        ax.set_xlabel('Time after onset')
        ax.set_ylabel('Frequency')
        ax.set_title(title)
        warnings.filterwarnings(
            "ignore",
            message='This figure includes Axes that are not compatible')
        plt.tight_layout()
    return mesh
Exemplo n.º 8
0
    def set_data(self, sf, data, time, method='Fourier transform',
                 cmap='rainbow', nfft=30., overlap=0., fstart=.5, fend=20.,
                 contrast=.5, interp='nearest', norm=0):
        """Set data to the spectrogram.

        Use this method to change data, colormap, spectrogram settings, the
        starting and ending frequencies.

        Parameters
        ----------
        sf: float
            The sampling frequency.
        data: array_like
            The data to use for the spectrogram. Must be a row vector.
        time: array_like
            The time vector.
        method: string | 'Fourier transform'
            Computation method.
        cmap : string | 'viridis'
            The matplotlib colormap to use.
        nfft : float | 30.
            Number of fft points for the spectrogram (in seconds).
        overlap : float | .5
            Ovelap proprotion (0 <= overlap <1).
        fstart : float | .5
            Frequency from which the spectrogram have to start.
        fend : float | 20.
            Frequency from which the spectrogram have to finish.
        contrast : float | .5
            Contrast of the colormap.
        interp : string | 'nearest'
            Interpolation method.
        norm : int | 0
            Normalization method for TF.
        """
        # =================== PREPARE DATA ===================
        # Prepare data (only if needed)
        if self:
            data = self._prepare_data(sf, data.copy(), time)

        nperseg = int(round(nfft * sf))

        # =================== TF // SPECTRO ===================
        if method == 'Wavelet':
            self.tf.set_data(data, sf, f_min=fstart, f_max=fend, cmap=cmap,
                             contrast=contrast, n_window=nperseg,
                             overlap=overlap, window='hamming', norm=norm)
            self.tf._image.interpolation = interp
            self.rect = self.tf.rect
            self.freq = self.tf.freqs
        else:
            # =================== CONVERSION ===================
            overlap = int(round(overlap * nperseg))

            if method == 'Multitaper':
                from lspopt import spectrogram_lspopt
                freq, _, mesh = spectrogram_lspopt(data, fs=sf,
                                                   nperseg=nperseg,
                                                   c_parameter=20,
                                                   noverlap=overlap)
            elif method == 'Fourier transform':
                freq, _, mesh = scpsig.spectrogram(data, fs=sf,
                                                   nperseg=nperseg,
                                                   noverlap=overlap,
                                                   window='hamming')
            mesh = 20 * np.log10(mesh)

            # =================== FREQUENCY SELECTION ===================
            # Find where freq is [fstart, fend] :
            f = [0., 0.]
            f[0] = np.abs(freq - fstart).argmin() if fstart else 0
            f[1] = np.abs(freq - fend).argmin() if fend else len(freq)
            # Build slicing and select frequency vector :
            sls = slice(f[0], f[1] + 1)
            freq = freq[sls]
            self._fstart, self._fend = freq[0], freq[-1]

            # =================== COLOR ===================
            # Get clim :
            _mesh = mesh[sls, :]
            is_finite = np.isfinite(_mesh)
            _mesh[~is_finite] = np.percentile(_mesh[is_finite], 5)
            contrast = 1. if contrast is None else contrast
            clim = (contrast * _mesh.min(), contrast * _mesh.max())
            # Turn mesh into color array for selected frequencies:
            self.mesh.set_data(_mesh)
            _min, _max = _mesh.min(), _mesh.max()
            _cmap = cmap_to_glsl(limits=(_min, _max), clim=clim, cmap=cmap)
            self.mesh.cmap = _cmap
            self.mesh.clim = 'auto'
            self.mesh.interpolation = interp

            # =================== TRANSFORM ===================
            tm, th = time.min(), time.max()
            # Re-scale the mesh for fitting in time / frequency :
            fact = (freq.max() - freq.min()) / len(freq)
            sc = (th / mesh.shape[1], fact, 1)
            tr = [0., freq.min(), 0.]
            self.mesh.transform.translate = tr
            self.mesh.transform.scale = sc
            # Update object :
            self.mesh.update()
            # Get camera rectangle :
            self.rect = (tm, freq.min(), th - tm, freq.max() - freq.min())
            self.freq = freq
        # Visibility :
        self.mesh.visible = 0 if method == 'Wavelet' else 1
        self.tf.visible = 1 if method == 'Wavelet' else 0
Exemplo n.º 9
0
def plot_spectrogram(data, sf, hypno=None, win_sec=30, fmin=0.5, fmax=25, trimperc=2.5, cmap='Spectral_r'):
    __all__ = ['plot_spectrogram']

    # Set default font size to 12
    plt.rcParams.update({'font.size': 12})

    # Calculate multi-taper spectrogram
    nperseg = int(win_sec * sf)
    assert data.size > 2 * nperseg, 'Data length must be at least 2 * win_sec.'
    f, t, Sxx = spectrogram_lspopt(data, sf, nperseg=nperseg, noverlap=0)
    Sxx = 10 * np.log10(Sxx)  # Convert uV^2 / Hz --> dB / Hz

    # Select only relevant frequencies (up to 30 Hz)
    good_freqs = np.logical_and(f >= fmin, f <= fmax)
    Sxx = Sxx[good_freqs, :]
    f = f[good_freqs]
    t /= 3600  # Convert t to hours

    # Normalization
    vmin, vmax = np.percentile(Sxx, [0 + trimperc, 100 - trimperc])
    norm = Normalize(vmin=vmin, vmax=vmax)

    if hypno is None:
        fig, ax = plt.subplots(nrows=1, figsize=(12, 4))
        im = ax.pcolormesh(t, f, Sxx, norm=norm, cmap=cmap, antialiased=True)
        ax.set_xlim(0, t.max())
        ax.set_ylabel('Frequency [Hz]')
        ax.set_xlabel('Time [sec]')

        # Add colorbar
        cbar = fig.colorbar(im, ax=ax, shrink=0.95, fraction=0.1, aspect=25)
        cbar.ax.set_ylabel('Log Power (dB / Hz)', rotation=270, labelpad=20)
        return fig
    else:
        hypno = np.asarray(hypno).astype(int)
        assert hypno.ndim == 1, 'Hypno must be 1D.'
        assert hypno.size == data.size, 'Hypno must have the same sf as data.'
        t_hyp = np.arange(hypno.size) / (sf * 3600)
        # Make sure that REM is displayed after Wake
        hypno = pd.Series(hypno).map({-2: -2, -1: -1, 0: 0, 1: 2,
                                      2: 3, 3: 4, 4: 1}).values
        hypno_rem = np.ma.masked_not_equal(hypno, 1)

        fig = plt.figure(constrained_layout = True, figsize=(22, 14))
        grid_spec = fig.add_gridspec(3, 2, height_ratios=[1, 1, 1.6])
        ax0 = fig.add_subplot(grid_spec[0, :])
        ax1 = fig.add_subplot(grid_spec[1, :])
        # plt.subplots_adjust(hspace=0.1)
        fig.tight_layout(pad=1)

        # Hypnogram (top axis)
        ax0.step(t_hyp, -1 * hypno, color='k', linewidth=4)
        ax0.step(t_hyp, -1 * hypno_rem, color='r')
        if -2 in hypno and -1 in hypno:
            # Both Unscored and Artefacts are present
            ax0.set_yticks([2, 1, 0, -1, -2, -3, -4])
            ax0.set_yticklabels(['Uns', 'Art', 'W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 2.5)
        elif -2 in hypno and -1 not in hypno:
            # Only Unscored are present
            ax0.set_yticks([2, 0, -1, -2, -3, -4])
            ax0.set_yticklabels(['Uns', 'W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 2.5)

        elif -2 not in hypno and -1 in hypno:
            # Only Artefacts are present
            ax0.set_yticks([1, 0, -1, -2, -3, -4])
            ax0.set_yticklabels(['Art', 'W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 1.5)
        else:
            # No artefacts or Unscored
            ax0.set_yticks([0, -1, -2, -3, -4])
            ax0.set_yticklabels(['W', 'R', 'N1', 'N2', 'N3'])
            ax0.set_ylim(-4.5, 0.5)
        ax0.set_xlim(0, t_hyp.max())
        ax0.set_ylabel('Stage')
        ax0.xaxis.set_visible(False)
        ax0.spines['right'].set_visible(False)
        ax0.spines['top'].set_visible(False)

        # Spectrogram (bottom axis)
        im = ax1.pcolormesh(t, f, Sxx, norm=norm, cmap=cmap, antialiased=True)
        ax1.set_xlim(0, t.max())
        ax1.set_ylabel('Frequency [Hz]')
        ax1.set_xlabel('Time [hrs]')
        return fig, grid_spec, ax0, ax1
Exemplo n.º 10
0
from SleepData import SleepRecord
import ospath
from tqdm import tqdm
from lspopt import spectrogram_lspopt
import numpy as np

files = ospath.list_files('C:/Users/SimonKern/Desktop/nt1-hrv/',
                          subfolders=True,
                          exts='edf')

mins = []
maxs = []

for file in tqdm(files):
    sr = SleepRecord(file)
    data = sr.raw
    sfreq = sr.sfreq
    perc_overlap = 1 / 3
    sperseg = 30
    nperseg = int(round(sperseg * sfreq))
    overlap = int(round(perc_overlap * nperseg))
    freq, xy, mesh = spectrogram_lspopt(data,
                                        sfreq,
                                        nperseg=nperseg,
                                        noverlap=overlap,
                                        c_parameter=20.)
    mesh = 20 * np.log10(mesh)
    idx_notfinite = np.isfinite(mesh) == False
    mesh[idx_notfinite] = np.min(mesh[~idx_notfinite])
    mins.append(mesh.min())
    maxs.append(mesh.max())
Exemplo n.º 11
0
for i in range(len(list_data)):
   
    s = str(i) 
    curr_data = list_data[s]
    
    # Create the subplots
    if i ==0 : 
        fig, axs = plt.subplots(len_data,1, figsize=(26, 14))
    
    # Choose current axes
    plt.axes(axs[i])
    
    # Make the spectrograms
    try: 
        f, t, Sxx = spectrogram_lspopt(x=curr_data, fs=fs, c_parameter=20.0, nperseg=int(30*fs), \
                                           scaling='density')
    except ValueError:
        f, t, Sxx = spectrogram_lspopt(x=curr_data, fs=fs, c_parameter=20.0, nperseg=int(30*fs), \
                                           scaling='density')
    Sxx = 10 * np.log10(Sxx) #power to db
    
    # Limit Sxx to the largest freq of interest:
    f_tmp   = f[0:900]
    Sxx_tmp = Sxx[0][0:900, :]
    
    plt.pcolormesh(t, f_tmp, Sxx_tmp, cmap = 'jet')
    plt.ylim([0, 30])
    
    # Assign the number of night 
    plt.ylabel(f'Night {i+1}')