Esempio n. 1
0
def test_stockwell_api():
    """Test stockwell functions."""
    raw = read_raw_fif(raw_fname)
    event_id, tmin, tmax = 1, -0.2, 0.5
    event_name = op.join(base_dir, 'test-eve.fif')
    events = read_events(event_name)
    epochs = Epochs(
        raw,
        events,  # XXX pick 2 has epochs of zeros.
        event_id,
        tmin,
        tmax,
        picks=[0, 1, 3])
    for fmin, fmax in [(None, 50), (5, 50), (5, None)]:
        with pytest.warns(RuntimeWarning, match='padding'):
            power, itc = tfr_stockwell(epochs,
                                       fmin=fmin,
                                       fmax=fmax,
                                       return_itc=True)
        if fmax is not None:
            assert (power.freqs.max() <= fmax)
        with pytest.warns(RuntimeWarning, match='padding'):
            power_evoked = tfr_stockwell(epochs.average(),
                                         fmin=fmin,
                                         fmax=fmax,
                                         return_itc=False)
        # for multitaper these don't necessarily match, but they seem to
        # for stockwell... if this fails, this maybe could be changed
        # just to check the shape
        assert_array_almost_equal(power_evoked.data, power.data)
    assert (isinstance(power, AverageTFR))
    assert (isinstance(itc, AverageTFR))
    assert_equal(power.data.shape, itc.data.shape)
    assert (itc.data.min() >= 0.0)
    assert (itc.data.max() <= 1.0)
    assert (np.log(power.data.max()) * 20 <= 0.0)
    assert (np.log(power.data.max()) * 20 <= 0.0)
    with pytest.raises(TypeError, match='ndarray'):
        tfr_array_stockwell('foo', 1000.)
    data = np.random.RandomState(0).randn(1, 1024)
    with pytest.raises(ValueError, match='3D with shape'):
        tfr_array_stockwell(data, 1000.)
    data = data[np.newaxis]
    power, itc, freqs = tfr_array_stockwell(data, 1000., return_itc=True)
    assert_allclose(itc, np.ones_like(itc))
    assert power.shape == (1, len(freqs), data.shape[-1])
    assert_array_less(0, power)
    def S_transform(self, epoch_data, baseline_corr=True, n_jobs=-1):
        """Applay Stockwell-transform to epoch_data.
        
        Parameters
        ----------
        epoch_data : {array-like, sample × index}.
            finger flection data. 
        
        baseline_corr: bool
            if True, baseline correction is used
        
        n_jobs: int 
            n_jobs is parallel computing parameter which how many core will be used for analysis.
            if enter n_job=-1, the system will use all available threads.
        
        Returns
        ----------
        st_power: time-frequency power
        itc: inter trial coherence
        freqs: frequencies range was used for analysis.
        """

        st_power, itc, freqs = tfr_array_stockwell(epoch_data,
                                                   self.srate,
                                                   fmin=self.filter_band[0],
                                                   fmax=self.filter_band[1],
                                                   width=.5,
                                                   return_itc=True,
                                                   n_jobs=n_jobs)
        if baseline_corr == True:
            mne.baseline.rescale(st_power,
                                 self.time,
                                 self.baseline,
                                 mode='logratio',
                                 copy=False)

        return st_power, itc, freqs
Esempio n. 3
0
def compute_features(eoi, data, data_80, data_hil, win_size, f_ini, f_fin,
                     sfreq, th, bs, channel, version, file_id):
    epoch = np.zeros([1, 1, win_size * 2])
    p_events = False
    Ev_ini = list()
    Ev_fi = list()
    dur_f = list()
    dur_t = list()
    area = list()
    entropy_calc = list()
    perimeter = list()
    symmetryt = list()
    symmetryf = list()
    oscillations = list()
    kurtosis = list()
    skewness = list()
    inst_freq = list()
    amplitude = list()
    amplitude_norm = list()
    mean_power = list()
    max_power = list()
    for idx, event in enumerate(eoi):
        # Compute Stockwell transform for each eoi, binarize and obtain event features
        mid_event = ((event[1] + event[0]) / 2).astype(int)
        epoch[0, 0, :] = data[:, mid_event - win_size:mid_event + win_size]
        pwr = tfr_array_stockwell(epoch,
                                  fmin=0,
                                  fmax=sfreq / 2,
                                  width=3,
                                  sfreq=sfreq,
                                  n_fft=int(win_size * 2))
        single_epoch = pwr[0][0, f_ini:f_fin,
                              int(win_size / 4):-int(win_size / 4)]
        single_epoch_all = pwr[0][0, 0:f_fin,
                                  int(win_size / 4):-int(win_size / 4)]
        frec_vector = pwr[2]
        # Extract properties from pwr "image"

        image = single_epoch.astype('float32')
        image_all = single_epoch_all.astype('float32')
        if version == 1:
            # H-dome correction
            seed = np.copy(image)
            seed[1:-1, 1:-1] = image.min()
            mask = image
            dilated = reconstruction(seed, mask, method='dilation')
            image_corrected = image - dilated
            # Thresholding with yet
            thresh = threshold_yen(image_corrected)
            binary = image_all > thresh

        if version == 2:
            t_mig = int(single_epoch.shape[1] / 2)
            thresh = np.quantile(single_epoch[:, t_mig], 0.75)
            binary = image_all > thresh
        label_image = label(binary)
        # Extract features
        n_events = 0
        for idx2, region in enumerate(regionprops(label_image)):
            minf, mint, maxf, maxt = region.bbox
            # Just consider events that its middle frequency is higher or equal than f_ini
            mid_f = (frec_vector[minf] + frec_vector[maxf]) / 2
            # Just use events that are in the middle of the st (because is centered in the eoi)
            if (single_epoch.shape[1] / 2 >= mint) & (
                    single_epoch.shape[1] / 2 <= maxt) & (mid_f >= f_ini):
                n_events = n_events + 1
                # Global times
                Ev_ini.append(event[0])
                Ev_fi.append(event[1])
                # Duration in frequency and time
                dur_f.append(maxf - minf)
                dur_t.append(maxt - mint)
                # Area
                area.append(region.area)
                # Entropy
                aux = np.zeros(image_all.shape)
                aux[minf:maxf, mint:maxt] = image_all[minf:maxf, mint:maxt]
                entropy_calc.append(shannon_entropy(aux))
                # Other features from regionpropos
                perimeter.append(region.perimeter)
                # Symmetry
                mean_power.append(np.mean(image_all[minf:maxf, mint:maxt]))
                max_power.append(np.max(image_all[minf:maxf, mint:maxt]))

                hfo = data_80[0, mid_event - int(3 * win_size / 4) + mint -
                              10:mid_event - int(3 * win_size / 4) + maxt + 10]
                hfo_hil = data_hil[0, mid_event - int(3 * win_size / 4) +
                                   mint - 10:mid_event -
                                   int(3 * win_size / 4) + maxt + 10]
                max_id = np.where(image_all == np.max(image_all[minf:maxf,
                                                                mint:maxt]))

                symt = (max_id[1][0] - mint) / (maxt - mint)
                symf = (max_id[0][0] - minf) / (maxf - minf)

                symmetryt.append(symt)
                symmetryf.append(symf)
                # number of oscillations (number of peaks)
                peaks = signal.find_peaks(hfo)
                hil_th = (hfo_hil > th / 2)
                ispeak = np.zeros(hfo.shape, dtype=bool)
                ispeak[peaks[0]] = True
                oscillations.append(np.sum(ispeak * hil_th))

                # Kurtosis and skewness (from hilbert transform)

                kurtosis.append(stats.kurtosis(hfo_hil))
                skewness.append(stats.skew(hfo_hil))
                amplitude.append(np.max(hfo_hil))
                amplitude_norm.append(np.max(hfo_hil) / np.mean(bs))
                # Mean peak frequency and std peak frequency
                peaks = signal.find_peaks(np.abs(hfo))
                inst_freq.append(1 / np.mean(np.diff(peaks[0])) * sfreq * 0.5)

                if p_events == True:
                    ev = pd.DataFrame([[
                        mint, maxt, minf, maxf, region.area,
                        shannon_entropy(aux), symt, symf,
                        np.sum(ispeak * hil_th),
                        1 / np.mean(np.diff(peaks[0])) * sfreq * 0.5,
                        np.max(hfo_hil)
                    ]],
                                      columns=[
                                          't_ini', 't_fin', 'f_ini', 'f_fin',
                                          'Area', 'Entropy', 'Symmetry T',
                                          'Symmetry F', 'Oscillations',
                                          'Inst freq', 'Amplitude'
                                      ])
                    dat = data[0, mid_event - win_size:mid_event + win_size]
                    datfilt = data_80[0, mid_event - win_size:mid_event +
                                      win_size]
                    tf_dat = pwr[0][0, :, int(win_size / 4):-int(win_size / 4)]
                    tf_dat_bin = tf_dat > thresh
                    frec_vector = (pwr[2])
                    image_path = '/home/cmigliorelli/synology/Epilepsia_HSJD/Resultados/hfos_graficas/'
                    plot_eoi(ev, sfreq, dat, datfilt, tf_dat, tf_dat_bin,
                             frec_vector, image_path, channel, idx, idx2,
                             file_id)

    feature_list = [
        Ev_ini, Ev_fi, dur_f, dur_t, area, entropy_calc, perimeter, symmetryt,
        symmetryf, oscillations, kurtosis, skewness, inst_freq, amplitude,
        amplitude_norm, mean_power, max_power
    ]
    return feature_list