pyNIBS 0.2024.8__py3-none-any.whl → 0.2026.1__py3-none-any.whl

pynibs/expio/Mep.py

@@ -1,17 +1,13 @@
 import re
-import json
 import pylab
 import warnings
-import datetime
 import numpy as np
-import pandas as pd
 from lmfit import Model
 import scipy.io as spio
-from scipy.signal import butter, lfilter
 import matplotlib.pyplot as plt
+from scipy.signal import butter, lfilter
 
 import pynibs
-
 from pynibs.expio.fit_funs import sigmoid, sigmoid4_log, linear, exp, exp0
 
 try:
@@ -22,11 +18,7 @@ except ImportError:
 np.seterr(over="ignore")
 
 
-def get_mep_virtual_subject_TVS(x, p1=-5.0818, p2=-2.4677, p3=3.6466, p4=0.42639, p5=1.6665,
-                                mu_y_add=10 ** -5.0818, mu_y_mult=-0.9645334, mu_x_add=0.68827324,
-                                sigma_y_add=1.4739 * 1e-6, k=0.39316, sigma2_y_mult=2.2759 * 1e-2,
-                                sigma2_x_add=2.3671 * 1e-2,
-                                subject_variability=False, trial_variability=True):
+def get_mep_virtual_subject_TVS(**kwargs):
     print("get_mep_virtual_subject_TVS() got renamed to get_virtual_mep_tvs()")
     raise NotImplementedError
 
@@ -97,11 +89,13 @@ def get_virtual_mep_tvs(x, p1=-5.0818, p2=-2.4677, p3=3.6466, p4=0.42639, p5=1.6
         e_x_add = 10 ** np.random.normal(loc=mu_x_add, scale=np.sqrt(sigma2_x_add), size=n_x)
 
         # determine generalized value distribution of additive y variability
-        p_e_y_add = pynibs.generalized_extreme_value_distribution(x=np.linspace(5e-6, 1e-4, 100000),
-                                                                  mu=mu_y_add, sigma=sigma_y_add, k=k)
+        p_e_y_add = pynibs.util.utils.generalized_extreme_value_distribution(x=np.linspace(5e-6, 1e-4,
+                                                                                           100000),
+                                                                             mu=mu_y_add, sigma=sigma_y_add, k=k)
 
         # sample from generalized value distribution to determine additive y variability
-        e_y_add = np.random.choice(np.linspace(5e-6, 1e-4, 100000), p=p_e_y_add / np.sum(p_e_y_add), size=n_x)
+        e_y_add = np.random.choice(np.linspace(5e-6, 1e-4, 100000), p=p_e_y_add / np.sum(p_e_y_add),
+                                   size=n_x)
 
     else:
         e_y_mult = np.ones(n_x) * 10 ** mu_y_mult
@@ -232,7 +226,6 @@ class Mep:
         mep_min_threshold : float, optional
             Minimum user defined MEP amplitude (values below it will be filtered out).
         """
-
         self.intensities_orig = intensities
         self.mep_orig = mep
         self.cvar = []
@@ -330,7 +323,7 @@ class Mep:
 
             print('Fitting data to {} function ...'.format(str(self.fun.__name__)))
 
-            # filter out unseccussful fit
+            # filter out unsuccessful fit
             if self.fit.covar is None:
                 i_try = i_try + 1
                 print('Unsuccessful fit ... trying next function!')
@@ -492,9 +485,8 @@ class Mep:
         Returns
         -------
         fit : object instance
-            Gmodel object instance of best parameter fit with lowest parameter variance.
+            Gmodel object instance of the best parameter fit with the lowest parameter variance.
         """
-
         argnames = fun.__code__.co_varnames[1:fun.__code__.co_argcount]
         gmodel = Model(fun)
 
@@ -577,7 +569,6 @@ class Mep:
         Mep.mt : float
             Motor threshold for given MEP threshold.
         """
-
         self.mt = np.nan
 
         # sample MEP curve very fine in given range
@@ -592,7 +583,7 @@ class Mep:
              fontsize_axis=10, fontsize_legend=10, fontsize_label=10, fontsize_title=10, fun=None):
         """
         Plotting mep data and fitted curve together with uncertainties.
-        If ``fun == None`, the optimal function is plotted.
+        If ``fun == None``, the optimal function is plotted.
 
         Parameters
         ----------
@@ -627,7 +618,8 @@ class Mep:
         p = []
         if show_plot or fname_plot:
             x_range = np.max(self.intensities) - np.min(self.intensities)
-            x = np.linspace(np.min(self.intensities) - 0.0 * x_range, np.max(self.intensities) + 0.0 * x_range, 100)
+            x = np.linspace(np.min(self.intensities) - 0.0 * x_range,
+                            np.max(self.intensities) + 0.0 * x_range, 100)
 
             # plot random sampling curves
             if plot_samples:
@@ -717,14 +709,13 @@ class Mep:
         y_max : np.ndarray of float
             (N_x) Upper bounds of y-values.
         """
-
         if not self.fit:
             raise Exception('Please fit function first before evaluating uncertainties!')
 
         p = [np.array([self.popt[i] - sigma * self.pstd[i], self.popt[i] + sigma * self.pstd[i]])
              for i in range(self.popt.shape[0])]
 
-        para_combinations = pynibs.get_cartesian_product(p)
+        para_combinations = pynibs.util.utils.get_cartesian_product(p)
 
         y = np.zeros((x.shape[0], para_combinations.shape[0]))
 
@@ -750,7 +741,6 @@ class Mep:
         y : np.ndarray of float
             (N_x) Function values.
         """
-
         y = self.fun(x, *self.popt)
         return y
 
@@ -770,7 +760,6 @@ class Mep:
         y: np.ndarray of float
             (N_x) Function values.
         """
-
         y = self.fun(x, *p)
         return y
 
@@ -790,348 +779,10 @@ class Mep:
         y: np.ndarray of float
             (N_x) Function values.
         """
-
         y = self.fun_sig(x, *p)
         return y
 
 
-def read_biosig_emg_data(fn_data, include_first_trigger=False, type="cfs"):
-    """
-    Reads EMG data from a biosig file.
-
-    Parameters
-    ----------
-    fn_data : str
-        Path to the biosig file.
-    include_first_trigger : bool, default: False
-        Whether to include the first trigger event in the data (default: False).
-    type : str, default: 'cfs'
-        Type of the biosig file.
-
-    Returns
-    -------
-    emg_data : np.ndarray
-        (num_sweeps, num_channels, samples_per_sweep) EMG data with shape.
-    time_diff_list : list
-        Time differences between trigger events in seconds.
-    num_sweeps : int
-        Number of sweeps in the EMG data.
-    num_channels : int
-        Number of channels in the EMG data.
-    samples_per_sweep : int
-        Number of samples per sweep in the EMG data.
-    sampling_rate : int
-        Sampling rate of the EMG data.
-    """
-    try:
-        import biosig
-    except ImportError:
-        ImportError("Please install biosig from pynibs/pkg/biosig folder!")
-        return
-
-    if type == "cfs":  # TODO: also move the TXT reader here?
-        cfs_fn = fn_data
-        cfs_header = json.loads(biosig.header(cfs_fn))
-        cfs_emg = biosig.data(cfs_fn)
-
-        num_sweeps = cfs_header["NumberOfSweeps"]
-        num_channels = cfs_emg.shape[1]
-
-        total_num_samples = cfs_header["NumberOfSamples"]
-        samples_per_sweep = int(total_num_samples / num_sweeps)
-        sampling_rate = int(cfs_header["Samplingrate"])
-
-        # get timestamps
-        tms_pulse_timedelta = datetime.timedelta()
-        # get hour, minute and second
-        time_mep_list = []
-        time_diff_list = []
-        trigger_event_idcs = []
-        if include_first_trigger:
-            trigger_event_idcs.append(0)
-            time_diff_list.append(0)
-            time_mep_list.append(
-                datetime.datetime.strptime(
-                    cfs_header["EVENT"][0]["TimeStamp"], '%Y-%b-%d %H:%M:%S'
-                )
-                -
-                datetime.timedelta(
-                    seconds=float(cfs_header["EVENT"][0]["POS"])
-                )
-            )
-
-        # convert time string into integer
-        for event in cfs_header["EVENT"]:
-            date = datetime.datetime.strptime(event["TimeStamp"], '%Y-%b-%d %H:%M:%S')
-
-            # we are interested in the tms pulse time, so add it to ts
-            date += tms_pulse_timedelta
-            time_mep_list.append(date)
-            time_diff_list.append((date - time_mep_list[0]).total_seconds())
-
-            # compute indices in data block corresponding to the events
-            if event["TYP"] == "0x7ffe":
-                trigger_event_idcs.append(
-                    round(event["POS"] * cfs_header["Samplingrate"])
-                )
-
-        num_sweeps = min(num_sweeps, len(trigger_event_idcs))
-
-        emg_data = np.zeros((num_sweeps, num_channels, samples_per_sweep), dtype=np.float32)
-
-        for c_idx in range(num_channels):
-            # Use emg data starting from the index of the first trigger event
-            # assumptions:
-            # - after an initial offset all emg data were captured consecutively
-            # - the first emg data frame may be captured without an explicit TMS
-            #   tigger (eg. by checking the "write to disk" option)
-            # - if we had dropouts in between the emg data block (not just at the
-            #   beginning) we would need to adhere to the entire trigger_event_indices
-            #   list.
-            emg_data[:, c_idx, :] = np.reshape(
-                cfs_emg[trigger_event_idcs[0]:, c_idx],
-                (num_sweeps, samples_per_sweep)
-            )
-
-        return emg_data, time_diff_list, num_sweeps, num_channels, samples_per_sweep, sampling_rate
-
-
-def get_mep_elements(mep_fn, tms_pulse_time, drop_mep_idx=None, cfs_data_column=0, channels=None, time_format="delta",
-                     plot=False, start_mep=18, end_mep=35):
-    """
-    Read EMG data from CED .cfs or .txt file and returns MEP amplitudes.
-
-    Parameters
-    ----------
-    mep_fn : string
-        path to .cfs-file or .txt file (Signal export).
-    tms_pulse_time : float
-        Time in [s] of TMS pulse as specified in signal.
-    drop_mep_idx : List of int or None, optional
-        Which MEPs to remove before matching.
-    cfs_data_column : int or list of int, default: 0
-        Column(s) of dataset in cfs file. +1 for .txt.
-    channels : list of str, optional
-        Channel names.
-    time_format : str, default: "delta"
-        Format of mep time stamps in time_mep_lst to return.
-
-        * ``"delta"`` returns list of datetime.timedelta in seconds.
-        * ``"hms"`` returns datetime.datetime(year, month, day, hour, minute, second, microsecond).
-
-    plot : bool, default: False
-        Plot MEPs.
-    start_mep : float, default: 18
-        Start of time frame after TMS pulse where p2p value is evaluated (in ms).
-    end_mep : float, default: 35
-        End of time frame after TMS pulse where p2p value is evaluated (in ms).
-
-    Returns
-    -------
-    p2p_array : np.ndarray of float
-        (N_stim) Peak to peak values of N sweeps.
-    time_mep_lst : list of datetime.timedelta
-        MEP-timestamps
-    mep_raw_data : np.ndarray of float
-        (N_channel, N_stim, N_samples) Raw (unfiltered) MEP data.
-    mep_filt_data : np.ndarray of float
-        (N_channel, N_stim, N_samples) Filtered MEP data (Butterworth lowpass filter).
-    time : np.ndarray of float
-        (N_samples) Time axis corresponding to MEP data.
-    mep_onset_array : np.ndarray of float
-        (S_samples) MEP onset after TMS pulse.
-    """
-    # convert pulse time to datetime object in case of "delta"
-    if time_format == "delta":
-        tms_pulse_timedelta = datetime.timedelta(milliseconds=tms_pulse_time * 1000)
-    elif time_format == "hms":
-        tms_pulse_timedelta = datetime.timedelta()
-    else:
-        raise NotImplementedError("Specified time_format not implemented yet...")
-
-    if mep_fn.endswith('.cfs'):
-        # get data from cfs file
-        import biosig
-        mep_raw_data_tmp = biosig.data(mep_fn)
-        mep_raw_data_tmp = mep_raw_data_tmp[:, cfs_data_column]  # get first channel
-
-        # get header from cfs file
-        cfs_header = biosig.header(mep_fn)
-
-        # get timestamps
-        # get all indices of timestamps from cfs header
-        ts_mep_lst = [timestamp.start() for timestamp in re.finditer('TimeStamp', cfs_header)]
-        # get hour, minute and second
-        time_mep_list = []
-        # convert time string into integer
-        for index in ts_mep_lst:
-            hour = int(cfs_header[index + 26:index + 28])
-            minute = int(cfs_header[index + 29:index + 31])
-            second = int(cfs_header[index + 32:index + 34])
-            # fix bug with second 60
-            if second == 60:
-                ts = datetime.datetime(1900, 1, 1, hour, minute, 59)
-                ts += datetime.timedelta(seconds=1)
-            else:
-                ts = datetime.datetime(1900, 1, 1, hour, minute, second)
-
-            # we are interested in the tms pulse time, so add it to ts
-            ts += tms_pulse_timedelta
-            time_mep_list.append(ts)
-
-        if time_format == "delta":
-            time_mep_list = [time_mep_list[i] - time_mep_list[0] for i in range(len(time_mep_list))]
-        if time_format == "hms":
-            pass
-
-        # add first timestamp (not saved by signal) and shift other by isi
-        time_mep_list = [datetime.timedelta(seconds=0)] + [t + time_mep_list[1] - time_mep_list[0] for t in
-                                                           time_mep_list]
-
-        # get peak-to-peak values
-        # get the ratio of samples per sweep
-        sweep_index = cfs_header.find('NumberOfSweeps')
-        comma_index = cfs_header.find(',', sweep_index)
-        n_sweeps = int(cfs_header[sweep_index + 18:comma_index])
-        record_index = cfs_header.find('NumberOfRecords')
-        comma_index = cfs_header.find(',', record_index)
-        records = int(cfs_header[record_index + 19:comma_index])
-        n_samples = int(records / n_sweeps)
-        if not isinstance(n_samples, int):
-            print('Warning: Number of samples is not an integer.')
-            # TODO: Correct get_mep_elements() sample number check. This does not work as expected (from Ole)
-
-        # reshape numpy array
-        mep_raw_arr = np.zeros((len(cfs_data_column), n_sweeps, n_samples))
-
-        for i in cfs_data_column:
-            mep_raw_arr[i, :, :] = np.reshape(mep_raw_data_tmp[:, i], (n_sweeps, n_samples))
-
-        sampling_rate = get_mep_sampling_rate(mep_fn)
-
-    elif mep_fn.endswith('.mat'):
-        mep_data = spio.loadmat(mep_fn, struct_as_record=False, squeeze_me=True)
-
-        # find data
-        for k in mep_data.keys():
-            if isinstance(mep_data[k], spio.matlab.mio5_params.mat_struct):
-                mep_data = mep_data[k].__dict__
-                break
-
-        n_samples = mep_data['points']
-        mep_raw_arr = mep_data['values'].transpose(1, 2, 0)
-        time_mep_list = [datetime.timedelta(seconds=f.__dict__['start']) for f in mep_data['frameinfo']]
-        sampling_rate = get_mep_sampling_rate(mep_fn)
-
-    elif mep_fn.endswith('.txt'):
-        warnings.warn(".txt import is deprecated - use .mat or .cfs.", DeprecationWarning)
-        print("Reading MEP from .txt file")
-        # The Signal text export looks like this:
-        #
-        # "s"\t"ADC 0"\t"ADC 1"
-        # 0.00000000\t-0.066681\t-0.047607
-        # 0.00025000\t-0.066376\t-0.049286
-        # 0.00050000\t-0.066528\t-0.056610
-        #
-        # "s"\t"ADC 0"\t"ADC 1"
-        # 0.00000000\t-0.066681\t-0.047607
-        # 0.00025000\t-0.066376\t-0.049286
-        # 0.00050000\t-0.066528\t-0.056610
-        #
-        # With first column = time, second = 1st electrode, ...
-        # This is an example of 2 sweeps, 3 samples each, sampling rate = 4000
-
-        # Find number of samples per sweep
-        pattern = '"s"'
-        with open(mep_fn, 'r') as f:
-            for line_nr, line in enumerate(f):
-                print(f'{line_nr}: {line}')
-                if pattern in line and line_nr > 0:
-                    # find second occurance of "s" -> end of first sweep
-                    n_samples = line_nr
-                    print(f'{line_nr}: {line}')
-                if line != '\n':
-                    last_sample_time = line
-
-        # extract time (first column) of last samples
-        last_sample_time = float(last_sample_time[0:last_sample_time.find('\t')])
-
-        # subtract 2 because first row is header ("s"\t"ADC 0"\t"ADC 1") and last row is blank
-        n_samples = n_samples - 2
-
-        df_mep = pd.read_csv(mep_fn,
-                             delimiter="\t",
-                             skip_blank_lines=True,
-                             skiprows=lambda x: x % (n_samples + 2) == 0 and x > 0)
-
-        n_sweeps = int(df_mep.shape[0] / n_samples)
-        mep_raw_arr = np.zeros((len(cfs_data_column), n_sweeps, n_samples))
-
-        for i in range(n_sweeps):
-            mep_raw_arr[:, i, :] = df_mep.iloc[i * n_samples:(i + 1) * n_samples, 1:].transpose()
-
-        # get sampling rate by dividing number of sweeps by timing
-        sampling_rate = int(mep_raw_arr.shape[2] - 1) / last_sample_time
-
-        # build time_mep_list
-        # we only have information about the single mep timings, so let's assume signal sticks strictly to the protocol
-        sample_len = last_sample_time + 1 / sampling_rate
-
-        # TODO: The ISI is missing here, do we want to add it to the subject object?
-        time_mep_list = [datetime.timedelta(seconds=i * sample_len) +
-                         tms_pulse_timedelta for i in range(mep_raw_arr.shape[1])]
-
-    else:
-        raise ValueError("Unknown MEP file extension. Use .cfs or .txt.")
-
-    # get peak to peak value of every sweep and plot results in mep/plots/channels
-    if channels is None:
-        channels = [str(i) for i in cfs_data_column]
-
-    tmp = np.zeros((mep_raw_arr.shape[0], mep_raw_arr.shape[1], 3)).astype(object)
-    for i_channel in range(mep_raw_arr.shape[0]):
-        print(f"Calculating p2p values for channel: {channels[i_channel]}")
-
-        for i_zap in range(mep_raw_arr.shape[1]):
-            tmp[i_channel, i_zap, 0], \
-                tmp[i_channel, i_zap, 1], \
-                tmp[i_channel, i_zap, 2] = calc_p2p(sweep=mep_raw_arr[i_channel, i_zap, :],
-                                                    tms_pulse_time=tms_pulse_time,
-                                                    sampling_rate=sampling_rate,
-                                                    fn_plot=None,
-                                                    start_mep=start_mep,
-                                                    end_mep=end_mep)
-
-    p2p_arr = np.zeros((tmp.shape[0], tmp.shape[1]))
-    mep_onset_arr = np.zeros((tmp.shape[0], tmp.shape[1]))
-    mep_filt_arr = np.zeros(mep_raw_arr.shape)
-
-    time = np.arange(mep_raw_arr.shape[2]) / sampling_rate
-
-    for idx_channel in cfs_data_column:
-        for i, t in enumerate(tmp[idx_channel, :, :]):
-            p2p_arr[idx_channel, i] = tmp[idx_channel, i, 0]
-            mep_onset_arr[idx_channel, i] = tmp[idx_channel, i, 2]
-            mep_filt_arr[idx_channel, i, :] = tmp[idx_channel, i, 1]
-
-    if time_format == "delta":
-        time_mep_list = [time_mep_list[i] - time_mep_list[0] for i in range(len(time_mep_list))]
-    elif time_format == "hms":
-        pass
-
-    # remove MEPs according to drop_mep_idx and reset time
-    if drop_mep_idx is not None:
-        p2p_arr = np.delete(p2p_arr, drop_mep_idx)
-        mep_onset_arr = np.delete(mep_onset_arr, drop_mep_idx)
-        time_mep_list = np.delete(time_mep_list, drop_mep_idx)
-
-    keep_mep_idx = [i for i in range(mep_raw_arr.shape[1]) if i not in np.array(drop_mep_idx)]
-    mep_raw_arr = mep_raw_arr[:, keep_mep_idx, :]
-    mep_filt_arr = mep_filt_arr[:, keep_mep_idx, :]
-
-    return p2p_arr, time_mep_list, mep_raw_arr, mep_filt_arr, time, mep_onset_arr
-
-
 def calc_p2p_old_exp0(sweep, start_mep=None, end_mep=None, tms_pulse_time=None, sampling_rate=None):
     """
     Calc peak-to-peak values of an mep sweep.
@@ -1260,6 +911,48 @@ def calc_p2p_old_exp1(sweep, start_mep=18, end_mep=35, tms_pulse_time=None, samp
 
     return sweep_max - sweep_min
 
+def calc_emg_preactivation(sweep, tms_pulse_time=.2, measurement_start_time=0,
+                           sampling_rate=4000):
+    """
+    Computes EMG preactivation, i.e. max-min and SD of the EMG timeseries before the TMS pulse.
+
+    Parameters
+    ----------
+    sweep :  np.ndarray of float
+        (Nx1) Input curve.
+    tms_pulse_time : float, default: .2
+        Onset time of TMS pulse trigger in [s].
+    measurement_start_time : float, default: 0
+        Start time of the EMG measurement in [ms].
+    sampling_rate : int, default: 2000
+        Sampling rate in Hz.
+
+    Returns
+    -------
+    maxmin : float
+        The max-min of EMG timeseries before TMS pulse
+    sd : float
+        The max-min of EMG timeseries before TMS pulse
+    """
+    def time_to_idx_conversion(t):
+        return int((t - measurement_start_time) * sampling_rate / 1000)
+
+    def idx_to_time_conversion(i):
+        return i * 1000 / sampling_rate + measurement_start_time
+
+    # Compute start and stop idx according to sampling rate
+    if tms_pulse_time > 1:
+        warnings.warn(f"Is tms_pulse_time={tms_pulse_time} really in seconds?")
+
+    srch_win_end = time_to_idx_conversion(tms_pulse_time * 1000)  # get TMS impulse
+
+    if srch_win_end >= sweep.size:
+        srch_win_end = sweep.size - 1
+
+    maxmin = sweep[:srch_win_end].max() - sweep[:srch_win_end].min()
+
+    sd = np.var(sweep[:srch_win_end])
+    return maxmin, sd
 
 def calc_p2p(sweep, tms_pulse_time=.2, start_mep=20, end_mep=35, measurement_start_time=0, sampling_rate=4000,
              cutoff_freq=500, fn_plot=None):
@@ -1294,7 +987,6 @@ def calc_p2p(sweep, tms_pulse_time=.2, start_mep=20, end_mep=35, measurement_sta
     onset : float
         MEP onset after tms_pulse_time.
     """
-
     def time_to_idx_conversion(t):
         return int((t - measurement_start_time) * sampling_rate / 1000)
 
@@ -1307,9 +999,9 @@ def calc_p2p(sweep, tms_pulse_time=.2, start_mep=20, end_mep=35, measurement_sta
 
     # Filter requirements.
     order = 6
-
     sweep_filt = butter_lowpass_filter(sweep, cutoff_freq, sampling_rate, order)
-
+    # sweep_filt = butter_highpass_filter(sweep, 5, sampling_rate, order)
+    # sweep_filt = sweep.copy()
     # beginning of mep search window
     srch_win_start = time_to_idx_conversion(tms_pulse_time * 1000 + start_mep)  # get TMS impulse
 
@@ -1346,15 +1038,26 @@ def calc_p2p(sweep, tms_pulse_time=.2, start_mep=20, end_mep=35, measurement_sta
         plt.scatter(timepoints[sweep_max_idx], sweep_max, 15, color="r")
         plt.plot(timepoints, np.ones(len(timepoints)) * sweep_min, linestyle="--", color="r", linewidth=1)
         plt.plot(timepoints, np.ones(len(timepoints)) * sweep_max, linestyle="--", color="r", linewidth=1)
+        plt.vlines(x=timepoints[srch_win_start], ymin=sweep.min(), ymax=sweep.max(), color="r", linewidth=1)
+        plt.vlines(x=timepoints[srch_win_end], ymin=sweep.min(), ymax=sweep.max(), color="r", linewidth=1)
         plt.grid()
         plt.legend(["raw", "filtered", "p2p"], loc='upper right')
+        # plt.show()
+        # plt.close()
 
         plt.xlim([np.max((tms_pulse_time - 0.01, np.min(timepoints))),
                   np.min((timepoints[srch_win_end] + .1, np.max(timepoints)))])
+
+        # let's have a minimum of 50µV for the plot
+        diff = np.abs(sweep_min) - np.abs(sweep_max)
+        if diff < .05:
+            sweep_min -= .025
+            sweep_max += .025
         plt.ylim([-1.1 * np.abs(sweep_min), 1.1 * np.abs(sweep_max)])
 
         plt.xlabel("time in s", fontsize=11)
         plt.ylabel("MEP in mV", fontsize=11)
+        plt.title(f"MEP: {p2p:.2f} mV", fontsize=11)
         plt.tight_layout()
 
         plt.savefig(fn_plot, dpi=300, transparent=True)
@@ -1371,7 +1074,8 @@ def get_mep_sampling_rate(cfs_path):
 
     .. code-block:: sh
 
-       ``Samplingrate"\t: 3999.999810,\n``
+       Samplingrate\t: 3999.999810
+
 
     Parameters
     ----------
@@ -1444,13 +1148,36 @@ def butter_lowpass(cutoff, fs, order=5):
     b, a : np.ndarray, np.ndarray
         Numerator (b) and denominator (a) polynomials of the IIR filter.
     """
-
     nyq = 0.5 * fs
     normal_cutoff = cutoff / nyq
     b, a = butter(order, normal_cutoff, btype='low', analog=False)
     return b, a
 
 
+def butter_highpass(cutoff, fs, order=5):
+    """
+    Setup Butter high-pass filter and return filter parameters.
+
+    Parameters
+    ----------
+    cutoff : float
+        Cutoff frequency in [Hz].
+    fs : float
+        Sampling frequency in [Hz].
+    order : int, default: 5
+        Filter order.
+
+    Returns
+    -------
+    b, a : np.ndarray, np.ndarray
+        Numerator (b) and denominator (a) polynomials of the IIR filter.
+    """
+    nyq = 0.5 * fs
+    normal_cutoff = cutoff / nyq
+    b, a = butter(order, normal_cutoff, btype='high', analog=False)
+    return b, a
+
+
 def butter_lowpass_filter(data, cutoff, fs, order=5):
     """
     Applies Butterworth lowpass filter.
@@ -1471,12 +1198,36 @@ def butter_lowpass_filter(data, cutoff, fs, order=5):
     y : np.ndarray
         (N_samples) Output of the digital filter.
     """
-
     b, a = butter_lowpass(cutoff, fs, order=order)
     y = lfilter(b, a, data)
     return y
 
 
+def butter_highpass_filter(data, cutoff, fs, order=5):
+    """
+    Applies Butterworth lowpass filter.
+
+    Parameters
+    ----------
+    data : np.ndarray of float
+        (N_samples) Input of the digital filter.
+    cutoff : float
+        Cutoff frequency in [Hz].
+    fs : float
+        Sampling frequency in [Hz].
+    order : int
+        Filter order.
+
+    Returns
+    -------
+    y : np.ndarray
+        (N_samples) Output of the digital filter.
+    """
+    b, a = butter_highpass(cutoff, fs, order=order)
+    y = lfilter(b, a, data)
+    return y
+
+
 def get_time_date(cfs_paths):
     """
     Get time and date of the start of the recording out of .cfs file.
@@ -1491,7 +1242,6 @@ def get_time_date(cfs_paths):
     time_date : str
         Date and time.
     """
-
     cfs_header = biosig.header(cfs_paths[0])
     index = cfs_header.find('StartOfRecording')
     time_date = cfs_header[index + 21:index + 40]
@@ -1515,4 +1265,4 @@ def scale_e_for_dvs(e, mt=60, upper_limit=100):
     -------
     float : scaled electric field in V/m.
     """
-    return (e - mt)/(upper_limit - mt)
+    return (e - mt)/(upper_limit - mt)

pynibs/expio/__init__.py

@@ -1,8 +1,18 @@
+import pynibs
 from .brainvis import *
 from .brainsight import *
 from .exp import *
 from .fit_funs import *
+from .invesalius import *
 from .localite import *
 from .Mep import *
 from .signal_ced import *
 from .visor import *
+import warnings
+
+
+def get_mep_elements(*args, **kwargs):
+    warnings.warn(
+        "pyhibs.get_mep_elements() is deprecated, use pynibs.expio.signal_ced.get_mep_elements()"
+        " or pynibs.expio.neurone.get_mep_elements() instead.", DeprecationWarning, stacklevel=2)
+    return pynibs.expio.signal_ced.get_mep_elements(*args, **kwargs)