py-neuromodulation 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

packages/tmsi/build/lib/TMSiFileFormats/file_readers/__init__.py

@@ -1,35 +0,0 @@
-"""
-(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-#######  #     #   #####   #
-   #     ##   ##  #        
-   #     # # # #  #        #
-   #     #  #  #   #####   #
-   #     #     #        #  #
-   #     #     #        #  #
-   #     #     #  #####    #
-
-/**
- * @file ${__init__.py} 
- * @brief Initialisation of the file_readers directory classes.
- *
- */
-
-
-"""
-
-from .poly5reader import Poly5Reader
-from .xdf_reader import Xdf_Reader
-from .edf_reader import Edf_Reader

packages/tmsi/build/lib/TMSiFileFormats/file_readers/edf_reader.py

@@ -1,116 +0,0 @@
-"""
-(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-#######  #     #   #####   #
-   #     ##   ##  #        
-   #     # # # #  #        #
-   #     #  #  #   #####   #
-   #     #     #        #  #
-   #     #     #        #  #
-   #     #     #  #####    #
-
-/**
- * @file ${xdf_reader.py} 
- * @brief EDF to MNE Converter.
- *
- */
-
-
-"""
-
-import tkinter as tk
-from tkinter import filedialog
-import mne
-import pandas as pd
-
-from os.path import join, dirname, realpath
-
-Reader_dir = dirname(realpath(__file__))  # directory of this file
-modules_dir = join(Reader_dir, "../../")  # directory with all modules
-
-
-class Edf_Reader:
-    def __init__(self, filename=None, add_ch_locs=False):
-        if filename == None:
-            root = tk.Tk()
-            filename = filedialog.askopenfilename(
-                title="Select edf-file",
-                filetypes=(("edf-files", "*.edf"), ("All files", "*.*")),
-            )
-            root.withdraw()
-
-        # read raw edf-file
-        # change channel type of COUNTER channel to misc
-        mne_object = mne.io.read_raw_edf(filename, misc=[-2], preload=True)
-
-        if add_ch_locs:
-            # add channel locations from txt file
-            chLocs = pd.read_csv(
-                join(modules_dir, "TMSiSDK/_resources/EEGchannelsTMSi3D.txt"),
-                sep="\t",
-                header=None,
-            )
-            chLocs.columns = ["default_name", "eeg_name", "X", "Y", "Z"]
-            # add locations and convert to head size of 95 mm
-            for idx, ch in enumerate(mne_object.info["chs"]):
-                try:
-                    a = [
-                        i
-                        for i, e in (
-                            enumerate(chLocs["eeg_name"].values)
-                            or enumerate(chLocs["default_name"].values)
-                        )
-                        if e == ch["ch_name"]
-                    ]
-                    mne_object.info["chs"][idx]["loc"][0] = (
-                        95 * 1e-3 * chLocs["X"].values[a]
-                    )
-                    mne_object.info["chs"][idx]["loc"][1] = (
-                        95 * 1e-3 * chLocs["Y"].values[a]
-                    )
-                    mne_object.info["chs"][idx]["loc"][2] = (
-                        95 * 1e-3 * chLocs["Z"].values[a]
-                    )
-                except:
-                    pass
-
-        # unit conversion of eeg channels
-        mne_object.apply_function(lambda x: x * 1e-6, picks="eeg")
-
-        self.mne_object = mne_object
-
-    def add_impedances(self, imp_filename=None):
-        """Add impedances from .txt-file"""
-        if imp_filename == None:
-            root = tk.Tk()
-            imp_filename = filedialog.askopenfilename(
-                title="Select impedance file",
-                filetypes=(("text files", "*.txt"), ("All files", "*.*")),
-            )
-            root.withdraw()
-        impedances = []
-
-        imp_df = pd.read_csv(imp_filename, delimiter="\t", header=None)
-        imp_df.columns = ["ch_name", "impedance", "unit"]
-
-        for ch in range(len(self.mne_object.info["chs"])):
-            for i_ch in range(len(imp_df)):
-                if (
-                    self.mne_object.info["chs"][ch]["ch_name"]
-                    == imp_df["ch_name"][i_ch]
-                ):
-                    impedances.append(imp_df["impedance"][i_ch])
-
-        self.mne_object.impedances = impedances

packages/tmsi/build/lib/TMSiFileFormats/file_readers/poly5reader.py

@@ -1,294 +0,0 @@
-"""
-(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-#######  #     #   #####   #
-   #     ##   ##  #        
-   #     # # # #  #        #
-   #     #  #  #   #####   #
-   #     #     #        #  #
-   #     #     #        #  #
-   #     #     #  #####    #
-
-/**
- * @file ${poly5reader.py} 
- * @brief Poly5 File Reader.
- *
- */
-
-
-"""
-
-import numpy as np
-import struct
-import datetime
-import mne
-import tkinter as tk
-from tkinter import filedialog
-
-
-class Poly5Reader:
-    def __init__(self, filename=None, readAll=True):
-        if filename == None:
-            root = tk.Tk()
-
-            filename = filedialog.askopenfilename(
-                title="Select poly5-file",
-                filetypes=(("poly5-files", "*.poly5"), ("All files", "*.*")),
-            )
-            root.withdraw()
-
-        self.filename = filename
-        self.readAll = readAll
-        print("Reading file ", filename)
-        self._readFile(filename)
-
-    def read_data_MNE(
-        self,
-    ) -> mne.io.RawArray:
-        """Return MNE RawArray given internal channel names and types
-
-        Returns
-        -------
-        mne.io.RawArray
-        """
-
-        streams = self.channels
-        fs = self.sample_rate
-        labels = [s._Channel__name for s in streams]
-        units = [s._Channel__unit_name for s in streams]
-
-        type_options = [
-            "ecg",
-            "bio",
-            "stim",
-            "eog",
-            "misc",
-            "seeg",
-            "dbs",
-            "ecog",
-            "mag",
-            "eeg",
-            "ref_meg",
-            "grad",
-            "emg",
-            "hbr",
-            "hbo",
-        ]
-        types_clean = []
-        for t in labels:
-            for t_option in type_options:
-                if t_option in t.lower():
-                    types_clean.append(t_option)
-                    break
-            else:
-                types_clean.append("misc")
-
-        info = mne.create_info(ch_names=labels, sfreq=fs, ch_types=types_clean)
-
-        # convert from microvolts to volts if necessary
-        scale = np.array([1e-6 if u == "µVolt" else 1 for u in units])
-
-        raw = mne.io.RawArray(
-            self.samples * np.expand_dims(scale, axis=1), info
-        )
-        return raw
-
-    def _readFile(self, filename):
-        try:
-            self.file_obj = open(filename, "rb")
-            file_obj = self.file_obj
-            try:
-                self._readHeader(file_obj)
-                self.channels = self._readSignalDescription(file_obj)
-                self._myfmt = (
-                    "f" * self.num_channels * self.num_samples_per_block
-                )
-                self._buffer_size = (
-                    self.num_channels * self.num_samples_per_block
-                )
-
-                if self.readAll:
-                    sample_buffer = np.zeros(
-                        self.num_channels * self.num_samples
-                    )
-
-                    for i in range(self.num_data_blocks):
-                        print(
-                            "\rProgress: % 0.1f %%"
-                            % (100 * i / self.num_data_blocks),
-                            end="\r",
-                        )
-
-                        # Check whether final data block is filled completely or not
-                        if i == self.num_data_blocks - 1:
-                            _final_block_size = (
-                                self.num_samples / self.num_data_blocks
-                            )
-                            if (
-                                _final_block_size % self.num_samples_per_block
-                                != 0
-                            ):
-                                data_block = self._readSignalBlock(
-                                    file_obj,
-                                    buffer_size=(
-                                        self.num_samples
-                                        % self.num_samples_per_block
-                                    )
-                                    * self.num_channels,
-                                    myfmt="f"
-                                    * (
-                                        self.num_samples
-                                        % self.num_samples_per_block
-                                    )
-                                    * self.num_channels,
-                                )
-                            else:
-                                data_block = self._readSignalBlock(
-                                    file_obj, self._buffer_size, self._myfmt
-                                )
-                        else:
-                            data_block = self._readSignalBlock(
-                                file_obj, self._buffer_size, self._myfmt
-                            )
-
-                        # Get indices that need to be filled in the samples array
-                        i1 = i * self.num_samples_per_block * self.num_channels
-                        i2 = (
-                            (i + 1)
-                            * self.num_samples_per_block
-                            * self.num_channels
-                        )
-
-                        # Correct for final data block if this is not fully filled
-                        if i2 >= self.num_samples * self.num_channels:
-                            i2 = self.num_samples * self.num_channels
-
-                        # Insert the read data_block into the sample_buffer array
-                        sample_buffer[i1:i2] = data_block
-
-                    samples = np.transpose(
-                        np.reshape(
-                            sample_buffer, [self.num_samples, self.num_channels]
-                        )
-                    )
-
-                    self.ch_names = [s._Channel__name for s in self.channels]
-                    self.ch_unit_names = [
-                        s._Channel__unit_name for s in self.channels
-                    ]
-
-                    self.samples = samples
-                    print("Done reading data.")
-                    self.file_obj.close()
-
-            except Exception as e:
-                print("Reading data failed, because of the following error:\n")
-                raise
-        except OSError:
-            print("Could not open file. ")
-
-    def readSamples(self, n_blocks=None):
-        "Function to read a subset of sample blocks from a file"
-        if n_blocks == None:
-            n_blocks = self.num_data_blocks
-
-        sample_buffer = np.zeros(
-            self.num_channels * n_blocks * self.num_samples_per_block
-        )
-
-        for i in range(n_blocks):
-            data_block = self._readSignalBlock(
-                self.file_obj, self._buffer_size, self._myfmt
-            )
-            i1 = i * self.num_samples_per_block * self.num_channels
-            i2 = (i + 1) * self.num_samples_per_block * self.num_channels
-            sample_buffer[i1:i2] = data_block
-
-        samples = np.transpose(
-            np.reshape(
-                sample_buffer,
-                [self.num_samples_per_block * (i + 1), self.num_channels],
-            )
-        )
-        return samples
-
-    def _readHeader(self, f):
-        header_data = struct.unpack(
-            "=31sH81phhBHi4xHHHHHHHiHHH64x", f.read(217)
-        )
-        magic_number = str(header_data[0])
-        version_number = header_data[1]
-        self.sample_rate = header_data[3]
-        # self.storage_rate=header_data[4]
-        self.num_channels = header_data[6] // 2
-        self.num_samples = header_data[7]
-        self.start_time = datetime.datetime(
-            header_data[8],
-            header_data[9],
-            header_data[10],
-            header_data[12],
-            header_data[13],
-            header_data[14],
-        )
-        self.num_data_blocks = header_data[15]
-        self.num_samples_per_block = header_data[16]
-        if magic_number != "b'POLY SAMPLE FILEversion 2.03\\r\\n\\x1a'":
-            print("This is not a Poly5 file.")
-        elif version_number != 203:
-            print("Version number of file is invalid.")
-        else:
-            print("\t Number of samples:  %s " % self.num_samples)
-            print("\t Number of channels:  %s " % self.num_channels)
-            print("\t Sample rate: %s Hz" % self.sample_rate)
-
-    def _readSignalDescription(self, f):
-        chan_list = []
-        for ch in range(self.num_channels):
-            channel_description = struct.unpack(
-                "=41p4x11pffffH62x", f.read(136)
-            )
-            name = channel_description[0][5:].decode("ascii")
-            unit_name = channel_description[1].decode("utf-8")
-            ch = Channel(name, unit_name)
-            chan_list.append(ch)
-            f.read(136)
-        return chan_list
-
-    def _readSignalBlock(self, f, buffer_size, myfmt):
-        f.read(86)
-        sampleData = f.read(buffer_size * 4)
-        DataBlock = struct.unpack(myfmt, sampleData)
-        SignalBlock = np.asarray(DataBlock)
-        return SignalBlock
-
-    def close(self):
-        self.file_obj.close()
-
-
-class Channel:
-    """'Channel' represents a device channel. It has the next properties:
-
-    name : 'string' The name of the channel.
-
-    unit_name : 'string' The name of the unit (e.g. 'μVolt)  of the sample-data of the channel.
-    """
-
-    def __init__(self, name, unit_name):
-        self.__unit_name = unit_name
-        self.__name = name
-
-
-if __name__ == "__main__":
-    data = Poly5Reader()

packages/tmsi/build/lib/TMSiFileFormats/file_readers/xdf_reader.py

@@ -1,229 +0,0 @@
-"""
-(c) 2022 Twente Medical Systems International B.V., Oldenzaal The Netherlands
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-
-#######  #     #   #####   #
-   #     ##   ##  #        
-   #     # # # #  #        #
-   #     #  #  #   #####   #
-   #     #     #        #  #
-   #     #     #        #  #
-   #     #     #  #####    #
-
-/**
- * @file ${xdf_reader.py} 
- * @brief XDF File Reader.
- *
- */
-
-
-"""
-
-from pyxdf import load_xdf
-import mne
-import tkinter as tk
-from tkinter import filedialog
-import numpy as np
-import pandas as pd
-import copy
-
-from os.path import join, dirname, realpath
-
-Reader_dir = dirname(realpath(__file__))  # directory of this file
-modules_dir = join(Reader_dir, "../../")  # directory with all modules
-
-
-class Xdf_Reader:
-    def __init__(self, filename=None, add_ch_locs=False):
-        if filename == None:
-            root = tk.Tk()
-
-            filename = filedialog.askopenfilename(
-                title="Select xdf-file",
-                filetypes=(("xdf-files", "*.xdf"), ("All files", "*.*")),
-            )
-            root.withdraw()
-
-        self.filename = filename
-        self.add_ch_locs = add_ch_locs
-        print("Reading file ", filename)
-        self.data, self.time_stamps = self._readFile(filename)
-
-    def _readFile(self, fname):
-        try:
-            streams, header = load_xdf(fname)
-            num_streams = len(streams)
-            self.stream_info = {}
-
-            print("Number of streams in file: " + str(num_streams))
-            for i in range(num_streams):
-                stream = streams[i]
-                self.stream_info[i] = stream["info"]
-                if stream is not None:
-                    fs = float(stream["info"]["nominal_srate"][0])
-
-                    labels, types, units, impedances = self._get_ch_info(stream)
-
-                    type_options = [
-                        "ecg",
-                        "bio",
-                        "stim",
-                        "eog",
-                        "misc",
-                        "seeg",
-                        "dbs",
-                        "ecog",
-                        "mag",
-                        "eeg",
-                        "ref_meg",
-                        "grad",
-                        "emg",
-                        "hbr",
-                        "hbo",
-                    ]
-                    for ind, t in enumerate(types):
-                        if t == "EEG":
-                            types[ind] = "eeg"
-                        elif not t in type_options:
-                            types[ind] = "misc"
-                    info = mne.create_info(
-                        ch_names=labels, sfreq=fs, ch_types=types
-                    )
-                    info = self._get_ch_locations(stream, info)
-                    if self.add_ch_locs:
-                        info = self._add_ch_locations(info)
-
-                    # convert from microvolts to volts if necessary
-                    scale = np.array(
-                        [1e-6 if u == "µVolt" else 1 for u in units]
-                    )
-                    raw = mne.io.RawArray(
-                        (stream["time_series"] * scale).T, info
-                    )
-                    raw.impedances = impedances
-
-                    if raw is not None:
-                        print(raw, end="\n\n")
-                        print(raw.info)
-
-                        if num_streams == 1:
-                            return (raw,), (stream["time_stamps"],)
-                        else:
-                            if i == 0:
-                                output_data = (copy.copy(raw),)
-                                output_timestamps = (
-                                    copy.copy(stream["time_stamps"]),
-                                )
-                            elif i == num_streams - 1:
-                                output_data = output_data + (copy.copy(raw),)
-                                output_timestamps = output_timestamps + (
-                                    copy.copy(stream["time_stamps"]),
-                                )
-                                return output_data, output_timestamps
-                            else:
-                                output_data = output_data + (copy.copy(raw),)
-                                output_timestamps = output_timestamps + (
-                                    copy.copy(stream["time_stamps"]),
-                                )
-        except Exception as e:
-            print("Reading data failed because of the following error:\n")
-            raise
-
-    def add_impedances(self, imp_filename=None):
-        """Add impedances from .txt-file"""
-        if imp_filename == None:
-            root = tk.Tk()
-            imp_filename = filedialog.askopenfilename(
-                title="Select impedance file",
-                filetypes=(("text files", "*.txt"), ("All files", "*.*")),
-            )
-            root.withdraw()
-        impedances = []
-
-        imp_df = pd.read_csv(imp_filename, delimiter="\t", header=None)
-        imp_df.columns = ["ch_name", "impedance", "unit"]
-
-        for ch in range(len(self.data[0].info["chs"])):
-            for i_ch in range(len(imp_df)):
-                if (
-                    self.data[0].info["chs"][ch]["ch_name"]
-                    == imp_df["ch_name"][i_ch]
-                ):
-                    impedances.append(imp_df["impedance"][i_ch])
-
-        self.data[0].impedances = impedances
-
-    def _get_ch_info(self, stream):
-        # read channel labels, types, units and impedances
-        labels, types, units, impedances = [], [], [], []
-
-        for ch in stream["info"]["desc"][0]["channels"][0]["channel"]:
-            labels.append(str(ch["label"][0]))
-            types.append(ch["type"][0])
-            units.append(ch["unit"][0])
-            if ch["impedance"]:
-                impedances.append(str(ch["impedance"][0]))
-        return labels, types, units, impedances
-
-    def _get_ch_locations(self, stream, info):
-        # read channel locations and convert unit from mm to m
-        for i, ch in enumerate(
-            stream["info"]["desc"][0]["channels"][0]["channel"]
-        ):
-            if ch["location"]:
-                info["chs"][i]["loc"][0] = (
-                    float(ch["location"][0]["X"][0]) * 1e-3
-                )
-                info["chs"][i]["loc"][1] = (
-                    float(ch["location"][0]["Y"][0]) * 1e-3
-                )
-                info["chs"][i]["loc"][2] = (
-                    float(ch["location"][0]["Z"][0]) * 1e-3
-                )
-                self.add_ch_locs = False
-        return info
-
-    def _add_ch_locations(self, info):
-        # add channel locations from txt file
-        chLocs = pd.read_csv(
-            join(modules_dir, "TMSiSDK/_resources/EEGchannelsTMSi3D.txt"),
-            sep="\t",
-            header=None,
-        )
-        chLocs.columns = ["default_name", "eeg_name", "X", "Y", "Z"]
-
-        # add locations and convert to head size of 95 mm
-        for idx, ch in enumerate(info["chs"]):
-            try:
-                a = [
-                    i
-                    for i, e in (
-                        enumerate(chLocs["eeg_name"].values)
-                        or enumerate(chLocs["default_name"].values)
-                    )
-                    if e == ch["ch_name"]
-                ]
-                info["chs"][idx]["loc"][0] = 95 * 1e-3 * chLocs["X"].values[a]
-                info["chs"][idx]["loc"][1] = 95 * 1e-3 * chLocs["Y"].values[a]
-                info["chs"][idx]["loc"][2] = 95 * 1e-3 * chLocs["Z"].values[a]
-            except:
-                pass
-        return info
-
-    def get_stream_info(self):
-        # Retrieve the information from the streams in the data.
-        if hasattr(self, "stream_info"):
-            return self.stream_info
-        else:
-            return None