eegprep 0.0.2__py3-none-any.whl

eegprep/ICL_feature_extractor.py

@@ -0,0 +1,90 @@
+import numpy as np
+from .topoplot import topoplot
+from .eeg_rpsd import eeg_rpsd
+from .eeg_autocorr_welch import eeg_autocorr_welch
+from .eeg_autocorr import eeg_autocorr
+from .eeg_autocorr_fftw import eeg_autocorr_fftw
+from .pop_reref import pop_reref
+
+def ICL_feature_extractor(EEG, flag_autocorr=False):
+
+    # Check inputs
+    ncomp = EEG['icawinv'].shape[1]
+
+    # Check for ICA key and if it is not empty
+    if not 'icawinv' in EEG.keys() or EEG['icawinv'].size == 0:
+        raise ValueError('You must have an ICA decomposition to use ICLabel')
+
+    # Assuming chanlocs are correct
+    if EEG['ref'] != 'average' and EEG['ref'] != 'averef':
+        EEG = pop_reref(EEG, []) #, exclude=list(set(range(EEG.nbchan)) - set(EEG.icachansind)))
+        # raise ValueError('Data must be rereferenced to average to use ICLabel')
+        # EEG = pop_reref(EEG, [], exclude=list(set(range(EEG.nbchan)) - set(EEG.icachansind)))
+
+    # Calculate ICA activations if missing and cast to double
+    if EEG['icaact'] is None:
+        raise ValueError('You must have ICA activations to use ICLabel')
+        # EEG['icaact'] = eeg_getica(EEG)
+        
+    EEG['icaact'] = EEG['icaact'].astype(float)
+
+    # Check ICA is real
+    assert np.isreal(EEG['icaact']).all(), 'Your ICA decomposition must be real to use ICLabel'
+
+    # Calculate topo
+    topo = np.zeros((32, 32, 1, ncomp))
+    for it in range(ncomp):
+        _, temp_topo, _, _, _ = topoplot(EEG['icawinv'][:, it], EEG['chanlocs'][EEG['icachansind']], noplot='on')
+        temp_topo[np.isnan(temp_topo)] = 0
+        topo[:, :, 0, it] = temp_topo / np.max(np.abs(temp_topo))
+
+    # Cast
+    topo = topo.astype(np.float32)
+
+    # Calculate PSD
+    psd = eeg_rpsd(EEG, 100)
+
+    # Extrapolate or prune as needed
+    nfreq = psd.shape[1]
+    if nfreq < 100:
+        psd = np.hstack((psd, np.tile(psd[:, -1][:, np.newaxis], (1, 100 - nfreq))))
+
+    # Undo notch filter
+    for linenoise_ind in [50, 60]:
+        linenoise_around = [linenoise_ind - 1, linenoise_ind + 1]
+        difference = psd[:, linenoise_around] - psd[:, linenoise_ind][:, np.newaxis]
+        notch_ind = np.all(difference > 5, axis=1)
+        if np.any(notch_ind):
+            psd[notch_ind, linenoise_ind] = np.mean(psd[notch_ind][:, linenoise_around], axis=1)
+
+    # Normalize
+    psd = psd / np.max(np.abs(psd), axis=1)[:, np.newaxis]
+
+    psd = np.transpose(np.expand_dims(np.expand_dims(psd, axis=-1), axis=-1), (2, 1, 3, 0)).astype(np.float32)
+
+    # Calculate autocorrelation
+    if flag_autocorr:
+        if EEG['trials'] == 1:
+            if EEG['pnts'] / EEG['srate'] > 5:
+                autocorr = eeg_autocorr_welch(EEG)
+            else:
+                autocorr = eeg_autocorr(EEG)
+        else:
+            autocorr = eeg_autocorr_fftw(EEG)
+
+        # Reshape and cast
+        autocorr = np.transpose(np.expand_dims(np.expand_dims(autocorr, axis=-1), axis=-1), (2, 1, 3, 0)).astype(np.float32)
+
+    # Format outputs
+    if flag_autocorr:
+        features = [0.99 * topo, 0.99 * psd, 0.99 * autocorr]
+    else:
+        features = [0.99 * topo, 0.99 * psd]
+        
+    return features
+
+def test_ICL_feature_extractor():
+    flag_autocorr = True
+    EEG = EEG2
+    EEG['ref'] = 'averef'
+    EEG['chanlocs'] = np.random.randn(32, 3)

eegprep/ICL_feature_extractor_compare_helper.py

@@ -0,0 +1,19 @@
+from ICL_feature_extractor import ICL_feature_extractor
+from pop_loadset import pop_loadset
+import sys
+
+# check if a parameter is present and if it is assign eeglab_file_path to it
+if len(sys.argv) > 1:
+    eeglab_file_path = sys.argv[1]
+else:
+    eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+    eeglab_file_path = '/Users/arno/Downloads/STUDYstern/S01/Memorize.set'
+EEG = pop_loadset(eeglab_file_path)
+
+# Print the loaded data
+res = ICL_feature_extractor(EEG, True)
+
+# save in a matlab file
+import scipy.io
+scipy.io.savemat('python_temp.mat', {'grid': res})
+print('Saved python_temp.mat')

eegprep/__init__.py

@@ -0,0 +1 @@
+from .iclabel import iclabel

eegprep/eeg_autocorr.py

@@ -0,0 +1,61 @@
+import numpy as np
+from scipy.signal import resample_poly
+from numpy.fft import fft, ifft
+
+def eeg_autocorr(EEG, pct_data=None):
+    if pct_data is None:
+        pct_data = 100
+
+    # convert EEG['icaact'] to single precision
+    EEG['icaact'] = EEG['icaact'].astype(np.float32)
+
+    ncomp = EEG['icaact'].shape[0]
+    nfft = 2**np.ceil(np.log2(2 * EEG['pnts'] - 1)).astype(int)
+
+    # Calculate autocorrelation
+    c = np.zeros((ncomp, nfft))
+    for it in range(ncomp):
+        comp = EEG['icaact'][it,:].reshape(-1)
+        Xtmp = fft(comp, nfft)
+        Xtmp = Xtmp.astype(np.complex64) # matches MATLAB's single precision since python convert to double precision by default
+        X = np.abs(Xtmp)**2
+        c[it, :] = np.real(ifft(X))
+
+    # Adjust the size of the autocorrelation to match sampling rate
+    if EEG['pnts'] < EEG['srate']:
+        ac = np.hstack([c[:, :EEG['pnts']], np.zeros((ncomp, EEG['srate'] - EEG['pnts'] + 1))])
+    else:
+        ac = c[:, :EEG['srate'] + 1]
+
+    # Normalize by the 0-tap of the autocorrelation
+    ac /= ac[:, [0]]
+
+    # Resample to 1 second at 100 samples/sec
+
+    # print the size of the second dim of ac
+    ac = resample_poly(ac.T, up=100, down=EEG['srate']).T
+    ac = ac[:, 1:]
+    
+    return ac
+
+def test_eeg_autocorr():
+    EEG = {
+        'srate': 256,
+        'icaweights': np.random.randn(10, 256),
+        'pnts': 1000,
+        'trials': 5,
+        'icaact': np.random.randn(10, 1000, 5)
+    }
+    
+    psdmed = eeg_autocorr(EEG, 100)
+    
+    # print information about psdmed
+    print(psdmed.shape)
+    
+    #print(psdmed)
+    
+    
+    #assert psdmed.shape == (10, 100)
+    #assert np.all(np.isfinite(psdmed))
+
+test_eeg_autocorr()

eegprep/eeg_autocorr_compare_helper.py

@@ -0,0 +1,13 @@
+from eeg_autocorr import eeg_autocorr
+from pop_loadset import pop_loadset
+
+eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+EEG = pop_loadset(eeglab_file_path)
+
+# Print the loaded data
+res = eeg_autocorr(EEG, 100)
+
+# save in a matlab file
+import scipy.io
+scipy.io.savemat('eeg_autocorr_data.mat', {'grid': res})
+print('Saved eeg_autocorr_data.mat')

eegprep/eeg_autocorr_fftw.py

@@ -0,0 +1,68 @@
+import numpy as np
+from scipy import signal
+from scipy.fft import fft, ifft, next_fast_len
+from scipy.signal import resample_poly
+from .pop_loadset import pop_loadset
+from .pop_reref import pop_reref
+
+def eeg_autocorr_fftw(EEG, pct_data=100):
+    
+    # FFT length
+    nfft = next_fast_len(2 * EEG['pnts'] - 1)
+    
+    # Initialize autocorrelation array
+    ncomp = EEG['icaact'].shape[0]
+    ac = np.zeros((ncomp, nfft))
+    
+    # Calculate autocorrelation using FFT
+    for it in range(EEG['icaact'].shape[0]):
+        # Apply FFT
+        X = fft(EEG['icaact'][it, :, :], n=nfft, axis=0)
+        # Compute the mean of the power spectrum
+        ac[it, :] = np.mean(np.abs(X)**2, axis=1)
+    
+    # Inverse FFT to get autocorrelation
+    ac = ifft(ac, axis=1)
+
+    # make sure the data is in real
+    ac = np.real(ac)
+    
+    # Adjust the size of autocorrelation array
+    if EEG['pnts'] < EEG['srate']:
+        # ac = np.hstack(     [ac[:, :EEG['pnts']], np.zeros((ncomp      , EEG['srate'] - EEG['pnts'] + 1))])
+        ac = np.concatenate((ac[:, :EEG['pnts']], np.zeros((ac.shape[0], EEG['srate'] - EEG['pnts'] + 1))), axis=1)
+    else:
+        ac = ac[:, :EEG['srate'] + 1]
+    
+    # Normalize by 0-lag autocorrelation
+    ac = ac / ac[:, 0][:, np.newaxis]
+    
+    # resample to 1 second at 100 samples/sec
+    ac = resample_poly(ac.T, up=100, down=EEG['srate']).T
+    ac = ac[:, 1:101]
+
+    return ac
+    
+    
+def test_eeg_autocorr_fftw():
+    EEG = {
+        'srate': 256,
+        'icaweights': np.random.randn(10, 256),
+        'pnts': 1000,
+        'trials': 5,
+        'icaact': np.random.randn(10, 1000, 5)
+    }
+    EEG = pop_loadset('/System/Volumes/Data/data/data/STUDIES/STERN/S01/Memorize.set')
+    
+    # reshape the last two dimensions of EEG['icaact']
+    # EEG['icaact'] = EEG['icaact'].reshape(EEG['icaact'].shape[0], -1)
+    
+    # convert EEG['icaact'] to double precision
+    
+    psdmed = eeg_autocorr_fftw(EEG, 100)
+    
+    # print information about psdmed
+    print(psdmed.shape)
+    print(psdmed)
+    
+# test_eeg_autocorr_fftw()

eegprep/eeg_autocorr_fftw_compare_helper.py

@@ -0,0 +1,20 @@
+from eeg_autocorr_fftw import eeg_autocorr_fftw
+from pop_loadset import pop_loadset
+from pop_reref import pop_reref
+import sys
+
+# check if a parameter is present and if it is assign eeglab_file_path to it
+if len(sys.argv) > 1:
+    eeglab_file_path = sys.argv[1]
+else:
+    eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+EEG = pop_loadset(eeglab_file_path)
+EEG = pop_reref(EEG, [])
+
+# Print the loaded data
+res = eeg_autocorr_fftw(EEG, 100)
+
+# save in a matlab file
+import scipy.io
+scipy.io.savemat('eeg_autocorr_data.mat', {'grid': res})
+print('Saved eeg_autocorr_data.mat')

eegprep/eeg_autocorr_welch.py

@@ -0,0 +1,61 @@
+import numpy as np
+from scipy.signal import resample_poly
+import random
+from .pop_loadset import pop_loadset
+import numpy as np
+from numpy.fft import fft, ifft
+
+def eeg_autocorr_welch(EEG, pct_data=100):
+    # clean input cutoff freq
+    if pct_data is None or pct_data == 0:
+        pct_data = 100
+    
+    # setup constants
+    ncomp = EEG['icaweights'].shape[0]
+    n_points = min(EEG['pnts'], EEG['srate'] * 3)
+    nfft = 2**(int(np.log2(n_points * 2 - 1)) + 1)
+    cutoff = (EEG['pnts'] // n_points) * n_points
+    index = np.add.outer(np.ceil(np.arange(0, cutoff - n_points + 1, n_points // 2)).astype(int), np.arange(n_points)).astype(int)
+    index = index.T
+    
+    # separate data segments
+    if pct_data != 100:
+        random.seed(0)
+        n_seg = index.shape[0] * EEG['trials']
+        subset = random.sample(range(n_seg), int(np.ceil(n_seg * pct_data / 100)))
+        random.seed()  # restore normal random behavior
+        temp = np.reshape(EEG['icaact'][:, index, :], (ncomp, *index.shape, EEG['trials']))
+        segments = temp[:, :, subset]
+    else:
+        segments = np.reshape(EEG['icaact'][:, index, :], (ncomp, *index.shape, EEG['trials']))
+    
+    # calc autocorrelation
+    ac = np.zeros((ncomp, nfft))
+    for it in range(ncomp):
+        fftpow = np.mean(np.abs(fft(segments[it, :, :], nfft, axis=0))**2, axis=1)
+        ac[it, :] = np.real(ifft(fftpow, axis=0)).T
+    
+    # normalizefft
+    if EEG['pnts'] < EEG['srate']:
+        ac = np.concatenate([ac[:, :EEG['pnts']] / (ac[:, 0][:, np.newaxis] * np.arange(n_points, 0, -1) / n_points), 
+                             np.zeros((ncomp, EEG['srate'] - n_points + 1))], axis=1)
+    else:
+        ac = ac[:, :EEG['srate'] + 1] / (ac[:, 0][:, np.newaxis] * np.concatenate((np.arange(n_points, n_points - EEG['srate'], -1), np.array([max(1, n_points - EEG['srate'])]))) / n_points)
+    
+    # resample to 1 second at 100 samples/sec
+    ac = resample_poly(ac.T, up=100, down=EEG['srate']).T
+    ac = ac[:, 1:101]
+      
+    return ac
+
+def test_eeg_autocorr_welch():
+    eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+    EEG = pop_loadset(eeglab_file_path)
+    
+    psdmed = eeg_autocorr_welch(EEG, 100)
+    
+    # print information about psdmed
+    print(psdmed.shape)
+    print(psdmed)
+
+# test_eeg_autocorr_welch()

eegprep/eeg_autocorr_welch_compare_helper.py

@@ -0,0 +1,13 @@
+from eeg_autocorr_welch import eeg_autocorr_welch
+from pop_loadset import pop_loadset
+
+eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+EEG = pop_loadset(eeglab_file_path)
+
+# Print the loaded data
+res = eeg_autocorr_welch(EEG, 100)
+
+# save in a matlab file
+import scipy.io
+scipy.io.savemat('eeg_autocorr_welch_data.mat', {'grid': res})
+print('Saved eeg_autocorr_welch_data.mat')

eegprep/eeg_checkset.py

@@ -0,0 +1,110 @@
+import numpy as np
+import os
+from pop_loadset import pop_loadset
+
+def eeg_checkset(EEG):
+     
+    # Define the expected types
+    expected_types = {
+        'setname': str,
+        'filename': str,
+        'filepath': str,
+        'subject': str,
+        'group': str,
+        'condition': str,
+        'session': (str, int),
+        'comments': np.ndarray,
+        'nbchan': int,
+        'trials': int,
+        'pnts': int,
+        'srate': (float,int),
+        'xmin': float,
+        'xmax': float,
+        'times': np.ndarray,  # Expecting a float numpy array
+        'data': np.ndarray,   # Expecting a float numpy array
+        'icaact': np.ndarray, # Expecting a float numpy array
+        'icawinv': np.ndarray,# Expecting a float numpy array
+        'icasphere': np.ndarray, # Expecting a float numpy array
+        'icaweights': np.ndarray, # Expecting a float numpy array
+        'icachansind': np.ndarray, # Expecting an integer numpy array
+        'chanlocs': np.ndarray,    # Expecting numpy array of dictionaries
+        'urchanlocs': np.ndarray,  # Expecting numpy array of dictionaries
+        'chaninfo': dict,
+        'ref': str,
+        'event': np.ndarray,       # Expecting numpy array of dictionaries
+        'urevent': np.ndarray,     # Expecting numpy array of dictionaries
+        'eventdescription': np.ndarray, # Expecting numpy array of strings
+        'epoch': np.ndarray,       # Expecting numpy array of dictionaries
+        'epochdescription': np.ndarray, # Expecting numpy array of strings
+        'reject': dict,
+        'stats': dict,
+        'specdata': dict,
+        'specicaact': dict,
+        'splinefile': str,
+        'icasplinefile': str,
+        'dipfit': dict,
+        'history': str,
+        'saved': str,
+        'etc': dict,
+        'datfile': str,
+        'run': (str, int),
+        'roi': dict,
+    }
+    
+    # Iterate through expected types and check input dictionary
+    for field, expected_type in expected_types.items():
+        if field not in EEG:
+            print(f"Field '{field}' is missing from the EEG dictionnary, adding it.")
+            
+            # add default values
+            if expected_type == str:
+                EEG[field] = ''
+            elif expected_type == int:
+                EEG[field] = np.array([], dtype=int)
+            elif expected_type == float:
+                EEG[field] = np.array([], dtype=float)
+            elif expected_type == dict:
+                EEG[field] = {}
+            elif expected_type == np.ndarray:
+                EEG[field] = np.array([])
+            else:
+                EEG[field] = np.array([])
+            continue
+        
+        value = EEG[field]
+        
+        # Special cases for numpy arrays with specific content types
+        if isinstance(expected_type, type) and expected_type == np.ndarray:
+            if not isinstance(value, np.ndarray):
+                print(f"Field '{field}' is expected to be a numpy array but is of type {type(value).__name__}.")
+                continue
+            # Further checks for numpy array content types
+            if field in ['times', 'data', 'icaact', 'icawinv', 'icasphere', 'icaweights']:
+                if not np.issubdtype(value.dtype, np.floating):
+                    print(f"Field '{field}' is expected to be a numpy array of floats but has dtype {value.dtype}.")
+            elif field in ['icachansind']:
+                if not np.issubdtype(value.dtype, np.integer):
+                    print(f"Field '{field}' is expected to be a numpy array of integers but has dtype {value.dtype}.")
+            elif field in ['chanlocs', 'urchanlocs', 'event', 'urevent', 'epoch']:
+                if not all(isinstance(item, dict) for item in value):
+                    print(f"Field '{field}' is expected to be a numpy array of dictionaries but contains other types.")
+            # elif field in ['eventdescription', 'epochdescription']:
+            #     if not all(isinstance(item, str) for item in value):
+            #         print(f"Field '{field}' is expected to be a numpy array of strings but contains other types.")
+        else:
+            # General type check
+            if not isinstance(value, expected_type):
+                # check for empty Ndarray
+                if isinstance(value, np.ndarray) and value.size == 0:
+                    continue
+                print(f"Field '{field}' is expected to be of type {expected_type} but is of type {type(value).__name__}.")  
+    
+    return EEG
+
+def test_eeg_checkset():
+    eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+    EEG = pop_loadset(eeglab_file_path)
+    EEG = eeg_checkset(EEG)
+    print('Checkset done')
+
+test_eeg_checkset()

eegprep/eeg_eeglab2mne.py

@@ -0,0 +1,39 @@
+from eeg_autocorr import eeg_autocorr
+from pop_loadset import pop_loadset
+import mne
+import tempfile
+import os
+from mne.export import export_raw
+from pop_saveset import pop_saveset # in development
+
+# write a funtion that converts a MNE raw object to an EEGLAB set file
+def eeg_eeglab2mne(EEG):
+    
+    # Generate a temporary file name
+    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+        temp_file_path = temp_file.name    
+    
+    base, _ = os.path.splitext(temp_file_path)
+    new_temp_file_path = base + ".set"
+
+    # save the raw file as a new EEGLAB .set file using MNE EEGLAB writer
+    pop_saveset(EEG, new_temp_file_path)
+    
+    # load the EEGLAB set file
+    if EEG['trials'] > 1:
+        raw = mne.io.read_epochs_eeglab(new_temp_file_path)
+    else:
+        raw = mne.io.read_raw_eeglab(new_temp_file_path, preload=True)
+    
+    return raw
+
+def test_eeg_eeglab2mne():
+    eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+    eeglab_file_path = '/System/Volumes/Data/data/matlab/eeglab/sample_data/eeglab_data_epochs_ica.set'
+    EEG = pop_loadset(eeglab_file_path)
+    raw = eeg_eeglab2mne(EEG)
+    
+    # print the keys of the EEG dictionary
+    print(raw.info)
+
+# test_eeg_eeglab2mne()

eegprep/eeg_mne2eeglab.py

@@ -0,0 +1,46 @@
+from eeg_autocorr import eeg_autocorr
+from pop_loadset import pop_loadset
+import mne
+import tempfile
+import os
+from mne.export import export_raw
+import eeglabio
+import numpy as np
+
+# write a funtion that converts a MNE raw object to an EEGLAB set file
+def eeg_mne2eeglab(raw):
+    # Generate a temporary file name
+    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+        temp_file_path = temp_file.name    
+    
+    base, _ = os.path.splitext(temp_file_path)
+    new_temp_file_path = base + ".set"
+
+    # save the raw file as a new EEGLAB .set file using MNE EEGLAB writer
+    export_raw(new_temp_file_path, raw, fmt='eeglab')
+
+    # load the EEGLAB set file
+    EEG = pop_loadset(new_temp_file_path)
+    
+    return EEG
+
+def test_eeg_mne2eeglab():
+    eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+    eeglab_file_path = '/System/Volumes/Data/data/matlab/eeglab/sample_data/eeglab_data_epochs_ica.set'
+    EEG = pop_loadset(eeglab_file_path)
+
+    # create MNE info structure
+    info = mne.create_info(ch_names=[ x['labels'] for x in EEG['chanlocs']], sfreq=EEG['srate'], ch_types='eeg')
+    if EEG['trials'] > 1:
+        events = np.array([[i, 0, 1] for i in range(EEG['trials'])]) # NOT CORRECT CONVERTION JUST FOR TESTING
+        event_id = dict(dummy=1)
+        raw = mne.EpochsArray(EEG['data'].transpose(2,0,1), info, events, tmin=0, event_id=event_id)
+    else:
+        raw = mne.io.RawArray(EEG['data'], info)
+    
+    EEG2 = eeg_mne2eeglab(raw)
+    
+    # print the keys of the EEG dictionary
+    print(EEG2.keys())
+
+# test_eeg_mne2eeglab()