Raw object from numpy array.
array
, shape (n_channels, n_times)The channels’ time series. See notes for proper units of measure.
mne.Info
The mne.Info
object with information about the sensors and methods of measurement. Consider using mne.create_info()
to populate
this structure. This may be modified in place by the class.
int
First sample offset used during recording (default 0).
New in version 0.12.
None
}Determines what gets copied on instantiation. “auto” (default) will copy info, and copy “data” only if necessary to get to double floating point precision.
New in version 0.18.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
Proper units of measure: * V: eeg, eog, seeg, dbs, emg, ecg, bio, ecog * T: mag * T/m: grad * M: hbo, hbr * Am: dipole * AU: misc
annotations
Annotations
for marking segments of data.
ch_names
Channel names.
compensation_grade
The current gradient compensation grade.
filenames
The filenames used.
first_samp
The first data sample.
first_time
The first time point (including first_samp but not meas_date).
last_samp
The last data sample.
n_times
Number of time points.
proj
Whether or not projections are active.
times
Time points.
tmax
Last time point.
tmin
First time point.
Methods
|
Check channel type membership. |
|
Get raw data and times. |
|
Return the number of time points. |
|
Append new channels to the instance. |
|
Add events to stim channel. |
|
Add SSP projection vectors. |
|
Add reference channels to data that consists of all zeros. |
|
Anonymize measurement information in place. |
|
Concatenate raw instances as if they were continuous. |
|
Apply a function to a subset of channels. |
|
Apply CTF gradient compensation. |
|
Compute analytic signal or envelope for a subset of channels. |
|
Apply the signal space projection (SSP) operators to the data. |
|
Clean up the object. |
|
Return copy of Raw instance. |
|
Crop raw data file. |
|
Get crops of raw data file for selected annotations. |
|
Decimate the time-series data. |
|
Remove SSP projection vector. |
|
Describe channels (name, type, descriptive statistics). |
|
Drop channel(s). |
|
Export Raw to external formats. |
|
Filter a subset of channels. |
|
Get a list of channel type for each channel. |
|
Get data in the given range. |
Get a DigMontage from instance. |
|
|
Interpolate bad MEG and EEG channels. |
|
Mark channels as bad from a text file. |
|
Load raw data. |
|
Notch filter a subset of channels. |
|
Pick a subset of channels. |
|
Pick some channels. |
|
Pick some channels by type and names. |
|
Plot raw data. |
|
Plot SSP vector. |
|
Plot the power spectral density across channels. |
|
Plot channel-wise frequency spectra as topography. |
|
Plot sensor positions. |
|
Rename channels. |
|
Reorder channels. |
|
Resample all channels. |
|
Save raw data to file. |
|
Filter the data using Savitzky-Golay polynomial method. |
|
Setter for annotations. |
|
Define the sensor type of channels. |
|
Specify which reference to use for EEG data. |
|
Set the measurement start date. |
|
Set EEG/sEEG/ECoG/DBS/fNIRS channel positions and digitization points. |
|
Shift time scale in epoched or evoked data. |
|
Convert time to indices. |
|
Export data in tabular structure as a pandas DataFrame. |
Check channel type membership.
str
Channel type to check for. Can be e.g. ‘meg’, ‘eeg’, ‘stim’, etc.
Whether or not the instance contains the given channel type.
Examples
Channel type membership can be tested as:
>>> 'meg' in inst
True
>>> 'seeg' in inst
False
Get raw data and times.
tuple
or array-likeSee below for use cases.
Examples
Generally raw data is accessed as:
>>> data, times = raw[picks, time_slice]
To get all data, you can thus do either of:
>>> data, times = raw[:]
Which will be equivalent to:
>>> data, times = raw[:, :]
To get only the good MEG data from 10-20 seconds, you could do:
>>> picks = mne.pick_types(raw.info, meg=True, exclude='bads')
>>> t_idx = raw.time_as_index([10., 20.])
>>> data, times = raw[picks, t_idx[0]:t_idx[1]]
Return the number of time points.
int
The number of time points.
Examples
This can be used as:
>>> len(raw)
1000
Append new channels to the instance.
list
A list of objects to append to self. Must contain all the same type as the current object.
If True, force the info for objects to be appended to match the
values in self
. This should generally only be used when adding
stim channels for which important metadata won’t be overwritten.
New in version 0.12.
See also
Notes
If self
is a Raw instance that has been preloaded into a
numpy.memmap
instance, the memmap will be resized.
Add events to stim channel.
ndarray
, shape (n_events, 3)Events to add. The first column specifies the sample number of each event, the second column is ignored, and the third column provides the event value. If events already exist in the Raw instance at the given sample numbers, the event values will be added together.
str
| None
Name of the stim channel to add to. If None, the config variable ‘MNE_STIM_CHANNEL’ is used. If this is not found, it will default to ‘STI 014’.
If True the old events on the stim channel are removed before adding the new ones.
Notes
Data must be preloaded in order to add events.
Add SSP projection vectors.
list
List with projection vectors.
Remove the projection vectors currently in the file.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Add reference channels to data that consists of all zeros.
Adds reference channels to data that were not included during recording. This is useful when you need to re-reference your data to different channels. These added channels will consist of all zeros.
Annotations
for marking segments of data.
Anonymize measurement information in place.
int
| None
Number of days to subtract from all dates.
If None
(default), the acquisition date, info['meas_date']
,
will be set to January 1ˢᵗ, 2000
. This parameter is ignored if
info['meas_date']
is None
(i.e., no acquisition date has been set).
If True
, his_id
of subject_info
will not be overwritten.
Defaults to False
.
Warning
This could mean that info
is not fully
anonymized. Use with caution.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
Removes potentially identifying information if it exists in info
.
Specifically for each of the following we use:
A default value, or as specified by daysback
.
Default values, except for ‘birthday’ which is adjusted to maintain the subject age.
Default strings.
None
.
Zeros.
Dates use the meas_date
logic, and experimenter a default string.
Dates use the meas_date
logic, meta info uses defaults.
If info['meas_date']
is None
, it will remain None
during processing
the above fields.
Operates in place.
New in version 0.13.0.
Concatenate raw instances as if they were continuous.
Note
Boundaries of the raw files are annotated bad. If you wish to
use the data as continuous recording, you can remove the
boundary annotations after concatenation (see
mne.Annotations.delete()
).
list
, or Raw
instanceList of Raw instances to concatenate to the current instance (in order), or a single raw instance to concatenate.
str
, or None
(default None
)Preload data into memory for data manipulation and faster indexing. If True, the data will be preloaded into memory (fast, requires large amount of memory). If preload is a string, preload is the file name of a memory-mapped file which is used to store the data on the hard drive (slower, requires less memory). If preload is None, preload=True or False is inferred using the preload status of the instances passed in.
Apply a function to a subset of channels.
The function fun
is applied to the channels defined in picks
.
The raw object’s data is modified in-place. If the function returns a different
data type (e.g. numpy.complex128
) it must be specified
using the dtype
parameter, which causes the data type of all the data
to change (even if the function is only applied to channels in picks
). The object has to have the data loaded e.g. with preload=True
or self.load_data()
.
Note
If n_jobs
> 1, more memory is required as
len(picks) * n_times
additional time points need to
be temporarily stored in memory.
Note
If the data type changes (dtype != None
), more memory is
required since the original and the converted data needs
to be stored in memory.
callable()
A function to be applied to the channels. The first argument of
fun has to be a timeseries (numpy.ndarray
). The function must
operate on an array of shape (n_times,)
if channel_wise=True
and (len(picks), n_times)
otherwise.
The function must return an ndarray
shaped like its input.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all data channels (excluding reference
MEG channels). Note that channels in info['bads']
will be included if
their names or indices are explicitly provided.
numpy.dtype
Data type to use after applying the function. If None (default) the data type is not modified.
int
| None
The number of jobs to run in parallel. If -1
, it is set
to the number of CPU cores. Requires the joblib
package.
None
(default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1
(sequential execution) unless the call is performed under
a joblib.parallel_backend()
context manager that sets another
value for n_jobs
.
Whether to apply the function to each channel individually. If False
,
the function will be applied to all channels at once. Default True
.
New in version 0.18.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
dict
Additional keyword arguments to pass to fun
.
Raw
The raw object with transformed data.
Apply CTF gradient compensation.
Warning
The compensation matrices are stored with single precision, so repeatedly switching between different of compensation (e.g., 0->1->3->2) can increase numerical noise, especially if data are saved to disk in between changing grades. It is thus best to only use a single gradient compensation level in final analyses.
int
CTF gradient compensation level.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Raw
The modified Raw instance. Works in-place.
Compute analytic signal or envelope for a subset of channels.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all data channels (excluding reference
MEG channels). Note that channels in info['bads']
will be included if
their names or indices are explicitly provided.
Compute the envelope signal of each channel. Default False. See Notes.
int
| None
The number of jobs to run in parallel. If -1
, it is set
to the number of CPU cores. Requires the joblib
package.
None
(default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1
(sequential execution) unless the call is performed under
a joblib.parallel_backend()
context manager that sets another
value for n_jobs
.
int
| None
| str
Points to use in the FFT for Hilbert transformation. The signal will be padded with zeros before computing Hilbert, then cut back to original length. If None, n == self.n_times. If ‘auto’, the next highest fast FFT length will be use.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
Parameters
If envelope=False
, the analytic signal for the channels defined in
picks
is computed and the data of the Raw object is converted to
a complex representation (the analytic signal is complex valued).
If envelope=True
, the absolute value of the analytic signal for the
channels defined in picks
is computed, resulting in the envelope
signal.
If envelope=False, more memory is required since the original raw data
as well as the analytic signal have temporarily to be stored in memory.
If n_jobs > 1, more memory is required as len(picks) * n_times
additional time points need to be temporaily stored in memory.
Also note that the n_fft
parameter will allow you to pad the signal
with zeros before performing the Hilbert transform. This padding
is cut off, but it may result in a slightly different result
(particularly around the edges). Use at your own risk.
Analytic signal
The analytic signal “x_a(t)” of “x(t)” is:
x_a = F^{-1}(F(x) 2U) = x + i y
where “F” is the Fourier transform, “U” the unit step function, and “y” the Hilbert transform of “x”. One usage of the analytic signal is the computation of the envelope signal, which is given by “e(t) = abs(x_a(t))”. Due to the linearity of Hilbert transform and the MNE inverse solution, the enevlope in source space can be obtained by computing the analytic signal in sensor space, applying the MNE inverse, and computing the envelope in source space.
Apply the signal space projection (SSP) operators to the data.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
Once the projectors have been applied, they can no longer be removed. It is usually not recommended to apply the projectors at too early stages, as they are applied automatically later on (e.g. when computing inverse solutions). Hint: using the copy method individual projection vectors can be tested without affecting the original data. With evoked data, consider the following example:
projs_a = mne.read_proj('proj_a.fif')
projs_b = mne.read_proj('proj_b.fif')
# add the first, copy, apply and see ...
evoked.add_proj(a).copy().apply_proj().plot()
# add the second, copy, apply and see ...
evoked.add_proj(b).copy().apply_proj().plot()
# drop the first and see again
evoked.copy().del_proj(0).apply_proj().plot()
evoked.apply_proj() # finally keep both
Channel names.
Clean up the object.
Does nothing for objects that close their file descriptors. Things like RawFIF will override this method.
The current gradient compensation grade.
Crop raw data file.
Limit the data from the raw file to go between specific times. Note
that the new tmin
is assumed to be t=0
for all subsequently
called functions (e.g., time_as_index()
, or
Epochs
). New first_samp and last_samp
are set accordingly.
Thus function operates in-place on the instance.
Use mne.io.Raw.copy()
if operation on a copy is desired.
float
Start time of the raw data to use in seconds (must be >= 0).
float
End time of the raw data to use in seconds (cannot exceed data duration).
If True (default), include tmax. If False, exclude tmax (similar to how Python indexing typically works).
New in version 0.19.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Raw
The cropped raw object, modified in-place.
Get crops of raw data file for selected annotations.
Annotations
| None
The annotations to use for cropping the raw file. If None, the annotations from the instance are used.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
list
The cropped raw objects.
Decimate the time-series data.
int
Factor by which to subsample the data.
Warning
Low-pass filtering is not performed, this simply selects
every Nth sample (where N is the value passed to
decim
), i.e., it compresses the signal (see Notes).
If the data are not properly filtered, aliasing artifacts
may occur.
int
Apply an offset to where the decimation starts relative to the sample corresponding to t=0. The offset is in samples at the current sampling rate.
New in version 0.12.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
The decimated object.
See also
Notes
For historical reasons, decim
/ “decimation” refers to simply subselecting
samples from a given signal. This contrasts with the broader signal processing
literature, where decimation is defined as (quoting
[1], p. 172; which cites
[2]):
“… a general system for downsampling by a factor of M is the one shown in Figure 4.23. Such a system is called a decimator, and downsampling by lowpass filtering followed by compression [i.e, subselecting samples] has been termed decimation (Crochiere and Rabiner, 1983).”
Hence “decimation” in MNE is what is considered “compression” in the signal processing community.
Decimation can be done multiple times. For example,
inst.decimate(2).decimate(2)
will be the same as
inst.decimate(4)
.
If decim
is 1, this method does not copy the underlying data.
New in version 0.10.0.
References
Remove SSP projection vector.
Note
The projection vector can only be removed if it is inactive (has not been applied to the data).
Describe channels (name, type, descriptive statistics).
If True, return results in a pandas.DataFrame. If False, only print results. Columns ‘ch’, ‘type’, and ‘unit’ indicate channel index, channel type, and unit of the remaining five columns. These columns are ‘min’ (minimum), ‘Q1’ (first quartile or 25% percentile), ‘median’, ‘Q3’ (third quartile or 75% percentile), and ‘max’ (maximum).
None
| pandas.DataFrame
If data_frame=False, returns None. If data_frame=True, returns results in a pandas.DataFrame (requires pandas).
Drop channel(s).
See also
Notes
New in version 0.9.0.
Export Raw to external formats.
BrainVision (.vhdr
, .vmrk
, .eeg
, uses pybv)
EEGLAB (.set
, uses eeglabio
)
EDF (.edf
, uses EDFlib-Python)
Warning
Since we are exporting to external formats, there’s no guarantee that all the info will be preserved in the external format. See Notes for details.
str
Name of the output file.
Format of the export. Defaults to 'auto'
, which will infer the format
from the filename extension. See supported formats above for more
information.
str
| tuple
The physical range of the data. If ‘auto’ (default), then it will infer the physical min and max from the data itself, taking the minimum and maximum values per channel type. If it is a 2-tuple of minimum and maximum limit, then those physical ranges will be used. Only used for exporting EDF files.
Whether to incorporate the channel type into the signal label (e.g. whether
to store channel “Fz” as “EEG Fz”). Only used for EDF format. Default is
False
.
If True (default False), overwrite the destination file if it exists.
New in version 0.24.1.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
New in version 0.24.
Export to external format may not preserve all the information from the
instance. To save in native MNE format (.fif
) without information loss,
use mne.io.Raw.save()
instead.
Export does not apply projector(s). Unapplied projector(s) will be lost.
Consider applying projector(s) before exporting with
mne.io.Raw.apply_proj()
.
For EEGLAB exports, channel locations are expanded to full EEGLAB format.
For more details see eeglabio.utils.cart_to_eeglab()
.
For EDF exports, only channels measured in Volts are allowed; in MNE-Python
this means channel types ‘eeg’, ‘ecog’, ‘seeg’, ‘emg’, ‘eog’, ‘ecg’, ‘dbs’,
‘bio’, and ‘misc’. ‘stim’ channels are dropped. Although this function
supports storing channel types in the signal label (e.g. EEG Fz
or
MISC E
), other software may not support this (optional) feature of
the EDF standard.
If add_ch_type
is True, then channel types are written based on what
they are currently set in MNE-Python. One should double check that all
their channels are set correctly. You can call
raw.set_channel_types
to set
channel types.
In addition, EDF does not support storing a montage. You will need
to store the montage separately and call raw.set_montage()
.
The filenames used.
Filter a subset of channels.
float
| None
For FIR filters, the lower pass-band edge; for IIR filters, the lower cutoff frequency. If None the data are only low-passed.
float
| None
For FIR filters, the upper pass-band edge; for IIR filters, the upper cutoff frequency. If None the data are only high-passed.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all data channels. Note that channels
in info['bads']
will be included if their names or indices are
explicitly provided.
str
| int
Length of the FIR filter to use (if applicable):
‘auto’ (default): The filter length is chosen based on the size of the transition regions (6.6 times the reciprocal of the shortest transition band for fir_window=’hamming’ and fir_design=”firwin2”, and half that for “firwin”).
str: A human-readable time in
units of “s” or “ms” (e.g., “10s” or “5500ms”) will be
converted to that number of samples if phase="zero"
, or
the shortest power-of-two length at least that duration for
phase="zero-double"
.
int: Specified length in samples. For fir_design=”firwin”, this should not be used.
float
| str
Width of the transition band at the low cut-off frequency in Hz
(high pass or cutoff 1 in bandpass). Can be “auto”
(default) to use a multiple of l_freq
:
min(max(l_freq * 0.25, 2), l_freq)
Only used for method='fir'
.
float
| str
Width of the transition band at the high cut-off frequency in Hz
(low pass or cutoff 2 in bandpass). Can be “auto”
(default in 0.14) to use a multiple of h_freq
:
min(max(h_freq * 0.25, 2.), info['sfreq'] / 2. - h_freq)
Only used for method='fir'
.
int
| str
Number of jobs to run in parallel. Can be ‘cuda’ if cupy
is installed properly and method=’fir’.
str
‘fir’ will use overlap-add FIR filtering, ‘iir’ will use IIR forward-backward filtering (via filtfilt).
dict
| None
Dictionary of parameters to use for IIR filtering.
If iir_params is None and method=”iir”, 4th order Butterworth will be used.
For more information, see mne.filter.construct_iir_filter()
.
str
Phase of the filter, only used if method='fir'
.
Symmetric linear-phase FIR filters are constructed, and if phase='zero'
(default), the delay of this filter is compensated for, making it
non-causal. If phase='zero-double'
,
then this filter is applied twice, once forward, and once backward
(also making it non-causal). If 'minimum'
, then a minimum-phase filter
will be constricted and applied, which is causal but has weaker stop-band
suppression.
New in version 0.13.
str
The window to use in FIR design, can be “hamming” (default), “hann” (default in 0.13), or “blackman”.
New in version 0.15.
str
Can be “firwin” (default) to use scipy.signal.firwin()
,
or “firwin2” to use scipy.signal.firwin2()
. “firwin” uses
a time-domain design technique that generally gives improved
attenuation using fewer samples than “firwin2”.
New in version 0.15.
str
| list
of str
If a string (or list of str), any annotation segment that begins
with the given string will not be included in filtering, and
segments on either side of the given excluded annotated segment
will be filtered separately (i.e., as independent signals).
The default (('edge', 'bad_acq_skip')
will separately filter
any segments that were concatenated by mne.concatenate_raws()
or mne.io.Raw.append()
, or separated during acquisition.
To disable, provide an empty list. Only used if inst
is raw.
New in version 0.16..
str
The type of padding to use. Supports all numpy.pad()
mode
options. Can also be "reflect_limited"
, which pads with a
reflected version of each vector mirrored on the first and last values
of the vector, followed by zeros.
Only used for method='fir'
.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
See also
Notes
Applies a zero-phase low-pass, high-pass, band-pass, or band-stop
filter to the channels selected by picks
.
The data are modified inplace.
The object has to have the data loaded e.g. with preload=True
or self.load_data()
.
l_freq
and h_freq
are the frequencies below which and above
which, respectively, to filter out of the data. Thus the uses are:
l_freq < h_freq
: band-pass filter
l_freq > h_freq
: band-stop filter
l_freq is not None and h_freq is None
: high-pass filter
l_freq is None and h_freq is not None
: low-pass filter
self.info['lowpass']
and self.info['highpass']
are only
updated with picks=None.
Note
If n_jobs > 1, more memory is required as
len(picks) * n_times
additional time points need to
be temporaily stored in memory.
For more information, see the tutorials
Background information on filtering and Filtering and resampling data and
mne.filter.create_filter()
.
New in version 0.15.
The first data sample.
See first_samp.
The first time point (including first_samp but not meas_date).
Get a list of channel type for each channel.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all channels. Note that channels in
info['bads']
will be included if their names or indices are
explicitly provided.
Whether to return only unique channel types. Default is False
.
Whether to ignore non-data channels. Default is False
.
list
The channel types.
Get data in the given range.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all channels. Note that channels in
info['bads']
will be included if their names or indices are
explicitly provided.
int
The first sample to include. Defaults to 0.
int
| None
End sample (first not to include). If None (default), the end of the data is used.
None
| ‘omit’ | ‘NaN’Whether to reject by annotation. If None (default), no rejection is done. If ‘omit’, segments annotated with description starting with ‘bad’ are omitted. If ‘NaN’, the bad samples are filled with NaNs.
Whether to return times as well. Defaults to False.
str
| dict
| None
Specify the unit(s) that the data should be returned in. If
None
(default), the data is returned in the
channel-type-specific default units, which are SI units (see
Internal representation (units) and data channels). If a string, must be a
sub-multiple of SI units that will be used to scale the data from
all channels of the type associated with that unit. This only works
if the data contains one channel type that has a unit (unitless
channel types are left unchanged). For example if there are only
EEG and STIM channels, units='uV'
will scale EEG channels to
micro-Volts while STIM channels will be unchanged. Finally, if a
dictionary is provided, keys must be channel types, and values must
be units to scale the data of that channel type to. For example
dict(grad='fT/cm', mag='fT')
will scale the corresponding types
accordingly, but all other channel types will remain in their
channel-type-specific default unit.
int
| float
| None
Start time of data to get in seconds. The tmin
parameter is
ignored if the start
parameter is bigger than 0.
New in version 0.24.0.
int
| float
| None
End time of data to get in seconds. The tmax
parameter is
ignored if the stop
parameter is defined.
New in version 0.24.0.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
New in version 0.14.0.
Get a DigMontage from instance.
None
| str
| DigMontage
A montage containing channel positions. If a string or
DigMontage
is
specified, the existing channel information will be updated with the
channel positions from the montage. Valid strings are the names of the
built-in montages that ship with MNE-Python; you can list those via
mne.channels.get_builtin_montages()
.
If None
(default), the channel positions will be removed from the
Info
.
Interpolate bad MEG and EEG channels.
Operates in place.
If True, remove the bads from info.
str
Either 'accurate'
or 'fast'
, determines the quality of the
Legendre polynomial expansion used for interpolation of channels
using the minimum-norm method.
str
Origin of the sphere in the head coordinate frame and in meters.
Can be 'auto'
(default), which means a head-digitization-based
origin fit.
New in version 0.17.
dict
Method to use for each channel type. Currently only the key “eeg” has multiple options:
"spline"
(default)Use spherical spline interpolation.
"MNE"
Use minimum-norm projection to a sphere and back. This is the method used for MEG channels.
The value for “meg” is “MNE”, and the value for “fnirs” is “nearest”. The default (None) is thus an alias for:
method=dict(meg="MNE", eeg="spline", fnirs="nearest")
New in version 0.21.
list
| tuple
The channels to exclude from interpolation. If excluded a bad channel will stay in bads.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
New in version 0.9.0.
The last data sample.
Mark channels as bad from a text file.
This function operates mostly in the style of the C function
mne_mark_bad_channels
. Each line in the text file will be
interpreted as a name of a bad channel.
None
File name of the text file containing bad channels.
If None
(default), bad channels are cleared, but this
is more easily done directly with raw.info['bads'] = []
.
Whether or not to force bad channel marking (of those
that exist) if channels are not found, instead of
raising an error. Defaults to False
.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Load raw data.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Raw
The raw object with data.
Notes
This function will load raw data if it was not already preloaded. If data were already preloaded, it will do nothing.
New in version 0.10.0.
Number of time points.
Notch filter a subset of channels.
float
| array
of float
| None
Specific frequencies to filter out from data, e.g.,
np.arange(60, 241, 60)
in the US or np.arange(50, 251, 50)
in Europe. None
can only be used with the mode
'spectrum_fit'
, where an F test is used to find sinusoidal
components.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all data channels. Note that channels
in info['bads']
will be included if their names or indices are
explicitly provided.
str
| int
Length of the FIR filter to use (if applicable):
‘auto’ (default): The filter length is chosen based on the size of the transition regions (6.6 times the reciprocal of the shortest transition band for fir_window=’hamming’ and fir_design=”firwin2”, and half that for “firwin”).
str: A human-readable time in
units of “s” or “ms” (e.g., “10s” or “5500ms”) will be
converted to that number of samples if phase="zero"
, or
the shortest power-of-two length at least that duration for
phase="zero-double"
.
int: Specified length in samples. For fir_design=”firwin”, this should not be used.
When method=='spectrum_fit'
, this sets the effective window duration
over which fits are computed. See mne.filter.create_filter()
for options. Longer window lengths will give more stable frequency
estimates, but require (potentially much) more processing and are not able
to adapt as well to non-stationarities.
The default in 0.21 is None, but this will change to '10s'
in 0.22.
float
| array
of float
| None
Width of each stop band (centred at each freq in freqs) in Hz.
If None, freqs / 200
is used.
float
Width of the transition band in Hz.
Only used for method='fir'
.
int
| str
Number of jobs to run in parallel. Can be ‘cuda’ if cupy
is installed properly and method=’fir’.
str
‘fir’ will use overlap-add FIR filtering, ‘iir’ will use IIR forward-backward filtering (via filtfilt).
dict
| None
Dictionary of parameters to use for IIR filtering.
If iir_params is None and method=”iir”, 4th order Butterworth will be used.
For more information, see mne.filter.construct_iir_filter()
.
float
| None
The bandwidth of the multitaper windowing function in Hz. Only used in ‘spectrum_fit’ mode.
float
P-value to use in F-test thresholding to determine significant
sinusoidal components to remove when method='spectrum_fit'
and
freqs=None
. Note that this will be Bonferroni corrected for the
number of frequencies, so large p-values may be justified.
str
Phase of the filter, only used if method='fir'
.
Symmetric linear-phase FIR filters are constructed, and if phase='zero'
(default), the delay of this filter is compensated for, making it
non-causal. If phase='zero-double'
,
then this filter is applied twice, once forward, and once backward
(also making it non-causal). If 'minimum'
, then a minimum-phase filter
will be constricted and applied, which is causal but has weaker stop-band
suppression.
New in version 0.13.
str
The window to use in FIR design, can be “hamming” (default), “hann” (default in 0.13), or “blackman”.
New in version 0.15.
str
Can be “firwin” (default) to use scipy.signal.firwin()
,
or “firwin2” to use scipy.signal.firwin2()
. “firwin” uses
a time-domain design technique that generally gives improved
attenuation using fewer samples than “firwin2”.
New in version 0.15.
str
The type of padding to use. Supports all numpy.pad()
mode
options. Can also be "reflect_limited"
, which pads with a
reflected version of each vector mirrored on the first and last values
of the vector, followed by zeros.
Only used for method='fir'
.
The default is 'reflect_limited'
.
New in version 0.15.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Raw
The raw instance with filtered data.
See also
Notes
Applies a zero-phase notch filter to the channels selected by “picks”. By default the data of the Raw object is modified inplace.
The Raw object has to have the data loaded e.g. with preload=True
or self.load_data()
.
Note
If n_jobs > 1, more memory is required as
len(picks) * n_times
additional time points need to
be temporaily stored in memory.
For details, see mne.filter.notch_filter()
.
Pick a subset of channels.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all channels. Note that channels in
info['bads']
will be included if their names or indices are
explicitly provided.
list
| str
Set of channels to exclude, only used when picking based on types (e.g., exclude=”bads” when picks=”meg”).
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
New in version 0.24.0.
Pick some channels.
list
The list of channels to select.
If True (default False), ensure that the order of the channels in
the modified instance matches the order of ch_names
.
New in version 0.20.0.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
New in version 1.1.
See also
Notes
The channel names given are assumed to be a set, i.e. the order
does not matter. The original order of the channels is preserved.
You can use reorder_channels
to set channel order if necessary.
New in version 0.9.0.
Pick some channels by type and names.
str
If True include MEG channels. If string it can be ‘mag’, ‘grad’, ‘planar1’ or ‘planar2’ to select only magnetometers, all gradiometers, or a specific type of gradiometer.
If True include EEG channels.
If True include stimulus channels.
If True include EOG channels.
If True include ECG channels.
If True include EMG channels.
str
If True include CTF / 4D reference channels. If ‘auto’, reference
channels are included if compensations are present and meg
is
not False. Can also be the string options for the meg
parameter.
If True include miscellaneous analog channels.
If True
include respiratory channels.
If True include continuous HPI coil channels.
Flux excitation channel used to be a stimulus channel.
Internal Active Shielding data (maybe on Triux only).
System status channel information (on Triux systems only).
Stereotactic EEG channels.
Dipole time course channels.
Dipole goodness of fit channels.
Bio channels.
Electrocorticography channels.
str
Functional near-infrared spectroscopy channels. If True include all fNIRS channels. If False (default) include none. If string it can be ‘hbo’ (to include channels measuring oxyhemoglobin) or ‘hbr’ (to include channels measuring deoxyhemoglobin).
EEG-CSD channels.
Deep brain stimulation channels.
list
of str
List of additional channels to include. If empty do not include any.
list
of str
| str
List of channels to exclude. If ‘bads’ (default), exclude channels
in info['bads']
.
list
of str
Restrict sensor channels (MEG, EEG) to this list of channel names.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
See also
Notes
New in version 0.9.0.
Plot raw data.
array
| None
Events to show with vertical bars.
float
Time window (s) to plot. The lesser of this value and the duration of the raw file will be used.
float
Initial time to show (can be changed dynamically once plotted). If
show_first_samp is True, then it is taken relative to
raw.first_samp
.
int
Number of channels to plot at once. Defaults to 20. The lesser of
n_channels
and len(raw.ch_names)
will be shown.
Has no effect if order
is ‘position’, ‘selection’ or ‘butterfly’.
Color of the background.
dict
| color object | None
Color for the data traces. If None, defaults to:
dict(mag='darkblue', grad='b', eeg='k', eog='k', ecg='m',
emg='k', ref_meg='steelblue', misc='k', stim='k',
resp='k', chpi='k')
Color to make bad channels.
dict
| None
Color(s) to use for events. To show all events in the same
color, pass any matplotlib-compatible color. To color events differently,
pass a dict
that maps event names or integer event numbers to colors
(must include entries for all events, or include a “fallback” entry with
key -1
). If None
, colors are chosen from the current Matplotlib
color cycle.
Defaults to 'cyan'
.
dict
| None
Scaling factors for the traces. If a dictionary where any
value is 'auto'
, the scaling factor is set to match the 99.5th
percentile of the respective data. If 'auto'
, all scalings (for all
channel types) are set to 'auto'
. If any values are 'auto'
and the
data is not preloaded, a subset up to 100 MB will be loaded. If None
,
defaults to:
dict(mag=1e-12, grad=4e-11, eeg=20e-6, eog=150e-6, ecg=5e-4,
emg=1e-3, ref_meg=1e-12, misc=1e-3, stim=1,
resp=1, chpi=1e-4, whitened=1e2)
Note
A particular scaling value s
corresponds to half of the visualized
signal range around zero (i.e. from 0
to +s
or from 0
to
-s
). For example, the default scaling of 20e-6
(20µV) for EEG
signals means that the visualized range will be 40 µV (20 µV in the
positive direction and 20 µV in the negative direction).
If True remove DC component when plotting data.
array
of int
| None
Order in which to plot data. If the array is shorter than the number of
channels, only the given channels are plotted. If None (default), all
channels are plotted. If group_by
is 'position'
or
'selection'
, the order
parameter is used only for selecting the
channels to be plotted.
If True, a dialog for options related to projection is shown.
str
| None
The title of the window. If None, and either the filename of the raw object or ‘<unknown>’ will be displayed as title.
Show figure if True.
Whether to halt program execution until the figure is closed.
Useful for setting bad channels on the fly by clicking on a line.
May not work on all systems / platforms.
(Only Qt) If you run from a script, this needs to
be True
or a Qt-eventloop needs to be started somewhere
else in the script (e.g. if you want to implement the browser
inside another Qt-Application).
float
| None
Highpass to apply when displaying data.
float
| None
Lowpass to apply when displaying data. If highpass > lowpass, a bandstop rather than bandpass filter will be applied.
int
Filtering order. 0 will use FIR filtering with MNE defaults.
Other values will construct an IIR filter of the given order
and apply it with filtfilt()
(making the effective
order twice filtorder
). Filtering may produce some edge artifacts
(at the left and right edges) of the signals during display.
Changed in version 0.18: Support for filtorder=0
to use FIR filtering.
str
| float
| None
If None, channels are allowed to exceed their designated bounds in
the plot. If “clamp”, then values are clamped to the appropriate
range for display, creating step-like artifacts. If “transparent”,
then excessive values are not shown, creating gaps in the traces.
If float, clipping occurs for values beyond the clipping
multiple
of their dedicated range, so clipping=1.
is an alias for
clipping='transparent'
.
Changed in version 0.21: Support for float, and default changed from None to 1.5.
If True, show time axis relative to the raw.first_samp
.
Whether to apply projectors prior to plotting (default is True
).
Individual projectors can be enabled/disabled interactively (see
Notes). This argument only affects the plot; use raw.apply_proj()
to modify the data stored in the Raw object.
str
How to group channels. 'type'
groups by channel type,
'original'
plots in the order of ch_names, 'selection'
uses
Elekta’s channel groupings (only works for Neuromag data),
'position'
groups the channels by the positions of the sensors.
'selection'
and 'position'
modes allow custom selections by
using a lasso selector on the topomap. In butterfly mode, 'type'
and 'original'
group the channels by type, whereas 'selection'
and 'position'
use regional grouping. 'type'
and 'original'
modes are ignored when order
is not None
. Defaults to 'type'
.
Whether to start in butterfly mode. Defaults to False.
int
| ‘auto’Amount to decimate the data during display for speed purposes.
You should only decimate if the data are sufficiently low-passed,
otherwise aliasing can occur. The ‘auto’ mode (default) uses
the decimation that results in a sampling rate least three times
larger than min(info['lowpass'], lowpass)
(e.g., a 40 Hz lowpass
will result in at least a 120 Hz displayed sample rate).
Covariance
| str
| None
Noise covariance used to whiten the data while plotting.
Whitened data channels are scaled by scalings['whitened']
,
and their channel names are shown in italic.
Can be a string to load a covariance from disk.
See also mne.Evoked.plot_white()
for additional inspection
of noise covariance properties when whitening evoked data.
For data processed with SSS, the effective dependence between
magnetometers and gradiometers may introduce differences in scaling,
consider using mne.Evoked.plot_white()
.
New in version 0.16.0.
dict
| None
Event IDs used to show at event markers (default None shows the event numbers).
New in version 0.16.0.
Whether to show scrollbars when the plot is initialized. Can be toggled
after initialization by pressing z (“zen mode”) while the plot
window is focused. Default is True
.
New in version 0.19.0.
Whether to show scale bars when the plot is initialized. Can be toggled
after initialization by pressing s while the plot window is focused.
Default is True
.
New in version 0.20.0.
Style of time labels on the horizontal axis. If 'float'
, labels will be
number of seconds from the start of the recording. If 'clock'
,
labels will show “clock time” (hours/minutes/seconds) inferred from
raw.info['meas_date']
. Default is 'float'
.
New in version 0.24.
str
Whether to load all data (not just the visible portion) into RAM and
apply preprocessing (e.g., projectors) to the full data array in a separate
processor thread, instead of window-by-window during scrolling. The default
None uses the MNE_BROWSER_PRECOMPUTE
variable, which defaults to
'auto'
. 'auto'
compares available RAM space to the expected size of
the precomputed data, and precomputes only if enough RAM is available.
This is only used with the Qt backend.
New in version 0.24.
Changed in version 1.0: Support for the MNE_BROWSER_PRECOMPUTE config variable.
None
Whether to use OpenGL when rendering the plot (requires pyopengl
).
May increase performance, but effect is dependent on system CPU and
graphics hardware. Only works if using the Qt backend. Default is
None, which will use False unless the user configuration variable
MNE_BROWSER_USE_OPENGL
is set to 'true'
,
see mne.set_config()
.
New in version 0.24.
str
| path-likeCan be “auto”, “light”, or “dark” or a path-like to a
custom stylesheet. For Dark-Mode and automatic Dark-Mode-Detection,
qdarkstyle
and
darkdetect,
respectively, are required. If None (default), the config option MNE_BROWSER_THEME will be used,
defaulting to “auto” if it’s not found.
Only supported by the 'qt'
backend.
New in version 1.0.
str
| None
Can be “channels”, “empty”, or “hidden” to set the overview bar mode
for the 'qt'
backend. If None (default), the config option
MNE_BROWSER_OVERVIEW_MODE
will be used, defaulting to “channels”
if it’s not found.
New in version 1.1.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
matplotlib.figure.Figure
| mne_qt_browser.figure.MNEQtBrowserBrowser instance.
Notes
The arrow keys (up/down/left/right) can typically be used to navigate
between channels and time ranges, but this depends on the backend
matplotlib is configured to use (e.g., mpl.use(‘TkAgg’) should work). The
left/right arrows will scroll by 25% of duration
, whereas
shift+left/shift+right will scroll by 100% of duration
. The scaling
can be adjusted with - and + (or =) keys. The viewport dimensions can be
adjusted with page up/page down and home/end keys. Full screen mode can be
toggled with the F11 key, and scrollbars can be hidden/shown by pressing
‘z’. Right-click a channel label to view its location. To mark or un-mark a
channel as bad, click on a channel label or a channel trace. The changes
will be reflected immediately in the raw object’s raw.info['bads']
entry.
If projectors are present, a button labelled “Prj” in the lower right corner of the plot window opens a secondary control window, which allows enabling/disabling specific projectors individually. This provides a means of interactively observing how each projector would affect the raw data if it were applied.
Annotation mode is toggled by pressing ‘a’, butterfly mode by pressing
‘b’, and whitening mode (when noise_cov is not None
) by pressing ‘w’.
By default, the channel means are removed when remove_dc
is set to
True
. This flag can be toggled by pressing ‘d’.
Note
For the Qt backend to run in IPython with block=False
you must run the magic command %gui qt5
first.
Note
To report issues with the qt-backend, please use the
issues
of mne-qt-browser
.
Examples using plot
:
Creating MNE-Python data structures from scratch
How to use data in neural ensemble (NEO) format
Simulate raw data using subject anatomy
Generate simulated source data
Visualise NIRS artifact correction methods
Plot SSP vector.
None
| list
The channel type to plot. For ‘grad’, the gradiometers are collec- ted in pairs and the RMS for each pair is plotted. If None (default), it will return all channel types present. If a list of ch_types is provided, it will return multiple figures.
None
Colormap to use. If tuple, the first value indicates the colormap to
use and the second value is a boolean defining interactivity. In
interactive mode (only works if colorbar=True
) the colors are
adjustable by clicking and dragging the colorbar with left and right
mouse button. Left mouse button moves the scale up and down and right
mouse button adjusts the range. Hitting space bar resets the range. Up
and down arrows can be used to change the colormap. If None (default),
‘Reds’ is used for all positive data, otherwise defaults to ‘RdBu_r’.
If ‘interactive’, translates to (None, True).
str
Add markers for sensor locations to the plot. Accepts matplotlib plot format string (e.g., ‘r+’ for red plusses). If True, a circle will be used (via .add_artist). Defaults to True.
Plot a colorbar.
int
The resolution of the topomap image (n pixels along each side).
Side length of the topomaps in inches (only applies when plotting multiple topomaps at a time).
Show figure if True.
dict
| None
The outlines to be drawn. If ‘head’, the default head scheme will be drawn. If ‘skirt’ the head scheme will be drawn, but sensors are allowed to be plotted outside of the head circle. If dict, each key refers to a tuple of x and y positions, the values in ‘mask_pos’ will serve as image mask. Alternatively, a matplotlib patch object can be passed for advanced masking options, either directly or as a function that returns patches (required for multi-axis plots). If None, nothing will be drawn. Defaults to ‘head’.
int
| array
of float
The number of contour lines to draw. If 0, no contours will be drawn. When an integer, matplotlib ticker locator is used to find suitable values for the contour thresholds (may sometimes be inaccurate, use array for accuracy). If an array, the values represent the levels for the contours. Defaults to 6.
str
The image interpolation to be used. Options are 'cubic'
(default)
to use scipy.interpolate.CloughTocher2DInterpolator
,
'nearest'
to use scipy.spatial.Voronoi
or
'linear'
to use scipy.interpolate.LinearNDInterpolator
.
Axes
| list
| None
The axes to plot to. If list, the list must be a list of Axes of the same length as the number of projectors. If instance of Axes, there must be only one projector. Defaults to None.
tuple
of length 2 | ‘joint’Colormap limits to use. If tuple
, specifies the lower and
upper bounds of the colormap (in that order); providing None
for
either of these will set the corresponding boundary at the min/max of
the data (separately for each projector). The keyword value 'joint'
will compute the colormap limits jointly across all provided
projectors of the same channel type, using the min/max of the projector
data. If vlim is 'joint'
, info
must not be None
. Defaults
to (None, None)
.
float
| array-like | instance of ConductorModel
| None
| ‘auto’ | ‘eeglab’The sphere parameters to use for the head outline. Can be array-like of
shape (4,) to give the X/Y/Z origin and radius in meters, or a single float
to give just the radius (origin assumed 0, 0, 0). Can also be an instance
of a spherical ConductorModel
to use the origin and
radius from that object. If 'auto'
the sphere is fit to digitization
points. If 'eeglab'
the head circle is defined by EEG electrodes
'Fpz'
, 'Oz'
, 'T7'
, and 'T8'
(if 'Fpz'
is not present,
it will be approximated from the coordinates of 'Oz'
). None
(the
default) is equivalent to 'auto'
when enough extra digitization points
are available, and (0, 0, 0, 0.095) otherwise. Currently the head radius
does not affect plotting.
New in version 0.20.
Changed in version 1.1: Added 'eeglab'
option.
str
The image interpolation to be used. Options are 'cubic'
(default)
to use scipy.interpolate.CloughTocher2DInterpolator
,
'nearest'
to use scipy.spatial.Voronoi
or
'linear'
to use scipy.interpolate.LinearNDInterpolator
.
str
Options:
'box'
Extrapolate to four points placed to form a square encompassing all data points, where each side of the square is three times the range of the data in the respective dimension.
'local'
(default for MEG sensors)Extrapolate only to nearby points (approximately to points closer than median inter-electrode distance). This will also set the mask to be polygonal based on the convex hull of the sensors.
'head'
(default for non-MEG sensors)Extrapolate out to the edges of the clipping circle. This will be on the head circle when the sensors are contained within the head circle, but it can extend beyond the head when sensors are plotted outside the head circle.
Changed in version 0.21:
The default was changed to 'local'
for MEG sensors.
'local'
was changed to use a convex hull mask
'head'
was changed to extrapolate out to the clipping circle.
New in version 0.20.
float
| ‘mean’Value to extrapolate to on the topomap borders. If 'mean'
(default),
then each extrapolated point has the average value of its neighbours.
New in version 0.20.
Figure
Figure distributing one image per channel across sensor topography.
Plot the power spectral density across channels.
Different channel types are drawn in sub-plots. When the data have been processed with a bandpass, lowpass or highpass filter, dashed lines (╎) indicate the boundaries of the filter. The line noise frequency is also indicated with a dashed line (⋮).
float
Start frequency to consider.
float
End frequency to consider.
float
| None
Start time to consider.
float
| None
End time to consider.
Apply projection.
int
| None
Number of points to use in Welch FFT calculations. Default is None, which uses the minimum of 2048 and the number of time points.
int
The number of points of overlap between blocks. The default value is 0 (no overlap).
Whether to omit bad segments from the data before fitting. If True
(default), annotated segments whose description begins with 'bad'
are
omitted. If False
, no rejection based on annotations is performed.
Has no effect if inst
is not a mne.io.Raw
object.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as channel indices. In lists, channel type strings
(e.g., ['meg', 'eeg']
) will pick channels of those
types, channel name strings (e.g., ['MEG0111', 'MEG2623']
will pick the given channels. Can also be the string values
“all” to pick all channels, or “data” to pick data channels.
None (default) will pick good data channels. Note that channels in info['bads']
will be included if their names or indices are explicitly provide
Cannot be None if ax
is supplied.If both picks
and ax
are None
separate subplots will be created for each standard channel type
(mag
, grad
, and eeg
).
Axes
| None
Axes to plot into. If None, axes will be created.
str
| tuple
A matplotlib-compatible color to use. Has no effect when spatial_colors=True.
str
Can be ‘linear’ (default) or ‘log’.
str
| None
Mode for plotting area. If ‘std’, the mean +/- 1 STD (across channels) will be plotted. If ‘range’, the min and max (across channels) will be plotted. Bad channels will be excluded from these calculations. If None, no area will be plotted. If average=False, no area is plotted.
float
Alpha for the area.
Plot Power Spectral Density (PSD), in units (amplitude**2/Hz (dB)) if
dB=True
, and estimate='power'
or estimate='auto'
. Plot PSD
in units (amplitude**2/Hz) if dB=False
and,
estimate='power'
. Plot Amplitude Spectral Density (ASD), in units
(amplitude/sqrt(Hz)), if dB=False
and estimate='amplitude'
or
estimate='auto'
. Plot ASD, in units (amplitude/sqrt(Hz) (db)), if
dB=True
and estimate='amplitude'
.
str
, {‘auto’, ‘power’, ‘amplitude’}Can be “power” for power spectral density (PSD), “amplitude” for amplitude spectrum density (ASD), or “auto” (default), which uses “power” when dB is True and “amplitude” otherwise.
Show the figure if True
.
int
| None
The number of jobs to run in parallel. If -1
, it is set
to the number of CPU cores. Requires the joblib
package.
None
(default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1
(sequential execution) unless the call is performed under
a joblib.parallel_backend()
context manager that sets another
value for n_jobs
.
If False, the PSDs of all channels is displayed. No averaging is done and parameters area_mode and area_alpha are ignored. When False, it is possible to paint an area (hold left mouse button and drag) to plot a topomap.
float
| None
Alpha for the PSD line. Can be None (default) to use 1.0 when
average=True
and 0.1 when average=False
.
Whether to use spatial colors. Only used when average=False
.
float
| array-like | instance of ConductorModel
| None
| ‘auto’ | ‘eeglab’The sphere parameters to use for the head outline. Can be array-like of
shape (4,) to give the X/Y/Z origin and radius in meters, or a single float
to give just the radius (origin assumed 0, 0, 0). Can also be an instance
of a spherical ConductorModel
to use the origin and
radius from that object. If 'auto'
the sphere is fit to digitization
points. If 'eeglab'
the head circle is defined by EEG electrodes
'Fpz'
, 'Oz'
, 'T7'
, and 'T8'
(if 'Fpz'
is not present,
it will be approximated from the coordinates of 'Oz'
). None
(the
default) is equivalent to 'auto'
when enough extra digitization points
are available, and (0, 0, 0, 0.095) otherwise. Currently the head radius
does not affect plotting.
New in version 0.20.
Changed in version 1.1: Added 'eeglab'
option.
str
| float
| tuple
Windowing function to use. See scipy.signal.get_window()
.
New in version 0.22.0.
list
of str
| ‘bads’Channels names to exclude from being shown. If ‘bads’, the bad channels are excluded. Pass an empty list to plot all channels (including channels marked “bad”, if any).
New in version 0.24.0.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Figure
Figure with frequency spectra of the data channels.
Plot channel-wise frequency spectra as topography.
float
Start time for calculations. Defaults to zero.
float
| None
End time for calculations. If None (default), the end of data is used.
float
Start frequency to consider. Defaults to zero.
float
End frequency to consider. Defaults to 100.
Apply projection. Defaults to False.
int
Number of points to use in Welch FFT calculations. Defaults to 2048.
int
The number of points of overlap between blocks. Defaults to 0 (no overlap).
Layout
| None
Layout instance specifying sensor positions (does not need to be specified for Neuromag data). If None (default), the correct layout is inferred from the data.
str
| tuple
A matplotlib-compatible color to use for the curves. Defaults to white.
str
| tuple
A matplotlib-compatible color to use for the figure background. Defaults to black.
str
| tuple
A matplotlib-compatible color to use for the axis background. Defaults to black.
If True, transform data to decibels. Defaults to True.
Show figure if True. Defaults to True.
Whether to halt program execution until the figure is closed. May not work on all systems / platforms. Defaults to False.
int
| None
The number of jobs to run in parallel. If -1
, it is set
to the number of CPU cores. Requires the joblib
package.
None
(default) is a marker for ‘unset’ that will be interpreted
as n_jobs=1
(sequential execution) unless the call is performed under
a joblib.parallel_backend()
context manager that sets another
value for n_jobs
.
Axes
| None
Axes to plot into. If None, axes will be created.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
matplotlib.figure.Figure
Figure distributing one image per channel across sensor topography.
Plot sensor positions.
str
Whether to plot the sensors as 3d, topomap or as an interactive sensor selection dialog. Available options ‘topomap’, ‘3d’, ‘select’. If ‘select’, a set of channels can be selected interactively by using lasso selector or clicking while holding control key. The selected channels are returned along with the figure instance. Defaults to ‘topomap’.
None
| str
The channel type to plot. Available options ‘mag’, ‘grad’, ‘eeg’,
‘seeg’, ‘dbs’, ‘ecog’, ‘all’. If 'all'
, all the available mag,
grad, eeg, seeg, dbs, and ecog channels are plotted. If
None (default), then channels are chosen in the order given above.
str
| None
Title for the figure. If None (default), equals to 'Sensor
positions (%s)' % ch_type
.
array
of str
Whether to display all channel names. If an array, only the channel names in the array are shown. Defaults to False.
array
of shape (n_ch_groups, n_picks) | None
Channel groups for coloring the sensors. If None (default), default
coloring scheme is used. If ‘position’, the sensors are divided
into 8 regions. See order
kwarg of mne.viz.plot_raw()
. If
array, the channels are divided by picks given in the array.
New in version 0.13.0.
Whether to project the 3d locations to a sphere. When False, the sensor array appears similar as to looking downwards straight above the subject’s head. Has no effect when kind=’3d’. Defaults to True.
New in version 0.14.0.
Axes
| instance of Axes3D
| None
Axes to draw the sensors to. If kind='3d'
, axes must be an
instance of Axes3D. If None (default), a new axes will be created.
New in version 0.13.0.
Whether to halt program execution until the figure is closed. Defaults to False.
New in version 0.13.0.
Show figure if True. Defaults to True.
float
| array-like | instance of ConductorModel
| None
| ‘auto’ | ‘eeglab’The sphere parameters to use for the head outline. Can be array-like of
shape (4,) to give the X/Y/Z origin and radius in meters, or a single float
to give just the radius (origin assumed 0, 0, 0). Can also be an instance
of a spherical ConductorModel
to use the origin and
radius from that object. If 'auto'
the sphere is fit to digitization
points. If 'eeglab'
the head circle is defined by EEG electrodes
'Fpz'
, 'Oz'
, 'T7'
, and 'T8'
(if 'Fpz'
is not present,
it will be approximated from the coordinates of 'Oz'
). None
(the
default) is equivalent to 'auto'
when enough extra digitization points
are available, and (0, 0, 0, 0.095) otherwise. Currently the head radius
does not affect plotting.
New in version 0.20.
Changed in version 1.1: Added 'eeglab'
option.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
See also
Notes
This function plots the sensor locations from the info structure using
matplotlib. For drawing the sensors using PyVista see
mne.viz.plot_alignment()
.
New in version 0.12.0.
Examples using plot_sensors
:
Importing data from fNIRS devices
Whether or not projections are active.
Rename channels.
dict
| callable()
A dictionary mapping the old channel to a new channel name e.g. {‘EEG061’ : ‘EEG161’}. Can also be a callable function that takes and returns a string.
Changed in version 0.10.0: Support for a callable function.
If True (default False), allow duplicates, which will automatically
be renamed with -N
at the end.
New in version 0.22.0.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
New in version 0.9.0.
Examples using rename_channels
:
EEG forward operator with a template MRI
Reorder channels.
list
The desired channel order.
See also
Notes
Channel names must be unique. Channels that are not in ch_names
are dropped.
New in version 0.16.0.
Resample all channels.
If appropriate, an anti-aliasing filter is applied before resampling. See Resampling and decimating data for more information.
Warning
The intended purpose of this function is primarily to speed up computations (e.g., projection calculation) when precise timing of events is not required, as downsampling raw data effectively jitters trigger timings. It is generally recommended not to epoch downsampled data, but instead epoch and then downsample, as epoching downsampled data jitters triggers. For more, see this illustrative gist.
If resampling the continuous data is desired, it is recommended to construct events using the original data. The event onsets can be jointly resampled with the raw data using the ‘events’ parameter (a resampled copy is returned).
float
New sample rate to use.
int
| str
Amount to pad the start and end of the data. Can also be “auto” to use a padding that will result in a power-of-two size (can be much faster).
str
| tuple
Frequency-domain window to use in resampling.
See scipy.signal.resample()
.
list
of int
| None
Stim channels. These channels are simply subsampled or
supersampled (without applying any filtering). This reduces
resampling artifacts in stim channels, but may lead to missing
triggers. If None, stim channels are automatically chosen using
mne.pick_types()
.
int
| str
Number of jobs to run in parallel. Can be ‘cuda’ if cupy
is installed properly.
array
, shape (n_events, 3) | None
An optional event matrix. When specified, the onsets of the events are resampled jointly with the data. NB: The input events are not modified, but a new array is returned with the raw instead.
str
The type of padding to use. Supports all numpy.pad()
mode
options. Can also be "reflect_limited"
, which pads with a
reflected version of each vector mirrored on the first and last values
of the vector, followed by zeros.
The default is 'reflect_limited'
.
New in version 0.15.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
See also
Notes
For some data, it may be more accurate to use npad=0
to reduce
artifacts. This is dataset dependent – check your data!
For optimum performance and to make use of n_jobs > 1
, the raw
object has to have the data loaded e.g. with preload=True
or
self.load_data()
, but this increases memory requirements. The
resulting raw object will have the data loaded into memory.
Save raw data to file.
str
File name of the new dataset. This has to be a new filename
unless data have been preloaded. Filenames should end with
raw.fif
(common raw data), raw_sss.fif
(Maxwell-filtered continuous data),
raw_tsss.fif
(temporally signal-space-separated data),
_meg.fif
(common MEG data), _eeg.fif
(common EEG data),
or _ieeg.fif
(common intracranial EEG data). You may also
append an additional .gz
suffix to enable gzip compression.
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all channels. Note that channels in
info['bads']
will be included if their names or indices are
explicitly provided.
float
Start time of the raw data to use in seconds (must be >= 0).
float
End time of the raw data to use in seconds (cannot exceed data duration).
float
| None
Size of data chunks in seconds. If None (default), the buffer size of the original file is used.
Drop or not the last buffer. It is required by maxfilter (SSS) that only accepts raw files with buffers of the same size.
If True the data is saved with the projections applied (active).
Note
If apply_proj()
was used to apply the projections,
the projectons will be active even if proj
is False.
Format to use to save raw data. Valid options are ‘double’, ‘single’, ‘int’, and ‘short’ for 64- or 32-bit float, or 32- or 16-bit integers, respectively. It is strongly recommended to use ‘single’, as this is backward-compatible, and is standard for maintaining precision. Note that using ‘short’ or ‘int’ may result in loss of precision, complex data cannot be saved as ‘short’, and neither complex data types nor real data stored as ‘double’ can be loaded with the MNE command-line tools. See raw.orig_format to determine the format the original data were stored in.
If True (default False), overwrite the destination file if it exists. To overwrite original file (the same one that was loaded), data must be preloaded upon reading.
str
| int
Large raw files are automatically split into multiple pieces. This parameter specifies the maximum size of each piece. If the parameter is an integer, it specifies the size in Bytes. It is also possible to pass a human-readable string, e.g., 100MB.
Note
Due to FIFF file limitations, the maximum split size is 2GB.
When splitting files, append a filename partition with the appropriate
naming schema: for 'neuromag'
, a split file fname.fif
will be named
fname.fif
, fname-1.fif
, fname-2.fif
etc.; while for 'bids'
,
it will be named fname_split-01.fif
, fname_split-02.fif
, etc.
New in version 0.17.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
If Raw is a concatenation of several raw files, be warned that only the measurement information from the first raw file is stored. This likely means that certain operations with external tools may not work properly on a saved concatenated file (e.g., probably some or all forms of SSS). It is recommended not to concatenate and then save raw files for this reason.
Samples annotated BAD_ACQ_SKIP
are not stored in order to optimize
memory. Whatever values, they will be loaded as 0s when reading file.
Filter the data using Savitzky-Golay polynomial method.
float
Approximate high cut-off frequency in Hz. Note that this is not an exact cutoff, since Savitzky-Golay filtering [3] is done using polynomial fits instead of FIR/IIR filtering. This parameter is thus used to determine the length of the window over which a 5th-order polynomial smoothing is used.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
See also
Notes
For Savitzky-Golay low-pass approximation, see:
New in version 0.9.0.
References
Examples
>>> import mne
>>> from os import path as op
>>> evoked_fname = op.join(mne.datasets.sample.data_path(), 'MEG', 'sample', 'sample_audvis-ave.fif')
>>> evoked = mne.read_evokeds(evoked_fname, baseline=(None, 0))[0]
>>> evoked.savgol_filter(10.) # low-pass at around 10 Hz
>>> evoked.plot()
Setter for annotations.
This setter checks if they are inside the data range.
mne.Annotations
| None
Annotations to set. If None, the annotations is defined but empty.
Whether to emit warnings when cropping or omitting annotations. The default is True.
Can be 'raise'
(default) to raise an error, 'warn'
to emit a
warning, or 'ignore'
to ignore when entries in ch_names are not present in the raw instance.
New in version 0.23.0.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Raw
The raw object with annotations.
Examples using set_annotations
:
Visualise NIRS artifact correction methods
Define the sensor type of channels.
dict
A dictionary mapping a channel to a sensor type (str), e.g.,
{'EEG061': 'eog'}
.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
Notes
The following sensor types are accepted:
ecg, eeg, emg, eog, exci, ias, misc, resp, seeg, dbs, stim, syst, ecog, hbo, hbr, fnirs_cw_amplitude, fnirs_fd_ac_amplitude, fnirs_fd_phase, fnirs_od
New in version 0.9.0.
Specify which reference to use for EEG data.
Use this function to explicitly specify the desired reference for EEG. This can be either an existing electrode or a new virtual channel. This function will re-reference the data according to the desired reference.
list
of str
| str
Can be:
The name(s) of the channel(s) used to construct the reference.
'average'
to apply an average reference (default)
'REST'
to use the Reference Electrode Standardization Technique
infinity reference [4].
An empty list, in which case MNE will not attempt any re-referencing of the data
If ref_channels='average'
this argument specifies if the
average reference should be computed as a projection (True) or not
(False; default). If projection=True
, the average reference is
added as a projection and is not applied to the data (it can be
applied afterwards with the apply_proj
method). If
projection=False
, the average reference is directly applied to
the data. If ref_channels
is not 'average'
, projection
must be set to False
(the default in this case).
list
of str
| str
The name of the channel type to apply the reference to.
Valid channel types are 'auto'
, 'eeg'
, 'ecog'
, 'seeg'
,
'dbs'
. If 'auto'
, the first channel type of eeg, ecog, seeg or dbs
that is found (in that order) will be selected.
New in version 0.19.
Forward
| None
Forward solution to use. Only used with ref_channels='REST'
.
New in version 0.21.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
See also
mne.set_bipolar_reference
Convenience function for creating bipolar references.
Notes
Some common referencing schemes and the corresponding value for the
ref_channels
parameter:
A new virtual reference electrode is created by averaging the current
EEG signal by setting ref_channels='average'
. Bad EEG channels are
automatically excluded if they are properly set in info['bads']
.
Set ref_channels
to a list containing the name of the channel that
will act as the new reference, for example ref_channels=['Cz']
.
A new virtual reference electrode is created by computing the average
of the current EEG signal recorded from two or more selected channels.
Set ref_channels
to a list of channel names, indicating which
channels to use. For example, to apply an average mastoid reference,
when using the 10-20 naming scheme, set ref_channels=['M1', 'M2']
.
The given EEG electrodes are referenced to a point at infinity using the
lead fields in forward
, which helps standardize the signals.
If a reference is requested that is not the average reference, this function removes any pre-existing average reference projections.
During source localization, the EEG signal should have an average reference.
In order to apply a reference, the data must be preloaded. This is not
necessary if ref_channels='average'
and projection=True
.
For an average or REST reference, bad EEG channels are automatically
excluded if they are properly set in info['bads']
.
New in version 0.9.0.
References
Examples using set_eeg_reference
:
EEG forward operator with a template MRI
Simulate raw data using subject anatomy
Set the measurement start date.
datetime
| float
| tuple
| None
The new measurement date.
If datetime object, it must be timezone-aware and in UTC.
A tuple of (seconds, microseconds) or float (alias for
(meas_date, 0)
) can also be passed and a datetime
object will be automatically created. If None, will remove
the time reference.
See also
Notes
If you want to remove all time references in the file, call
mne.io.anonymize_info(inst.info)
after calling inst.set_meas_date(None)
.
New in version 0.20.
Set EEG/sEEG/ECoG/DBS/fNIRS channel positions and digitization points.
None
| str
| DigMontage
A montage containing channel positions. If a string or
DigMontage
is
specified, the existing channel information will be updated with the
channel positions from the montage. Valid strings are the names of the
built-in montages that ship with MNE-Python; you can list those via
mne.channels.get_builtin_montages()
.
If None
(default), the channel positions will be removed from the
Info
.
If True (default), channel name matching will be case sensitive.
New in version 0.20.
dict
Whether to use a lookup table to match unrecognized channel location names
to their known aliases. If True, uses the mapping in
mne.io.constants.CHANNEL_LOC_ALIASES
. If a dict
is passed, it
will be used instead, and should map from non-standard channel names to
names in the specified montage
. Default is False
.
New in version 0.23.
Can be 'raise'
(default) to raise an error, 'warn'
to emit a
warning, or 'ignore'
to ignore when channels have missing coordinates.
New in version 0.20.1.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
See also
Notes
Warning
Only EEG/sEEG/ECoG/DBS/fNIRS channels can have their positions set using a montage. Other channel types (e.g., MEG channels) should have their positions defined properly using their data reading functions.
Examples using set_montage
:
Importing data from fNIRS devices
EEG forward operator with a template MRI
Shift time scale in epoched or evoked data.
float
The (absolute or relative) time shift in seconds. If relative
is True, positive tshift increases the time value associated with
each sample, while negative tshift decreases it.
If True, increase or decrease time values by tshift
seconds.
Otherwise, shift the time values such that the time of the first
sample equals tshift
.
The modified instance.
Notes
This method allows you to shift the time values associated with each data sample by an arbitrary amount. It does not resample the signal or change the data values in any way.
Convert time to indices.
float
| int
List of numbers or a number representing points in time.
If True, use rounding (instead of truncation) when converting times to indices. This can help avoid non-unique indices.
datetime
| float
| int
| None
Time reference for times. If None, times
are assumed to be
relative to first_samp.
New in version 0.17.0.
ndarray
Indices relative to first_samp corresponding to the times supplied.
Time points.
Last time point.
First time point.
Export data in tabular structure as a pandas DataFrame.
Channels are converted to columns in the DataFrame. By default, an
additional column “time” is added, unless index
is not None
(in which case time values form the DataFrame’s index).
str
| list
| slice
| None
Channels to include. Slices and lists of integers will be interpreted as
channel indices. In lists, channel type strings (e.g., ['meg',
'eeg']
) will pick channels of those types, channel name strings (e.g.,
['MEG0111', 'MEG2623']
will pick the given channels. Can also be the
string values “all” to pick all channels, or “data” to pick data
channels. None (default) will pick all channels. Note that channels in
info['bads']
will be included if their names or indices are
explicitly provided.
None
Kind of index to use for the DataFrame. If None
, a sequential
integer index (pandas.RangeIndex
) will be used. If 'time'
, a
pandas.Float64Index
, pandas.Int64Index
, pandas.DatetimeIndex
, or
pandas.TimedeltaIndex
will be used
(depending on the value of time_format
).
Defaults to None
.
dict
| None
Scaling factor applied to the channels picked. If None
, defaults to
dict(eeg=1e6, mag=1e15, grad=1e13)
— i.e., converts EEG to µV,
magnetometers to fT, and gradiometers to fT/cm.
If True
, data will be copied. Otherwise data may be modified in place.
Defaults to True
.
int
| None
Starting sample index for creating the DataFrame from a temporal
span of the Raw object. None
(the default) uses the first
sample.
int
| None
Ending sample index for creating the DataFrame from a temporal span
of the Raw object. None
(the default) uses the last sample.
If True, the DataFrame is returned in long format where each row is one
observation of the signal at a unique combination of time point and channel.
For convenience, a ch_type
column is added to facilitate subsetting the resulting DataFrame. Defaults to False
.
str
| None
Desired time format. If None
, no conversion is applied, and time values
remain as float values in seconds. If 'ms'
, time values will be rounded
to the nearest millisecond and converted to integers. If 'timedelta'
,
time values will be converted to pandas.Timedelta
values. If 'datetime'
, time values will be converted to pandas.Timestamp
values, relative to raw.info['meas_date']
and offset by raw.first_samp
.
Default is None
.
New in version 0.20.
str
| int
| None
Control verbosity of the logging output. If None
, use the default
verbosity level. See the logging documentation and
mne.verbose()
for details. Should only be passed as a keyword
argument.
pandas.DataFrame
A dataframe suitable for usage with other statistical/plotting/analysis packages.
mne.io.RawArray
#Importing data from MEG devices
Importing data from fNIRS devices
EEG forward operator with a template MRI
Creating MNE-Python data structures from scratch
How to use data in neural ensemble (NEO) format
Simulate raw data using subject anatomy
Generate simulated source data
Identify EEG Electrodes Bridged by too much Gel
Visualise NIRS artifact correction methods
Receptive Field Estimation and Prediction