def events(vhdr_path=None):
if vhdr_path is None:
vhdr_path = ui.ask_file("Pick a Brain Vision EEG Header File",
"Pick a Brain Vision EEG Header File",
ext=[('vhdr', 'Brain Vision Header File')])
if not vhdr_path:
return
hdr = vhdr(vhdr_path)
if hdr.markerfile is None:
raise IOError("No marker file referenced in %r" % vhdr_path)
elif hdr.DataType == 'FREQUENCYDOMAIN':
raise NotImplementedError
txt = open(hdr.markerfile).read()
m = marker_re.findall(txt)
m = np.array(m)
name, _ = os.path.split(os.path.basename(hdr.path))
ds = dataset(name=name)
ds['Mk'] = var(np.array(m[:,0], dtype=int))
ds['event_type'] = factor(m[:,1])
ds['event_ID'] = var(np.array(m[:,3], dtype=int))
ds['i_start'] = var(np.array(m[:,4], dtype=int))
ds['points'] = var(np.array(m[:,5], dtype=int))
ds['channel'] = var(np.array(m[:,6], dtype=int))
ds.info['hdr'] = hdr
ds.info['samplingrate'] = hdr.samplingrate
return ds
def fiff_events(source_path=None, name=None):
"""
Returns a dataset containing events from a raw fiff file. Use
:func:`fiff_epochs` to load MEG data corresponding to those events.
source_path : str (path)
the location of the raw file (if ``None``, a file dialog will be
displayed).
name : str
A name for the dataset.
"""
if source_path is None:
source_path = ui.ask_file("Pick a Fiff File", "Pick a Fiff File",
ext=[('fif', 'Fiff')])
if name is None:
name = os.path.basename(source_path)
raw = mne.fiff.Raw(source_path)
events = mne.find_events(raw)
if any(events[:,1] != 0):
raise NotImplementedError("Events starting with ID other than 0")
# this was the case in the raw-eve file, which contained all event
# offsets, but not in the raw file created by kit2fiff. For handling
# see :func:`fiff_event_file`
istart = _data.var(events[:,0], name='i_start')
event = _data.var(events[:,2], name='eventID')
info = {'source': source_path}
return _data.dataset(event, istart, name=name, info=info)
def OnFindPath(self, event=None):
filenames = ui.ask_file(wildcard='', mult=True)
if filenames:
if len(filenames) == 1:
filenames = '"'+filenames[0]+'"'
else:
filenames = str(filenames)
self.shell.ReplaceSelection(filenames)
def import_pickled(self, path=None):
"Imports the values from a pickled python object."
if path is None:
path = ui.ask_file(title="Import Parameter Values",
message="Select a file that contains the pickle parameter values:",
ext=[('pickled', "pickled Python object")])
with open(path, 'r') as f:
self._value.update(pickle.load(f))
def FileOpen(self, path=None, internal_call=False):
if path is None:
path = ui.ask_file(title="Open File",
message="Open a Python script in an editor",
ext=[('py', 'Python script')])
if not path:
return
if isinstance(path, basestring) and os.path.isfile(path):
ext = path.split(os.extsep)[-1].lower()
if ext == 'py':
self.create_py_editor(pyfile=path)
else:
msg = "Error: %r is no known file extension." % ext
self.shell_message(msg, internal_call=internal_call)
else:
msg = "No valid file path: %r" % path
self.shell_message(msg, internal_call=internal_call)
def REJECTION_IMPORT(self, fn=None):
if fn is None:
fn = ui.ask_file(wildcard = "pickled file (*.pickled)|*.pickled")
if os.path.exists(fn):
with open(fn, 'r') as f:
rej = pickle.load(f)
safety = rej.pop('safety')
for s in self.segments:
if s.name != safety[s.id]:
raise IOError("segment mismatch!")
remove = []
for id, d in rej.iteritems():
try:
int(id)
if len(d) > 0:
self.delete_cache(id)
except:
remove.append(id)
print "Dict contained invalid item: {k}: {v}".format(k=id, v=d)
[rej.pop(id) for id in remove]
self._reject_dict = rej
def __init__(self, path=None):
"""
Parameters
----------
path : str(path) | None
Path to the .edf file. The If path contains '*', the files matching
the pattern are concatenated. If None, a file-open dialogue will be
displayed.
"""
if path is None:
path = ui.ask_file("Load an eyelink .edf file", "Pick the edf file",
ext=[('edf', 'eyelink data format')])
# find all paths from which to read
self.path = path
if '*' in path:
head, tail = os.path.split(path)
if '*' in head:
err = ("Invalid path: %r. All edf files need to be in the same "
"directory." % path)
raise ValueError(err)
fnames = sorted(fnmatch.filter(os.listdir(head), tail))
self.paths = [os.path.join(head, fname) for fname in fnames]
else:
self.paths = [path]
triggers = []
artifacts = []
for path in self.paths:
edf = subp.edf_file(path)
triggers += edf.triggers
artifacts += edf.artifacts
dtype = [('T', np.uint32), ('Id', np.uint8)]
self.triggers = np.array(triggers, dtype=dtype)
dtype = np.dtype([('event', np.str_, 6), ('start', np.uint32), ('stop', np.uint32)])
self.artifacts = np.array(artifacts, dtype=dtype)
def OnInsertPath(self, event, t=None):
if t is None:
t = event.GetSelection()
# get
if t == 0: # File
filenames = ui.ask_file(mult=True)
elif t == 1: # Dir
filenames = ui.ask_dir()
elif t == 2: # New
filenames = ui.ask_saveas(title = "Get New File Name",
message = "Please Pick a File Name",
ext = None)
# put to terminal
if filenames:
if len(filenames) == 1:
filenames = '"'+filenames[0]+'"'
else:
filenames = '"'+str(filenames)+'"'
if 'wxMSW' in wx.PlatformInfo:
filenames = 'r'+filenames
self.InsertStr(filenames)
def var(path=None, name=None):
"""
Loads a ``var`` object from a text file by splitting at white-spaces.
path : str(path) | None
Source file. If None, a system file dialog is opened.
name : str | None
Name for the var.
"""
if path is None:
path = ui.ask_file("Select var File", "()")
FILE = open(path)
lines = FILE.read().split()
FILE.close()
is_bool = all(line in ['True', 'False'] for line in lines)
if is_bool:
x = np.genfromtxt(path, dtype=bool)
else:
x = np.loadtxt(path)
return _data.var(x, name=None)
def Raw(path=None, proj=False, **kwargs):
"""
Returns a mne.fiff.Raw object with added projections if appropriate.
Parameters
----------
path : None | str(path)
path to the raw fiff file. If ``None``, a file can be chosen form a
file dialog.
proj : bool | str(path)
Add projections from a separate file to the Raw object.
**``False``**: No proj file will be added.
**``True``**: ``'{raw}*proj.fif'`` will be used.
``'{raw}'`` will be replaced with the raw file's path minus '_raw.fif',
and '*' will be expanded using fnmatch. If multiple files match the
pattern, a ValueError will be raised.
**``str``**: A custom path template can be provided, ``'{raw}'`` and
``'*'`` will be treated as with ``True``.
kwargs
Additional keyword arguments are forwarded to mne.fiff.Raw
initialization.
"""
if path is None:
path = ui.ask_file("Pick a Raw Fiff File", "Pick a Raw Fiff File",
ext=[('fif', 'Fiff')])
if not path:
return
if not os.path.isfile(path):
raise IOError("%r is not a file" % path)
raw = mne.fiff.Raw(path, **kwargs)
if proj:
if proj == True:
proj = '{raw}*proj.fif'
if '{raw}' in proj:
raw_file = raw.info['filename']
raw_root, _ = os.path.splitext(raw_file)
raw_root = raw_root.rstrip('raw')
proj = proj.format(raw=raw_root)
if '*' in proj:
head, tail = os.path.split(proj)
names = fnmatch.filter(os.listdir(head), tail)
if len(names) == 1:
proj = os.path.join(head, names[0])
else:
if len(names) == 0:
err = "No file matching %r"
else:
err = "Multiple files matching %r"
raise ValueError(err % proj)
# add the projections to the raw file
proj = mne.read_proj(proj)
raw.add_proj(proj, remove_existing=True)
return raw
def tsv(path=None, names=True, types='auto', empty='nan', delimiter=None,
skiprows=0):
"""
returns a ``dataset`` with data from a tab-separated values file.
Parameters
----------
names : list of str | bool
* ``['name1', ...]`` use these names
* ``True``: look for names on the first line of the file
* ``False``: use "v1", "v2", ...
types : 'auto' | list of int
* ``'auto'`` -> import as var if all values can be converted float,
otherwise as factor
* list of 0=auto, 1=factor, 2=var. e.g. ``[0,1,1,0]``
empty :
value to substitute for empty cells
delimiter : str
value delimiting cells in the input file (None = any whitespace;
e.g., ``'\\t'``)
skiprows : int
Skip so many rows at the beginning of the file (for tsv files with
headers). Column names (if names==True) are expected to come after
the skipped rows.
"""
if path is None:
path = ui.ask_file("Select file to import as dataframe",
"Select file to import as dataframe")
if not path:
return
with open(path) as f:
for i in xrange(skiprows):
f.readline()
# read / create names
if names == True:
names = f.readline().split(delimiter)
names = [n.strip().strip('"') for n in names]
lines = []
for line in f:
values = []
for v in line.split(delimiter):
v = v.strip()
if not v:
v = empty
values.append(v)
lines.append(values)
n_vars = len(lines[0])
if not names:
names = ['v%i' % i for i in xrange(n_vars)]
n = len(names)
# decide whether to drop first column
if n_vars == n:
start = 0
elif n_vars == n + 1:
start = 1
else:
raise ValueError("number of header different from number of data")
if types in ['auto', None, False, True]:
types = [0] * n
else:
assert len(types) == n
# prepare for reading data
data = []
for _ in xrange(n):
data.append([])
# read rest of the data
for line in lines:
for i, v in enumerate(line[start:]):
for str_del in ["'", '"']:
if v[0] == str_del:
v = v.strip(str_del)
types[i] = 1
data[i].append(v)
ds = _data.dataset(name=os.path.basename(path))
for name, values, force_type in zip(names, data, types):
v = np.array(values)
if force_type in [0, 2]:
try:
v = v.astype(float)
f = _data.var(v, name=name)
except:
f = _data.factor(v, name=name)
else:
f = _data.factor(v, name=name)
ds.add(f)
return ds
def __init__(self, path=None):
"""
Reads a .vhdr file and returns its content as a dictionary
The .markerfile and .datafile attributes provide absolute paths to those
files.
"""
if path is None:
path = ui.ask_file("Pick a Brain Vision EEG Header File",
"Pick a Brain Vision EEG Header File",
ext=[('vhdr', 'Brain Vision Header File')])
if not path:
raise RuntimeError("User Canceled")
kv_re = re.compile('^(\w+)=(.+)', re.MULTILINE)
hdr_section = {}
with open(path) as FILE:
if not FILE.readline().startswith(vhdr_hdr):
err = ("Not a brain vision vhdr file: %r (needs to start with"
" %r" % (path, vhdr_hdr))
raise IOError(err)
for line in FILE:
m = section_re.match(line)
if m:
name = m.group(1)
hdr_section = self[name] = {}
else:
m = kv_re.match(line)
if m:
key = m.group(1)
value = m.group(2).strip()
hdr_section[key] = value
self.path = path
info = self['Common Infos']
# paths
self.dirname, self.basename = os.path.split(path)
datafile = info['DataFile']
if os.path.isabs(datafile):
self.datafile = datafile
else:
self.datafile = os.path.join(self.dirname, datafile)
if 'MarkerFile' in info:
markerfile = info['MarkerFile']
if os.path.isabs(markerfile):
self.markerfile = markerfile
else:
self.markerfile = os.path.join(self.dirname, markerfile)
else:
self.markerfile = None
# other info
self.DataFormat = info.get('DataFormat', 'ASCII')
self.DataOrientation = info.get('DataOrientation', 'MULTIPLEXED')
self.DataType = info.get('DataType', 'TIMEDOMAIN')
self.NumberOfChannels = int(info['NumberOfChannels'])
self.samplingrate = 1e6 / float(info['SamplingInterval'])
