dataset: avima

README.md

@@ -1,19 +1,38 @@
 # EEGprep
 Standardized EEG preprocessing
 
+[![https://www.singularity-hub.org/static/img/hosted-singularity--hub-%23e32929.svg](https://www.singularity-hub.org/static/img/hosted-singularity--hub-%23e32929.svg)](https://singularity-hub.org/collections/3833)
+
 
 ## Singularity
 
-Build the EEGprep singularity image:
+Download the EEGprep singularity image:
 ```
-sudo singularity build eegprep.simg Singularity
+singularity pull --name eegprep.simg shub://Charestlab/eegprep
 ```
 
 Run EEGprep on your data:
 ```
 singularity run -c -e --bind /your/data/dir/:/data eegprep.simg
 ```
-where /your/data/dir/ contains a *BIDS* folder.
+
+## Commandline
+
+You can run eegprep on the commandline. Start by running `eegprep -h` and you'll see:
+```
+usage: eegprep [-h] [-s SUBJECT_INDEX] [-l SUBJECT_LABEL] [data_directory]
+
+positional arguments:
+  data_directory        root data directory
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -s SUBJECT_INDEX, --subject-index SUBJECT_INDEX
+                        index of subject to work on when sorted alphabetically
+  -l SUBJECT_LABEL, --subject-label SUBJECT_LABEL
+                        label of subject to work on
+
+```
 
 ## Configuration
 

Singularity

@@ -11,10 +11,10 @@ From: python:3.7
     dist/eegprep-0.1.tar.gz .
 
 %post
-    pip install numpy ipython
-    pip install --no-cache-dir -U https://api.github.com/repos/mne-tools/mne-python/zipball/master#egg=mne
-    pip install --no-cache-dir -U https://api.github.com/repos/autoreject/autoreject/zipball/master#egg=autoreject
     pip install eegprep-0.1.tar.gz
 
 %runscript
     exec eegprep
+
+%labels
+    Version 0.1

eegprep/args.py

@@ -0,0 +1,24 @@
+from argparse import ArgumentParser
+
+
+def parse_arguments(args=None):
+    """Parse commandline parameters
+
+    Args:
+        args (str, optional): String of arguments, for testing purposes only. 
+            Defaults to None.
+
+    Returns:
+        Namespace: Object with parsed arguments as properties
+    """
+    parser = ArgumentParser()
+    parser.add_argument('data_directory', type=str, nargs='?', default='/data',
+        help='root data directory')
+    parser.add_argument('--dry-run', action='store_true', 
+        help='rshow assembled pipeline but do not run analyses or store files')
+    subject = parser.add_mutually_exclusive_group()
+    subject.add_argument('-s', '--subject-index', type=int,
+        help='index of subject to work on, when sorted alphabetically')
+    subject.add_argument('-l', '--subject-label', type=str,
+        help='label of subject to work on')
+    return parser.parse_args(args)

eegprep/configuration.py

@@ -1,4 +1,18 @@
+"""[summary]
 
+Previously used like:
+
+    # print('data directory: {}'.format(datadir))
+    # conf_file_path = join(datadir, 'eegprep.conf')
+    # config = Configuration()
+    # config.setDefaults(defaults)
+    # if os.path.isfile(conf_file_path):
+    #     with open(conf_file_path) as fh:
+    #         conf_string = fh.read()
+    #     config.updateFromString(conf_string)
+    # print('configuration:')
+    # print(config)
+"""
 
 class Configuration(object):
 

eegprep/input_output.py

@@ -0,0 +1,130 @@
+from bids import BIDSLayout
+import copy
+from os.path import join, dirname, isdir
+from os import makedirs
+
+
+class InputOutput(object):
+
+    def __init__(self, log, memory, root_dir, scope=None, layout=None):
+        self.log = log
+        self.memory = memory
+        self.root_dir = root_dir
+        self._layout = layout or None
+        self.scope = scope or dict()
+
+    @property
+    def layout(self):
+        """pyBIDS layout object, lazily loaded.
+
+        If the layout has not been created yet, it will
+        be done here, which takes time (<1min) for larger datasets.
+
+        Returns:
+            bids.BIDSLayout: The BIDS layout object
+        """
+        if self._layout is None:
+            self.log.discovering_data()
+            self._layout = BIDSLayout(self.root_dir)
+        return self._layout
+
+    def describe_scope(self):
+        return ' '.join([f'{k[:3]}={v}' for k, v in self.scope.items()])
+
+    def for_(self, subject=None, session=None, run=None):
+        new_scope = copy.copy(self.scope)
+        filters = dict(subject=subject, session=session, run=run)
+        for spec, val in filters.items():
+            if val is not None:
+                new_scope[spec] = val
+        return InputOutput(
+            self.log,
+            self.memory,
+            self.root_dir,
+            new_scope,
+            self.layout
+        )
+
+    def get_subject_labels(self):
+        subjects = self.layout.get(
+            return_type='id',
+            target='subject',
+            datatype='eeg'
+        )
+        self.log.found_subjects(subjects)
+        return subjects
+
+    def get_session_labels(self):
+        return self.layout.get(
+            return_type='id',
+            target='session',
+            datatype='eeg',
+            **self.scope
+        )
+
+    def get_run_labels(self):
+        return self.layout.get(
+            return_type='id', 
+            target='run',
+            datatype='eeg',
+            **self.scope
+        )
+
+    def get_filepath(self, suffix):
+        fpaths = self.layout.get(
+            return_type='filename',
+            suffix=suffix,
+            datatype='eeg',
+            **self.scope
+        )
+        fpaths = [f for f in fpaths if '.json' not in f]
+        assert len(fpaths) == 1
+        return fpaths[0]
+
+    def store_object(self, obj, name, job):
+        # first delete existing copies (overwriting)
+        self.memory.delete(name=name, **self.scope)
+        identifiers = dict(name=name, job=job.get_id(), **self.scope)
+        self.memory.store(obj, **identifiers)
+
+    def retrieve_objects(self, name):
+        filters = dict(name=name, **self.scope)
+        return self.memory.find(**filters)
+
+    def retrieve_object(self, name):
+        objects = self.retrieve_objects(name)
+        assert len(objects) == 1
+        return objects[0]
+
+    def expire_output_of(self, job):
+        self.memory.delete(job=job.get_id(), **self.scope)
+
+    def write_output_of(self, job):
+        keys = self.memory.find_matching_keys(job=job.get_id(), **self.scope)
+        for key in keys:
+            name = dict(key)['name']
+            self.write_object(name, self.memory.get(key))
+
+    def write_object(self, name, obj):
+        fpath = self.build_fpath(suffix=name, ext='fif')
+        self.ensure_dir(dirname(fpath))
+        self.log.writing_object(obj, fpath)
+        obj.save(fpath)
+
+    def ensure_dir(self, dirpath):
+        if not isdir(dirpath):
+            makedirs(dirpath)
+
+    def build_fpath(self, suffix, ext):
+        outdir = join(self.root_dir, 'derivatives', 'eegprep')
+        for entity in ('subject', 'session'):
+            if entity in self.scope:
+                label = self.scope[entity]
+                outdir = join(outdir, f'{entity[:3]}-{label}')
+        fname = ''
+        for entity in ('subject', 'session'):
+            if entity in self.scope:
+                label = self.scope[entity]
+                fname += f'{entity[:3]}-{label}_'
+        fname += f'{suffix}.{ext}'
+        return join(outdir, fname)

eegprep/jobs/base.py

@@ -0,0 +1,43 @@
+
+
+class BaseJob(object):
+
+    def __init__(self, io, log):
+        self.io = io
+        self.log = log
+        self.jobs_to_expire = []
+        self.jobs_to_write = []
+
+    def get_id(self):
+        return self.__class__.__name__.replace('Job', '')
+
+    def describe(self):
+        """Return a string that describes this job
+
+        Returns:
+            str: one-line string describing this job and it's scope
+        """
+        scope = self.io.describe_scope()
+        return scope + ' ' + self.get_id()
+
+    def add_to(self, pipeline):
+        self.add_children_to(pipeline)
+        pipeline.add(self)
+
+    def add_children_to(self, pipeline):
+        pass
+
+    def run(self):
+        pass
+
+    def cleanup(self):
+        for job in self.jobs_to_write:
+            self.io.write_output_of(job)
+        for job in self.jobs_to_expire:
+            self.io.expire_output_of(job)
+
+    def expire_output_on_cleanup(self, job):
+        self.jobs_to_expire.append(job)
+
+    def write_output_on_cleanup(self, job):
+        self.jobs_to_write.append(job)

eegprep/jobs/concat_epochs.py

@@ -0,0 +1,10 @@
+from eegprep.jobs.base import BaseJob
+import mne
+
+
+class ConcatEpochsJob(BaseJob):
+
+    def run(self):
+        epochs_per_run = self.io.retrieve_objects('epo')
+        epochs = mne.epochs.concatenate_epochs(epochs_per_run)
+        self.io.store_object(epochs, name='epo', job=self)

eegprep/jobs/epoch.py

@@ -0,0 +1,20 @@
+from eegprep.jobs.base import BaseJob
+import mne
+
+
+class EpochJob(BaseJob):
+
+    def run(self):
+        raw = self.io.retrieve_object('raw')
+        # additional options: consecutive=False, min_duration=0.005)
+        events = mne.find_events(raw, verbose=False)
+        picks = mne.pick_types(raw.info, eeg=True)
+        epochs_params = dict(
+            events=events,
+            tmin=-0.2,
+            tmax=3.1,
+            picks=picks,
+            verbose=False
+        )
+        epochs = mne.Epochs(raw, preload=True, **epochs_params)
+        self.io.store_object(epochs, name='epo', job=self)

eegprep/jobs/filter.py

@@ -0,0 +1,9 @@
+from eegprep.jobs.base import BaseJob
+
+
+class FilterJob(BaseJob):
+
+    def run(self):
+        raw = self.io.retrieve_object('raw')
+        raw.filter(l_freq=0.05, h_freq=45, fir_design='firwin')
+        self.io.store_object(raw, name='raw', job=self)

eegprep/jobs/read.py

@@ -0,0 +1,46 @@
+import mne, pandas
+from eegprep.jobs.base import BaseJob
+from eegprep.guess import guess_montage
+
+
+class ReadJob(BaseJob):
+
+    def run(self):
+
+        fpath_raw = self.io.get_filepath(suffix='eeg')
+        ext = fpath_raw[-3:]
+        raw_funcs = {
+            'bdf': mne.io.read_raw_bdf,
+            'edf': mne.io.read_raw_edf
+        }
+        raw = raw_funcs[ext](fpath_raw, preload=True, verbose=False)
+
+        # Set channel types and select reference channels
+        fpath_channels = self.io.get_filepath(suffix='channels')
+        channels = pandas.read_csv(fpath_channels, index_col='name', sep='\t')
+        bids2mne = {
+            'MISC': 'misc',
+            'EEG': 'eeg',
+            'EOG': 'eog',
+            'VEOG': 'eog',
+            'TRIG': 'stim',
+            'REF': 'eeg',
+        }
+        channels['mne'] = channels.type.replace(bids2mne)
+        raw.set_channel_types(channels.mne.to_dict())
+
+        # set bad channels
+        # raw.info['bads'] = channels[channels.status=='bad'].index.tolist()
+
+         # Set reference
+        refChannels = channels[channels.type=='REF'].index.tolist()     
+        raw.set_eeg_reference(ref_channels=refChannels) 
+        # can now drop reference electrodes
+        raw.set_channel_types({k: 'misc' for k in refChannels})
+
+        # tell MNE about electrode locations
+        montageName = guess_montage(raw.ch_names)
+        montage = mne.channels.make_standard_montage(kind=montageName)
+        raw.set_montage(montage, verbose=False)
+
+        self.io.store_object(raw, name='raw', job=self)