eegprep 0.0.2__py3-none-any.whl

eegprep/iclabel_net_load_py_measures.py

@@ -0,0 +1,137 @@
+import scipy.io
+import torch
+import scipy
+import numpy as np
+
+class Reshape(torch.nn.Module):
+        def __init__(self, shape):
+            super().__init__()
+            self.shape = shape
+
+        def forward(self, x):
+            return x.view(x.shape[0], *self.shape)
+
+class Concatenate(torch.nn.Module):
+    def __init__(self, dim):
+        super().__init__()
+        self.dim = dim
+    
+    def forward(self, x: list):
+        return torch.cat(x, dim=self.dim)
+
+
+class ICLabelNet(torch.nn.Module):
+    def __init__(self, mat_path):
+        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)
+        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())
+        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_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_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_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_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_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_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_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_relu = torch.nn.LeakyReLU(0.2)
+        self.discriminator_psdmed_reshape = Reshape((100, 1, 1))
+        self.discriminator_psdmed_concat1 = Concatenate(dim=2)
+        self.discriminator_psdmed_concat2 = Concatenate(dim=3)
+        self.discriminator_autocorr_reshape = Reshape((100, 1, 1))
+        self.discriminator_autocorr_concat1 = Concatenate(dim=2)
+        self.discriminator_autocorr_concat2 = Concatenate(dim=3)
+        self.discriminator_concat = Concatenate(dim=1)
+        self.discriminator_conv = torch.nn.Conv2d(in_channels=712, out_channels=7, kernel_size=4, stride=1, padding=0, dilation=1)
+        self.discriminator_conv.weight = torch.nn.Parameter(torch.tensor(params[18][1]).permute(3, 2, 0, 1))
+        self.discriminator_conv.bias = torch.nn.Parameter(torch.tensor(params[19][1]).squeeze())
+        self.discriminator_softmax = torch.nn.Softmax(dim=1)
+
+    def forward(self, image, psdmed, autocorr):
+        x_image = self.discriminator_image_layer1_conv(image)
+        x_image = self.discriminator_image_layer1_relu(x_image)
+        x_image = self.discriminator_image_layer2_conv(x_image)
+        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)
+
+        x_psdmed = self.discriminator_psdmed_layer1_conv_conv(psdmed)
+        x_psdmed = self.discriminator_psdmed_layer1_conv_relu(x_psdmed)
+        x_psdmed = self.discriminator_psdmed_layer2_conv_conv(x_psdmed)
+        x_psdmed = self.discriminator_psdmed_layer2_conv_relu(x_psdmed)
+        x_psdmed = self.discriminator_psdmed_layer3_conv_conv(x_psdmed)
+        x_psdmed = self.discriminator_psdmed_layer3_conv_relu(x_psdmed)
+        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)
+
+        x_autocorr = self.discriminator_autocorr_layer1_conv_conv(autocorr)
+        x_autocorr = self.discriminator_autocorr_layer1_conv_relu(x_autocorr)
+        x_autocorr = self.discriminator_autocorr_layer2_conv_conv(x_autocorr)
+        x_autocorr = self.discriminator_autocorr_layer2_conv_relu(x_autocorr)
+        x_autocorr = self.discriminator_autocorr_layer3_conv_conv(x_autocorr)
+        x_autocorr = self.discriminator_autocorr_layer3_conv_relu(x_autocorr)
+        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)
+
+        x = self.discriminator_concat([x_image, x_psdmed, x_autocorr])
+        x = self.discriminator_conv(x)
+        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)
+        
+        return x
+    
+if __name__ == "__main__":
+    model = ICLabelNet('netICL.mat')
+    data = scipy.io.loadmat('python_temp_reformated.mat')
+    image_mat    = data['grid'][0][0]
+    psdmed_mat   = data['grid'][0][1]
+    autocorr_mat = data['grid'][0][2]
+    # assuming third dimension is trivial and last dimension is channel. First two dimensions (32 x 32) are size of topoplot
+    image = torch.tensor(image_mat).permute(-1, 2, 0, 1)
+    print('image shape', image.shape)
+    psdmed = torch.tensor(psdmed_mat).permute(-1, 2, 0, 1)
+    print('psd shape', psdmed.shape)
+    autocorr = torch.tensor(autocorr_mat).permute(-1, 2, 0, 1)
+    print('autocorr shape', autocorr.shape)
+    output = model(image, psdmed, autocorr)
+    print(output.shape)
+    
+    # save the output to a mat file
+    scipy.io.savemat('output4_py.mat', {'output': output.detach().numpy()})
+    

eegprep/pop_loadset.py

@@ -0,0 +1,97 @@
+import scipy.io
+import numpy as np
+import os
+
+# Allows access using . notation
+# class EEG:
+#     def __init__(self, **kwargs):
+#         self.__dict__.update(kwargs)
+#     def __getitem__(self, key):
+#         return self.__dict__[key]
+#     def __setitem__(self, key, value):
+#         self.__dict__[key] = value
+
+default_empty = np.array([])
+#default_empty = None
+
+def loadset(file_path):
+    return pop_loadset(file_path)
+
+def pop_loadset(file_path):
+    # Load MATLAB file
+    EEG = scipy.io.loadmat(file_path, struct_as_record=False, squeeze_me=True)
+        
+    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
+        if isinstance(obj, dict):
+            return {key: new_check(obj[key]) for key in obj}
+        # check if obj is a numpy array and apply recursively the function to each object not changing the struture of the array
+        elif isinstance(obj, list):
+            if len(obj) == 0:
+                return default_empty
+            else:
+                return [new_check(item) for item in obj]
+        elif isinstance(obj, np.ndarray):
+            # check if empty and return none
+            if obj.size == 0:
+                return default_empty
+            # check if it is a numeric array
+            elif obj.dtype.kind in ['i', 'u', 'f', 'c']:
+                return obj
+            else:
+                return np.array([new_check(item) for item in obj])
+        # check if it is a scalar or a string and return it
+        elif np.isscalar(obj) or isinstance(obj, str):
+            return obj
+        # check if obj is a mat_struct object and convert it to a dictionary
+        elif isinstance(obj, scipy.io.matlab.mat_struct) or isinstance(obj, scipy.io.matlab.mio5_params.mat_struct):
+            dict_obj = {}
+            for field_name in obj._fieldnames:
+                field_value = getattr(obj, field_name)
+                dict_obj[field_name] = new_check(field_value)
+            return dict_obj
+    
+    # check if EEG['data'] is a string, and if it the case, read the binary float32 file
+    #EEG = check_keys(EEG)
+    EEG = new_check(EEG)
+    if 'EEG' in EEG:
+        EEG = EEG['EEG']
+        
+    if 'data' in EEG and isinstance(EEG['data'], str):
+        # get path from file_path
+        EEG['filepath'] = os.path.dirname(file_path)
+        file_name = EEG['filepath'] + os.sep + EEG['data']
+        EEG['data'] = np.fromfile(file_name, dtype='float32').reshape( EEG['pnts']*EEG['trials'], EEG['nbchan'])
+        EEG['data'] = EEG['data'].T.reshape(EEG['nbchan'], EEG['trials'], EEG['pnts']).transpose(0, 2, 1)
+
+    # compute ICA activations
+    if 'icaweights' in EEG and 'icasphere' in EEG and EEG['icaweights'].size > 0 and EEG['icasphere'].size > 0:
+        EEG['icaact'] = np.dot(np.dot(EEG['icaweights'], EEG['icasphere']), EEG['data'].reshape(int(EEG['nbchan']), -1))
+        EEG['icaact'] = EEG['icaact'].astype(np.float32)
+        EEG['icaact'] = EEG['icaact'].reshape(EEG['icaweights'].shape[0], -1, int(EEG['trials']))
+    
+    # subtract 1 to EEG['icachansind'] to make it 0-based
+    if 'icachansind' in EEG and EEG['icachansind'].size > 0:
+        EEG['icachansind'] = EEG['icachansind'] - 1
+    
+    # type conversion
+    EEG['xmin'] = float(EEG['xmin'])
+    EEG['xmax'] = float(EEG['xmax'])
+    EEG['srate'] = float(EEG['srate'])
+    
+    return EEG
+
+def test_pop_loadset():
+    file_path = './tmp2.set'
+    file_path = '/System/Volumes/Data/data/data/STUDIES/STERN/S04/Memorize.set' #'./eeglab_data_with_ica_tmp.set'
+    EEG = pop_loadset(file_path)
+    
+    # print the keys of the EEG dictionary
+    print(EEG.keys())
+    
+# test_pop_loadset()
+
+# STILL OPEN QUESTION: Better to have empty MATLAB arrays as None for empty numpy arrays (current default).
+# The current default is to make it more MALTAB compatible. A lot of MATLAB function start indexing MATLAB
+# empty arrays to add values to them. This is not possible with None and would create more conversion and 
+# bugs. However, None is more pythonic. 

eegprep/pop_reref.py

@@ -0,0 +1,44 @@
+import numpy as np
+
+def pop_reref(EEG, ref):
+    
+    # check if ref is not empty and not none
+    if ref is not None and ref != []:
+        raise ValueError('Feature not implemented: The ref parameter must be empty or None')
+            
+    # Check if the number of channels in EEG['icachansind'] is the same as the number of channels in EEG['nbchan']
+    if len(EEG['icachansind']) == EEG['nbchan']:
+        # Subtract mean from EEG data using broadcasting in NumPy
+        EEG['data'] = EEG['data'] - np.mean(EEG['data'], axis=0)
+        
+        #print(np.array2string(EEG['icaweights'][:10, :10], precision=3, suppress_small=True))
+
+        # Subtract mean from EEG icawinv using broadcasting in NumPy
+        EEG['icawinv'] = EEG['icawinv'] - np.mean(EEG['icawinv'], axis=0)
+        
+        # show the first 10 rows and columns of EEG['icawinv']
+        # print it pretty line by line with 4 digit after the decimal point
+        
+        # Compute the pseudoinverse of EEG['icawinv']
+        EEG['icaweights'] = np.linalg.pinv(EEG['icawinv'])
+        #print(' ')
+        #print(np.array2string(EEG['icaweights'][:10, :10], precision=3, suppress_small=True))
+
+        EEG['icasphere'] = np.eye(EEG['nbchan'])
+
+        # Compute the ICA activations        
+        # data = EEG['data'].reshape(EEG['data'].shape[0], -1)
+        # EEG['icaact'] = np.dot(EEG['icaweights'], data)
+        # EEG['icaact'] = EEG['icaact'].reshape(EEG['icaweights'].shape[0], EEG['pnts'], EEG['trials'])
+                
+        # Set EEG['ref'] to 'average'
+        EEG['ref'] = 'average'
+        
+        # Update the reference for each channel in EEG['chanlocs']
+        for iChan in range(len(EEG['chanlocs'])):
+            EEG['chanlocs'][iChan]['ref'] = 'average'
+        
+        return EEG
+            
+    else:
+        raise ValueError('Feature not implemented: The number of channels in EEG[''icachansind''] must be the same as the number of channels in EEG[''nbchan'']')

eegprep/pop_reref_compare_helper.py

@@ -0,0 +1,31 @@
+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/pop_reref_helper.py

@@ -0,0 +1,22 @@
+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
+if len(sys.argv) > 2:
+    eeglab_file_path_in  = sys.argv[1]
+    eeglab_file_path_out = sys.argv[2]
+else:
+    eeglab_file_path_in  = './eeglab_data_with_ica_tmp.set'
+    eeglab_file_path_out = './eeglab_data_with_ica_tmp_averef.set'
+    
+EEG = pop_loadset(eeglab_file_path_in)
+
+# Print the loaded data
+EEG = pop_reref(EEG, [])
+
+# save dataset
+pop_saveset(EEG, eeglab_file_path_out)
+

eegprep/pop_resample.py

@@ -0,0 +1,42 @@
+
+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
+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
+        
+    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')
+
+    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 test_pop_resample():
+    eeglab_file_path = './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()
+    
+    

eegprep/pop_saveset.py

@@ -0,0 +1,201 @@
+import scipy.io
+import numpy as np
+import os
+
+# Allows access using . notation
+# class EEG:
+#     def __init__(self, **kwargs):
+#         self.__dict__.update(kwargs)
+#     def __getitem__(self, key):
+#         return self.__dict__[key]
+#     def __setitem__(self, key, value):
+#         self.__dict__[key] = value
+
+default_empty = np.array([])
+
+def flatten_dict_sub(d, parent_key='', sep='_'):
+    items = []
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict_sub(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+def flatten_dict(data):
+    # Flatten each dictionary and collect the fields and types
+    flat_data = [flatten_dict_sub(item) for item in data]
+    fields = list(flat_data[0].keys())
+    dtypes = []
+
+    # Determine data types
+    for field in fields:
+        sample_value = flat_data[0][field]
+        if isinstance(sample_value, int):
+            dtypes.append((field, np.int32))
+        elif isinstance(sample_value, float):
+            dtypes.append((field, np.float64))
+        else:
+            dtypes.append((field, 'U{}'.format(max(len(str(item[field])) for item in flat_data))))
+            
+    # Convert the flattened data to a list of tuples
+    data_tuples = [tuple(item[field] for field in fields) for item in flat_data]
+
+    # Create the rec.array
+    dtype = np.dtype([(key, 'O') for key in data[0].keys()])
+    rec_array = np.array(data_tuples, dtype=dtype).view(np.recarray)
+    return rec_array
+        
+def saveset(EEG, file_name):
+    return pop_saveset(EEG, file_name)
+
+def pop_saveset(EEG, file_path):
+    # convert Events to structured array
+    # if 'event' in EEG:
+    #     EEG['event'] = flatten_dict(EEG['event'])    
+        
+    # add 1 to EEG['icachansind'] to make it 1-based
+    if 'icachansind' in EEG and EEG['icachansind'].size > 0:
+        EEG['icachansind'] = EEG['icachansind'] + 1 
+        
+    # search for array of dictionaries and convert them to flatten_dicts
+    for key in EEG:
+        if isinstance(EEG[key], np.ndarray) and len(EEG[key]) > 0 and isinstance(EEG[key][0], dict):
+            EEG[key] = flatten_dict(EEG[key])
+
+    EEG['icaact'] = default_empty 
+    scipy.io.savemat(file_path, EEG)
+            
+    return EEG
+
+
+# Example to export MNE epochs to EEGLAB dataset
+# Events are not handled correctly in this example but it works
+
+import mne
+from mne.datasets import sample
+import numpy as np
+from scipy.io import savemat
+
+def pop_saveset2(EEG, file_name):
+    
+     # add 1 to EEG['icachansind'] to make it 1-based
+    if 'icachansind' in EEG and EEG['icachansind'].size > 0:
+        EEG['icachansind'] = EEG['icachansind'] + 1 
+        
+    eeglab_dict = {
+        'setname'         : '',
+        'filename'        : '',
+        'filepath'        : '',
+        'subject'         : '',
+        'group'           : '',
+        'condition'       : '',
+        'session'         : np.array([]),
+        'comments'        : '',
+        'nbchan'          : float(EEG['nbchan']),
+        'trials'          : float(EEG['trials']),
+        'pnts'            : float(EEG['pnts']),
+        'srate'           : float(EEG['srate']),
+        'xmin'            : float(EEG['xmin']),
+        'xmax'            : float(EEG['xmax']),
+        'times'           : EEG['times'],
+        'data'            : EEG['data'],
+        'icaact'          : np.array([]),
+        'icawinv'         : np.array([]),
+        'icasphere'       : np.array([]),
+        'icaweights'      : np.array([]),
+        'icachansind'     : np.array([]),
+        'chanlocs'        : np.array([]),
+        'urchanlocs'      : np.array([]),
+        'chaninfo'        : np.array([]),
+        'ref'             : np.array([]),
+        'event'           : np.array([]),
+        'urevent'         : np.array([]),
+        'eventdescription': np.array([]),
+        'epoch'           : np.array([]),
+        'epochdescription': np.array([]),
+        'reject'          : np.array([]),
+        'stats'           : np.array([]),
+        'specdata'        : np.array([]),
+        'specicaact'      : np.array([]),
+        'splinefile'      : np.array([]),
+        'icasplinefile'   : np.array([]),
+        'dipfit'          : np.array([]),
+        'history'         : np.array([]),
+        'saved'           : np.array([]),
+        'etc'             : np.array([]),
+        'datfile'         : np.array([]),
+        'run'             : np.array([]),
+        'roi'             : np.array([]),
+    }
+    
+    # Create the list of dictionaries with a string field
+    d_list = [{
+        'labels': c['labels'],
+        'theta':  c['theta']   if not isinstance(c['theta'], np.ndarray) else None,
+        'radius': c['radius']  if not isinstance(c['radius'], np.ndarray) else None,
+        'X':      c['X']       if not isinstance(c['X'], np.ndarray) else None,
+        'Y':      c['Y']       if not isinstance(c['Y'], np.ndarray) else None,
+        'Z':      c['Z']       if not isinstance(c['Z'], np.ndarray) else None,
+        'sph_theta':  c['sph_theta']  if not isinstance(c['sph_theta'], np.ndarray) else None,
+        'sph_phi':    c['sph_phi']    if not isinstance(c['sph_phi'], np.ndarray) else None,
+        'sph_radius': c['sph_radius'] if not isinstance(c['sph_radius'], np.ndarray) else None,
+        'type':       c['type']       if not isinstance(c['type'], np.ndarray) else None,
+        'urchan':     c['urchan']     if not isinstance(c['urchan'], np.ndarray) else None,
+        'ref':        c['ref']        if not isinstance(c['ref'], np.ndarray) else None
+    } for c in EEG['chanlocs']]
+
+    dtype = np.dtype([
+        ('labels', 'U100'),      # String up to 100 characters
+        ('theta', np.float64),
+        ('radius', np.float64),
+        ('X', np.float64),
+        ('Y', np.float64),
+        ('Z', np.float64),
+        ('sph_theta', np.float64),
+        ('sph_phi', np.float64),
+        ('sph_radius', np.float64),
+        ('type', 'U10'),         # String up to 10 characters
+        ('urchan', np.int32),
+        ('ref', 'U100')          # String up to 100 characters
+    ])
+
+    # Convert the list of dictionaries to a structured NumPy array
+    eeglab_dict['chanlocs'] = np.array([
+        (
+            item['labels'],
+            item['theta'],
+            item['radius'],
+            item['X'],
+            item['Y'],
+            item['Z'],
+            item['sph_theta'],
+            item['sph_phi'],
+            item['sph_radius'],
+            item['type'],
+            item['urchan'],
+            item['ref']
+        )
+        for item in d_list
+    ], dtype=dtype)
+
+    # # 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():
+    file_path = './eeglab_data_with_ica_tmp.set'
+    EEG = pop_loadset(file_path)
+    pop_saveset( EEG, 'tmp.set')
+    pop_saveset2(EEG, 'tmp2.set') # does not do events and function above is better
+    # print the keys of the EEG dictionary
+    print(EEG.keys())
+    
+# test_pop_saveset()
+
+# STILL OPEN QUESTION: Better to have empty MATLAB arrays as None for empty numpy arrays (current default).
+# The current default is to make it more MALTAB compatible. A lot of MATLAB function start indexing MATLAB
+# empty arrays to add values to them. This is not possible with None and would create more conversion and 
+# bugs. However, None is more pythonic. 

eegprep/save_struct_as_hdf5.py

@@ -0,0 +1,50 @@
+import numpy as np
+import h5py
+
+def save_dict_to_hdf5(data, filename, dataset_name):
+    # Create a structured dtype from the dictionary keys and their corresponding types
+    dtype = []
+    for key, value in data.items():
+        if isinstance(value, str):
+            dtype.append((key, 'S{}'.format(len(value))))
+        elif isinstance(value, int):
+            dtype.append((key, 'i4'))
+        elif isinstance(value, float):
+            dtype.append((key, 'f8'))
+        elif isinstance(value, np.ndarray):
+            dtype.append((key, 'f8', value.shape))            
+        elif value is None:
+            dtype.append((key, 'S4'))
+        else:
+            raise TypeError(f"Unsupported data type for key {key}: {type(value)}")
+
+    structured_dtype = np.dtype(dtype)
+
+    # Convert dictionary values to a structured array
+    structured_data = np.array([tuple(
+        value.encode('utf-8') if isinstance(value, str) else 
+        str(value).encode('utf-8') if value is None else 
+        value for value in data.values()
+    )], dtype=structured_dtype)
+
+    # Save to HDF5
+    with h5py.File(filename, 'w') as hdf:
+        hdf.create_dataset(dataset_name, data=structured_data)
+
+# Example usage
+data = {
+    'labels': 'FPz',
+    'theta': np.array([0,1,2,3]),
+    'radius': 0.5066888888888889,
+    'X': 84.98123361344625,
+    'Y': 0,
+    'Z': -1.7860385037488253,
+    'sph_theta': 0,
+    'sph_phi': -1.203999999999994,
+    'sph_radius': 85,
+    'type': 'EEG',
+    'urchan': 1,
+    'ref': None
+}
+
+save_dict_to_hdf5(data, 'data.h5', 'dataset_name')