eegprep 0.0.2__py3-none-any.whl

eegprep/topoplot.py

@@ -0,0 +1,194 @@
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.interpolate import griddata
+from scipy.interpolate import Rbf
+from scipy.spatial import cKDTree
+
+def griddata_v4(x, y, v, xq, yq):
+    """
+    Python version of MATLAB's GDATAV4 interpolation based on David T. Sandwell's biharmonic spline interpolation.
+    
+    Parameters:
+    x, y : 1D arrays of coordinates for known points
+    v : 1D array of values at known points
+    xq, yq : 2D arrays of query points coordinates
+    
+    Returns:
+    vq : 2D array of interpolated values at query points
+    """
+    # Combine x and y into complex numbers for convenience
+    xy = x + 1j * y
+    
+    # Determine distances between points
+    d = np.abs(xy[:, None] - xy[None, :])
+    
+    # Determine weights for interpolation
+    with np.errstate(divide='ignore', invalid='ignore'):
+        g = (d**2) * (np.log(d) - 1)  # Green's function
+    np.fill_diagonal(g, 0)  # Fix value along diagonal
+    weights = np.linalg.solve(g, v)
+    
+    # Initialize output array
+    m, n = xq.shape
+    vq = np.zeros_like(xq)
+    
+    # Evaluate at requested points
+    xy = xy[:, None]  # Make it column vector for broadcasting
+    for i in range(m):
+        for j in range(n):
+            d = np.abs(xq[i, j] + 1j * yq[i, j] - xy.ravel())
+            with np.errstate(divide='ignore', invalid='ignore'):
+                g = (d**2) * (np.log(d) - 1)  # Green's function
+            g[d == 0] = 0  # Handle Green's function at zero
+            vq[i, j] = np.dot(g, weights)
+    
+    return vq
+
+def topoplot(datavector, chan_locs, **kwargs):
+    # Set default values
+    noplot = kwargs.get('noplot', 'off')
+    plotgrid = kwargs.get('plotgrid', 'off')
+    plotchans = kwargs.get('plotchans', [])
+    handle = None
+    Zi = None
+    chanval = np.nan
+    rmax = 0.5  # actual head radius
+    INTERPLIMITS = 'head'
+    INTSQUARE = 'on'
+    default_intrad = 1
+    ELECTRODES = kwargs.get('ELECTRODES', 'on')
+    MAXDEFAULTSHOWLOCS = 64
+    intrad = kwargs.get('intrad', np.nan)
+    plotrad = kwargs.get('plotrad', np.nan)
+    headrad = kwargs.get('headrad', 0.5)
+    squeezefac = 1.0
+    ContourVals = datavector
+    method = kwargs.get('method', 'rbf')
+    
+    # print method
+    # print(f'method = {method}')
+    
+    # Handle additional arguments
+    if 'noplot' in kwargs:
+        noplot = kwargs['noplot']
+        if not isinstance(noplot, str):
+            if len(noplot) != 2:
+                raise ValueError("'noplot' location should be [radius, angle]")
+            else:
+                chanrad = noplot[0]
+                chantheta = noplot[1]
+                noplot = 'on'
+
+    # Set colormap
+    cmap = plt.get_cmap('jet')
+    cmaplen = cmap.N
+    GRID_SCALE = 32
+    # GRID_SCALE = 67 # 67 is the default value in EEGLAB
+
+    if len(datavector) > MAXDEFAULTSHOWLOCS:
+        ELECTRODES = 'off'
+    else:
+        ELECTRODES = 'on'
+
+    datavector = np.array(datavector).flatten()
+    ContourVals = np.array(ContourVals).flatten()
+
+    # Read the channel location information
+    tmpeloc = chan_locs
+    labels = [loc['labels'] for loc in tmpeloc]
+    indices = [i for i, loc in enumerate(tmpeloc) if 'theta' in loc]
+    Th = np.array([tmpeloc[i]['theta'] if i in indices and not isinstance(tmpeloc[i]['theta'], np.ndarray) else np.nan for i in range(len(tmpeloc))])
+    Rd = np.array([tmpeloc[i]['radius'] if i in indices and not isinstance(tmpeloc[i]['radius'], np.ndarray) else np.nan for i in range(len(tmpeloc))])
+    Th = np.deg2rad(Th)
+    allchansind = list(range(len(Th)))
+    plotchans = indices
+
+    if len(tmpeloc) == len(datavector) + 1:
+        if plotchans and plotchans[-1] == len(tmpeloc):
+            plotchans.pop()
+
+    if len(datavector) > 1:
+        inds = np.union1d(np.where(np.isnan(datavector))[0], np.where(np.isinf(datavector))[0])
+        plotchans = list(set(plotchans) - set(inds))
+
+    x, y = np.cos(Th) * Rd, np.sin(Th) * Rd
+    plotchans = np.abs(plotchans)
+    allchansind = np.array(allchansind)[plotchans]
+    Th, Rd, x, y = Th[plotchans], Rd[plotchans], x[plotchans], y[plotchans]
+    labels = np.array(labels)[plotchans]
+
+    if np.isnan(plotrad):
+        plotrad = min(1.0, max(Rd) * 1.02)
+        plotrad = max(plotrad, 0.5)
+
+    if np.isnan(intrad):
+        default_intrad = 1
+        intrad = min(1.0, max(Rd) * 1.02)
+    else:
+        default_intrad = 0
+        if plotrad > intrad:
+            plotrad = intrad
+
+    pltchans = np.where(Rd <= plotrad)[0]
+    intchans = np.where((x <= intrad) & (y <= intrad) if INTSQUARE == 'on' else (Rd <= intrad))[0]
+
+    labels = labels[pltchans]
+
+    if datavector is not None and len(datavector) > 1:
+        intdatavector = datavector[intchans]
+        datavector = datavector[pltchans]
+        ContourVals = ContourVals[pltchans]
+
+    squeezefac = rmax / plotrad
+    Rd, intRd = Rd * squeezefac, Rd[intchans] * squeezefac
+    x, y, intx, inty = x[pltchans] * squeezefac, y[pltchans] * squeezefac, x[intchans] * squeezefac, y[intchans] * squeezefac
+
+    if default_intrad:
+        xmin, xmax = min(-rmax, min(intx)), max(rmax, max(intx))
+        ymin, ymax = min(-rmax, min(inty)), max(rmax, max(inty))
+    else:
+        xmin, xmax, ymin, ymax = -intrad * squeezefac, intrad * squeezefac, -intrad * squeezefac, intrad * squeezefac
+
+    xi, yi = np.linspace(xmin, xmax, GRID_SCALE), np.linspace(ymin, ymax, GRID_SCALE)
+    yi, xi = np.meshgrid(yi, xi)
+    
+    if method == 'griddata':
+        Zi = griddata((inty, intx), intdatavector, (yi, xi), method='cubic')
+    else:
+        coords = np.array([intx.ravel(), inty.ravel()])
+        values = intdatavector.ravel()
+            
+        # find nan in values and remove values
+        nanidx = np.where(np.isnan(values))[0]
+        coords = np.delete(coords, nanidx, axis=1)
+        values = np.delete(values, nanidx)
+
+        # use griddata_v4 to interpolate
+        Zi = griddata_v4(coords[0], coords[1], values, xi, yi)
+
+        # Create the RBF interpolator
+        
+        # rbf = Rbf(coords[0], coords[1], values, function='inverse') #, function='linear')
+        # Zi1 = rbf(xi, yi)
+        
+        # rbf = Rbf(coords[0], coords[1], values, function='thin_plate') #, function='linear')
+        # Zi2 = rbf(xi, yi)
+        
+        # # average the two results
+        # Zi = (Zi1 + Zi2) / 2
+        
+    mask = (np.sqrt(xi**2 + yi**2) <= rmax)
+    Zi[~mask] = np.nan
+
+    if noplot == 'off':
+        plt.imshow(Zi, extent=(xmin, xmax, ymin, ymax), origin='lower', cmap=cmap)
+        plt.colorbar()
+        plt.scatter(x, y, c='k')
+        plt.plot(np.cos(np.linspace(0, 2 * np.pi, 100)) * rmax, np.sin(np.linspace(0, 2 * np.pi, 100)) * rmax, 'k')
+        for i, txt in enumerate(labels):
+            plt.annotate(txt, (x[i], y[i]), fontsize=8, ha='right')
+        plt.title('Topoplot')
+        plt.axis('off')
+        plt.show()
+
+    return handle, Zi, plotrad, xi, yi

eegprep/topoplot_compare_helper.py

@@ -0,0 +1,29 @@
+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')
+    

eegprep-0.0.2.dist-info/LICENSE

@@ -0,0 +1,20 @@
+GNU General Public License
+
+Copyright (C) 2024-2025
+
+Young Truong, UCSD, dt.young112@gmail.com
+Arnaud Delorme, UCSD, adelorme@ucsd.edu
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1.07  USA

eegprep-0.0.2.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: eegprep
+Version: 0.0.2
+Summary: EEG preprocessing pipeline on Python
+Author-email: Arnaud Delorme <adelorme@gmail.com>, Young Truong <dt.young112@gmail.com>
+License: GNU General Public License
+        
+        Copyright (C) 2024-2025
+        
+        Young Truong, UCSD, dt.young112@gmail.com
+        Arnaud Delorme, UCSD, adelorme@ucsd.edu
+        
+        This program is free software; you can redistribute it and/or modify
+        it under the terms of the GNU General Public License as published by
+        the Free Software Foundation; either version 2 of the License, or
+        (at your option) any later version.
+        
+        This program is distributed in the hope that it will be useful,
+        but WITHOUT ANY WARRANTY; without even the implied warranty of
+        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+        GNU General Public License for more details.
+        
+        You should have received a copy of the GNU General Public License
+        along with this program; if not, write to the Free Software
+        Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1.07  USA
+        
+Project-URL: Homepage, https://github.com/sccn/eegprep
+Project-URL: Issues, https://github.com/sccn/eegprep/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: mne>=1.0.0
+Requires-Dist: oct2py>=5.5.0
+Requires-Dist: torch>=1.10.0
+Requires-Dist: h5py>=3.3.0
+
+## how to duplicate a function
+
+1. Get a MATLAB file to load and process an EEG file
+
+2. Convert the code using GPT4 or when short Copilot and test in a Notebook. Once the code runs without erroring, move to 3.
+
+3. Use the Jupyter code to create a Python file (not notebook) to load the same file as MATLAB and process it as well (in plain Python, not in a subfunction)
+
+4. Start the debugger in both and compare. Note that it is better to use the debugger on Python file than Jupyter Notebook (could not get it to stop)
+
+5. Once the result is the same, package the Python code in a function with the same name as MATLAB
+
+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)
+

eegprep-0.0.2.dist-info/RECORD

@@ -0,0 +1,34 @@
+eegprep/ICL_feature_extractor.py,sha256=UBhCG6CH3OS37lGyQay9vntu2v5pn9nFVqooOjR5QmA,3260
+eegprep/ICL_feature_extractor_compare_helper.py,sha256=AQPinTWHDqfCzSYQ058b2XOiNitCfusKNhzIReU1yfE,597
+eegprep/__init__.py,sha256=l544MjhdEudUAeQEVYQ2aNgee4owaeNgcIfqdakj52g,28
+eegprep/eeg_autocorr.py,sha256=czg6UzGMMdrBfFd6W0mo_0xGSfXk5EJvYDDGl91-h5A,1696
+eegprep/eeg_autocorr_compare_helper.py,sha256=yp-SjCMJQtKzlC9b-OnOXfHMxe8cgV6jawNIzkI0IKA,351
+eegprep/eeg_autocorr_fftw.py,sha256=Zjbsi7-gImj9p7GJePP8FiZT-k4ET14tyknQTf_C-m4,2063
+eegprep/eeg_autocorr_fftw_compare_helper.py,sha256=YKf9-ULNHJ1SdsukGjQUd22QY_1A6N_JnYOwxEoHPgg,578
+eegprep/eeg_autocorr_welch.py,sha256=9UVEy0owqxA3AqeAPi-bNw6wvA6zrAJx3qZdrGOvl1c,2303
+eegprep/eeg_autocorr_welch_compare_helper.py,sha256=wn1zDUOg3HbAdY2DbdSvXWZjuj74TCqduN3kCsHR56E,381
+eegprep/eeg_checkset.py,sha256=DhU4tt4gnSkMPqtnnaKEN-Vvj7AUEtNHIKgFQOt6V0I,4681
+eegprep/eeg_eeglab2mne.py,sha256=NrdsaVNVuBuq1wVddGTGp0ud1J1GRsb_NghukHVlV_Q,1226
+eegprep/eeg_mne2eeglab.py,sha256=4xPcAsP8lUBIr50hhByIKMaRf7ff-7FZ3XrlMt9k31w,1573
+eegprep/eeg_mne2eeglab_epochs.py,sha256=8pSX0Kawd05SRfgqpwQ2Z0sVx33o4H57-D3TL-HnrbE,6350
+eegprep/eeg_rpsd.py,sha256=EAAwUcEooAbfGNisDE5oZns1cU7PgT6Wt6GHqKyNhtI,2077
+eegprep/eeg_rpsd_compare_helper.py,sha256=Po2R3QAjnugaNt4dcS9Y7kPfJy3Fkz3adU88tSI3h4s,457
+eegprep/eeglabcompat.py,sha256=zgv2sI73AEyVYDi1IvlaZgmVsyLtb4g_w1ABzgMloDE,4274
+eegprep/iclabel.py,sha256=8ScIt1-XMgNsrlBAEufzsDfN2K9lZh1z3GNvHPbLDzk,2240
+eegprep/iclabel_helper.py,sha256=8rHz8kWG20ZLE0VKxbOIwTq-jfZs8vmweHnOiztth7A,815
+eegprep/iclabel_net.py,sha256=iQzLkD2K46Mj-JkHmVC2vHO80PfrigyuqMDjRiHlWec,8999
+eegprep/iclabel_net_load_py_measures.py,sha256=GrAvWKh0fdhKwHja3hQtQB-roP0D7vE5zVoVZqx8TQM,8951
+eegprep/pop_loadset.py,sha256=tX8q2TrAow_oJMrTsAZU1sAtnrL4fDpKSHyXw38ODVs,4079
+eegprep/pop_reref.py,sha256=LEfzvZ9VK2f2ck2-3_hORDb-9zm60CyGUlMTOTTfIM0,1967
+eegprep/pop_reref_compare_helper.py,sha256=3xs76U-j4F9wf_DfGyG9lgYPZDYfUA0E_fSqPsf_DkE,922
+eegprep/pop_reref_helper.py,sha256=qNYaQLfd3LGxPDzyaQn730DO9UWxMxQKFroCvqjjuGk,632
+eegprep/pop_resample.py,sha256=3kS1TLG2rQKkCpSlqFtpUVLvqRUZcQXOVhTkBOLE4Dc,1365
+eegprep/pop_saveset.py,sha256=ahN23cv6aq5MoEKnK6EmRopcZy6KeFu0YkFIpCIN2l4,7488
+eegprep/save_struct_as_hdf5.py,sha256=ovsyv5iKtQN9c57c244ha4xha0uNFFfsDs4V-fNt608,1557
+eegprep/topoplot.py,sha256=cZT9evJ7j5DReoshnzR3Ns5UA6D9ZTEzCIiZwAVrMJY,6863
+eegprep/topoplot_compare_helper.py,sha256=H4a-K6Q9tmZqaoENCzRXbKJGhGvmXyv1KpXe4MunsG4,781
+eegprep-0.0.2.dist-info/LICENSE,sha256=Xafu48R-h_kyaNj2tuhfgdEv9_ovciktjUEgRRwMZ6w,812
+eegprep-0.0.2.dist-info/METADATA,sha256=dyTQhcmhCHrNf7cQB_96ddR9v4-5d_A3UpTBGaYHq1w,2493
+eegprep-0.0.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+eegprep-0.0.2.dist-info/top_level.txt,sha256=PvYxowtqrnpb1Nz5a3sJMCDqi-PX8CqYys4wQRhko-s,8
+eegprep-0.0.2.dist-info/RECORD,,

eegprep-0.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eegprep-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+eegprep