def test_plot_sparse_source_estimates(): """Test plotting of (sparse) source estimates.""" sample_src = read_source_spaces(src_fname) # dense version vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_size = stc_data.size stc_data[(np.random.rand(stc_size // 20) * stc_size).astype(int)] = \ np.random.RandomState(0).rand(stc_data.size // 20) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = 'mne_analyze' plot_source_estimates(stc, 'sample', colormap=colormap, background=(1, 1, 0), subjects_dir=subjects_dir, colorbar=True, clim='auto') assert_raises(TypeError, plot_source_estimates, stc, 'sample', figure='foo', hemi='both', clim='auto', subjects_dir=subjects_dir) # now do sparse version vertices = sample_src[0]['vertno'] inds = [111, 333] stc_data = np.zeros((len(inds), n_time)) stc_data[0, 1] = 1. stc_data[1, 4] = 2. vertices = [vertices[inds], np.empty(0, dtype=np.int)] stc = SourceEstimate(stc_data, vertices, 1, 1) plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=False)
def test_plot_sparse_source_estimates(): """Test plotting of (sparse) source estimates """ sample_src = read_source_spaces(op.join(data_dir, 'subjects', 'sample', 'bem', 'sample-oct-6-src.fif')) # dense version vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = mne_analyze_colormap(format='matplotlib') # don't really need to test matplotlib method since it's not used now... colormap = mne_analyze_colormap() plot_source_estimates(stc, 'sample', colormap=colormap, config_opts={'background': (1, 1, 0)}, subjects_dir=subjects_dir, colorbar=True) assert_raises(TypeError, plot_source_estimates, stc, 'sample', figure='foo', hemi='both') # now do sparse version vertices = sample_src[0]['vertno'] n_verts = len(vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) inds = np.where(np.any(stc_data, axis=1))[0] stc_data = stc_data[inds] vertices = [vertices[inds], np.empty(0, dtype=np.int)] stc = SourceEstimate(stc_data, vertices, 1, 1) plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=True)
def test_plot_sparse_source_estimates(): """Test plotting of (sparse) source estimates """ # dense version vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = mne_analyze_colormap(format='matplotlib') # don't really need to test matplotlib method since it's not used now... colormap = mne_analyze_colormap() plot_source_estimates(stc, 'sample', colormap=colormap) # now do sparse version vertices = sample_src[0]['vertno'] n_verts = len(vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) inds = np.where(np.any(stc_data, axis=1))[0] stc_data = stc_data[inds] vertices = vertices[inds] stc = SourceEstimate(stc_data, vertices, 1, 1) plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=True)
def test_plot_sparse_source_estimates(): """Test plotting of (sparse) source estimates.""" sample_src = read_source_spaces(src_fname) # dense version vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_size = stc_data.size stc_data[(np.random.rand(stc_size // 20) * stc_size).astype(int)] = \ np.random.RandomState(0).rand(stc_data.size // 20) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = 'mne_analyze' plot_source_estimates(stc, 'sample', colormap=colormap, background=(1, 1, 0), subjects_dir=subjects_dir, colorbar=True, clim='auto') pytest.raises(TypeError, plot_source_estimates, stc, 'sample', figure='foo', hemi='both', clim='auto', subjects_dir=subjects_dir) # now do sparse version vertices = sample_src[0]['vertno'] inds = [111, 333] stc_data = np.zeros((len(inds), n_time)) stc_data[0, 1] = 1. stc_data[1, 4] = 2. vertices = [vertices[inds], np.empty(0, dtype=np.int)] stc = SourceEstimate(stc_data, vertices, 1, 1) plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=False)
def test_plot_sparse_source_estimates(): """Test plotting of (sparse) source estimates """ # dense version vertices = [s["vertno"] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = mne_analyze_colormap(format="matplotlib") # don't really need to test matplotlib method since it's not used now... colormap = mne_analyze_colormap() plot_source_estimates( stc, "sample", colormap=colormap, config_opts={"background": (1, 1, 0)}, subjects_dir=subjects_dir ) assert_raises(RuntimeError, plot_source_estimates, stc, "sample", figure="foo", hemi="both") # now do sparse version vertices = sample_src[0]["vertno"] n_verts = len(vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) inds = np.where(np.any(stc_data, axis=1))[0] stc_data = stc_data[inds] vertices = vertices[inds] stc = SourceEstimate(stc_data, vertices, 1, 1) plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=True)
def test_plot_sparse_source_estimates(): """Test plotting of (sparse) source estimates """ sample_src = read_source_spaces(op.join(data_dir, 'subjects', 'sample', 'bem', 'sample-oct-6-src.fif')) # dense version vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = mne_analyze_colormap(format='matplotlib') # don't really need to test matplotlib method since it's not used now... colormap = mne_analyze_colormap() plot_source_estimates(stc, 'sample', colormap=colormap, config_opts={'background': (1, 1, 0)}, subjects_dir=subjects_dir, colorbar=True) assert_raises(TypeError, plot_source_estimates, stc, 'sample', figure='foo', hemi='both') # now do sparse version vertices = sample_src[0]['vertno'] inds = [111, 333] stc_data = np.zeros((len(inds), n_time)) stc_data[0, 1] = 1. stc_data[1, 4] = 2. vertices = [vertices[inds], np.empty(0, dtype=np.int)] stc = SourceEstimate(stc_data, vertices, 1, 1) plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=False)
def test_process_clim_plot(renderer_interactive, brain_gc): """Test functionality for determining control points with stc.plot.""" _check_skip_pysurfer(renderer_interactive) sample_src = read_source_spaces(src_fname) kwargs = dict(subjects_dir=subjects_dir, smoothing_steps=1, time_viewer=False, show_traces=False) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.random.RandomState(0).rand((n_verts * n_time)) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1, 'sample') # Test for simple use cases brain = stc.plot(**kwargs) assert brain.data['center'] is None brain.close() brain = stc.plot(clim=dict(pos_lims=(10, 50, 90)), **kwargs) assert brain.data['center'] == 0. brain.close() brain = stc.plot(colormap='hot', clim='auto', **kwargs) brain.close() brain = stc.plot(colormap='mne', clim='auto', **kwargs) brain.close() brain = stc.plot(clim=dict(kind='value', lims=(10, 50, 90)), figure=99, **kwargs) brain.close() with pytest.raises(TypeError, match='must be a'): stc.plot(clim='auto', figure=[0], **kwargs) # Test for correct clim values with pytest.raises(ValueError, match='monotonically'): stc.plot(clim=dict(kind='value', pos_lims=[0, 1, 0]), **kwargs) with pytest.raises(ValueError, match=r'.*must be \(3,\)'): stc.plot(colormap='mne', clim=dict(pos_lims=(5, 10, 15, 20)), **kwargs) with pytest.raises(ValueError, match="'value', 'values', and 'percent'"): stc.plot(clim=dict(pos_lims=(5, 10, 15), kind='foo'), **kwargs) with pytest.raises(ValueError, match='must be "auto" or dict'): stc.plot(colormap='mne', clim='foo', **kwargs) with pytest.raises(TypeError, match='must be an instance of'): plot_source_estimates('foo', clim='auto', **kwargs) with pytest.raises(ValueError, match='hemi'): stc.plot(hemi='foo', clim='auto', **kwargs) with pytest.raises(ValueError, match='Exactly one'): stc.plot(clim=dict(lims=[0, 1, 2], pos_lims=[0, 1, 2], kind='value'), **kwargs) # Test handling of degenerate data: thresholded maps stc._data.fill(0.) with pytest.warns(RuntimeWarning, match='All data were zero'): brain = plot_source_estimates(stc, **kwargs) brain.close()
def test_plot_sparse_source_estimates(renderer_interactive, brain_gc): """Test plotting of (sparse) source estimates.""" _check_skip_pysurfer(renderer_interactive) sample_src = read_source_spaces(src_fname) # dense version vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_size = stc_data.size stc_data[(np.random.rand(stc_size // 20) * stc_size).astype(int)] = \ np.random.RandomState(0).rand(stc_data.size // 20) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = 'mne_analyze' brain = plot_source_estimates(stc, 'sample', colormap=colormap, background=(1, 1, 0), subjects_dir=subjects_dir, colorbar=True, clim='auto') brain.close() del brain with pytest.raises(TypeError, match='figure must be'): plot_source_estimates(stc, 'sample', figure='foo', hemi='both', clim='auto', subjects_dir=subjects_dir) # now do sparse version vertices = sample_src[0]['vertno'] inds = [111, 333] stc_data = np.zeros((len(inds), n_time)) stc_data[0, 1] = 1. stc_data[1, 4] = 2. vertices = [vertices[inds], np.empty(0, dtype=np.int64)] stc = SourceEstimate(stc_data, vertices, 1, 1) surf = plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=False) if renderer_interactive._get_3d_backend() == 'mayavi': import mayavi # noqa: F401 analysis:ignore assert isinstance(surf, mayavi.modules.surface.Surface)
def test_limits_to_control_points(): """Test functionality for determing control points.""" sample_src = read_source_spaces(src_fname) kwargs = dict(subjects_dir=subjects_dir, smoothing_steps=1) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.random.RandomState(0).rand((n_verts * n_time)) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1, 'sample') # Test for simple use cases mlab = _import_mlab() stc.plot(**kwargs) stc.plot(clim=dict(pos_lims=(10, 50, 90)), **kwargs) stc.plot(colormap='hot', clim='auto', **kwargs) stc.plot(colormap='mne', clim='auto', **kwargs) figs = [mlab.figure(), mlab.figure()] stc.plot(clim=dict(kind='value', lims=(10, 50, 90)), figure=99, **kwargs) assert_raises(ValueError, stc.plot, clim='auto', figure=figs, **kwargs) # Test both types of incorrect limits key (lims/pos_lims) assert_raises(KeyError, plot_source_estimates, stc, colormap='mne', clim=dict(kind='value', lims=(5, 10, 15)), **kwargs) assert_raises(KeyError, plot_source_estimates, stc, colormap='hot', clim=dict(kind='value', pos_lims=(5, 10, 15)), **kwargs) # Test for correct clim values assert_raises(ValueError, stc.plot, clim=dict(kind='value', pos_lims=[0, 1, 0]), **kwargs) assert_raises(ValueError, stc.plot, colormap='mne', clim=dict(pos_lims=(5, 10, 15, 20)), **kwargs) assert_raises(ValueError, stc.plot, clim=dict(pos_lims=(5, 10, 15), kind='foo'), **kwargs) assert_raises(ValueError, stc.plot, colormap='mne', clim='foo', **kwargs) assert_raises(ValueError, stc.plot, clim=(5, 10, 15), **kwargs) assert_raises(ValueError, plot_source_estimates, 'foo', clim='auto', **kwargs) assert_raises(ValueError, stc.plot, hemi='foo', clim='auto', **kwargs) # Test handling of degenerate data with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # thresholded maps stc._data.fill(0.) plot_source_estimates(stc, **kwargs) assert_equal(len(w), 1) mlab.close(all=True)
def test_limits_to_control_points(): """Test functionality for determing control points.""" sample_src = read_source_spaces(src_fname) kwargs = dict(subjects_dir=subjects_dir, smoothing_steps=1) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.random.RandomState(0).rand((n_verts * n_time)) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1, 'sample') # Test for simple use cases mlab = _import_mlab() stc.plot(**kwargs) stc.plot(clim=dict(pos_lims=(10, 50, 90)), **kwargs) stc.plot(colormap='hot', clim='auto', **kwargs) stc.plot(colormap='mne', clim='auto', **kwargs) figs = [mlab.figure(), mlab.figure()] stc.plot(clim=dict(kind='value', lims=(10, 50, 90)), figure=99, **kwargs) assert_raises(ValueError, stc.plot, clim='auto', figure=figs, **kwargs) # Test both types of incorrect limits key (lims/pos_lims) assert_raises(KeyError, plot_source_estimates, stc, colormap='mne', clim=dict(kind='value', lims=(5, 10, 15)), **kwargs) assert_raises(KeyError, plot_source_estimates, stc, colormap='hot', clim=dict(kind='value', pos_lims=(5, 10, 15)), **kwargs) # Test for correct clim values assert_raises(ValueError, stc.plot, clim=dict(kind='value', pos_lims=[0, 1, 0]), **kwargs) assert_raises(ValueError, stc.plot, colormap='mne', clim=dict(pos_lims=(5, 10, 15, 20)), **kwargs) assert_raises(ValueError, stc.plot, clim=dict(pos_lims=(5, 10, 15), kind='foo'), **kwargs) assert_raises(ValueError, stc.plot, colormap='mne', clim='foo', **kwargs) assert_raises(ValueError, stc.plot, clim=(5, 10, 15), **kwargs) assert_raises(ValueError, plot_source_estimates, 'foo', clim='auto', **kwargs) assert_raises(ValueError, stc.plot, hemi='foo', clim='auto', **kwargs) # Test handling of degenerate data with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # thresholded maps stc._data.fill(0.) plot_source_estimates(stc, **kwargs) assert any('All data were zero' in str(ww.message) for ww in w) mlab.close(all=True)
def test_link_brains(renderer_interactive): """Test plotting linked brains.""" sample_src = read_source_spaces(src_fname) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_size = stc_data.size stc_data[(np.random.rand(stc_size // 20) * stc_size).astype(int)] = \ np.random.RandomState(0).rand(stc_data.size // 20) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = 'mne_analyze' brain = plot_source_estimates(stc, 'sample', colormap=colormap, background=(1, 1, 0), subjects_dir=subjects_dir, colorbar=True, clim='auto') if renderer_interactive._get_3d_backend() == 'mayavi': with pytest.raises(NotImplementedError, match='backend is pyvistaqt'): link_brains(brain) else: with pytest.raises(ValueError, match='is empty'): link_brains([]) with pytest.raises(TypeError, match='type is Brain'): link_brains('foo') link_brains(brain, time=True, camera=True)
def test_link_brains(renderer): """Test plotting linked brains.""" if renderer.get_3d_backend() == "mayavi": pytest.skip() # Skip PySurfer.TimeViewer else: # Disable testing to allow interactive window renderer.MNE_3D_BACKEND_TESTING = False with pytest.raises(ValueError, match='is empty'): link_brains([]) with pytest.raises(TypeError, match='type is Brain'): link_brains('foo') sample_src = read_source_spaces(src_fname) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_size = stc_data.size stc_data[(np.random.rand(stc_size // 20) * stc_size).astype(int)] = \ np.random.RandomState(0).rand(stc_data.size // 20) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = 'mne_analyze' brain = plot_source_estimates(stc, 'sample', colormap=colormap, background=(1, 1, 0), subjects_dir=subjects_dir, colorbar=True, clim='auto') link_brains(brain)
def test_limits_to_control_points(): """Test functionality for determining control points.""" sample_src = read_source_spaces(src_fname) kwargs = dict(subjects_dir=subjects_dir, smoothing_steps=1) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.random.RandomState(0).rand((n_verts * n_time)) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1, 'sample') # Test for simple use cases mlab = _import_mlab() stc.plot(**kwargs) stc.plot(clim=dict(pos_lims=(10, 50, 90)), **kwargs) stc.plot(colormap='hot', clim='auto', **kwargs) stc.plot(colormap='mne', clim='auto', **kwargs) figs = [mlab.figure(), mlab.figure()] stc.plot(clim=dict(kind='value', lims=(10, 50, 90)), figure=99, **kwargs) pytest.raises(ValueError, stc.plot, clim='auto', figure=figs, **kwargs) # Test for correct clim values with pytest.raises(ValueError, match='monotonically'): stc.plot(clim=dict(kind='value', pos_lims=[0, 1, 0]), **kwargs) with pytest.raises(ValueError, match=r'.*must be \(3,\)'): stc.plot(colormap='mne', clim=dict(pos_lims=(5, 10, 15, 20)), **kwargs) with pytest.raises(ValueError, match="'value', 'values' and 'percent'"): stc.plot(clim=dict(pos_lims=(5, 10, 15), kind='foo'), **kwargs) with pytest.raises(ValueError, match='must be "auto" or dict'): stc.plot(colormap='mne', clim='foo', **kwargs) with pytest.raises(TypeError, match='must be an instance of'): plot_source_estimates('foo', clim='auto', **kwargs) with pytest.raises(ValueError, match='hemi'): stc.plot(hemi='foo', clim='auto', **kwargs) with pytest.raises(ValueError, match='Exactly one'): stc.plot(clim=dict(lims=[0, 1, 2], pos_lims=[0, 1, 2], kind='value'), **kwargs) # Test handling of degenerate data: thresholded maps stc._data.fill(0.) with pytest.warns(RuntimeWarning, match='All data were zero'): plot_source_estimates(stc, **kwargs) mlab.close(all=True)
def test_limits_to_control_points(): """Test functionality for determining control points.""" sample_src = read_source_spaces(src_fname) kwargs = dict(subjects_dir=subjects_dir, smoothing_steps=1) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.random.RandomState(0).rand((n_verts * n_time)) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1, 'sample') # Test for simple use cases mlab = _import_mlab() stc.plot(**kwargs) stc.plot(clim=dict(pos_lims=(10, 50, 90)), **kwargs) stc.plot(colormap='hot', clim='auto', **kwargs) stc.plot(colormap='mne', clim='auto', **kwargs) figs = [mlab.figure(), mlab.figure()] stc.plot(clim=dict(kind='value', lims=(10, 50, 90)), figure=99, **kwargs) pytest.raises(ValueError, stc.plot, clim='auto', figure=figs, **kwargs) # Test for correct clim values with pytest.raises(ValueError, match='monotonically'): stc.plot(clim=dict(kind='value', pos_lims=[0, 1, 0]), **kwargs) with pytest.raises(ValueError, match=r'.*must be \(3,\)'): stc.plot(colormap='mne', clim=dict(pos_lims=(5, 10, 15, 20)), **kwargs) with pytest.raises(ValueError, match='must be "value" or "percent"'): stc.plot(clim=dict(pos_lims=(5, 10, 15), kind='foo'), **kwargs) with pytest.raises(ValueError, match='must be "auto" or dict'): stc.plot(colormap='mne', clim='foo', **kwargs) with pytest.raises(TypeError, match='must be an instance of'): plot_source_estimates('foo', clim='auto', **kwargs) with pytest.raises(ValueError, match='hemi'): stc.plot(hemi='foo', clim='auto', **kwargs) with pytest.raises(ValueError, match='Exactly one'): stc.plot(clim=dict(lims=[0, 1, 2], pos_lims=[0, 1, 2], kind='value'), **kwargs) # Test handling of degenerate data: thresholded maps stc._data.fill(0.) with pytest.warns(RuntimeWarning, match='All data were zero'): plot_source_estimates(stc, **kwargs) mlab.close(all=True)
def test_plot_sparse_source_estimates(): """Test plotting of (sparse) source estimates """ # dense version vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1) colormap = mne_analyze_colormap(format='matplotlib') # don't really need to test matplotlib method since it's not used now... colormap = mne_analyze_colormap() plot_source_estimates(stc, 'sample', colormap=colormap, config_opts={'background': (1, 1, 0)}) assert_raises(RuntimeError, plot_source_estimates, stc, 'sample', figure='foo', hemi='both') # now do sparse version vertices = sample_src[0]['vertno'] n_verts = len(vertices) stc_data = np.zeros((n_verts * n_time)) stc_data[(np.random.rand(20) * n_verts * n_time).astype(int)] = 1 stc_data.shape = (n_verts, n_time) inds = np.where(np.any(stc_data, axis=1))[0] stc_data = stc_data[inds] vertices = vertices[inds] stc = SourceEstimate(stc_data, vertices, 1, 1) plot_sparse_source_estimates(sample_src, stc, bgcolor=(1, 1, 1), opacity=0.5, high_resolution=True)
def test_limits_to_control_points(): """Test functionality for determing control points """ sample_src = read_source_spaces(src_fname) vertices = [s['vertno'] for s in sample_src] n_time = 5 n_verts = sum(len(v) for v in vertices) stc_data = np.random.RandomState(0).rand((n_verts * n_time)) stc_data.shape = (n_verts, n_time) stc = SourceEstimate(stc_data, vertices, 1, 1, 'sample') # Test for simple use cases from mayavi import mlab stc.plot(subjects_dir=subjects_dir) stc.plot(clim=dict(pos_lims=(10, 50, 90)), subjects_dir=subjects_dir) stc.plot(clim=dict(kind='value', lims=(10, 50, 90)), figure=99, subjects_dir=subjects_dir) stc.plot(colormap='hot', clim='auto', subjects_dir=subjects_dir) stc.plot(colormap='mne', clim='auto', subjects_dir=subjects_dir) figs = [mlab.figure(), mlab.figure()] assert_raises(RuntimeError, stc.plot, clim='auto', figure=figs, subjects_dir=subjects_dir) # Test both types of incorrect limits key (lims/pos_lims) assert_raises(KeyError, plot_source_estimates, stc, colormap='mne', clim=dict(kind='value', lims=(5, 10, 15)), subjects_dir=subjects_dir) assert_raises(KeyError, plot_source_estimates, stc, colormap='hot', clim=dict(kind='value', pos_lims=(5, 10, 15)), subjects_dir=subjects_dir) # Test for correct clim values assert_raises(ValueError, stc.plot, clim=dict(kind='value', pos_lims=[0, 1, 0]), subjects_dir=subjects_dir) assert_raises(ValueError, stc.plot, colormap='mne', clim=dict(pos_lims=(5, 10, 15, 20)), subjects_dir=subjects_dir) assert_raises(ValueError, stc.plot, clim=dict(pos_lims=(5, 10, 15), kind='foo'), subjects_dir=subjects_dir) assert_raises(ValueError, stc.plot, colormap='mne', clim='foo', subjects_dir=subjects_dir) assert_raises(ValueError, stc.plot, clim=(5, 10, 15), subjects_dir=subjects_dir) assert_raises(ValueError, plot_source_estimates, 'foo', clim='auto', subjects_dir=subjects_dir) assert_raises(ValueError, stc.plot, hemi='foo', clim='auto', subjects_dir=subjects_dir) # Test handling of degenerate data stc.plot(clim=dict(kind='value', lims=[0, 0, 1]), subjects_dir=subjects_dir) # ok with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') # thresholded maps stc._data.fill(1.) plot_source_estimates(stc, subjects_dir=subjects_dir) assert_equal(len(w), 0) stc._data[0].fill(0.) plot_source_estimates(stc, subjects_dir=subjects_dir) assert_equal(len(w), 0) stc._data.fill(0.) plot_source_estimates(stc, subjects_dir=subjects_dir) assert_equal(len(w), 1) mlab.close()