def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked."""
evoked, noise_cov = _get_data(ch_decim=16)
forward = mne.read_forward_solution(fname_fwd)
forward = mne.pick_channels_forward(forward, evoked.ch_names)
forward_surf_ori = mne.convert_forward_solution(forward, surf_ori=True)
forward_fixed = mne.convert_forward_solution(forward,
force_fixed=True,
surf_ori=True,
use_cps=True)
n_dipoles = 2
sim_evoked, stc = simu_data(evoked,
forward_fixed,
noise_cov,
n_dipoles,
evoked.times,
nave=evoked.nave)
# Check dipoles for fixed ori
with catch_logging() as log:
dipoles = rap_music(sim_evoked,
forward_fixed,
noise_cov,
n_dipoles=n_dipoles,
verbose=True)
assert_var_exp_log(log.getvalue(), 89, 91)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked)
assert 97 < dipoles[0].gof.max() < 100
assert 91 < dipoles[1].gof.max() < 93
assert dipoles[0].gof.min() >= 0.
nave = 100000 # add a tiny amount of noise to the simulated evokeds
sim_evoked, stc = simu_data(evoked,
forward_fixed,
noise_cov,
n_dipoles,
evoked.times,
nave=nave)
dipoles, residual = rap_music(sim_evoked,
forward_fixed,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked,
forward,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked,
forward_surf_ori,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked
"""
evoked, noise_cov, forward, forward_surf_ori, forward_fixed =\
_get_data()
n_dipoles = 2
sim_evoked, stc = simu_data(evoked, forward_fixed, noise_cov, n_dipoles,
evoked.times)
# Check dipoles for fixed ori
dipoles = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles)
_check_dipoles(dipoles, forward_fixed, stc, evoked)
dipoles, residual = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked, forward, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked, forward_surf_ori, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked
"""
evoked, noise_cov, forward, forward_surf_ori, forward_fixed =\
_get_data()
n_dipoles = 2
sim_evoked, stc = simu_data(evoked, forward_fixed, noise_cov,
n_dipoles, evoked.times)
# Check dipoles for fixed ori
dipoles = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles)
_check_dipoles(dipoles, forward_fixed, stc, evoked)
assert_true(0.98 < dipoles[0].gof.max() < 1.)
assert_true(dipoles[0].gof.min() >= 0.)
assert_array_equal(dipoles[0].gof, dipoles[1].gof)
dipoles, residual = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked, forward, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked, forward_surf_ori, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked
"""
evoked, noise_cov, forward, forward_surf_ori, forward_fixed =\
_get_data()
n_dipoles = 2
with warnings.catch_warnings(record=True): # not positive semidef
sim_evoked, stc = simu_data(evoked, forward_fixed, noise_cov,
n_dipoles, evoked.times)
# Check dipoles for fixed ori
dipoles = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles)
_check_dipoles(dipoles, forward_fixed, stc, evoked)
dipoles, residual = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked, forward, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked, forward_surf_ori, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked."""
evoked, noise_cov = _get_data(ch_decim=16)
forward = mne.read_forward_solution(fname_fwd)
forward = mne.pick_channels_forward(forward, evoked.ch_names)
forward_surf_ori = mne.convert_forward_solution(forward, surf_ori=True)
forward_fixed = mne.convert_forward_solution(forward,
force_fixed=True,
surf_ori=True,
use_cps=True)
n_dipoles = 2
sim_evoked, stc = simu_data(evoked,
forward_fixed,
noise_cov,
n_dipoles,
evoked.times,
nave=evoked.nave)
# Check dipoles for fixed ori
dipoles = rap_music(sim_evoked,
forward_fixed,
noise_cov,
n_dipoles=n_dipoles)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked)
assert (0.97 < dipoles[0].gof.max() < 1.)
assert (dipoles[0].gof.min() >= 0.)
assert_array_equal(dipoles[0].gof, dipoles[1].gof)
nave = 100000 # add a tiny amount of noise to the simulated evokeds
sim_evoked, stc = simu_data(evoked,
forward_fixed,
noise_cov,
n_dipoles,
evoked.times,
nave=nave)
dipoles, residual = rap_music(sim_evoked,
forward_fixed,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked,
forward,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked,
forward_surf_ori,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
def test_rap_music_sphere():
"""Test RAP-MUSIC with real data, sphere model, MEG only."""
evoked, noise_cov = _get_data(ch_decim=8)
sphere = mne.make_sphere_model(r0=(0., 0., 0.04))
src = mne.setup_volume_source_space(subject=None,
pos=10.,
sphere=(0.0, 0.0, 40, 65.0),
mindist=5.0,
exclude=0.0)
forward = mne.make_forward_solution(evoked.info,
trans=None,
src=src,
bem=sphere)
dipoles = rap_music(evoked, forward, noise_cov, n_dipoles=2)
# Test that there is one dipole on each hemisphere
pos = np.array([dip.pos[0] for dip in dipoles])
assert_equal(pos.shape, (2, 3))
assert_equal((pos[:, 0] < 0).sum(), 1)
assert_equal((pos[:, 0] > 0).sum(), 1)
# Check the amplitude scale
assert (1e-10 < dipoles[0].amplitude[0] < 1e-7)
# Check the orientation
dip_fit = mne.fit_dipole(evoked, noise_cov, sphere)[0]
assert (np.max(np.abs(np.dot(dip_fit.ori, dipoles[0].ori[0]))) > 0.99)
assert (np.max(np.abs(np.dot(dip_fit.ori, dipoles[1].ori[0]))) > 0.99)
def test_rap_music_simulated_sphere():
"""Test RAP-MUSIC with sphere model and MEG only."""
noise_cov = mne.read_cov(fname_cov)
evoked = mne.read_evokeds(fname_ave, baseline=(None, 0))[0]
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=0.070)
src = mne.setup_volume_source_space(subject=None,
fname=None,
pos=10.,
sphere=(0.0, 0.0, 0.0, 65.0),
mindist=5.0,
exclude=0.0)
forward = mne.make_forward_solution(evoked.info,
trans=None,
src=src,
bem=sphere,
eeg=False,
meg=True)
evoked.pick_types(meg=True)
evoked.crop(0.0, 0.3)
n_dipoles = 2
dipoles = rap_music(evoked, forward, noise_cov, n_dipoles=n_dipoles)
# Test that there is one dipole on each hemisphere
assert_true(dipoles[0].pos[0, 0] < 0.)
assert_true(dipoles[1].pos[0, 0] > 0.)
def test_rap_music_picks():
"""Test RAP-MUSIC with picking."""
evoked = mne.read_evokeds(fname_ave, condition='Right Auditory',
baseline=(None, 0))
evoked.crop(tmin=0.05, tmax=0.15) # select N100
evoked.pick_types(meg=True, eeg=False)
forward = mne.read_forward_solution(fname_fwd)
noise_cov = mne.read_cov(fname_cov)
dipoles = rap_music(evoked, forward, noise_cov, n_dipoles=2)
assert len(dipoles) == 2
def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked
"""
evoked, noise_cov, forward, forward_surf_ori, forward_fixed =\
_get_data()
n_dipoles = 2
sim_evoked, stc = simu_data(evoked, forward_fixed, noise_cov, n_dipoles,
evoked.times)
# Check dipoles for fixed ori
dipoles = rap_music(sim_evoked,
forward_fixed,
noise_cov,
n_dipoles=n_dipoles)
_check_dipoles(dipoles, forward_fixed, stc, evoked)
assert_true(0.98 < dipoles[0].gof.max() < 1.)
assert_true(dipoles[0].gof.min() >= 0.)
assert_array_equal(dipoles[0].gof, dipoles[1].gof)
dipoles, residual = rap_music(sim_evoked,
forward_fixed,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked,
forward,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked,
forward_surf_ori,
noise_cov,
n_dipoles=n_dipoles,
return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked
"""
evoked, noise_cov, forward, forward_surf_ori, forward_fixed = _get_data()
n_dipoles = 2
with warnings.catch_warnings(record=True): # not positive semidef
sim_evoked, stc = simu_data(evoked, forward_fixed, noise_cov, n_dipoles, evoked.times)
# Check dipoles for fixed ori
dipoles = rap_music(sim_evoked, forward_fixed, noise_cov, n_dipoles=n_dipoles)
_check_dipoles(dipoles, forward_fixed, stc, evoked)
dipoles, residual = rap_music(sim_evoked, forward_fixed, noise_cov, n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked, forward, noise_cov, n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked, forward_surf_ori, noise_cov, n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, evoked, residual)
def test_rap_music_simulated():
"""Test RAP-MUSIC with simulated evoked."""
evoked, noise_cov = _get_data(ch_decim=16)
forward = mne.read_forward_solution(fname_fwd)
forward = mne.pick_channels_forward(forward, evoked.ch_names)
forward_surf_ori = mne.convert_forward_solution(forward, surf_ori=True)
forward_fixed = mne.convert_forward_solution(forward, force_fixed=True,
surf_ori=True)
n_dipoles = 2
sim_evoked, stc = simu_data(evoked, forward_fixed, noise_cov,
n_dipoles, evoked.times, nave=evoked.nave)
# Check dipoles for fixed ori
dipoles = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked)
assert_true(0.98 < dipoles[0].gof.max() < 1.)
assert_true(dipoles[0].gof.min() >= 0.)
assert_array_equal(dipoles[0].gof, dipoles[1].gof)
nave = 100000 # add a tiny amount of noise to the simulated evokeds
sim_evoked, stc = simu_data(evoked, forward_fixed, noise_cov,
n_dipoles, evoked.times, nave=nave)
dipoles, residual = rap_music(sim_evoked, forward_fixed, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
# Check dipoles for free ori
dipoles, residual = rap_music(sim_evoked, forward, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
# Check dipoles for free surface ori
dipoles, residual = rap_music(sim_evoked, forward_surf_ori, noise_cov,
n_dipoles=n_dipoles, return_residual=True)
_check_dipoles(dipoles, forward_fixed, stc, sim_evoked, residual)
def test_rap_music_sphere():
"""Test RAP-MUSIC with real data, sphere model, MEG only."""
evoked, noise_cov = _get_data(ch_decim=8)
sphere = mne.make_sphere_model(r0=(0., 0., 0.04))
src = mne.setup_volume_source_space(subject=None, pos=10.,
sphere=(0.0, 0.0, 40, 65.0),
mindist=5.0, exclude=0.0)
forward = mne.make_forward_solution(evoked.info, trans=None, src=src,
bem=sphere)
dipoles = rap_music(evoked, forward, noise_cov, n_dipoles=2)
# Test that there is one dipole on each hemisphere
pos = np.array([dip.pos[0] for dip in dipoles])
assert_equal(pos.shape, (2, 3))
assert_equal((pos[:, 0] < 0).sum(), 1)
assert_equal((pos[:, 0] > 0).sum(), 1)
# Check the amplitude scale
assert_true(1e-10 < dipoles[0].amplitude[0] < 1e-7)
def test_rap_music_simulated_sphere():
"""Test RAP-MUSIC with sphere model and MEG only."""
noise_cov = mne.read_cov(fname_cov)
evoked = mne.read_evokeds(fname_ave, baseline=(None, 0))[0]
sphere = mne.make_sphere_model(r0=(0., 0., 0.), head_radius=0.070)
src = mne.setup_volume_source_space(subject=None, pos=10.,
sphere=(0.0, 0.0, 0.0, 65.0),
mindist=5.0, exclude=0.0)
forward = mne.make_forward_solution(evoked.info, trans=None, src=src,
bem=sphere, eeg=False, meg=True)
evoked.pick_types(meg=True)
evoked.crop(0.0, 0.3)
n_dipoles = 2
dipoles = rap_music(evoked, forward, noise_cov, n_dipoles=n_dipoles)
# Test that there is one dipole on each hemisphere
assert_true(dipoles[0].pos[0, 0] < 0.)
assert_true(dipoles[1].pos[0, 0] > 0.)
# Check the amplitude scale
assert_true(1e-10 < dipoles[0].amplitude[0] < 1e-7)
def test_rap_music_sphere():
"""Test RAP-MUSIC with real data, sphere model, MEG only."""
evoked, noise_cov = _get_data(ch_decim=8)
sphere = mne.make_sphere_model(r0=(0., 0., 0.04))
src = mne.setup_volume_source_space(subject=None,
pos=10.,
sphere=(0.0, 0.0, 40, 65.0),
mindist=5.0,
exclude=0.0,
sphere_units='mm')
forward = mne.make_forward_solution(evoked.info,
trans=None,
src=src,
bem=sphere)
with catch_logging() as log:
dipoles = rap_music(evoked,
forward,
noise_cov,
n_dipoles=2,
verbose=True)
assert_var_exp_log(log.getvalue(), 47, 49)
# Test that there is one dipole on each hemisphere
pos = np.array([dip.pos[0] for dip in dipoles])
assert pos.shape == (2, 3)
assert (pos[:, 0] < 0).sum() == 1
assert (pos[:, 0] > 0).sum() == 1
# Check the amplitude scale
assert (1e-10 < dipoles[0].amplitude[0] < 1e-7)
# Check the orientation
dip_fit = mne.fit_dipole(evoked, noise_cov, sphere)[0]
assert (np.max(np.abs(np.dot(dip_fit.ori, dipoles[0].ori[0]))) > 0.99)
assert (np.max(np.abs(np.dot(dip_fit.ori, dipoles[1].ori[0]))) > 0.99)
idx = dip_fit.gof.argmax()
dist = np.linalg.norm(dipoles[0].pos[idx] - dip_fit.pos[idx])
assert 0.004 <= dist < 0.007
assert_allclose(dipoles[0].gof[idx], dip_fit.gof[idx], atol=3)
subjects_dir = data_path + '/subjects'
fwd_fname = data_path + '/MEG/sample/sample_audvis-meg-eeg-oct-6-fwd.fif'
evoked_fname = data_path + '/MEG/sample/sample_audvis-ave.fif'
cov_fname = data_path + '/MEG/sample/sample_audvis-cov.fif'
# Read the evoked response and crop it
condition = 'Right Auditory'
evoked = mne.read_evokeds(evoked_fname, condition=condition,
baseline=(None, 0))
evoked.crop(tmin=0.05, tmax=0.15) # select N100
evoked.pick_types(meg=True, eeg=False)
# Read the forward solution
forward = mne.read_forward_solution(fwd_fname)
# Read noise covariance matrix
noise_cov = mne.read_cov(cov_fname)
dipoles, residual = rap_music(evoked, forward, noise_cov, n_dipoles=2,
return_residual=True, verbose=True)
trans = forward['mri_head_t']
plot_dipole_locations(dipoles, trans, 'sample', subjects_dir=subjects_dir)
plot_dipole_amplitudes(dipoles)
# Plot the evoked data and the residual.
evoked.plot(ylim=dict(grad=[-300, 300], mag=[-800, 800], eeg=[-6, 8]),
time_unit='s')
residual.plot(ylim=dict(grad=[-300, 300], mag=[-800, 800], eeg=[-6, 8]),
time_unit='s')
condition = 'Right Auditory'
evoked = mne.read_evokeds(evoked_fname,
condition=condition,
baseline=(None, 0))
# select N100
evoked.crop(tmin=0.05, tmax=0.15, verbose='error') # ignore baseline
evoked.pick_types(meg=True, eeg=False)
# Read the forward solution
forward = mne.read_forward_solution(fwd_fname)
# Read noise covariance matrix
noise_cov = mne.read_cov(cov_fname)
dipoles, residual = rap_music(evoked,
forward,
noise_cov,
n_dipoles=2,
return_residual=True,
verbose=True)
trans = forward['mri_head_t']
plot_dipole_locations(dipoles, trans, 'sample', subjects_dir=subjects_dir)
plot_dipole_amplitudes(dipoles)
# Plot the evoked data and the residual.
evoked.plot(ylim=dict(grad=[-300, 300], mag=[-800, 800], eeg=[-6, 8]),
time_unit='s')
residual.plot(ylim=dict(grad=[-300, 300], mag=[-800, 800], eeg=[-6, 8]),
time_unit='s')
def dipole_source_loc(evoked, cov, fs_subj, study_path, plot=False):
evo_crop = evoked.copy().crop(-0.005, 0.005)
subj = fs_subj.strip('_an') if fs_subj.find('_an') > 0 else fs_subj
img_type = 'anony' if fs_subj.find('_an') > 0 else 'orig'
seeg_ch_info = pd.read_csv(
op.join(study_path, 'physio_data', subj, 'chan_info',
'%s_seeg_ch_info.csv' % subj))
# ori_to_an_fname = op.join(study_path, 'freesurfer_subjects', subj, 'mri', 'ori_to_an_trans.lta') # mri to mri
# ori_to_an_trans = np.genfromtxt(ori_to_an_fname, skip_header=8, skip_footer=18)
trans_fname = op.join(study_path, 'source_stim', subj, 'source_files',
img_type, '%s_static-trans.fif' % fs_subj)
bem_fname = op.join(subjects_dir, fs_subj, 'bem',
'%s-bem-sol.fif' % fs_subj)
cond = eeg_epo.info['description']
stim_coords = find_stim_coords(cond, subj, study_path)
# Fit a dipole
dip = mne.fit_dipole(evo_crop,
cov,
bem_fname,
trans_fname,
min_dist=5,
n_jobs=2)[0]
from mne.beamformer import rap_music
dip = rap_music(evo_crop,
fwd,
cov,
n_dipoles=1,
return_residual=True,
verbose=True)[0][0]
import mne.transforms as tra
from scipy import linalg
trans = mne.read_trans(trans_fname)
surf_to_head = linalg.inv(trans['trans'])
# stim_point = tra.apply_trans(surf_to_head, stim_coords['surf']/1e3)
stim_point = stim_coords['surf_ori'] # get point for plot in mm
#dip.pos[np.argmax(dip.gof)] = tra.apply_trans(surf_to_head, stim_coords['surf_ori']/1e3) # check stim loc (apply affine in m)
#stim_point = tra.apply_trans(ori_to_an_trans, stim_point)
dip_surf = tra.apply_trans(trans['trans'], dip.pos[np.argmax(
dip.gof)]) * 1e3 # transform from head to surface
dist_surf = euclidean(dip_surf,
stim_point) # compute distance in surface space
print(dist_surf)
if plot:
# Plot the result in 3D brain with the MRI image.
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
dip.plot_locations(trans_fname,
fs_subj,
subjects_dir,
mode='orthoview',
coord_frame='mri',
ax=ax,
show_all=True,
idx='gof')
ax.scatter(stim_point[0], stim_point[1], stim_point[2])
ax.plot([stim_point[0], -128], [stim_point[1], stim_point[1]],
[stim_point[2], stim_point[2]],
color='g')
ax.plot([stim_point[0], stim_point[0]], [stim_point[1], -128],
[stim_point[2], stim_point[2]],
color='g')
ax.plot([stim_point[0], stim_point[0]], [stim_point[1], stim_point[1]],
[stim_point[2], -128],
color='g')
ax.text2D(0.05,
0.90,
'distance: %i mm \nstim coords = %0.1f %0.1f %0.1f' %
(dist_surf, stim_point[0], stim_point[1], stim_point[2]),
transform=ax.transAxes)
red_patch = mpatches.Patch(color='red')
green_patch = mpatches.Patch(color='green')
fig.legend(handles=[red_patch, green_patch],
labels=['dipole', 'electrode'])
fig.savefig(
op.join(study_path, 'source_stim', subj, 'figures', 'dipole',
'%s_dip_15mm.png' % cond))
plt.close()
from mne.viz import plot_dipole_locations, plot_dipole_amplitudes
plot_dipole_amplitudes(dip)
plot_dipole_locations(dip, trans, subj, subjects_dir=subjects_dir)
return dist_surf
