[med-svn] [python-mne] 348/376: Merge branch 'master' into invop

Yaroslav Halchenko debian at onerussian.com
Fri Nov 27 17:23:19 UTC 2015


This is an automated email from the git hooks/post-receive script.

yoh pushed a commit to annotated tag v0.1
in repository python-mne.

commit 5e7e14a4064eceaa1b62a96ba0147600cc962308
Merge: 45600a4 906abbb
Author: Alexandre Gramfort <alexandre.gramfort at inria.fr>
Date:   Tue Sep 13 16:46:59 2011 -0400

    Merge branch 'master' into invop
    
    Conflicts:
    	mne/minimum_norm/__init__.py
    	mne/minimum_norm/inverse.py
    	mne/minimum_norm/tests/test_inverse.py

 .../plot_compute_mne_inverse_epochs_in_label.py    |  65 +++++
 mne/minimum_norm/inverse.py                        | 306 ++++++++++++---------
 mne/minimum_norm/tests/test_inverse.py             |  60 +++-
 3 files changed, 296 insertions(+), 135 deletions(-)

diff --cc mne/minimum_norm/inverse.py
index 6183dcd,6930e94..787155a
--- a/mne/minimum_norm/inverse.py
+++ b/mne/minimum_norm/inverse.py
@@@ -15,11 -14,11 +15,11 @@@ from ..fiff.tag import find_ta
  from ..fiff.matrix import _read_named_matrix, _transpose_named_matrix
  from ..fiff.proj import read_proj, make_projector
  from ..fiff.tree import dir_tree_find
- from ..fiff.pick import pick_channels_evoked, pick_channels
+ from ..fiff.pick import pick_channels
  
 -from ..cov import read_cov
 +from ..cov import read_cov, prepare_noise_cov
 +from ..forward import compute_depth_prior
  from ..source_space import read_source_spaces_from_tree, find_source_space_hemi
 -from ..forward import _block_diag
  from ..transforms import invert_transform, transform_source_space_to
  from ..source_estimate import SourceEstimate
  
diff --cc mne/minimum_norm/tests/test_inverse.py
index bec08b9,d40f10f..07fdc6e
--- a/mne/minimum_norm/tests/test_inverse.py
+++ b/mne/minimum_norm/tests/test_inverse.py
@@@ -1,51 -1,94 +1,93 @@@
  import os.path as op
  
  import numpy as np
 -# from numpy.testing import assert_array_almost_equal, assert_equal
 +from numpy.testing import assert_array_almost_equal, assert_equal
  
  from ...datasets import sample
+ from ...label import read_label
+ from ...event import read_events
+ from ...epochs import Epochs
  from ... import fiff, Covariance, read_forward_solution
 -from ..inverse import minimum_norm, apply_inverse, read_inverse_operator, \
 -                      apply_inverse_raw, apply_inverse_epochs
 -
 +from ..inverse import apply_inverse, read_inverse_operator, \
++                      apply_inverse_raw, apply_inverse_epochs, \
 +                      make_inverse_operator
  
- 
  examples_folder = op.join(op.dirname(__file__), '..', '..', '..', 'examples')
  data_path = sample.data_path(examples_folder)
  fname_inv = op.join(data_path, 'MEG', 'sample',
 -                                        'sample_audvis-meg-oct-6-meg-inv.fif')
 +                            # 'sample_audvis-meg-eeg-oct-6-meg-eeg-inv.fif')
 +                            'sample_audvis-meg-oct-6-meg-inv.fif')
  fname_data = op.join(data_path, 'MEG', 'sample',
 -                                        'sample_audvis-ave.fif')
 +                            'sample_audvis-ave.fif')
  fname_cov = op.join(data_path, 'MEG', 'sample',
 -                                        'sample_audvis-cov.fif')
 +                            'sample_audvis-cov.fif')
  fname_fwd = op.join(data_path, 'MEG', 'sample',
 -                                        'sample_audvis-meg-eeg-oct-6-fwd.fif')
 +                            'sample_audvis-meg-oct-6-fwd.fif')
 +                            # 'sample_audvis-meg-eeg-oct-6-fwd.fif')
+ fname_raw = op.join(data_path, 'MEG', 'sample',
 -                                        'sample_audvis_filt-0-40_raw.fif')
++                            'sample_audvis_filt-0-40_raw.fif')
+ fname_event = op.join(data_path, 'MEG', 'sample',
 -                                        'sample_audvis_filt-0-40_raw-eve.fif')
++                            'sample_audvis_filt-0-40_raw-eve.fif')
+ label = 'Aud-lh'
+ fname_label = op.join(data_path, 'MEG', 'sample', 'labels', '%s.label' % label)
  
+ inverse_operator = read_inverse_operator(fname_inv)
+ label = read_label(fname_label)
+ raw = fiff.Raw(fname_raw)
+ snr = 3.0
+ lambda2 = 1.0 / snr ** 2
+ dSPM = True
  
 +def test_inverse_operator():
-     """Test MNE inverse computation with precomputed inverse operator."""
-     setno = 0
-     snr = 3.0
-     lambda2 = 1.0 / snr ** 2
-     dSPM = True
- 
-     evoked = fiff.Evoked(fname_data, setno=setno, baseline=(None, 0))
-     inverse_operator = read_inverse_operator(fname_inv)
++    """Test MNE inverse computation
  
 -def test_apply_mne_inverse():
 -    """Test MNE with precomputed inverse operator on Evoked
++    With and without precomputed inverse operator.
+     """
 -    setno = 0
+     evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0))
      stc = apply_inverse(evoked, inverse_operator, lambda2, dSPM)
  
      assert np.all(stc.data > 0)
      assert np.all(stc.data < 35)
  
 +    # Test MNE inverse computation starting from forward operator
 +    noise_cov = Covariance(fname_cov)
 +    evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0))
 +    fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
 +    my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
 +                                      loose=0.2, depth=0.8)
 +
 +    my_stc = apply_inverse(evoked, my_inv_op, lambda2, dSPM)
 +
 +    assert_equal(stc.times, my_stc.times)
 +    assert_array_almost_equal(stc.data, my_stc.data, 2)
++
+ 
+ def test_apply_mne_inverse_raw():
+     """Test MNE with precomputed inverse operator on Raw
+     """
+     stc = apply_inverse_raw(raw, inverse_operator, lambda2, dSPM=True,
+                             label=label, start=0, stop=10, nave=1,
+                             pick_normal=False)
+     assert np.all(stc.data > 0)
+ 
+ 
+ def test_apply_mne_inverse_epochs():
+     """Test MNE with precomputed inverse operator on Epochs
+     """
+     event_id, tmin, tmax = 1, -0.2, 0.5
+ 
+     picks = fiff.pick_types(raw.info, meg=True, eeg=False, stim=True,
+                             ecg=True, eog=True, include=['STI 014'])
+     reject = dict(grad=4000e-13, mag=4e-12, eog=150e-6)
+     flat = dict(grad=1e-15, mag=1e-15)
+ 
+     events = read_events(fname_event)[:3]
+     epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
+                     baseline=(None, 0), reject=reject, flat=flat)
+     stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, dSPM,
+                                 label=label)
+ 
+     assert len(stcs) == 1
+     assert np.all(stcs[0].data > 0)
+     assert np.all(stcs[0].data < 42)
+ 
 -
 -def test_compute_minimum_norm():
 -    """Test MNE inverse computation starting from forward operator
 -    """
 -    setno = 0
 -    noise_cov = Covariance(fname_cov)
 -    forward = read_forward_solution(fname_fwd)
 -    evoked = fiff.Evoked(fname_data, setno=setno, baseline=(None, 0))
 -    whitener = noise_cov.get_whitener(evoked.info, mag_reg=0.1,
 -                                      grad_reg=0.1, eeg_reg=0.1, pca=True)
 -    stc = minimum_norm(evoked, forward, whitener,
 -                       orientation='loose', method='dspm', snr=3, loose=0.2)
 -
 -    assert np.all(stc.data > 0)
 -    # XXX : test something

-- 
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/python-mne.git



More information about the debian-med-commit mailing list