1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
"""
.. _tut_creating_data_structures:
Creating MNE's data structures from scratch
===========================================
MNE provides mechanisms for creating various core objects directly from
NumPy arrays.
"""
import mne
import numpy as np
###############################################################################
# ------------------------------------------------------
# Creating :class:`Info <mne.Info>` objects
# ------------------------------------------------------
#
# .. note:: for full documentation on the `Info` object, see
# :ref:`tut_info_objects`. See also
# :ref:`sphx_glr_auto_examples_io_plot_objects_from_arrays.py`.
#
# Normally, :class:`mne.Info` objects are created by the various
# :ref:`data import functions <ch_convert>`.
# However, if you wish to create one from scratch, you can use the
# :func:`mne.create_info` function to initialize the minimally required
# fields. Further fields can be assigned later as one would with a regular
# dictionary.
#
# The following creates the absolute minimum info structure:
# Create some dummy metadata
n_channels = 32
sampling_rate = 200
info = mne.create_info(n_channels, sampling_rate)
print(info)
###############################################################################
# You can also supply more extensive metadata:
# Names for each channel
channel_names = ['MEG1', 'MEG2', 'Cz', 'Pz', 'EOG']
# The type (mag, grad, eeg, eog, misc, ...) of each channel
channel_types = ['grad', 'grad', 'eeg', 'eeg', 'eog']
# The sampling rate of the recording
sfreq = 1000 # in Hertz
# The EEG channels use the standard naming strategy.
# By supplying the 'montage' parameter, approximate locations
# will be added for them
montage = 'standard_1005'
# Initialize required fields
info = mne.create_info(channel_names, sfreq, channel_types, montage)
# Add some more information
info['description'] = 'My custom dataset'
info['bads'] = ['Pz'] # Names of bad channels
print(info)
###############################################################################
# .. note:: When assigning new values to the fields of an
# :class:`mne.Info` object, it is important that the
# fields are consistent:
#
# - The length of the channel information field `chs` must be
# `nchan`.
# - The length of the `ch_names` field must be `nchan`.
# - The `ch_names` field should be consistent with the `name` field
# of the channel information contained in `chs`.
#
# ---------------------------------------------
# Creating :class:`Raw <mne.io.Raw>` objects
# ---------------------------------------------
#
# To create a :class:`mne.io.Raw` object from scratch, you can use the
# :class:`mne.io.RawArray` class, which implements raw data that is backed by a
# numpy array. The correct units for the data are:
#
# - V: eeg, eog, seeg, emg, ecg, bio, ecog
# - T: mag
# - T/m: grad
# - M: hbo, hbr
# - Am: dipole
# - AU: misc
#
# The :class:`mne.io.RawArray` constructor simply takes the data matrix and
# :class:`mne.Info` object:
# Generate some random data
data = np.random.randn(5, 1000)
# Initialize an info structure
info = mne.create_info(
ch_names=['MEG1', 'MEG2', 'EEG1', 'EEG2', 'EOG'],
ch_types=['grad', 'grad', 'eeg', 'eeg', 'eog'],
sfreq=100
)
custom_raw = mne.io.RawArray(data, info)
print(custom_raw)
###############################################################################
# ---------------------------------------------
# Creating :class:`Epochs <mne.Epochs>` objects
# ---------------------------------------------
#
# To create an :class:`mne.Epochs` object from scratch, you can use the
# :class:`mne.EpochsArray` class, which uses a numpy array directly without
# wrapping a raw object. The array must be of `shape(n_epochs, n_chans,
# n_times)`. The proper units of measure are listed above.
# Generate some random data: 10 epochs, 5 channels, 2 seconds per epoch
sfreq = 100
data = np.random.randn(10, 5, sfreq * 2)
# Initialize an info structure
info = mne.create_info(
ch_names=['MEG1', 'MEG2', 'EEG1', 'EEG2', 'EOG'],
ch_types=['grad', 'grad', 'eeg', 'eeg', 'eog'],
sfreq=sfreq
)
###############################################################################
# It is necessary to supply an "events" array in order to create an Epochs
# object. This is of `shape(n_events, 3)` where the first column is the sample
# number (time) of the event, the second column indicates the value from which
# the transition is made from (only used when the new value is bigger than the
# old one), and the third column is the new event value.
# Create an event matrix: 10 events with alternating event codes
events = np.array([
[0, 0, 1],
[1, 0, 2],
[2, 0, 1],
[3, 0, 2],
[4, 0, 1],
[5, 0, 2],
[6, 0, 1],
[7, 0, 2],
[8, 0, 1],
[9, 0, 2],
])
###############################################################################
# More information about the event codes: subject was either smiling or
# frowning
event_id = dict(smiling=1, frowning=2)
###############################################################################
# Finally, we must specify the beginning of an epoch (the end will be inferred
# from the sampling frequency and n_samples)
# Trials were cut from -0.1 to 1.0 seconds
tmin = -0.1
###############################################################################
# Now we can create the :class:`mne.EpochsArray` object
custom_epochs = mne.EpochsArray(data, info, events, tmin, event_id)
print(custom_epochs)
# We can treat the epochs object as we would any other
_ = custom_epochs['smiling'].average().plot(time_unit='s')
###############################################################################
# ---------------------------------------------
# Creating :class:`Evoked <mne.Evoked>` Objects
# ---------------------------------------------
# If you already have data that is collapsed across trials, you may also
# directly create an evoked array. Its constructor accepts an array of
# `shape(n_chans, n_times)` in addition to some bookkeeping parameters.
# The proper units of measure for the data are listed above.
# The averaged data
data_evoked = data.mean(0)
# The number of epochs that were averaged
nave = data.shape[0]
# A comment to describe to evoked (usually the condition name)
comment = "Smiley faces"
# Create the Evoked object
evoked_array = mne.EvokedArray(data_evoked, info, tmin,
comment=comment, nave=nave)
print(evoked_array)
_ = evoked_array.plot(time_unit='s')
|
