def plot_erds(data, freqs, n_cycles, baseline, times=(None, None)):
tfr = tfr_multitaper(data, freqs, n_cycles, average=False, return_itc=False)
tfr.apply_baseline(baseline, mode="percent")
tfr.crop(*times)
figs = []
n_rows, n_cols = _get_rows_cols(data.info["nchan"])
widths = n_cols * [10] + [1] # each map has width 10, each colorbar width 1
for event in data.event_id: # separate figures for each event ID
fig, axes = plt.subplots(n_rows, n_cols + 1, gridspec_kw={"width_ratios": widths})
tfr_avg = tfr[event].average()
vmin, vmax = -1, 2 # default for ERDS maps
cmap = center_cmap(plt.cm.RdBu, vmin, vmax)
for ch, ax in enumerate(axes[..., :-1].flat): # skip last column
tfr_avg.plot([ch], vmin=vmin, vmax=vmax, cmap=(cmap, False), axes=ax,
colorbar=False, show=False)
ax.set_title(data.ch_names[ch], fontsize=10)
ax.axvline(0, linewidth=1, color="black", linestyle=":")
ax.set(xlabel="t (s)", ylabel="f (Hz)")
ax.label_outer()
for ax in axes[..., -1].flat: # colorbars in last column
fig.colorbar(axes.flat[0].images[-1], cax=ax)
fig.suptitle(f"ERDS ({event})")
figs.append(fig)
return figs
def erds_plot(epochs):
# compute ERDS maps ###########################################################
# idx = np.array(list(range(7, 11)) + list(range(12, 15)) + list(range(17, 21)) + list(range(32, 41)))
# chans = np.array(epochs.ch_names)[idx].tolist()
epochs.pick_channels(["C3","Cz","C4"])
event_ids = epochs.event_id
tmin, tmax = -1, 4
freqs = np.arange(60, 90, 1) # frequencies from 2-35Hz
n_cycles = freqs # use constant t/f resolution
vmin, vmax = -1, 1.5 # set min and max ERDS values in plot
# vmin, vmax = -0.5, 0.5 # set min and max ERDS values in plot
baseline = [-1, 0.3] # baseline interval (in s)
cmap = center_cmap(plt.cm.RdBu, vmin, vmax) # zero maps to white
kwargs = dict(n_permutations=100, step_down_p=0.05, seed=1,
buffer_size=None, out_type='mask') # for cluster test
# Run TF decomposition overall epochs
tfr = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles,
use_fft=True, return_itc=False, average=False,
decim=2)
tfr.crop(tmin, tmax)
tfr.apply_baseline(baseline, mode="percent")
for event in event_ids:
# select desired epochs for visualization
tfr_ev = tfr[event]
fig, axes = plt.subplots(1, 4, figsize=(12, 4),
gridspec_kw={"width_ratios": [10, 10, 10, 1]})
for ch, ax in enumerate(axes[:-1]): # for each channel
# positive clusters
_, c1, p1, _ = pcluster_test(tfr_ev.data[:, ch, ...], tail=1, **kwargs)
# negative clusters
_, c2, p2, _ = pcluster_test(tfr_ev.data[:, ch, ...], tail=-1,
**kwargs)
# note that we keep clusters with p <= 0.05 from the combined clusters
# of two independent tests; in this example, we do not correct for
# these two comparisons
c = np.stack(c1 + c2, axis=2) # combined clusters
p = np.concatenate((p1, p2)) # combined p-values
mask = c[..., p <= 0.05].any(axis=-1)
# plot TFR (ERDS map with masking)
tfr_ev.average().plot([ch], vmin=vmin, vmax=vmax, cmap=(cmap, False),
axes=ax, colorbar=False, show=False, mask=mask,
mask_style="mask")
ax.set_title(epochs.ch_names[ch], fontsize=10)
ax.axvline(0, linewidth=1, color="black", linestyle=":") # event
if not ax.is_first_col():
ax.set_ylabel("")
ax.set_yticklabels("")
fig.colorbar(axes[0].images[-1], cax=axes[-1])
fig.suptitle("ERDS ({})".format(event))
fig.show()
def test_center_cmap():
"""Test centering of colormap."""
from matplotlib.colors import LinearSegmentedColormap
from matplotlib.pyplot import Normalize
cmap = center_cmap(cm.get_cmap("RdBu"), -5, 10)
assert isinstance(cmap, LinearSegmentedColormap)
# get new colors for values -5 (red), 0 (white), and 10 (blue)
new_colors = cmap(Normalize(-5, 10)([-5, 0, 10]))
# get original colors for 0 (red), 0.5 (white), and 1 (blue)
reference = cm.RdBu([0., 0.5, 1.])
assert_allclose(new_colors, reference)
# new and old colors at 0.5 must be different
assert not np.allclose(cmap(0.5), reference[1])
picks = mne.pick_channels(raw.info["ch_names"], ["C3", "Cz", "C4"])
# epoch data ##################################################################
tmin, tmax = -1, 4 # define epochs around events (in s)
event_ids = dict(hands=2, feet=3) # map event IDs to tasks
epochs = mne.Epochs(raw, events, event_ids, tmin - 0.5, tmax + 0.5,
picks=picks, baseline=None, preload=True)
# compute ERDS maps ###########################################################
freqs = np.arange(2, 36, 1) # frequencies from 2-35Hz
n_cycles = freqs # use constant t/f resolution
vmin, vmax = -1, 1.5 # set min and max ERDS values in plot
baseline = [-1, 0] # baseline interval (in s)
cmap = center_cmap(plt.cm.RdBu, vmin, vmax) # zero maps to white
kwargs = dict(n_permutations=100, step_down_p=0.05, seed=1,
buffer_size=None) # for cluster test
# Run TF decomposition overall epochs
tfr = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles,
use_fft=True, return_itc=False, average=False,
decim=2)
tfr.crop(tmin, tmax)
tfr.apply_baseline(baseline, mode="percent")
for event in event_ids:
# select desired epochs for visualization
tfr_ev = tfr[event]
fig, axes = plt.subplots(1, 4, figsize=(12, 4),
gridspec_kw={"width_ratios": [10, 10, 10, 1]})
for ch, ax in enumerate(axes[:-1]): # for each channel
epochs = mne.Epochs(raw,
events,
event_ids,
tmin - 0.5,
tmax + 0.5,
picks=picks,
baseline=None,
preload=True)
# compute ERDS maps ###########################################################
freqs = np.arange(2, 36, 1) # frequencies from 2-35Hz
n_cycles = freqs # use constant t/f resolution
vmin, vmax = -1, 1.5 # set min and max ERDS values in plot
baseline = [-1, 0] # baseline interval (in s)
cmap = center_cmap(plt.cm.RdBu, vmin, vmax) # zero maps to white
kwargs = dict(n_permutations=100, step_down_p=0.05, seed=1,
buffer_size=None) # for cluster test
# Run TF decomposition overall epochs
tfr = tfr_multitaper(epochs,
freqs=freqs,
n_cycles=n_cycles,
use_fft=True,
return_itc=False,
average=False,
decim=2)
tfr.crop(tmin, tmax)
tfr.apply_baseline(baseline, mode="percent")
for event in event_ids:
# select desired epochs for visualization
# Definisco onset e offset delle epoche (secondi)
tmin, tmax = -1, 4
#Mappo i nomi degli eventi
event_ids = dict(left=2, right=3)
#Divido il tracciato in epoche
epochs = Epochs(reconst_raw, events, event_ids, tmin - 0.5, tmax + 0.5, picks=picks, baseline=None, preload=True)
#%% ERD
#Selezione un range di frequenza
freqs = np.arange(2, 50, 1)
n_cycles = freqs
#Onset e offset dei grafici
vmin, vmax = -1, 1.5
#Lunghezza della baseline
baseline = [-1, 0]
#Mappo i colori con una scala
cmap = center_cmap(plt.cm.RdBu, vmin, vmax)
kwargs = dict(n_permutations=100, step_down_p=0.05, seed=10, buffer_size=None)
#Instazio una time-frequency representation
tfr = tfr_multitaper(epochs, freqs=freqs, n_cycles=n_cycles, use_fft=True, return_itc=False, average=False, decim=2)
#tfr.crop(tmin, tmax)
#Applico la sottrazione della baseline
tfr.apply_baseline(baseline, mode="percent")
for event in event_ids:
#Per ogni evento
tfr_ev = tfr[event]
#Faccio i subplot
fig, axes = plt.subplots(1, 4, figsize=(12, 4), gridspec_kw={"width_ratios": [10, 10, 10, 1]})
for ch, ax in enumerate(axes[:-1]): #Per ogni canale, indice
# positive clusters
