py-neuromodulation 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

py_neuromodulation/ConnectivityDecoding/_get_grid_hull.m

@@ -0,0 +1,34 @@
+addpath('C:\code\wjn_toolbox');
+addpath(genpath('C:\code\leaddbs'));
+addpath(genpath('C:\code\spm12'));
+
+
+%%
+ctx = wjn_mni_cortex();
+downsample_ctx=ctx.vertices(1:20:end,:); %downsample by 10
+
+save("downsampled_cortex.mat", "downsample_ctx")
+
+figure;
+scatter3(downsample_ctx(:,1), downsample_ctx(:,2), downsample_ctx(:,3), 'filled');
+title('3D Scatter Plot Example');
+xlabel('X-axis');
+ylabel('Y-axis');
+zlabel('Z-axis');
+grid on;
+
+
+
+PATH_OUT = "D:\Connectome_RMAP_OUT\ROIs";
+
+for a =1:size(downsample_ctx,1)
+    disp(a)
+    roiname  = fullfile(PATH_OUT, strcat('ROI-', string(a), '.nii'));
+    mni = [downsample_ctx(a, 1) downsample_ctx(a, 2) downsample_ctx(a, 3)];
+    wjn_spherical_roi(roiname,mni,4);
+end
+
+
+
+
+

py_neuromodulation/ConnectivityDecoding/_get_grid_whole_brain.py

@@ -0,0 +1,106 @@
+import nibabel as nib
+import numpy as np
+import scipy.io as sio
+import os
+from matplotlib import pyplot as plt
+
+
+class NiiToMNI:
+
+    def __init__(
+        self,
+        PATH_nii_file: str = r"C:\code\RMap_ROI_Estimation\Automated Anatomical Labeling 3 (Rolls 2020).nii",
+    ) -> None:
+
+        self.img = nib.load(PATH_nii_file)
+        self.data = self.img.get_fdata()
+
+    def downsample_nii(
+        self,
+        resampling_factor: int = 150,
+    ):
+
+        # PATH_MNI_TO_ATLAS = r"C:\code\mni_to_atlas\src\mni_to_atlas\atlases\AAL.nii"
+        # img_mni_to_atlas = nib.load(PATH_MNI_TO_ATLAS)
+
+        x_dim, y_dim, z_dim = self.data.shape
+
+        # Create arrays of voxel coordinates
+        x_coords, y_coords, z_coords = np.meshgrid(
+            range(x_dim), range(y_dim), range(z_dim), indexing="ij"
+        )
+
+        # Downsample here the voxels --> check lateron if the voxels have non-zero values
+        x_c_flatten = x_coords.flatten()[::resampling_factor]
+        y_c_flatten = y_coords.flatten()[::resampling_factor]
+        z_c_flatten = z_coords.flatten()[::resampling_factor]
+
+        # Combine coordinates into a single array
+        voxel_coordinates = np.column_stack(
+            (
+                x_c_flatten,
+                y_c_flatten,
+                z_c_flatten,
+                np.ones(x_c_flatten.shape[0]),
+            )
+        )
+
+        aff_m = self.img.affine
+        aff_m[0, 0] = 2
+        aff_m[0, 3] = -90
+
+        mni_coordinates = np.dot(aff_m, voxel_coordinates.T).T[:, :3]
+
+        return mni_coordinates
+
+    def select_non_zero_voxels(
+        self,
+        mni_coordinates: np.array,
+    ):
+
+        coords = np.hstack(
+            (mni_coordinates, np.ones((mni_coordinates.shape[0], 1)))
+        )
+
+        # and transform back to get the voxel values
+        voxels_downsampled = np.array(
+            np.linalg.solve(self.img.affine, coords.T).T
+        ).astype(int)[:, :3]
+
+        ival = []
+        coord_ = []
+        for i in range(voxels_downsampled.shape[0]):
+            ival.append(self.data[tuple(voxels_downsampled[i, :])])
+            coord_.append(mni_coordinates[i, :])
+
+        # get only voxel values non-zero
+        ival = np.array(ival)
+        coord_ = np.array(coord_)
+        ival_non_zero = ival[ival != 0]
+        coord_non_zero = coord_[ival != 0]
+        print(coord_non_zero.shape)
+
+        return coord_non_zero, ival_non_zero
+
+    def plot_3d_coordinates(self, coord_non_zero: np.array):
+        fig = plt.figure()
+        ax = fig.add_subplot(111, projection="3d")
+        ax.scatter(
+            coord_non_zero[:, 0],
+            coord_non_zero[:, 1],
+            coord_non_zero[:, 2],
+            s=50,
+            alpha=0.2,
+        )
+        plt.show()
+
+
+if __name__ == "__main__":
+
+    nii_to_mni = NiiToMNI(
+        PATH_nii_file=r"C:\code\py_neuromodulation\ConnectivityDecoding\Automated Anatomical Labeling 3 (Rolls 2020).nii"
+    )
+    mni_coordinates = nii_to_mni.downsample_nii(resampling_factor=150)
+    coord_non_zero, ival_non_zero = nii_to_mni.select_non_zero_voxels(
+        mni_coordinates
+    )

py_neuromodulation/ConnectivityDecoding/_helper_write_connectome.py

@@ -0,0 +1,119 @@
+import nibabel as nib
+import numpy as np
+import scipy.io as sio
+import os
+from matplotlib import pyplot as plt
+
+
+def write_connectome_mat(
+    PATH_Fingerprints: str = r"D:\Connectome_RMAP_OUT\ROIs\HCP1000 6K",
+    PATH_CONNECTOME: str = os.path.join(
+        "py_neuromodulation",
+        "ConnectivityDecoding",
+        "connectome_struct.mat",
+    ),
+    func_: bool = False,
+):
+
+    # connectome = sio.loadmat(PATH_CONNECTOME)  # check if read was successful
+
+    # load all fingerprints and put them in .npy
+    dict_connectome = {}
+    if func_ is False:
+        files_fps = [f for f in os.listdir(PATH_Fingerprints) if ".nii" in f]
+    else:
+        files_fps = [
+            f
+            for f in os.listdir(PATH_Fingerprints)
+            if "func_seed_AvgR_Fz.nii" in f
+        ]
+
+    # I except 1025 files, check which ones are missing
+    missing_files = []
+
+    for i in range(1, 1026):
+
+        MISSING = False
+
+        if func_ is False:
+            if f"ROI-{i}_struc_seed.nii" not in files_fps:
+                missing_files.append(f"ROI-{i}_struc_seed.nii")
+                MISSING = True
+        else:
+            if f"ROI-{i}_func_seed_AvgR_Fz.nii" not in files_fps:
+                missing_files.append(f"ROI-{i}_func_seed_AvgR_Fz.nii")
+                MISSING = True
+
+        if MISSING:
+            ROI_file = os.path.join(
+                r"D:\Connectome_RMAP_OUT\whole_brain\ROIs", f"ROI-{i}.nii"
+            )
+            # copy the ROI file to the following folder:
+            PATH_ROI_OUT = (
+                r"D:\Connectome_RMAP_OUT\whole_brain\ROI_missing_struc"
+            )
+            import shutil
+
+            shutil.copy(ROI_file, os.path.join(PATH_ROI_OUT, f"ROI-{i}.nii"))
+
+    for idx, f in enumerate(files_fps):
+        # load the .nii file and put it all in in a dictionary with the name of the file
+        fp = (
+            nib.load(os.path.join(PATH_Fingerprints, f))
+            .get_fdata()
+            .astype(np.float16)
+        )
+        if "struc" in f:
+            dict_connectome[f[f.find("ROI-") + 4 : f.find("_struc")]] = fp
+        else:
+            dict_connectome[
+                f[f.find("ROI-") + 4 : f.find("_func_seed_AvgR_Fz.nii")]
+            ] = fp
+
+        print(idx)
+    # save the dictionary
+    sio.savemat(
+        PATH_CONNECTOME,
+        dict_connectome,
+    )
+
+
+if __name__ == "__main__":
+
+    write_connectome_mat(
+        PATH_Fingerprints=r"D:\Connectome_RMAP_OUT\whole_brain\struc\HCP1000 6K",
+        PATH_CONNECTOME=os.path.join(
+            "py_neuromodulation",
+            "ConnectivityDecoding",
+            "connectome_whole_brain_struc.mat",
+        ),
+    )  # 58 files are missing
+
+    write_connectome_mat(
+        PATH_Fingerprints=r"D:\Connectome_RMAP_OUT\whole_brain\func",
+        PATH_CONNECTOME=os.path.join(
+            "py_neuromodulation",
+            "ConnectivityDecoding",
+            "connectome_whole_brain_func.mat",
+        ),
+        func_=True,
+    )
+
+    write_connectome_mat(
+        PATH_Fingerprints=r"D:\Connectome_RMAP_OUT\hull\func\GSP 1000 (Yeo 2011)_Full Set (Yeo 2011)",
+        PATH_CONNECTOME=os.path.join(
+            "py_neuromodulation",
+            "ConnectivityDecoding",
+            "connectome_hull_func.mat",
+        ),
+        func_=True,
+    )  # all there
+
+    write_connectome_mat(
+        PATH_Fingerprints=r"D:\Connectome_RMAP_OUT\hull\struc\HCP1000 6K",
+        PATH_CONNECTOME=os.path.join(
+            "py_neuromodulation",
+            "ConnectivityDecoding",
+            "connectome_hull_struc.mat",
+        ),
+    )  # 5 missing

py_neuromodulation/{helper.py → _write_example_dataset_helper.py}

@@ -1,6 +1,6 @@
 import mne
 import mne_bids
-import pybv
+import pybv  # pip install pybv
 import os
 
 

py_neuromodulation/nm_EpochStream.py

@@ -4,11 +4,11 @@ import pickle
 import numpy as np
 import pandas as pd
 
-import py_neuromodulation as py_nm
+import py_neuromodulation as nm
 from py_neuromodulation import nm_generator
 
 
-class EpochStream(py_nm.nm_stream.PNStream):
+class EpochStream(nm.nm_stream.PNStream):
     def __init__(self) -> None:
         super().__init__()
 
@@ -43,7 +43,6 @@ class EpochStream(py_nm.nm_stream.PNStream):
     def run(
         self,
     ):
-
         self._set_run()
         # shape is n, channels=7, 800 Hz
 

py_neuromodulation/nm_IO.py

@@ -2,6 +2,10 @@ import json
 import os
 import sys
 from pathlib import Path
+import logging
+
+logger = logging.getLogger("PynmLogger")
+
 
 import mne
 import mne_bids
@@ -9,6 +13,9 @@ import numpy as np
 import pandas as pd
 from scipy import io
 
+import pyarrow
+from pyarrow import csv
+
 import py_neuromodulation
 
 _PathLike = str | os.PathLike
@@ -27,7 +34,6 @@ def load_nm_channels(
     reference Union[list, str]
     """
 
-    
     if isinstance(nm_channels, pd.DataFrame):
         nm_ch_return = nm_channels
     elif nm_channels:
@@ -39,6 +45,7 @@ def load_nm_channels(
 
     return nm_ch_return
 
+
 def read_BIDS_data(
     PATH_RUN: _PathLike | mne_bids.BIDSPath,
     BIDS_PATH: _PathLike | None = None,
@@ -70,10 +77,8 @@ def read_BIDS_data(
     if raw_arr.info["line_freq"] is not None:
         line_noise = int(raw_arr.info["line_freq"])
     else:
-        print(
-            "Line noise is not available in the data, using value of {} Hz.".format(
-                line_noise
-            )
+        logger.info(
+            f"Line noise is not available in the data, using value of {line_noise} Hz."
         )
     return (
         raw_arr,
@@ -120,7 +125,6 @@ def read_grid(PATH_GRIDS: _PathLike | None, grid_str: str) -> pd.DataFrame:
 def get_annotations(
     PATH_ANNOTATIONS: str, PATH_RUN: str, raw_arr: mne.io.RawArray
 ):
-
     try:
         annot = mne.read_annotations(
             Path(PATH_ANNOTATIONS) / (os.path.basename(PATH_RUN)[:-5] + ".txt")
@@ -130,18 +134,19 @@ def get_annotations(
         # annotations starting with "BAD" are omitted with reject_by_annotations 'omit' param
         annot_data = raw_arr.get_data(reject_by_annotation="omit")
     except FileNotFoundError:
-        print("Annotations file could not be found")
-        print(
-            "expected location: "
+        logger.critical(
+            "Annotations file could not be found"
+            + "expected location: "
             + str(
-                Path(PATH_ANNOTATIONS) / (os.path.basename(PATH_RUN)[:-5] + ".txt")
+                Path(PATH_ANNOTATIONS)
+                / (os.path.basename(PATH_RUN)[:-5] + ".txt")
             )
         )
     return annot, annot_data, raw_arr
 
 
 def read_plot_modules(
-    PATH_PLOT: _PathLike = Path(__file__).absolute().parent / "plots"
+    PATH_PLOT: _PathLike = Path(__file__).absolute().parent / "plots",
 ):
     """Read required .mat files for plotting
 
@@ -180,55 +185,6 @@ def read_plot_modules(
     )
 
 
-def add_labels(
-    features: pd.DataFrame,
-    settings: dict,
-    nm_channels: pd.DataFrame,
-    raw_arr_data: np.ndarray,
-    fs: int | float,
-) -> pd.DataFrame | None:
-    """Given a constructed feature data frame, resample the target labels and add to dataframe
-
-    Parameters
-    ----------
-    features : pd.DataFrame
-        computed feature dataframe
-    settings_wrapper : settings.py
-        initialized settings used for feature estimation
-    raw_arr_data : np.ndarray
-        raw data including target
-
-    Returns
-    -------
-    pd.DataFrame | None
-        computed feature dataframe including resampled features
-    """
-    # resample_label
-    ind_label = np.where(nm_channels.target == 1)[0]
-    if ind_label.shape[0] == 0:
-        print("no target specified")
-        return None
-
-    offset_time = settings["segment_length_features_ms"]
-
-    offset_start = np.ceil(offset_time / 1000 * fs).astype(int)
-    data = raw_arr_data[ind_label, offset_start:]
-    if data.ndim == 1:
-        data = np.expand_dims(data, axis=0)
-    label_downsampled = data[
-        :,
-        :: int(np.ceil(fs / settings["sampling_rate_features_hz"])),
-    ]
-
-    # and add to df
-    if features.shape[0] == label_downsampled.shape[1]:
-        for idx, label_ch in enumerate(nm_channels.name[ind_label]):
-            features[label_ch] = label_downsampled[idx, :]
-    else:
-        print("label dimensions don't match, saving downsampled label extra")
-    return features
-
-
 def save_features_and_settings(
     df_features,
     run_analysis,
@@ -256,7 +212,7 @@ def save_features_and_settings(
 
     # create out folder if doesn't exist
     if not os.path.exists(os.path.join(out_path, folder_name)):
-        print("Creating output folder: " + str(folder_name))
+        logger.Info(f"Creating output folder: {folder_name}")
         os.makedirs(os.path.join(out_path, folder_name))
 
     dict_sidecar = {"fs": fs, "coords": coords, "line_noise": line_noise}
@@ -267,6 +223,16 @@ def save_features_and_settings(
     save_nm_channels(nm_channels, out_path, folder_name)
 
 
+def write_csv(df, path_out):
+    """
+    Function to save Pandas dataframes to disk as CSV using
+    PyArrow (almost 10x faster than Pandas)
+    Difference with pandas.df.to_csv() is that it does not
+    write an index column by default
+    """
+    csv.write_csv(pyarrow.Table.from_pandas(df), path_out)
+
+
 def save_settings(
     settings: dict, path_out: _PathLike, folder_name: str | None = None
 ) -> None:
@@ -278,7 +244,7 @@ def save_settings(
 
     with open(path_out, "w") as f:
         json.dump(settings, f, indent=4)
-    print("settings.json saved to " + path_out)
+    logger.info(f"settings.json saved to {path_out}")
 
 
 def save_nm_channels(
@@ -291,8 +257,8 @@ def save_nm_channels(
         path_out = os.path.join(
             path_out, folder_name, folder_name + "_nm_channels.csv"
         )
-    nmchannels.to_csv(path_out)
-    print("nm_channels.csv saved to " + path_out)
+    write_csv(nmchannels, path_out)
+    logger.info(f"nm_channels.csv saved to {path_out}")
 
 
 def save_features(
@@ -305,8 +271,8 @@ def save_features(
         path_out = os.path.join(
             path_out, folder_name, folder_name + "_FEATURES.csv"
         )
-    df_features.to_csv(path_out)
-    print("FEATURES.csv saved to " + str(path_out))
+    write_csv(df_features, path_out)
+    logger.info(f"FEATURES.csv saved to {str(path_out)}")
 
 
 def save_sidecar(
@@ -333,7 +299,7 @@ def save_general_dict(
             indent=4,
             separators=(",", ": "),
         )
-    print(f"{str_add} saved to " + str(path_out))
+    logger.info(f"{str_add} saved to " + str(path_out))
 
 
 def default_json_convert(obj) -> list | int | float:
@@ -359,11 +325,11 @@ def read_settings(PATH: str) -> dict:
 
 
 def read_features(PATH: str) -> pd.DataFrame:
-    return pd.read_csv(PATH + "_FEATURES.csv", index_col=0)
+    return pd.read_csv(PATH + "_FEATURES.csv", engine="pyarrow")
 
 
 def read_nm_channels(PATH: str) -> pd.DataFrame:
-    return pd.read_csv(PATH + "_nm_channels.csv", index_col=0)
+    return pd.read_csv(PATH + "_nm_channels.csv")
 
 
 def get_run_list_indir(PATH: str) -> list:
@@ -405,7 +371,14 @@ def get_paths_example_data():
 
     PATH_BIDS = Path(SCRIPT_DIR) / "data"
 
-    PATH_RUN = Path(SCRIPT_DIR) / "data" / f"sub-{sub}" / f"ses-{ses}" / datatype / RUN_NAME
+    PATH_RUN = (
+        Path(SCRIPT_DIR)
+        / "data"
+        / f"sub-{sub}"
+        / f"ses-{ses}"
+        / datatype
+        / RUN_NAME
+    )
 
     # Provide a path for the output data.
     PATH_OUT = PATH_BIDS / "derivatives"