def apply_foward_model(self, x):
out = []
for z in x:
info = mne.io.read_info(self.raw_fname)
stc = mne.SourceEstimate(z.cpu().detach().numpy(),
self.vertices,
tmin=0.,
tstep=self.time_step)
# print("STC", stc)
# print("Info", info)
leadfield = mne.apply_forward(self.fwd_fixed, stc,
info).data[0:self.num_nodes]
# leadfield = torch.from_numpy(leadfield)
# leadfield = leadfield.transpose(0,1)
# print("YOUYOUYOUYOUY")
# array = leadfield.to_data_frame().values
# print("array", leadfield.shape)
out += [leadfield]
out = np.asarray(out)
out = torch.from_numpy(out).transpose(1, 2)
if x.is_cuda:
out = out.type(torch.cuda.FloatTensor)
else:
out = out.type(torch.FloatTensor)
# print("OUTOUTOUT", out.shape)
# (n sensors, n samples)
return out
def simu_data(evoked, forward, noise_cov, n_dipoles, times, nave=1):
"""Simulate an evoked dataset with 2 sources.
One source is put in each hemisphere.
"""
# Generate the two dipoles data
mu, sigma = 0.1, 0.005
s1 = 1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-(times - mu) ** 2 /
(2 * sigma ** 2))
mu, sigma = 0.075, 0.008
s2 = -1 / (sigma * np.sqrt(2 * np.pi)) * np.exp(-(times - mu) ** 2 /
(2 * sigma ** 2))
data = np.array([s1, s2]) * 1e-9
src = forward['src']
rng = np.random.RandomState(42)
rndi = rng.randint(len(src[0]['vertno']))
lh_vertno = src[0]['vertno'][[rndi]]
rndi = rng.randint(len(src[1]['vertno']))
rh_vertno = src[1]['vertno'][[rndi]]
vertices = [lh_vertno, rh_vertno]
tmin, tstep = times.min(), 1 / evoked.info['sfreq']
stc = mne.SourceEstimate(data, vertices=vertices, tmin=tmin, tstep=tstep)
sim_evoked = mne.simulation.simulate_evoked(forward, stc, evoked.info,
noise_cov, nave=nave,
random_state=rng)
return sim_evoked, stc
def run(mmvt):
mu = mmvt.utils
stc_fname = mmvt.coloring.get_stc_full_fname()
if not op.isfile(stc_fname):
print('Can\'t find the selected stc!')
return
stc = mne.read_source_estimate(stc_fname)
data = {}
if mmvt.play.get_play_to() > len(stc.times) - 1:
mmvt.play.set_play_to(len(stc.times) - 1)
time = np.arange(mmvt.play.get_play_from(), mmvt.play.get_play_to(),
mmvt.play.get_play_dt())
data['rh'] = np.zeros((stc.rh_data.shape[0], 1))
data['lh'] = np.zeros((stc.lh_data.shape[0], 1))
threshold = mmvt.coloring.get_lower_threshold()
for t_ind, t in tqdm(enumerate(time)):
for hemi in mu.HEMIS:
hemi_data = stc.rh_data[:,
t_ind] if hemi == 'rh' else stc.lh_data[:,
t_ind]
verts = np.where(hemi_data >= threshold)[0]
data[hemi][verts, 0] = time[t_ind]
data = np.concatenate([data['lh'], data['rh']])
vertices = [stc.lh_vertno, stc.rh_vertno]
stc = mne.SourceEstimate(data, vertices, 0, 0, subject=mu.get_user())
mmvt.colorbar.lock_colorbar_values(False)
mmvt.coloring.clear_colors()
mmvt.coloring.plot_stc(stc, bpy.context.scene.frame_current, 0, time[-1],
time[0])
mmvt.coloring.set_lower_threshold(
threshold) # Set threshold to its previous value
def make_stc(data, vertices, tstep=0.1, tmin=0., subject=None):
"""Create stc from data."""
if not isinstance(vertices, list):
vertices = [vertices, []]
n_sources_l, n_sources_r = [len(v) for v in vertices]
assert data.shape[0] == n_sources_l + n_sources_r
data_l = data[:n_sources_l]
data_r = data[n_sources_l:]
data_lr = [data_l, data_r]
ns = [n_sources_l, n_sources_r]
data = []
for i, (v, n) in enumerate(zip(vertices, ns)):
if n:
order = np.argsort(v)
data.append(data_lr[i][order])
vertices[i] = np.asarray(vertices[i][order])
if n_sources_l * n_sources_r:
data = np.concatenate(data)
else:
data = np.array(data[0])
stc = mne.SourceEstimate(data,
vertices,
tstep=tstep,
tmin=tmin,
subject=subject)
return stc
def _bias_params(evoked, noise_cov, fwd):
evoked.pick_types(meg=True, eeg=True, exclude=())
# restrict to limited set of verts (small src here) and one hemi for speed
vertices = [fwd['src'][0]['vertno'].copy(), []]
stc = mne.SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)),
vertices, 0, 1)
fwd = mne.forward.restrict_forward_to_stc(fwd, stc)
assert fwd['sol']['row_names'] == noise_cov['names']
assert noise_cov['names'] == evoked.ch_names
evoked = mne.EvokedArray(fwd['sol']['data'].copy(), evoked.info)
data_cov = noise_cov.copy()
data = fwd['sol']['data'] @ fwd['sol']['data'].T
data *= 1e-14 # 100 nAm at each source, effectively (1e-18 would be 1 nAm)
# This is rank-deficient, so let's make it actually positive semidefinite
# by regularizing a tiny bit
data.flat[::data.shape[0] + 1] += mne.make_ad_hoc_cov(evoked.info)['data']
# Do our projection
proj, _, _ = mne.io.proj.make_projector(data_cov['projs'],
data_cov['names'])
data = proj @ data @ proj.T
data_cov['data'][:] = data
assert data_cov['data'].shape[0] == len(noise_cov['names'])
want = np.arange(fwd['sol']['data'].shape[1])
if not mne.forward.is_fixed_orient(fwd):
want //= 3
return evoked, fwd, noise_cov, data_cov, want
def _check_stc(clst):
'''Make sure Clusters has a list of mne.SourceEstimate in stc attribute.'''
import mne
if clst.stc is None:
vertices = clst.dimcoords[0]
if vertices is None:
vert = [clst.src[0]['vertno'], clst.src[1]['vertno']]
else:
# this should use _to_data_vert when it is moved from DiamSar
lh, rh = [vertices[hemi] for hemi in ['lh', 'rh']]
vert = [clst.src[0]['vertno'][lh], clst.src[1]['vertno'][rh]]
assert clst.dimnames.index('vert') == 0
tmin, tstep = 1., 1.
if len(clst.dimnames) > 1:
data_single = clst.stat[:, [0]]
else:
data_single = clst.stat[:, np.newaxis].copy()
clst.stc = mne.SourceEstimate(data_single,
vertices=vert,
tmin=tmin,
tstep=tstep,
subject=clst.subject)
def gen_stupid_gamma_signal(ch_names, hemi='rh'):
ivs = InvasiveSignal()
ivs.ch_names = ch_names
if hemi == 'rh':
vertnos = [np.array(()), np.arange(len(ch_names))]
else:
vertnos = [np.arange(len(ch_names)), np.array(())]
from scipy.stats import gamma
tsignal = np.zeros((len(ch_names), 100))
for i, ch_name in enumerate(ch_names):
scale_param = np.random.randint(5, 15)
multi_param = np.random.randint(1, 4)
min_param = np.random.randint(10)
max_param = np.random.randint(10, 15)
#import pdb
#pdb.set_trace()
tsignal[i, :] = np.array([
gamma.pdf(j, scale_param) * multi_param
for j in np.linspace(min_param, max_param, 100)
])
stc = mne.SourceEstimate(tsignal,
tmin=1,
tstep=1,
vertices=vertnos,
subject='woethiezluok')
ivs.mne_source_estimate = stc
return ivs
def mne_python():
subjects_dir = data_path + '/subjects'
# Read data
evoked = mne.read_evokeds(fname_evoked,
condition='Left Auditory',
baseline=(None, 0))
fwd = mne.read_forward_solution(fname_fwd)
cov = mne.read_cov(fname_cov)
inv = make_inverse_operator(evoked.info,
fwd,
cov,
loose=0.,
depth=0.8,
verbose=True)
snr = 3.0
lambda2 = 1.0 / snr**2
kwargs = dict(initial_time=0.08,
hemi='both',
subjects_dir=subjects_dir,
size=(600, 600))
stc = abs(apply_inverse(evoked, inv, lambda2, 'MNE', verbose=True))
stc = mne.SourceEstimate(stc.data * 1e10,
stc.vertices,
stc.tmin,
stc.tstep,
subject='sample')
stc.save(data_path + '/MEG/sample/sample_audvis_MNE')
def gen_stupid_sinusoidal_signal(ch_names, hemi='rh'):
ivs = InvasiveSignal()
ivs.ch_names = ch_names
if hemi == 'rh':
vertnos = [np.array(()), np.arange(len(ch_names))]
else:
vertnos = [np.arange(len(ch_names)), np.array()]
tsignal = np.zeros((len(ch_names), 100))
for i, ch_name in enumerate(ch_names):
amp = np.random.random() * .5
freqp = np.random.random() * (5 - .2) + .2
phasep = np.random.random() * 2 * np.pi
funcp = [np.sin, np.cos][int(np.random.randint(2))]
tsignal[i, :] = np.array([
amp * funcp(2 * np.pi * freqp * j + phasep) + .5
for j in np.arange(100)
])
stc = mne.SourceEstimate(tsignal,
tmin=1,
tstep=1,
vertices=vertnos,
subject='woethiezluok')
ivs.mne_source_estimate = stc
return ivs
def normalise_stc(stc):
""" Normalise data in STC object to absolute maximum.
Parameters
----------
stc: SourceEstimate
The data to normalise.
Returns
-------
stc_norm: Source estimate.
STC with data normalised to absolute maximum.
"""
data = stc.data
data = data / np.absolute(data).max()
# convert normalised data to source estimate
stc_norm = mne.SourceEstimate(data,
stc.vertices,
tmin=stc.tmin,
tstep=stc.tstep)
return stc_norm
def add_stcs(stc1, stc2):
"""Adds two SourceEstimates together, allowing for different vertices."""
vertices = [
np.union1d(stc1.vertices[0], stc2.vertices[0]),
np.union1d(stc1.vertices[1], stc2.vertices[1])
]
assert stc1.data.shape[1] == stc2.data.shape[1]
assert stc1.tmin == stc2.tmin
assert stc1.tstep == stc2.tstep
data = np.zeros((len(vertices[0]) + len(vertices[1]), stc1.data.shape[1]))
i = 0
# Left hemisphere
for vert in vertices[0]:
if vert in stc1.vertices[0]:
data[[i]] += stc1.lh_data[stc1.vertices[0] == vert]
if vert in stc2.vertices[0]:
data[[i]] += stc2.lh_data[stc2.vertices[0] == vert]
i += 1
# Right hemisphere
for vert in vertices[1]:
if vert in stc1.vertices[1]:
data[[i]] += stc1.rh_data[stc1.vertices[1] == vert]
if vert in stc2.vertices[1]:
data[[i]] += stc2.rh_data[stc2.vertices[1] == vert]
i += 1
return mne.SourceEstimate(data, vertices, tmin=stc1.tmin, tstep=stc1.tstep)
def _stc_from_array(data, tr, filename, hemi=None, tmin=0):
#TODO allow bihemi stc
nvert, ntimes = data.shape
if hemi == None:
#try to read hemi from filename
lh = (filename.find('lh') != -1)
rh = (filename.find('rh') != -1)
if lh and not rh:
hemi = 'lh'
if rh and not lh:
hemi = 'rh'
if hemi not in ('lh', 'rh'):
error_dialog('Correct hemisphere not provided and could not figure it'
' out')
if hemi == 'lh':
vertices = [np.arange(nvert), np.array(())]
else:
vertices = [np.array(()), np.arange(nvert)]
stc = mne.SourceEstimate(data, vertices=vertices, tmin=tmin, tstep=tr)
return stc
def stc_from_fiff(fiff_file, names=None):
'''
Creates a source estimate from the sensor space channels in a fiff file
'''
ra = mne.io.Raw(fiff_file)
tmin = ra.index_as_time(0)
tstep = 1 / ra.info['sfreq']
if names is not None:
vertnos = np.squeeze([
np.where(np.array(ra.ch_names) == name)
for name in np.intersect1d(ra.ch_names, names)
])
else:
#use all names
vertnos = np.arange(len(ra.ch_names))
ordering_names = np.array(ra.ch_names)
ordering_names[np.setdiff1d(np.arange(len(ra.ch_names)), vertnos)] = 'del'
#convert to 'delete' without messing with datatypes
ordering_names = np.array(
map(lambda x: 'delete' if x == 'del' else x, ordering_names.tolist()))
#by arbitrary choice we use the RH no matter where are the electrodes
stc = mne.SourceEstimate(ra[:][0][np.sort(vertnos)],
vertices=[np.array(()),
np.sort(vertnos)],
tmin=tmin,
tstep=tstep)
return stc, ordering_names
def _simulate_data(fwd, idx): # Somewhere on the frontal lobe by default
"""Simulate an oscillator on the cortex."""
source_vertno = fwd['src'][0]['vertno'][idx]
sfreq = 50. # Hz.
times = np.arange(10 * sfreq) / sfreq # 10 seconds of data
signal = np.sin(20 * 2 * np.pi * times) # 20 Hz oscillator
signal[:len(times) // 2] *= 2 # Make signal louder at the beginning
signal *= 1e-9 # Scale to be in the ballpark of MEG data
# Construct a SourceEstimate object that describes the signal at the
# cortical level.
stc = mne.SourceEstimate(
signal[np.newaxis, :],
vertices=[[source_vertno], []],
tmin=0,
tstep=1 / sfreq,
subject='sample',
)
# Create an info object that holds information about the sensors
info = mne.create_info(fwd['info']['ch_names'], sfreq, ch_types='grad')
info.update(fwd['info']) # Merge in sensor position information
# heavily decimate sensors to make it much faster
info = mne.pick_info(info, np.arange(info['nchan'])[::5])
fwd = mne.pick_channels_forward(fwd, info['ch_names'])
# Run the simulated signal through the forward model, obtaining
# simulated sensor data.
raw = mne.apply_forward_raw(fwd, stc, info)
# Add a little noise
random = np.random.RandomState(42)
noise = random.randn(*raw._data.shape) * 1e-14
raw._data += noise
# Define a single epoch (weird baseline but shouldn't matter)
epochs = mne.Epochs(raw, [[0, 0, 1]],
event_id=1,
tmin=0,
tmax=raw.times[-1],
baseline=(0., 0.),
preload=True)
evoked = epochs.average()
# Compute the cross-spectral density matrix
csd = csd_morlet(epochs, frequencies=[10, 20], n_cycles=[5, 10], decim=5)
labels = mne.read_labels_from_annot('sample',
hemi='lh',
subjects_dir=subjects_dir)
label = [
label for label in labels if np.in1d(source_vertno, label.vertices)[0]
]
assert len(label) == 1
label = label[0]
vertices = np.intersect1d(label.vertices, fwd['src'][0]['vertno'])
source_ind = vertices.tolist().index(source_vertno)
assert vertices[source_ind] == source_vertno
return epochs, evoked, csd, source_vertno, label, vertices, source_ind
def generate_eeg(self, source_index):
stc = mne.SourceEstimate(self.preloaded_examples_source[source_index],
self.vertices,
tmin=0.,
tstep=1 / 250)
leadfield = mne.apply_forward(self.fwd_fixed, stc,
self.info).data / 1e-9
return list(leadfield[:self.num_channels])
def get(files):
stcs = reduce(lambda x, y: x + y,
[mne.read_source_estimate(s) for s in files])
if stcs.times[0] <= -1.5:
times = stcs.times + 0.75
stcs = mne.SourceEstimate(stcs.data, stcs.vertices, times[0],
np.diff(times)[0])
return stcs
def subject_Ttest(X, Y, forward, stc, CondComb):
# Compute statistic
np.random.seed(42)
# compute subject-by-subject difference
X = X[0:(len(X) / 2), :, :] - X[len(X) / 2:len(X), :, :]
# smooth the data (optional)
#fsave_vertices = [np.arange(10242), np.arange(10242)]
#morph_mat = compute_morph_matrix('sample', 'fsaverage', sample_vertices,
# fsave_vertices, 20, subjects_dir)
#n_vertices_fsave = morph_mat.shape[0]
# optional: restrict computation to temporal window of interest
#lower_bound = np.where(stc0.times >= 0.4)[0][0]
#upper_bound = np.where(stc0.times >= 0.9)[0][0]
#X = X[:,lower_bound:upper_bound,:]
con = mne.spatial_src_connectivity(forward['src'])
#con = spatial_tris_connectivity(grade_to_tris(5))
X = np.transpose(X, [0, 2, 1])
p_threshold = 0.05
t_threshold = -stats.distributions.t.ppf(p_threshold / 2.,
X.shape[0] - 1)
n_permutations = 1024
T_obs, clusters, cluster_p_values, H0 = mne.stats.spatio_temporal_cluster_1samp_test(
X,
connectivity=con,
n_jobs=1,
threshold=t_threshold,
n_permutations=n_permutations,
verbose=True)
# Replace the values & # save the stc
tmp = np.transpose(np.mean(X, axis=0), [1, 0])
fsave_vertices = [
np.arange(len(stc.vertices[0])),
np.arange(len(stc.vertices[1]))
]
stc_Diff = mne.SourceEstimate(tmp, fsave_vertices, stc.tmin, stc.tstep)
PlotDir = []
PlotDir = ('/neurospin/meg/meg_tmp/MTT_MEG_Baptiste/MEG/' + subject +
'/mne_python/STCS_diff/fromsingle_' + CondComb[0] + '-' +
CondComb[1])
if not os.path.exists(PlotDir):
os.makedirs(PlotDir)
stc_Diff.save(PlotDir + '/' + modality + '_' + Method + '_' + subject +
'_' + CondComb[0] + '-' + CondComb[1] + '_' +
'_ico-5-fwd-fsaverage-' + '.stc')
return T_obs, clusters, cluster_p_values, H0
def _simulate_data(fwd_fixed, source_vertno1, source_vertno2):
"""Simulate two oscillators on the cortex."""
sfreq = 50. # Hz.
base_freq = 10
t_rand = 0.001
std = 0.1
times = np.arange(10. * sfreq) / sfreq # 10 seconds of data
n_times = len(times)
# Generate an oscillator with varying frequency and phase lag.
iflaw = base_freq / sfreq + t_rand * np.random.randn(n_times)
signal1 = np.exp(1j * 2.0 * np.pi * np.cumsum(iflaw))
signal1 *= np.conj(signal1[0])
signal1 = signal1.real
# Add some random fluctuations to the signal.
signal1 += std * np.random.randn(n_times)
signal1 *= 1e-7
# Make identical signal
signal2 = signal1.copy()
# Add random fluctuations
signal1 += 1e-8 * np.random.randn(len(times))
signal2 += 1e-8 * np.random.randn(len(times))
# Construct a SourceEstimate object
stc = mne.SourceEstimate(
np.vstack((signal1[np.newaxis, :], signal2[np.newaxis, :])),
vertices=[np.array([source_vertno1]), np.array([source_vertno2])],
tmin=0,
tstep=1 / sfreq,
subject='sample',
)
# Create an info object that holds information about the sensors
info = mne.create_info(fwd_fixed['info']['ch_names'], sfreq,
ch_types='grad')
info.update(fwd_fixed['info']) # Merge in sensor position information
# Simulated sensor data.
raw = mne.apply_forward_raw(fwd_fixed, stc, info)
# Add noise
noise = random.randn(*raw._data.shape) * 1e-14
raw._data += noise
# Define a single epoch
epochs = mne.Epochs(raw, np.array([[0, 0, 1]]), event_id=1, tmin=0,
tmax=raw.times[-1], preload=True, baseline=(0, 0))
# Compute the cross-spectral density matrix
csd = csd_morlet(epochs, frequencies=[10, 20])
return csd
def load_data(stcs1_fname, stcs2_fname, dec):
stcs1 = [mne.SourceEstimate(fname) for fname in stcs1_fname]
stcs2 = [mne.SourceEstimate(fname) for fname in stcs2_fname]
mask = label_mask(stcs1[0], label_list)
print mask.shape
#mask_neg = ~mask
#This is just resampling in time, not space
def resample_stc(stc, dec):
"""Resample stc inplace"""
stc.data = stc.data[:,::dec].astype(np.float)
stc.tstep *= dec
stc.times = stc.times[::dec]
if dec is not None:
for stc in stcs1 + stcs2:
resample_stc(stc, dec=dec)
stc.crop(0.1, None) #cropping the time-window for faster runtime
def average_stcs(stcs):
mean_stc = copy.deepcopy(stcs[0])
times = mean_stc.times
n_sources, n_times = mean_stc.data.shape
X = np.empty((len(stcs), n_sources, n_times))
for i, stc in enumerate(stcs):
if len(times) == len(stc.times):
X[i] = stc.data
mean_stc.data = np.mean(X, axis=0)
return mean_stc, X
#X1, X2 are the full time,vertices,subject matrices; mean_stc1 and mean_stc2 are the grand-avgs
mean_stc1, X1 = average_stcs(stcs1)
mean_stc2, X2 = average_stcs(stcs2)
# apply mask by setting values outside label mask to 0.
mean_stc1.data[mask == False] = 0.
mean_stc2.data[mask == False] = 0.
X1[:, mask == False, :] = 0.
X2[:, mask == False, :] = 0.
return mean_stc1, X1, mean_stc2, X2
def plot_stc_over_time():
from collections import defaultdict
mmvt, mu = _mmvt(), _mmvt().utils
stc = coloring_panel.stc
if stc is None:
print('No stc was selected!')
return
data, valid_verts = {}, defaultdict(list)
if mmvt.play.get_play_to() > len(stc.times) - 1:
mmvt.play.set_play_to(len(stc.times) - 1)
time = np.arange(mmvt.play.get_play_from(), mmvt.play.get_play_to() + 1)
stc = mne.SourceEstimate(stc.data[:, time[0]:time[-1] + 1], stc.vertices, 0, stc.tstep, subject=mu.get_user())
# stc = coloring_panel.smooth_map.apply(stc)
stc = mmvt.coloring.apply_smooth_map(stc)
t0 = time[0]
time = time - time[0]
data['rh'] = np.ones((stc.rh_data.shape[0], 1)) * -1
data['lh'] = np.ones((stc.lh_data.shape[0], 1)) * -1
threshold = mmvt.coloring.get_lower_threshold()
for t in tqdm(time[::-1]):
for hemi in mu.HEMIS:
hemi_data = stc.rh_data[:, t] if hemi == 'rh' else stc.lh_data[:, t]
verts = np.where(hemi_data >= threshold)[0]
data[hemi][verts, 0] = t + t0
data = np.concatenate([data['lh'], data['rh']])
stc = mne.SourceEstimate(data, stc.vertices, 0, 0, subject=mu.get_user())
mmvt.colorbar.lock_colorbar_values(False)
data_max, data_min = time[-1] + t0, time[0] + t0
mmvt.colorbar.set_colorbar_max_min(data_max, data_min, force_update=True)
mmvt.colorbar.set_colorbar_title('MEG')
mmvt.colorbar.set_colormap('YlOrRd')
mmvt.coloring.clear_colors()
mmvt.coloring.plot_stc(
stc, 0, 0, data_max, data_min, use_abs=False, bigger_or_equal=True)
# mmvt.coloring.set_lower_threshold(threshold) # Set threshold to its previous value
if bpy.context.scene.epilepsy_save_stc_over_time:
stc_output_fname = '{}_{}_{}'.format(get_stc_fname()[:-len('-rh.stc')], data_min, data_max)
print('Saving stc over time to: {}'.format(stc_output_fname))
stc.save(stc_output_fname)
def _stc_from_bihemi_array(lh_data, rh_data, tr, filename, tmin=0):
lh_nvert, lh_ntimes = lh_data.shape
rh_nvert, rh_ntimes = rh_data.shape
if lh_ntimes != rh_ntimes:
error_dialog("Inconsistent timing across hemispheres")
data = np.vstack((lh_data, rh_data))
vertices = [np.arange(lh_nvert), np.arange(rh_nvert)]
stc = mne.SourceEstimate(data, vertices=vertices, tmin=tmin, tstep=tr)
return stc
def localize_epochs(epochs, fwd, reg=0):
''' Returns a list of Sourceestimates, one per Epoch '''
cov = mne.compute_covariance(epochs)
weights = calculate_weights(fwd, cov, reg=reg)
stcs = []
print 'Multiplying data by beamformer weights...'
for epoch in epochs:
sol = np.dot(weights, epoch)
src = mne.SourceEstimate(sol, [fwd['src'][0]['vertno'], fwd['src'][1]['vertno']], epochs.tmin, epochs.times[1] - epochs.times[0])
stcs.append(src)
return stcs
def _calc_source_ttest(subject):
fol = op.join(MMVT_DIR, subject, 'meg')
output_fname = op.join(fol, 'dSPM_mean_flip_vertices_power_spectrum_stat')
if utils.both_hemi_files_exist('{}-{}.stc'.format(
output_fname, '{hemi}')) and not args.overwrite:
print('{} already exist'.format(output_fname))
return True
file_name = '{cond}_dSPM_mean_flip_vertices_power_spectrum.pkl'
if not all([
op.isfile(op.join(fol, file_name.format(cond=cond.lower())))
for cond in MSIT_CONDS
]):
print('No stc files for both conditions!')
return False
vertices_data = {}
try:
for cond in MSIT_CONDS:
vertices_data[cond], freqs = utils.load(
op.join(fol, file_name.format(cond=cond.lower())))
except:
print('Can\'t read {}'.format(file_name.format(cond=cond.lower())))
return False
pvals, vertno = {}, {}
for hemi in utils.HEMIS:
vertices_inds = {}
pvals[hemi] = np.zeros(
(len(vertices_data[MSIT_CONDS[0]][hemi].keys()), len(freqs)))
for cond in MSIT_CONDS:
vertices_inds[cond] = np.array(
sorted(list(vertices_data[cond][hemi].keys())))
if not np.all(
vertices_inds[MSIT_CONDS[0]] == vertices_inds[MSIT_CONDS[1]]):
raise Exception('Not the same vertices!')
vertno[hemi] = vertices_inds[MSIT_CONDS[0]]
params = [(vert_ind, vertices_data[MSIT_CONDS[0]][hemi][vert], vertices_data[MSIT_CONDS[1]][hemi][vert], len(freqs)) \
for vert_ind, vert in enumerate(vertices_data[MSIT_CONDS[0]][hemi].keys())]
results = utils.run_parallel(calc_vert_pvals, params, args.n_jobs)
for vert_pvals, vert_ind in results:
pvals[hemi][vert_ind, :] = vert_pvals
data = np.concatenate([pvals['lh'], pvals['rh']])
vertices = [vertno['lh'], vertno['rh']]
stc_pvals = mne.SourceEstimate(data,
vertices,
freqs[0],
freqs[1] - freqs[0],
subject=subject)
print('Writing to {}'.format(output_fname))
stc_pvals.save(output_fname)
def get_stc(labels, data, tmin=0, tstep=1):
stc_vertices = [np.uint32(np.arange(10242)), np.uint32(np.arange(10242))]
if data.ndim == 1:
stc_data = np.ones((20484, 1), dtype=np.float32)
else:
stc_data = np.ones((20484, data.shape[1]), dtype=np.float32)
stc = mne.SourceEstimate(stc_data,
vertices=stc_vertices,
tmin=tmin,
tstep=tstep,
subject='fsaverage')
stc_new = labels2stc(labels, data, stc)
return stc_new
def save_stcs(src_df, measure='tval'):
for r_name in src_df.columns.levels[1]:
data = src_df.loc(axis=1)[measure, r_name].reset_index(level='time')
data = data.pivot(columns='time')
stc = mne.SourceEstimate(
data.values,
vertices=[
data.loc['lh'].index.values, data.loc['rh'].index.values
],
tmin=data.columns.levels[2][0] / 1000.,
tstep=np.diff(data.columns.levels[2][:2])[0] / 1000,
subject='fsaverage')
stc_file = '{}_{}_{}'.format(file[:-3], measure, r_name)
stc.save(stc_file)
def test_morph_data():
"""Test morphing of data
"""
import mne
subject_from = 'sample'
subject_to = 'morph'
fname = op.join(data_path, 'MEG', 'sample', 'sample_audvis-meg')
stc_from = mne.SourceEstimate(fname)
stc_to = mne.morph_data(subject_from, subject_to, stc_from, 3)
stc_to.save('%s_audvis-meg' % subject_to)
mean_from = stc_from.data.mean(axis=0)
mean_to = stc_to.data.mean(axis=0)
assert np.corrcoef(mean_to, mean_from).min() > 0.99
def _simulate_data(fwd):
"""Simulate an oscillator on the cortex."""
source_vertno = 146374 # Somewhere on the frontal lobe
sfreq = 50. # Hz.
times = np.arange(10 * sfreq) / sfreq # 10 seconds of data
signal = np.sin(20 * 2 * np.pi * times) # 20 Hz oscillator
signal[:len(times) // 2] *= 2 # Make signal louder at the beginning
signal *= 1e-9 # Scale to be in the ballpark of MEG data
# Construct a SourceEstimate object that describes the signal at the
# cortical level.
stc = mne.SourceEstimate(
signal[np.newaxis, :],
vertices=[[source_vertno], []],
tmin=0,
tstep=1 / sfreq,
subject='sample',
)
# Create an info object that holds information about the sensors
info = mne.create_info(fwd['info']['ch_names'], sfreq, ch_types='grad')
info.update(fwd['info']) # Merge in sensor position information
# heavily decimate sensors to make it much faster
info = mne.pick_info(info, np.arange(info['nchan'])[::5])
fwd = mne.pick_channels_forward(fwd, info['ch_names'])
# Run the simulated signal through the forward model, obtaining
# simulated sensor data.
raw = mne.apply_forward_raw(fwd, stc, info)
# Add a little noise
random = np.random.RandomState(42)
noise = random.randn(*raw._data.shape) * 1e-14
raw._data += noise
# Define a single epoch
epochs = mne.Epochs(raw, [[0, 0, 1]],
event_id=1,
tmin=0,
tmax=raw.times[-1],
preload=True)
evoked = epochs.average()
# Compute the cross-spectral density matrix
csd = csd_morlet(epochs, frequencies=[10, 20], n_cycles=[5, 10], decim=10)
return epochs, evoked, csd, source_vertno
def norm_stc(subject, stc_name):
norm_stc_template = op.join(MMVT_DIR, subject, 'meg',
'{}-norm-{}.stc'.format(stc_name, '{hemi}'))
if utils.both_hemi_files_exist(norm_stc_template):
return norm_stc_template.format(hemi='lh')
stc_fname = op.join(MMVT_DIR, subject, 'meg', '{}-lh.stc'.format(stc_name))
stc = mne.read_source_estimate(stc_fname)
stc_max = utils.max_stc(stc)
norm_data = stc.data / stc_max
stc_norm = mne.SourceEstimate(norm_data,
stc.vertices,
0,
0,
subject=subject)
stc_norm.save(op.join(MMVT_DIR, subject, 'meg',
'{}-norm'.format(stc_name)))
def _bias_params(evoked, noise_cov, fwd):
evoked.pick_types(meg=True, eeg=True, exclude=())
# restrict to limited set of verts (small src here) and one hemi for speed
vertices = [fwd['src'][0]['vertno'].copy(), []]
stc = mne.SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)),
vertices, 0., 1.)
fwd = mne.forward.restrict_forward_to_stc(fwd, stc)
assert fwd['sol']['row_names'] == noise_cov['names']
assert noise_cov['names'] == evoked.ch_names
evoked = mne.EvokedArray(fwd['sol']['data'].copy(), evoked.info)
data_cov = noise_cov.copy()
data_cov['data'] = np.dot(fwd['sol']['data'], fwd['sol']['data'].T)
assert data_cov['data'].shape[0] == len(noise_cov['names'])
want = np.arange(fwd['sol']['data'].shape[1])
if not mne.forward.is_fixed_orient(fwd):
want //= 3
return evoked, fwd, noise_cov, data_cov, want
def hotelling_t2(epochs,
inv_op,
src,
baseline=(None, 0),
update_interval=10,
epochs_other=None):
"""Compute p values from a VectorSourceEstimate."""
assert inv_op.ndim == 3 and inv_op.shape[1] == 3
data = epochs.get_data()
tmin, tstep = epochs.times[0], 1. / epochs.info['sfreq']
n_ave = len(data)
if epochs_other is not None:
assert np.allclose(epochs.times, epochs_other.times)
data_other = epochs_other.get_data()
n_ave_other = len(data_other)
else:
data_other = n_ave_other = None
del epochs
F_p = np.zeros((inv_op.shape[0], data.shape[-1]))
inv_op_t = np.array(inv_op.transpose(0, 2, 1))
for ti in range(data.shape[-1]): # iterate over times
if update_interval is not None and ti % update_interval == 0:
print(' %s' % ti, end='')
# Compute the means and covariances
this_data = data[:, :, ti].T
sens_cov = np.cov(this_data, ddof=1)[np.newaxis]
mu = np.dot(inv_op, this_data.mean(-1))
sigma = np.matmul(np.matmul(inv_op, sens_cov), inv_op_t)
if data_other is not None:
this_data = data_other[:, :, ti].T
sens_cov = np.cov(this_data, ddof=1)[np.newaxis]
mu_other = np.dot(inv_op, this_data.mean(-1))
sigma_other = np.matmul(np.matmul(inv_op, sens_cov), inv_op_t)
else:
mu_other = sigma_other = None
del this_data, sens_cov
F_p[:, ti] = _ht2_p(mu,
sigma,
n_ave,
mu_other,
sigma_other,
n_ave_other,
use_pinv=False)
stc = mne.SourceEstimate(F_p, [s['vertno'] for s in src], tmin, tstep,
src[0]['subject_his_id'])
return stc
