eegprep 0.0.2__tar.gz → 0.0.4__tar.gz

{eegprep-0.0.2/src/eegprep.egg-info → eegprep-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: eegprep
-Version: 0.0.2
+Version: 0.0.4
 Summary: EEG preprocessing pipeline on Python
 Author-email: Arnaud Delorme <adelorme@gmail.com>, Young Truong <dt.young112@gmail.com>
 License: GNU General Public License
@@ -39,8 +39,20 @@ Requires-Dist: mne>=1.0.0
 Requires-Dist: oct2py>=5.5.0
 Requires-Dist: torch>=1.10.0
 Requires-Dist: h5py>=3.3.0
+Requires-Dist: python-picard
 
-## how to duplicate a function
+## Build docker
+
+docker run --rm -it -v $(pwd):/usr/src/project dtyoung/eegprep /bin/bash
+docker run -u root --rm -it -v $(pwd):/usr/src/project dtyoung/eegprep /bin/bash
+
+# remove
+
+docker rmi dtyoung/eegprep
+
+Mounted folder in /usr/src/project
+
+## How to convert a function from MATLAB to Python
 
 1. Get a MATLAB file to load and process an EEG file
 
@@ -54,3 +66,14 @@ Requires-Dist: h5py>=3.3.0
 
 6. Write the function to compare (see example) and the helper Python function to load the file (note that there could be a general Python helper function)
 
+## Install package
+Packaging was done following the tutorial: https://packaging.python.org/en/latest/tutorials/packaging-projects/ with setuptools
+
+To install the package, run:
+```
+pip install eegprep
+```
+
+## Test
+
+use tests/main_compare.m

{eegprep-0.0.2 → eegprep-0.0.4}/README.md

@@ -1,4 +1,15 @@
-## how to duplicate a function
+## Build docker
+
+docker run --rm -it -v $(pwd):/usr/src/project dtyoung/eegprep /bin/bash
+docker run -u root --rm -it -v $(pwd):/usr/src/project dtyoung/eegprep /bin/bash
+
+# remove
+
+docker rmi dtyoung/eegprep
+
+Mounted folder in /usr/src/project
+
+## How to convert a function from MATLAB to Python
 
 1. Get a MATLAB file to load and process an EEG file
 
@@ -12,3 +23,14 @@
 
 6. Write the function to compare (see example) and the helper Python function to load the file (note that there could be a general Python helper function)
 
+## Install package
+Packaging was done following the tutorial: https://packaging.python.org/en/latest/tutorials/packaging-projects/ with setuptools
+
+To install the package, run:
+```
+pip install eegprep
+```
+
+## Test
+
+use tests/main_compare.m

{eegprep-0.0.2 → eegprep-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "eegprep"
-version = "0.0.2"
+version = "0.0.4"
 authors = [
   { name="Arnaud Delorme", email="adelorme@gmail.com" },
   { name="Young Truong", email="dt.young112@gmail.com" },
@@ -26,8 +26,9 @@ dependencies = [
   "oct2py>=5.5.0",
   "torch>=1.10.0",
   "h5py>=3.3.0",
+  "python-picard",
 ]
 
 [project.urls]
 Homepage = "https://github.com/sccn/eegprep"
-Issues = "https://github.com/sccn/eegprep/issues"
+Issues = "https://github.com/sccn/eegprep/issues"

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/ICL_feature_extractor.py

@@ -1,12 +1,12 @@
 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):
+    from eegprep import topoplot
+    from eegprep import eeg_rpsd
+    from eegprep import eeg_autocorr_welch
+    from eegprep import eeg_autocorr
+    from eegprep import eeg_autocorr_fftw
+    from eegprep import pop_reref
 
     # Check inputs
     ncomp = EEG['icawinv'].shape[1]

eegprep-0.0.4/src/eegprep/__init__.py

@@ -0,0 +1,14 @@
+from .iclabel import iclabel
+from .pop_saveset import pop_saveset
+from .pop_loadset import pop_loadset
+from .eeglabcompat import pop_eegfiltnew
+from .eeglabcompat import clean_artifacts
+from .ICL_feature_extractor import ICL_feature_extractor
+from .iclabel_net import ICLabelNet
+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
+from .eeg_picard import eeg_picard

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/eeg_autocorr.py

@@ -25,7 +25,7 @@ def eeg_autocorr(EEG, pct_data=None):
     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]
+        ac = c[:, :int(EEG['srate']) + 1]
 
     # Normalize by the 0-tap of the autocorrelation
     ac /= ac[:, [0]]
@@ -50,7 +50,7 @@ def test_eeg_autocorr():
     psdmed = eeg_autocorr(EEG, 100)
     
     # print information about psdmed
-    print(psdmed.shape)
+    # print(psdmed.shape)
     
     #print(psdmed)
     
@@ -58,4 +58,4 @@ def test_eeg_autocorr():
     #assert psdmed.shape == (10, 100)
     #assert np.all(np.isfinite(psdmed))
 
-test_eeg_autocorr()
+# test_eeg_autocorr()

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/eeg_autocorr_fftw.py

@@ -32,7 +32,7 @@ def eeg_autocorr_fftw(EEG, pct_data=100):
         # 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]
+        ac = ac[:, :int(EEG['srate']) + 1]
     
     # Normalize by 0-lag autocorrelation
     ac = ac / ac[:, 0][:, np.newaxis]

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/eeg_autocorr_welch.py

@@ -38,9 +38,9 @@ def eeg_autocorr_welch(EEG, pct_data=100):
     # 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)
+                             np.zeros((ncomp, int(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)
+        ac = ac[:, :int(EEG['srate']) + 1] / (ac[:, 0][:, np.newaxis] * np.concatenate((np.arange(n_points, n_points - int(EEG['srate']), -1), np.array([max(1, n_points - int(EEG['srate']))]))) / n_points)
     
     # resample to 1 second at 100 samples/sec
     ac = resample_poly(ac.T, up=100, down=EEG['srate']).T
@@ -55,7 +55,7 @@ def test_eeg_autocorr_welch():
     psdmed = eeg_autocorr_welch(EEG, 100)
     
     # print information about psdmed
-    print(psdmed.shape)
-    print(psdmed)
+    # print(psdmed.shape)
+    # print(psdmed)
 
 # test_eeg_autocorr_welch()

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/eeg_checkset.py

@@ -1,6 +1,6 @@
 import numpy as np
 import os
-from pop_loadset import pop_loadset
+from .pop_loadset import pop_loadset
 
 def eeg_checkset(EEG):
      

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/eeg_eeglab2mne.py

@@ -1,10 +1,10 @@
-from eeg_autocorr import eeg_autocorr
-from pop_loadset import pop_loadset
+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
+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):

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/eeg_mne2eeglab.py

@@ -1,5 +1,5 @@
-from eeg_autocorr import eeg_autocorr
-from pop_loadset import pop_loadset
+from .eeg_autocorr import eeg_autocorr
+from .pop_loadset import pop_loadset
 import mne
 import tempfile
 import os

eegprep-0.0.4/src/eegprep/eeg_picard.py

@@ -0,0 +1,30 @@
+from picard import picard
+import numpy as np
+
+def eeg_picard(EEG):
+
+    # Assuming EEG['data'] contains the EEG data as a numpy array of shape (channels, timepoints)
+    data = EEG['data']
+    
+    # reshape from 3D to 2D
+    data = data.reshape(data.shape[0], -1)
+    
+    # Note: Specify the number of components (optional). Default is min(timepoints, channels).
+    weighting_matrix, unmixing_matrix, sources = picard(data, ortho=False, random_state=0)
+
+    # Update EEG['icaweights'] with the separating (unmixing) matrix
+    if weighting_matrix is None:
+        EEG['icasphere'] = np.eye(EEG['nbchan'])
+    else:
+        EEG['icasphere'] = weighting_matrix
+    EEG['icaweights'] = unmixing_matrix
+    EEG['icawinv'] = np.linalg.pinv(EEG['icaweights']*EEG['icasphere'])  
+
+    # Calculate the inverse weights (mixing matrix) and store in EEG['icawinv']
+    EEG['icaact'] = sources
+
+    # reshape EEG['icaact'] back to 3D as EEG['data']
+    EEG['icaact'] = EEG['icaact'].reshape(EEG['icaact'].shape[0], EEG['pnts'], EEG['trials'])
+    EEG['icachansind'] = np.arange(EEG['nbchan'])
+    
+    return EEG

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/eeg_rpsd.py

@@ -40,7 +40,7 @@ def eeg_rpsd(EEG, nfreqs=None, pct_data=100):
     for it in range(ncomp):
         temp = np.reshape(EEG['icaact'][it, index, :], (1, index.shape[0], index.shape[1] * EEG['trials']))
         temp = temp[:, :, subset] * window[:, np.newaxis]
-        temp = fft(temp, n_points, axis=1)
+        temp = fft(temp, int(n_points), axis=1)
         temp = np.abs(temp) ** 2
         temp = temp[:, 1:nfreqs + 1, :] * 2 / (EEG['srate'] * np.sum(window ** 2))
         if nfreqs == nyquist:

eegprep-0.0.4/src/eegprep/eeglabcompat.py

@@ -0,0 +1,129 @@
+# import sys
+# sys.path.insert(0, 'src/')
+from .pop_loadset import pop_loadset
+from .pop_saveset import pop_saveset
+import logging
+import os
+eeglab = None
+
+def start_eeglab():
+    global eeglab
+    if eeglab is None:
+        from oct2py import Oct2Py, get_log
+        eeglab = Oct2Py(logger=get_log())
+        oc = Oct2Py(logger=get_log())
+        eeglab.logger = get_log("new_log")
+        eeglab.logger.setLevel(logging.WARNING)
+        eeglab.warning('off', 'backtrace')
+
+        # On the command line, type "octave-8.4.0" OCTAVE_EXECUTABLE or OCTAVE var
+        path2eeglab = 'eeglab' # init >10 seconds
+        eeglab.addpath(path2eeglab + '/functions/guifunc')
+        eeglab.addpath(path2eeglab + '/functions/popfunc')
+        eeglab.addpath(path2eeglab + '/functions/adminfunc')
+        eeglab.addpath(path2eeglab + '/plugins/firfilt')
+        eeglab.addpath(path2eeglab + '/functions/sigprocfunc')
+        eeglab.addpath(path2eeglab + '/functions/miscfunc')
+        eeglab.addpath(path2eeglab + '/plugins/dipfit')
+        eeglab.addpath(path2eeglab + '/plugins/clean_rawdata')
+        #res = eeglab.version()
+        #print('Running EEGLAB commands in compatibility mode with Octave ' + res)
+        eeglab.logger.setLevel(logging.INFO)
+
+def pop_resample( EEG, freq): # 2 additional parameters in MATLAB (never used)
+    start_eeglab()
+    
+    pop_saveset(EEG, './tmp.set') # 0.8 seconds
+    EEG2 = eeglab.pop_loadset('./tmp.set') # 2 seconds
+    EEG2 = eeglab.pop_resample(EEG2, freq) # 2.4 seconds
+    eeglab.pop_saveset(EEG2, './tmp2.set') # 2.4 seconds
+    EEG3 = pop_loadset('./tmp2.set') # 0.2 seconds
+    
+    # delete temporary files
+    os.remove('./tmp.set')
+    os.remove('./tmp2.set')
+    return EEG3
+
+
+def pop_eegfiltnew(EEG, locutoff=None,hicutoff=None,revfilt=False,plotfreqz=False):
+    start_eeglab()
+    # error if locutoff and hicutoff are none
+    if locutoff==None and hicutoff==None:
+        raise('Cannot have low cutoff and high cutoff not defined')
+    
+    pop_saveset(EEG, './tmp.set') # 0.8 seconds
+    EEG2 = eeglab.pop_loadset('./tmp.set') # 2 seconds
+    EEG3 = eeglab.pop_eegfiltnew(EEG2, 'locutoff',locutoff,'hicutoff',hicutoff,'revfilt',revfilt,'plotfreqz',plotfreqz)
+    eeglab.pop_saveset(EEG3, './tmp2.set') # 2.4 seconds
+    EEG4 = pop_loadset('./tmp2.set') # 0.2 seconds
+    
+    # delete temporary files
+    # os.remove('./tmp.set')
+    # os.remove('./tmp2.set')
+    return EEG4
+
+def clean_artifacts( EEG, ChannelCriterion=False, LineNoiseCriterion=False, FlatlineCriterion=False, BurstCriterion=False, BurstRejection=False, WindowCriterion=0, Highpass=[0.25, 0.75], WindowCriterionTolerances=[float('-inf'), 8]):
+    start_eeglab()
+    
+    if ChannelCriterion == False or ChannelCriterion == 'off':
+        ChannelCriterion='off'
+        
+    if LineNoiseCriterion == False or LineNoiseCriterion == 'off':
+        LineNoiseCriterion='off'
+    
+    if FlatlineCriterion == False or FlatlineCriterion == 'off':
+        FlatlineCriterion='off'
+
+    if BurstCriterion == False or BurstCriterion == 'off':
+        BurstCriterion='off'
+
+    if Highpass == False or Highpass == 'off':
+        Highpass='off'
+
+    if BurstRejection == False or BurstRejection == 'off':
+        BurstRejection='off'           
+    else:
+        BurstRejection='on'
+
+
+    pop_saveset(EEG, './tmp.set') # 0.8 seconds
+    EEG2 = eeglab.pop_loadset('./tmp.set') # 2 seconds
+    EEG3 = eeglab.clean_artifacts(EEG2, 'ChannelCriterion', ChannelCriterion, \
+        'LineNoiseCriterion', LineNoiseCriterion, \
+        'FlatlineCriterion', FlatlineCriterion, \
+        'BurstCriterion', BurstCriterion,  \
+        'BurstRejection', BurstRejection,  \
+        'WindowCriterion', WindowCriterion, \
+        'Highpass',Highpass, \
+        'WindowCriterionTolerances', WindowCriterionTolerances)
+    eeglab.pop_saveset(EEG3, './tmp2.set') # 2.4 seconds
+    EEG4 = pop_loadset('./tmp2.set') # 0.2 seconds
+    
+    # delete temporary files
+    os.remove('./tmp.set')
+    os.remove('./tmp2.set')
+    return EEG4
+
+# sys.exit()
+def test_eeglab_compat():
+
+    eeglab_file_path = '/System/Volumes/Data/data/matlab/eeglab/sample_data/eeglab_data_epochs_ica.set'
+
+    EEG = pop_loadset(eeglab_file_path)
+    EEG = pop_eegfiltnew(EEG, locutoff=5,hicutoff=25,revfilt=True,plotfreqz=False)
+    EEG = clean_artifacts(EEG, FlatlineCriterion=5,ChannelCriterion=0.87, LineNoiseCriterion=4,Highpass=False,BurstCriterion= 20, WindowCriterion=0.25, BurstRejection=False, WindowCriterionTolerances=[float('-inf'), 7])
+        
+    # EEG = eeglab.pop_loadset(eeglab_file_path)
+    # TMPEEG = eeglab.pop_eegfiltnew(EEG, 'locutoff',5,'hicutoff',25,'revfilt',1,'plotfreqz',0)
+    # CLEANEDEEG = eeglab.clean_artifacts(TMPEEG, 'ChannelCriterion', 'off', 
+    #     'LineNoiseCriterion', 'off',
+    #     'FlatlineCriterion', 'off',
+    #     'BurstCriterion', 'off',
+    #     'WindowCriterion', 0,
+    #     'Highpass',[0.25, 0.75],
+    #     'WindowCriterionTolerances', [-10000000, 8])
+
+    # clean_artifacts( EEG, ChannelCriterion='on' )
+
+
+# test_eeglab_compat()

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/iclabel.py

@@ -1,9 +1,11 @@
-from .ICL_feature_extractor import ICL_feature_extractor
-from .iclabel_net import ICLabelNet
 import torch
 import numpy as np
+import os
 
 def iclabel(EEG, algorithm='default'):
+    from eegprep import ICLabelNet
+    from eegprep import ICL_feature_extractor
+
     # issue error if algorithm is not 'default'
     if algorithm != 'default':
         raise ValueError('Only the default algorithm is supported')
@@ -15,12 +17,14 @@ def iclabel(EEG, algorithm='default'):
     features[0] = np.single(np.concatenate([features[0],-features[0],features[0][:, ::-1, :, :],-features[0][:, ::-1, :, :]], axis=3))
     features[1] = np.single(np.tile(features[1], (1, 1, 1, 4)))
     features[2] = np.single(np.tile(features[2], (1, 1, 1, 4)))
-    print('Feature 0 shape:', features[0].shape)
-    print('Feature 1 shape:', features[1].shape)
-    print('Feature 2 shape:', features[2].shape)
+    # print('Feature 0 shape:', features[0].shape)
+    # print('Feature 1 shape:', features[1].shape)
+    # print('Feature 2 shape:', features[2].shape)
 
     # Load the ICLabelNet model
-    model = ICLabelNet('netICL.mat')
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    data_path = os.path.join(base_dir, 'netICL.mat')
+    model = ICLabelNet(data_path)
     
     # Convert the features to torch tensors
     image = torch.tensor(features[0]).permute(-1, 2, 0, 1)
@@ -40,10 +44,11 @@ def iclabel(EEG, algorithm='default'):
         EEG['etc']['ic_classification'] = {}
     if 'ICLabel' not in EEG['etc']['ic_classification']:
         EEG['etc']['ic_classification']['ICLabel'] = {}
-        
+
+    np.object = object   
     EEG['etc']['ic_classification']['ICLabel']['classes'] = np.array(
         ['Brain', 'Muscle', 'Eye', 'Heart', 'Line Noise', 'Channel Noise', 'Other'], 
-        dtype=np.object
+        dtype=object
     )
     EEG['etc']['ic_classification']['ICLabel']['classifications'] = output_np
     EEG['etc']['ic_classification']['ICLabel']['version'] = 'default'

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/iclabel_net.py

@@ -25,44 +25,44 @@ class ICLabelNet(torch.nn.Module):
         super().__init__()
         iclabel_matlab = scipy.io.loadmat(mat_path)
         params = iclabel_matlab['params'][0]
-        i = 11
-        print('shape of param', i, torch.tensor(params[i][1]).shape)
+        # i = 11
+        # print('shape of param', i, torch.tensor(params[i][1]).shape)
         self.discriminator_image_layer1_conv = torch.nn.Conv2d(in_channels=1, out_channels=128, kernel_size=4, stride=2, padding=1, dilation=1)
-        print(self.discriminator_image_layer1_conv.weight.shape)
-        self.discriminator_image_layer1_conv.weight = torch.nn.Parameter(torch.tensor(params[0][1]).permute(3, 2, 0, 1))
-        self.discriminator_image_layer1_conv.bias = torch.nn.Parameter(torch.tensor(params[1][1]).squeeze())
+        # print(self.discriminator_image_layer1_conv.weight.shape)
+        self.discriminator_image_layer1_conv.weight = torch.nn.Parameter(torch.tensor(params[0][1], dtype=torch.float32).permute(3, 2, 0, 1))
+        self.discriminator_image_layer1_conv.bias = torch.nn.Parameter(torch.tensor(params[1][1], dtype=torch.float32).squeeze())
         self.discriminator_image_layer1_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_image_layer2_conv = torch.nn.Conv2d(in_channels=128, out_channels=256, kernel_size=4, stride=2, padding=1, dilation=1)
-        self.discriminator_image_layer2_conv.weight = torch.nn.Parameter(torch.tensor(params[2][1]).permute(3, 2, 0, 1))
-        self.discriminator_image_layer2_conv.bias = torch.nn.Parameter(torch.tensor(params[3][1]).squeeze())
+        self.discriminator_image_layer2_conv.weight = torch.nn.Parameter(torch.tensor(params[2][1], dtype=torch.float32).permute(3, 2, 0, 1))
+        self.discriminator_image_layer2_conv.bias = torch.nn.Parameter(torch.tensor(params[3][1], dtype=torch.float32).squeeze())
         self.discriminator_image_layer2_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_image_layer3_conv = torch.nn.Conv2d(in_channels=256, out_channels=512, kernel_size=4, stride=2, padding=1, dilation=1)
-        self.discriminator_image_layer3_conv.weight = torch.nn.Parameter(torch.tensor(params[4][1]).permute(3, 2, 0, 1))
-        self.discriminator_image_layer3_conv.bias = torch.nn.Parameter(torch.tensor(params[5][1]).squeeze())
+        self.discriminator_image_layer3_conv.weight = torch.nn.Parameter(torch.tensor(params[4][1], dtype=torch.float32).permute(3, 2, 0, 1))
+        self.discriminator_image_layer3_conv.bias = torch.nn.Parameter(torch.tensor(params[5][1], dtype=torch.float32).squeeze())
         self.discriminator_image_layer3_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_psdmed_layer1_conv_conv = torch.nn.Conv2d(in_channels=1, out_channels=128, kernel_size=(1,3), stride=1, padding=(0,1), dilation=1)
-        self.discriminator_psdmed_layer1_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[6][1]).permute(3, 2, 0, 1))
-        self.discriminator_psdmed_layer1_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[7][1]).squeeze())
+        self.discriminator_psdmed_layer1_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[6][1], dtype=torch.float32).permute(3, 2, 0, 1))
+        self.discriminator_psdmed_layer1_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[7][1], dtype=torch.float32).squeeze())
         self.discriminator_psdmed_layer1_conv_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_psdmed_layer2_conv_conv = torch.nn.Conv2d(in_channels=128, out_channels=256, kernel_size=(1,3), stride=1, padding=(0,1), dilation=1)
-        self.discriminator_psdmed_layer2_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[8][1]).permute(3, 2, 0, 1))
-        self.discriminator_psdmed_layer2_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[9][1]).squeeze())
+        self.discriminator_psdmed_layer2_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[8][1], dtype=torch.float32).permute(3, 2, 0, 1))
+        self.discriminator_psdmed_layer2_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[9][1], dtype=torch.float32).squeeze())
         self.discriminator_psdmed_layer2_conv_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_psdmed_layer3_conv_conv = torch.nn.Conv2d(in_channels=256, out_channels=1, kernel_size=(1,3), stride=1, padding=(0,1), dilation=1)
-        self.discriminator_psdmed_layer3_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[10][1]).unsqueeze(3).permute(3, 2, 0, 1))
-        self.discriminator_psdmed_layer3_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[11][1]).squeeze(1))
+        self.discriminator_psdmed_layer3_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[10][1], dtype=torch.float32).unsqueeze(3).permute(3, 2, 0, 1))
+        self.discriminator_psdmed_layer3_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[11][1], dtype=torch.float32).squeeze(1))
         self.discriminator_psdmed_layer3_conv_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_autocorr_layer1_conv_conv = torch.nn.Conv2d(in_channels=1, out_channels=128, kernel_size=(1,3), stride=1, padding=(0,1), dilation=1)
-        self.discriminator_autocorr_layer1_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[12][1]).permute(3, 2, 0, 1))
-        self.discriminator_autocorr_layer1_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[13][1]).squeeze())
+        self.discriminator_autocorr_layer1_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[12][1], dtype=torch.float32).permute(3, 2, 0, 1))
+        self.discriminator_autocorr_layer1_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[13][1], dtype=torch.float32).squeeze())
         self.discriminator_autocorr_layer1_conv_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_autocorr_layer2_conv_conv = torch.nn.Conv2d(in_channels=128, out_channels=256, kernel_size=(1,3), stride=1, padding=(0,1), dilation=1)
-        self.discriminator_autocorr_layer2_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[14][1]).permute(3, 2, 0, 1))
-        self.discriminator_autocorr_layer2_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[15][1]).squeeze())
+        self.discriminator_autocorr_layer2_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[14][1], dtype=torch.float32).permute(3, 2, 0, 1))
+        self.discriminator_autocorr_layer2_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[15][1], dtype=torch.float32).squeeze())
         self.discriminator_autocorr_layer2_conv_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_autocorr_layer3_conv_conv = torch.nn.Conv2d(in_channels=256, out_channels=1, kernel_size=(1,3), stride=1, padding=(0,1), dilation=1)
-        self.discriminator_autocorr_layer3_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[16][1]).unsqueeze(3).permute(3, 2, 0, 1))
-        self.discriminator_autocorr_layer3_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[17][1]).squeeze(1))
+        self.discriminator_autocorr_layer3_conv_conv.weight = torch.nn.Parameter(torch.tensor(params[16][1], dtype=torch.float32).unsqueeze(3).permute(3, 2, 0, 1))
+        self.discriminator_autocorr_layer3_conv_conv.bias = torch.nn.Parameter(torch.tensor(params[17][1], dtype=torch.float32).squeeze(1))
         self.discriminator_autocorr_layer3_conv_relu = torch.nn.LeakyReLU(0.2)
         self.discriminator_psdmed_reshape = Reshape((100, 1, 1))
         self.discriminator_psdmed_concat1 = Concatenate(dim=2)
@@ -83,7 +83,7 @@ class ICLabelNet(torch.nn.Module):
         x_image = self.discriminator_image_layer2_relu(x_image)
         x_image = self.discriminator_image_layer3_conv(x_image)
         x_image = self.discriminator_image_layer3_relu(x_image)
-        print('x_image', x_image.shape)
+        # print('x_image', x_image.shape)
 
         x_psdmed = self.discriminator_psdmed_layer1_conv_conv(psdmed)
         x_psdmed = self.discriminator_psdmed_layer1_conv_relu(x_psdmed)
@@ -94,7 +94,7 @@ class ICLabelNet(torch.nn.Module):
         x_psdmed = self.discriminator_psdmed_reshape(x_psdmed)
         x_psdmed = self.discriminator_psdmed_concat1([x_psdmed]*4)
         x_psdmed = self.discriminator_psdmed_concat2([x_psdmed]*4)
-        print('x_psdmed', x_psdmed.shape)
+        # print('x_psdmed', x_psdmed.shape)
 
         x_autocorr = self.discriminator_autocorr_layer1_conv_conv(autocorr)
         x_autocorr = self.discriminator_autocorr_layer1_conv_relu(x_autocorr)
@@ -105,11 +105,11 @@ class ICLabelNet(torch.nn.Module):
         x_autocorr = self.discriminator_autocorr_reshape(x_autocorr)
         x_autocorr = self.discriminator_autocorr_concat1([x_autocorr]*4)
         x_autocorr = self.discriminator_autocorr_concat2([x_autocorr]*4)
-        print('x_autocorr', x_autocorr.shape)
+        # print('x_autocorr', x_autocorr.shape)
 
         x = self.discriminator_concat([x_image, x_psdmed, x_autocorr])
         x = self.discriminator_conv(x)
-        print('x', x.shape)
+        # print('x', x.shape)
         # subtract max value to avoid overflow
         x = x - torch.max(x, dim=1, keepdim=True).values
         x = self.discriminator_softmax(x)

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/iclabel_net_load_py_measures.py

@@ -117,7 +117,7 @@ class ICLabelNet(torch.nn.Module):
         return x
     
 if __name__ == "__main__":
-    model = ICLabelNet('netICL.mat')
+    model = ICLabelNet('../../data/netICL.mat')
     data = scipy.io.loadmat('python_temp_reformated.mat')
     image_mat    = data['grid'][0][0]
     psdmed_mat   = data['grid'][0][1]

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/pop_loadset.py

@@ -19,7 +19,7 @@ def loadset(file_path):
 
 def pop_loadset(file_path):
     # Load MATLAB file
-    EEG = scipy.io.loadmat(file_path, struct_as_record=False, squeeze_me=True)
+    EEG = scipy.io.loadmat(file_path, struct_as_record=False, squeeze_me=True, appendmat=False)
         
     def new_check(obj):
         # check if obj is a dictionary and apply recursively the function to each object not changing the struture of the dictionary
@@ -39,7 +39,7 @@ def pop_loadset(file_path):
             elif obj.dtype.kind in ['i', 'u', 'f', 'c']:
                 return obj
             else:
-                return np.array([new_check(item) for item in obj])
+                return np.array([new_check(item) for item in obj], dtype=object)
         # check if it is a scalar or a string and return it
         elif np.isscalar(obj) or isinstance(obj, str):
             return obj
@@ -57,6 +57,14 @@ def pop_loadset(file_path):
     if 'EEG' in EEG:
         EEG = EEG['EEG']
         
+    # convert EEG['nbchan] to integer
+    if 'nbchan' in EEG:
+        EEG['nbchan'] = int(EEG['nbchan'])
+    if 'trials' in EEG:
+        EEG['trials'] = int(EEG['trials'])
+    if 'pnts' in EEG:
+        EEG['pnts'] = int(EEG['pnts'])
+    
     if 'data' in EEG and isinstance(EEG['data'], str):
         # get path from file_path
         EEG['filepath'] = os.path.dirname(file_path)

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/pop_reref_helper.py

@@ -1,7 +1,7 @@
-from ICL_feature_extractor import ICL_feature_extractor
-from pop_loadset import pop_loadset
-from pop_saveset import pop_saveset
-from pop_reref import pop_reref
+from .ICL_feature_extractor import ICL_feature_extractor
+from .pop_loadset import pop_loadset
+from .pop_saveset import pop_saveset
+from .pop_reref import pop_reref
 import sys
 
 # check if a parameter is present and if it is assign eeglab_file_path to it

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/pop_resample.py

@@ -2,14 +2,18 @@
 import os
 from scipy.io import savemat
 import tempfile # need to do something with tempfile
-from pop_loadset import pop_loadset
-from pop_saveset import pop_saveset
+import sys
+sys.path.insert(0, '/Users/arno/Python/eegprep/src/')
+sys.path.insert(0, '/usr/src/project/src/')
+from eegprep import pop_loadset
+from eegprep import pop_saveset
 from oct2py import octave as eeglab
 
 def pop_resample( EEG, freq): # 2 additional parameters in MATLAB (never used)
     
-    pop_saveset(EEG, 'tmp.set') # 0.8 seconds
+    pop_saveset(EEG, './tmp.set') # 0.8 seconds
         
+    eeglab.warning('off', 'backtrace')
     path2eeglab = '/System/Volumes/Data/data/matlab/eeglab/' # init >10 seconds
     eeglab.addpath(path2eeglab + '/functions/guifunc')
     eeglab.addpath(path2eeglab + '/functions/popfunc')
@@ -19,24 +23,24 @@ def pop_resample( EEG, freq): # 2 additional parameters in MATLAB (never used)
     eeglab.addpath(path2eeglab + '/functions/miscfunc')
     eeglab.addpath(path2eeglab + '/plugins/dipfit')
 
-    EEG2 = eeglab.pop_loadset('tmp.set') # 2 seconds
+    EEG2 = eeglab.pop_loadset('./tmp.set') # 2 seconds
     EEG2 = eeglab.pop_resample(EEG2, freq) # 2.4 seconds
-    eeglab.pop_saveset(EEG2, 'tmp2.set') # 2.4 seconds
+    eeglab.pop_saveset(EEG2, './tmp2.set') # 2.4 seconds
 
-    EEG3 = pop_loadset('tmp2.set') # 0.2 seconds
+    EEG3 = pop_loadset('./tmp2.set') # 0.2 seconds
     
     # delete temporary files
-    os.remove('tmp.set')
-    os.remove('tmp2.set')
+    os.remove('./tmp.set')
+    os.remove('./tmp2.set')
     return EEG3
 
 def test_pop_resample():
-    eeglab_file_path = './eeglab_data_with_ica_tmp.set'
+    eeglab_file_path = '/Users/arno/Python/eegprep/data/eeglab_data_with_ica_tmp.set'
     EEG = pop_loadset(eeglab_file_path)
     EEG2 = pop_resample(EEG, 100)
     print(EEG2.keys())
     print(EEG2['srate'])
     
-# test_pop_resample()
+test_pop_resample()
     
     

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep/pop_saveset.py

@@ -183,9 +183,10 @@ def pop_saveset2(EEG, file_name):
     # # Step 4: Save the EEGLAB dataset as a .mat file
     savemat(file_name, eeglab_dict)
 
-from pop_loadset import pop_loadset
 
 def test_pop_saveset():
+    from eegprep import pop_loadset
+
     file_path = './eeglab_data_with_ica_tmp.set'
     EEG = pop_loadset(file_path)
     pop_saveset( EEG, 'tmp.set')

{eegprep-0.0.2 → eegprep-0.0.4/src/eegprep.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: eegprep
-Version: 0.0.2
+Version: 0.0.4
 Summary: EEG preprocessing pipeline on Python
 Author-email: Arnaud Delorme <adelorme@gmail.com>, Young Truong <dt.young112@gmail.com>
 License: GNU General Public License
@@ -39,8 +39,20 @@ Requires-Dist: mne>=1.0.0
 Requires-Dist: oct2py>=5.5.0
 Requires-Dist: torch>=1.10.0
 Requires-Dist: h5py>=3.3.0
+Requires-Dist: python-picard
 
-## how to duplicate a function
+## Build docker
+
+docker run --rm -it -v $(pwd):/usr/src/project dtyoung/eegprep /bin/bash
+docker run -u root --rm -it -v $(pwd):/usr/src/project dtyoung/eegprep /bin/bash
+
+# remove
+
+docker rmi dtyoung/eegprep
+
+Mounted folder in /usr/src/project
+
+## How to convert a function from MATLAB to Python
 
 1. Get a MATLAB file to load and process an EEG file
 
@@ -54,3 +66,14 @@ Requires-Dist: h5py>=3.3.0
 
 6. Write the function to compare (see example) and the helper Python function to load the file (note that there could be a general Python helper function)
 
+## Install package
+Packaging was done following the tutorial: https://packaging.python.org/en/latest/tutorials/packaging-projects/ with setuptools
+
+To install the package, run:
+```
+pip install eegprep
+```
+
+## Test
+
+use tests/main_compare.m

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep.egg-info/SOURCES.txt

@@ -2,34 +2,27 @@ LICENSE
 README.md
 pyproject.toml
 src/eegprep/ICL_feature_extractor.py
-src/eegprep/ICL_feature_extractor_compare_helper.py
 src/eegprep/__init__.py
 src/eegprep/eeg_autocorr.py
-src/eegprep/eeg_autocorr_compare_helper.py
 src/eegprep/eeg_autocorr_fftw.py
-src/eegprep/eeg_autocorr_fftw_compare_helper.py
 src/eegprep/eeg_autocorr_welch.py
-src/eegprep/eeg_autocorr_welch_compare_helper.py
 src/eegprep/eeg_checkset.py
 src/eegprep/eeg_eeglab2mne.py
 src/eegprep/eeg_mne2eeglab.py
 src/eegprep/eeg_mne2eeglab_epochs.py
+src/eegprep/eeg_picard.py
 src/eegprep/eeg_rpsd.py
-src/eegprep/eeg_rpsd_compare_helper.py
 src/eegprep/eeglabcompat.py
 src/eegprep/iclabel.py
-src/eegprep/iclabel_helper.py
 src/eegprep/iclabel_net.py
 src/eegprep/iclabel_net_load_py_measures.py
 src/eegprep/pop_loadset.py
 src/eegprep/pop_reref.py
-src/eegprep/pop_reref_compare_helper.py
 src/eegprep/pop_reref_helper.py
 src/eegprep/pop_resample.py
 src/eegprep/pop_saveset.py
 src/eegprep/save_struct_as_hdf5.py
 src/eegprep/topoplot.py
-src/eegprep/topoplot_compare_helper.py
 src/eegprep.egg-info/PKG-INFO
 src/eegprep.egg-info/SOURCES.txt
 src/eegprep.egg-info/dependency_links.txt

{eegprep-0.0.2 → eegprep-0.0.4}/src/eegprep.egg-info/requires.txt

@@ -5,3 +5,4 @@ mne>=1.0.0
 oct2py>=5.5.0
 torch>=1.10.0
 h5py>=3.3.0
+python-picard

eegprep-0.0.2/src/eegprep/ICL_feature_extractor_compare_helper.py

@@ -1,19 +0,0 @@
-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-0.0.2/src/eegprep/__init__.py

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

eegprep-0.0.2/src/eegprep/eeg_autocorr_compare_helper.py

@@ -1,13 +0,0 @@
-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-0.0.2/src/eegprep/eeg_autocorr_fftw_compare_helper.py

@@ -1,20 +0,0 @@
-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-0.0.2/src/eegprep/eeg_autocorr_welch_compare_helper.py

@@ -1,13 +0,0 @@
-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-0.0.2/src/eegprep/eeg_rpsd_compare_helper.py

@@ -1,17 +0,0 @@
-from eeg_rpsd import eeg_rpsd
-from pop_loadset import pop_loadset
-import sys
-
-if len(sys.argv) > 1:
-    eeglab_file_path = sys.argv[1]
-else:
-    eeglab_file_path = '/System/Volumes/Data/data/matlab/eeglab/sample_data/eeglab_data_epochs_ica.set'
-EEG = pop_loadset(eeglab_file_path)
-
-# Print the loaded data
-res = eeg_rpsd(EEG, 100)
-
-# save in a matlab file
-import scipy.io
-scipy.io.savemat('eeg_rpsd_data.mat', {'grid': res})
-print('Saved eeg_rpsd_data.mat')

eegprep-0.0.2/src/eegprep/eeglabcompat.py

@@ -1,117 +0,0 @@
-from oct2py import Oct2Py, get_log
-from pop_saveset import pop_saveset
-from pop_loadset import pop_loadset
-import logging
-import os
-import sys
-
-eeglab = Oct2Py(logger=get_log())
-oc = Oct2Py(logger=get_log())
-eeglab.logger = get_log("new_log")
-    
-def pop_resample( EEG, freq): # 2 additional parameters in MATLAB (never used)
-    
-    pop_saveset(EEG, 'tmp.set') # 0.8 seconds
-    EEG2 = eeglab.pop_loadset('tmp.set') # 2 seconds
-    EEG2 = eeglab.pop_resample(EEG2, freq) # 2.4 seconds
-    eeglab.pop_saveset(EEG2, 'tmp2.set') # 2.4 seconds
-    EEG3 = pop_loadset('tmp2.set') # 0.2 seconds
-    
-    # delete temporary files
-    os.remove('tmp.set')
-    os.remove('tmp2.set')
-    return EEG3
-
-
-def pop_eegfiltnew(locutoff=None,hicutoff=None,revfilt=False,plotfreqz=False):
-    # error if locutoff and hicutoff are none
-    if locutoff==None and hicutoff==None:
-        raise('Cannot have low cutoff and high cutoff not defined')
-    
-    pop_saveset(EEG, 'tmp.set') # 0.8 seconds
-    EEG2 = eeglab.pop_loadset('tmp.set') # 2 seconds
-    EEG3 = pop_eegfiltnew(EEG2, 'locutoff',locutoff,'hicutoff',hicutoff,'revfilt',revfilt,'plotfreqz',plotfreqz)
-    eeglab.pop_saveset(EEG2, 'tmp2.set') # 2.4 seconds
-    EEG4 = pop_loadset('tmp2.set') # 0.2 seconds
-    
-    # delete temporary files
-    os.remove('tmp.set')
-    os.remove('tmp2.set')
-    return EEG4
-
-def clean_artifacts( EEG, ChannelCriterion=False, LineNoiseCriterion=False, FlatlineCriterion=False, BurstCriterion=False, WindowCriterion=0, Highpass=[0.25, 0.75], WindowCriterionTolerances=[float('-inf'), 8]):
-
-    if ChannelCriterion == False or ChannelCriterion == 'off':
-        ChannelCriterion='off'
-    else:
-        ChannelCriterion='on'
-        
-    if LineNoiseCriterion == False or LineNoiseCriterion == 'off':
-        LineNoiseCriterion='off'
-    else:
-        LineNoiseCriterion='on'
-    
-    if FlatlineCriterion == False or FlatlineCriterion == 'off':
-        FlatlineCriterion='off'
-    else:
-        FlatlineCriterion='on'
-
-    if BurstCriterion == False or BurstCriterion == 'off':
-        BurstCriterion='off'
-    else:
-        BurstCriterion='on'
-
-    pop_saveset(EEG, 'tmp.set') # 0.8 seconds
-    EEG2 = eeglab.pop_loadset('tmp.set') # 2 seconds
-    EEG3 = eeglab.clean_artifacts(EEG2, 'ChannelCriterion', ChannelCriterion, \
-        'LineNoiseCriterion', LineNoiseCriterion, \
-        'FlatlineCriterion', FlatlineCriterion, \
-        'BurstCriterion', BurstCriterion,  \
-        'WindowCriterion', WindowCriterion, \
-        'Highpass',Highpass, \
-        'WindowCriterionTolerances', WindowCriterionTolerances)
-    eeglab.pop_saveset(EEG3, 'tmp2.set') # 2.4 seconds
-    EEG4 = pop_loadset('tmp2.set') # 0.2 seconds
-    
-    # delete temporary files
-    os.remove('tmp.set')
-    os.remove('tmp2.set')
-    return EEG3
-
-# sys.exit()
-
-eeglab.logger.setLevel(logging.WARNING)
-eeglab.warning('off', 'backtrace')
-
-# On the command line, type "octave-8.4.0" OCTAVE_EXECUTABLE or OCTAVE var
-path2eeglab = '/System/Volumes/Data/data/matlab/eeglab/' # init >10 seconds
-eeglab.addpath(path2eeglab + '/functions/guifunc')
-eeglab.addpath(path2eeglab + '/functions/popfunc')
-eeglab.addpath(path2eeglab + '/functions/adminfunc')
-eeglab.addpath(path2eeglab + '/plugins/firfilt')
-eeglab.addpath(path2eeglab + '/functions/sigprocfunc')
-eeglab.addpath(path2eeglab + '/functions/miscfunc')
-eeglab.addpath(path2eeglab + '/plugins/dipfit')
-eeglab.addpath(path2eeglab + '/plugins/clean_rawdata')
-res = eeglab.version()
-print('Running EEGLAB commands in compatibility mode with Octave ' + res)
-eeglab.logger.setLevel(logging.INFO)
-
-eeglab_file_path = '/System/Volumes/Data/data/matlab/eeglab/sample_data/eeglab_data_epochs_ica.set'
-
-EEG = pop_loadset(eeglab_file_path)
-EEG = pop_eegfiltnew(EEG, locutoff=5,hicutoff=25,revfilt=True,plotfreqz=False)
-
-# EEG = eeglab.pop_loadset(eeglab_file_path)
-# TMPEEG = eeglab.pop_eegfiltnew(EEG, 'locutoff',5,'hicutoff',25,'revfilt',1,'plotfreqz',0)
-# CLEANEDEEG = eeglab.clean_artifacts(TMPEEG, 'ChannelCriterion', 'off', 
-#     'LineNoiseCriterion', 'off',
-#     'FlatlineCriterion', 'off',
-#     'BurstCriterion', 'off',
-#     'WindowCriterion', 0,
-#     'Highpass',[0.25, 0.75],
-#     'WindowCriterionTolerances', [-10000000, 8])
-
-# clean_artifacts( EEG, ChannelCriterion='on' )
-
-

eegprep-0.0.2/src/eegprep/iclabel_helper.py

@@ -1,26 +0,0 @@
-from iclabel import iclabel
-from pop_loadset import pop_loadset
-from pop_saveset import pop_saveset
-import sys
-
-# check if there are 2 arguments otherwise issue an error
-if len(sys.argv) != 3:
-    raise ValueError('Please provide the input and output file paths as command line arguments')
-
-# get first command line argument
-eeglab_file_path_in  = sys.argv[1]
-eeglab_file_path_out = sys.argv[2]
-
-EEG = pop_loadset(eeglab_file_path_in)
-# EEG['data']   = EEG['data'].reshape(EEG['data'].shape[0], -1)
-# EEG['icaact'] = EEG['icaact'].reshape(EEG['icaact'].shape[0], -1)
-# EEG['nbchan'] = EEG['data'].shape[0]
-# EEG['pnts']   = EEG['data'].shape[1]
-# EEG['trials'] = 1
-
-# Print the loaded data
-print('Data shape:', EEG['data'].shape)
-EEG = iclabel(EEG, 'default')
-
-# save dataset
-pop_saveset(EEG, eeglab_file_path_out)

eegprep-0.0.2/src/eegprep/pop_reref_compare_helper.py

@@ -1,31 +0,0 @@
-from pop_reref import pop_reref
-from pop_loadset import pop_loadset
-import sys
-import os
-import scipy.io
-
-# Check if a parameter was provided
-if len(sys.argv) > 1:
-    # The first element in sys.argv is the script name, so we access the second one for the argument
-    file_name = sys.argv[1]
-    print(f"The EEG file is: {file_name}")
-    print(f"Output will be in python_temp.mat (result field)")
-else:
-    file_name = './eeglab_data_with_ica_tmp.set'
-    # raise("Provide the name of a file containing EEG (full path) as the first parameter.")
-    
-# check if file name exists on disk
-if not os.path.isfile(file_name):
-    raise(f"File {file_name} does not exist.")
-
-EEG = pop_loadset(file_name)
-EEG = pop_reref(EEG, None)
-EEG['chanlocs'] = []
-EEG['urchanlocs'] = []
-EEG['event'] = []
-EEG['urevent'] = []
-EEG['epoch'] = []
-
-# save in a matlab file
-scipy.io.savemat('python_temp.mat', EEG)
-print('Saved python_temp.mat')

eegprep-0.0.2/src/eegprep/topoplot_compare_helper.py

@@ -1,29 +0,0 @@
-from topoplot import topoplot
-from pop_loadset import pop_loadset
-import sys
-
-print('Topoplot compare helper')
-    
-# need 2 arguments or error
-if len(sys.argv) != 3:
-    print(f'len(sys.argv) = {len(sys.argv)}')
-    print('Usage: need 2 arguments python topoplot_compare_helper.py <eeglab_file_path> <comp_num>')
-    sys.exit(1)
-
-# Load the data
-eeglab_file_path = sys.argv[1]
-comp_num = int(sys.argv[2])
-
-# '/System/Volumes/Data/data/matlab/eeglab/sample_data/eeglab_data_epochs_ica.set'
-EEG = pop_loadset(eeglab_file_path)
-
-# Print the loaded data
-res = topoplot(EEG['icawinv'].transpose()[comp_num], EEG['chanlocs'], noplot='on')
-
-grid = res[1]
-
-# save in a matlab file
-import scipy.io
-scipy.io.savemat('topoplot_data.mat', {'grid': grid})
-print('Saved topoplot_data.mat')
-