def print_nix(nixfname):
nf = nix.File(nixfname, mode=nix.FileMode.ReadOnly)
print(":: DATA ::")
print_nix_data(nf)
print(":: METADATA ::")
print_md(nf)
nf.close()
def write_raw_mne(nfname,
mneraw,
split_data_channels=False,
split_stimuli=False):
"""
Writes the provided Raw MNE structure to a NIX file with the given name.
:param nfname: Name for the NIX file to write to. Existing file will be
overwritten.
:param mneraw: An MNE Raw structure (any mne.io.BaseRaw subclass).
:param split_data_channels: If True, each raw data channel will be stored
in a separate DataArray.
:param split_stimuli: If True, stimuli will be split into separate
MultiTags based on the stimulus type (label).
:rtype: None
"""
mneinfo = mneraw.info
extrainfo = mneraw._raw_extras
# Create NIX file
print(nfname)
print(nix.FileMode.Overwrite)
nf = nix.File(nfname, nix.FileMode.Overwrite)
# Write Data to NIX
block = nf.create_block(DATA_BLOCK_NAME,
DATA_BLOCK_TYPE,
compression=nix.Compression.DeflateNormal)
block.create_group(RAW_DATA_GROUP_NAME, RAW_DATA_GROUP_TYPE)
if split_data_channels:
write_multi_da(mneraw, block)
else:
write_single_da(mneraw, block)
if mneraw.annotations:
write_stim_tags(mneraw, block, split_stimuli)
# Write metadata to NIX
# info dictionary
infomd = nf.create_section("Info", "File metadata")
create_md_tree(infomd, mneinfo, block)
# extras
if len(extrainfo) > 1:
for idx, emd_i in enumerate(extrainfo):
extrasmd = nf.create_section(f"Extras-{idx}",
"Raw Extras metadata")
create_md_tree(extrasmd, emd_i, block)
elif extrainfo:
extrasmd = nf.create_section("Extras", "Raw Extras metadata")
create_md_tree(extrasmd, extrainfo[0], block)
# all done
nf.close()
print(f"Created NIX file at '{nfname}'")
print("Done")
def test_double_conversion(self):
convert.nixwrite(self.odml_doc, 'tmp.nix')
nix_file = nix.File('tmp.nix')
convert.odmlwrite(nix_file, 'tmp.odml')
odml_doc = odml.fileio.load('tmp.odml')
for attr in document_attributes:
self.assertEqual(getattr(self.odml_doc, attr),
getattr(odml_doc, attr))
for sec in self.odml_doc.sections:
sec2 = odml_doc.sections[sec.name]
for attr in section_attributes:
self.assertEqual(getattr(sec, attr), getattr(sec2, attr))
for prop in sec.properties:
prop2 = sec2.properties[prop.name]
for attr in property_attributes:
self.assertEqual(getattr(prop, attr), getattr(prop2, attr))
def import_nix(nixfilename):
"""
Import a NIX file (generated with mne2nix.py) into an MNE Raw structure.
:param nixfilename: Path to the NIX file to be loaded.
:rtype: mne.io.RawArray
"""
nixfile = nix.File(nixfilename, mode=nix.FileMode.ReadOnly)
# root, ext = os.path.splitext(nixfilename)
# bvfilename = root + os.extsep + "vhdr"
# bvfile = mne.io.read_raw_brainvision(bvfilename, stim_channel=False)
# Create MNE Info object
infosec = nixfile.sections["Info"]
nchan = infosec["nchan"]
sfreq = infosec["sfreq"]
info = mne.create_info(nchan, sfreq)
nixinfodict = md_to_dict(infosec)
info.update(nixinfodict)
# Read raw data into MNE objects
datagroup = nixfile.blocks[DATA_BLOCK_NAME].groups[RAW_DATA_GROUP_NAME]
if len(datagroup.data_arrays) > 1:
# Data split: One DataArray per channel. Merging
nixrawdata = merge_data_arrays(datagroup.data_arrays)
else:
nixrawdata = datagroup.data_arrays[0][:]
# Create MNE RawArray
mnerawdata = mne.io.RawArray(nixrawdata, info)
# Add annotations: Stimuli from MultiTags
mtags = datagroup.multi_tags
annotations = create_mne_annotations(mtags)
mnerawdata.set_annotations(annotations)
nixfile.close()
return mnerawdata
def test_double_conversion(self):
nf = os.path.join(self.test_dir, 'tmp.nix')
of = os.path.join(self.test_dir, 'tmp.odml')
convert.nixwrite(self.odml_doc, nf, 'overwrite')
nix_file = nix.File(nf)
convert.odmlwrite(nix_file, of)
odml_doc = odml.load(of)
for attr in document_attributes:
self.assertEqual(getattr(self.odml_doc, attr), getattr(odml_doc, attr))
for sec in self.odml_doc.sections:
sec2 = odml_doc.sections[sec.name]
for attr in section_attributes:
self.assertEqual(getattr(sec, attr), getattr(sec2, attr))
for prop in sec.properties:
prop2 = sec2.properties[prop.name]
for attr in property_attributes:
self.assertEqual(getattr(prop, attr), getattr(prop2, attr))
nix_file.close()
def validate(filename):
nf = nix.File(filename, mode=nix.FileMode.ReadOnly)
results = nf.validate()
print("Results for '{}'".format(filename))
errors = results["errors"]
if errors:
plural = "s" if len(errors) > 1 else ""
print_header("{} object{} with errors".format(len(errors), plural))
for idx, (obj, messages) in enumerate(errors.items()):
print(" [{}] {}".format(idx+1, format_obj(obj)))
for msg in messages:
print(" {}".format(msg))
warnings = results["warnings"]
if warnings:
plural = "s" if len(warnings) > 1 else ""
print_header("{} object{} with warnings".format(len(warnings), plural))
for idx, (obj, messages) in enumerate(warnings.items()):
print(" [{}] {}".format(idx+1, format_obj(obj)))
for msg in messages:
print(" {}".format(msg))
print()
def do_merge(nixfname, odmlfname):
nf = nix.File(nixfname, mode=nix.FileMode.ReadWrite)
md = odml.load(odmlfname)
odmlnixsec = nf.create_section(odmlfname, "odML import")
write_recurse(md.sections, odmlnixsec)
nf.close()
import sys
import matplotlib.pyplot as plt
import nixio as nix
fname = sys.argv[1]
nixfile = nix.File(fname, mode=nix.FileMode.ReadOnly)
block = nixfile.blocks[0]
# plot all signals
data = block.data_arrays["EEG Data"]
time = data.dimensions[1].ticks
for idx, row in enumerate(data):
plt.plot(time, row + idx * 0.001)
stim = block.multi_tags["Stimuli"]
for idx, p in enumerate(stim.positions):
if stim.positions.dimensions[0].labels[idx] == "Stimulus/S 2":
plt.plot([p, p], [0, len(data) * 0.001], "k")
plt.show()
nixfile.close()