def test_1_successive_outlier_karlsson(self):
     rri_list = [110, 100, 125, 100, 100, 70, 100, 130, 105, 100, 78, 100]
     self.assertEqual(
         remove_ectopic_beats(rr_intervals=rri_list, method="karlsson"), [
             110, 100, np.nan, 100, 100, np.nan, 100, np.nan, 105, 100,
             np.nan, 100
         ])
 def test_1_successive_outlier_Acer(self):
     rri_list = [
         100, 100, 100, 100, 100, 100, 100, 100, 110, 930, 110, 100, 10
     ]
     self.assertEqual(
         (remove_ectopic_beats(rr_intervals=rri_list, method="acar")), [
             100, 100, 100, 100, 100, 100, 100, 100, 110, np.nan, 110, 100,
             np.nan
         ])
Beispiel #3
0
def get_peak_error_features(data_sample,
                            sample_rate=100,
                            rpeak_detector=0,
                            low_rri=300,
                            high_rri=2000):
    rules = ["malik", "karlsson", "kamath", "acar"]
    try:
        wd, m = hp.process(data_sample, sample_rate, calc_freq=True)
    except:
        try:
            wd, m = hp.process(data_sample, sample_rate)
        except:
            error_dict = {rule + "_error": np.nan for rule in rules}
            error_dict["outlier_error"] = np.nan
            return error_dict

    if rpeak_detector in [1, 2, 3, 4]:
        detector = PeakDetector(wave_type='ecg')
        peak_list = detector.ppg_detector(data_sample,
                                          rpeak_detector,
                                          preprocess=False)[0]
        wd["peaklist"] = peak_list
        wd = calc_rr(peak_list, sample_rate, working_data=wd)
        wd = check_peaks(wd['RR_list'],
                         wd['peaklist'],
                         wd['ybeat'],
                         reject_segmentwise=False,
                         working_data=wd)
        wd = clean_rr_intervals(working_data=wd)

    rr_intervals = wd["RR_list"]

    rr_intervals_cleaned = remove_outliers(rr_intervals,
                                           low_rri=low_rri,
                                           high_rri=high_rri)
    number_outliers = len(np.where(np.isnan(rr_intervals_cleaned))[0])
    outlier_ratio = number_outliers / (len(rr_intervals_cleaned) -
                                       number_outliers)

    error_sqi = {}
    error_sqi['outlier_error'] = outlier_ratio

    interpolated_rr_intervals = interpolate_nan_values(rr_intervals_cleaned)

    for rule in rules:
        nn_intervals = remove_ectopic_beats(interpolated_rr_intervals,
                                            method=rule)
        number_ectopics = len(np.where(np.isnan(nn_intervals))[0])
        ectopic_ratio = number_ectopics / (len(nn_intervals) - number_ectopics)
        error_sqi[rule + "_error"] = ectopic_ratio

    return error_sqi
Beispiel #4
0
def ectopic_sqi(
    data_sample,
    rule_index=0,
    sample_rate=100,
    rpeak_detector=0,
    wave_type='ppg',
    low_rri=300,
    high_rri=2000,
):
    """
    Evaluate the invalid peaks (which exceeds normal range)
    base on HRV rules: Malik, Karlsson, Kamath, Acar
    Output the ratio of invalid
    Parameters
    ----------
    data_sample :

    rule_index:
        0: Default Outlier Peak
        1: Malik
        2: Karlsson
        3: Kamath
        4: Acar
        (Default rule is Malik)

    sample_rate :
        (Default value = 100)
    rpeak_detector :
        (Default value = 0)
        To explain other detector options
    low_rri :
        (Default value = 300)
    high_rri :
        (Default value = 2000)

    Returns
    -------

    
    """
    rules = ["malik", "karlsson", "kamath", "acar"]
    try:
        wd, m = hp.process(data_sample, sample_rate, calc_freq=True)
    except:
        try:
            wd, m = hp.process(data_sample, sample_rate)
        except:
            error_dict = {rule + "_error": np.nan for rule in rules}
            error_dict["outlier_error"] = np.nan
            return error_dict

    # if rpeak_detector in [1, 2, 3, 4]:
    if wave_type == 'ecg':
        detector = PeakDetector(wave_type='ecg')
        peak_list = detector.ecg_detector(data_sample, rpeak_detector)[0]
    else:
        detector = PeakDetector(wave_type='ppg')
        peak_list = detector.ppg_detector(data_sample,
                                          rpeak_detector,
                                          preprocess=False)[0]
    wd["peaklist"] = peak_list
    wd = calc_rr(peak_list, sample_rate, working_data=wd)
    wd = check_peaks(wd['RR_list'],
                     wd['peaklist'],
                     wd['ybeat'],
                     reject_segmentwise=False,
                     working_data=wd)
    wd = clean_rr_intervals(working_data=wd)

    rr_intervals = wd["RR_list"]

    rr_intervals_cleaned = remove_outliers(rr_intervals,
                                           low_rri=low_rri,
                                           high_rri=high_rri)
    number_outliers = len(np.where(np.isnan(rr_intervals_cleaned))[0])
    outlier_ratio = number_outliers / (len(rr_intervals_cleaned) -
                                       number_outliers)
    if rule_index == 0:
        return outlier_ratio

    # error_sqi = {}
    # error_sqi['outlier_error'] = outlier_ratio

    interpolated_rr_intervals = interpolate_nan_values(rr_intervals_cleaned)

    rule = rules[rule_index]
    nn_intervals = remove_ectopic_beats(interpolated_rr_intervals, method=rule)
    number_ectopics = len(np.where(np.isnan(nn_intervals))[0])
    ectopic_ratio = number_ectopics / (len(nn_intervals) - number_ectopics)

    return ectopic_ratio
 def test_1_successive_outlier_kamath(self):
     rri_list = [101, 110, 100, 140, 100, 100, 70, 100, 130, 115, 100, 78]
     self.assertEqual(
         remove_ectopic_beats(rr_intervals=rri_list, method="kamath"),
         [101, 110, 100, np.nan, 100, 100, np.nan, 100, 130, 115, 100, 78])
 def test_1_successive_outlier_malik(self):
     rri_list = [100, 110, 100, 130, 100, 100, 70, 100, 120, 100]
     self.assertEqual(
         remove_ectopic_beats(rr_intervals=rri_list, method="malik"),
         [100, 110, 100, np.nan, 100, 100, np.nan, 100, 120, 100])