data/dataset_Biosensors.csv

"keyword","repo_name","file_path","file_extension","file_size","line_count","content","language"
"Biosensors","Cassey2016/PPG_Peak_Detection","main.m",".m","3040","58","% =========================================================================
% Below functions are the implementation for the comparison methods in
% paper:
% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
% David D. McManus, and Ki H. Chon. 2022. 
% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
%
% Please cite our paper if you used our implementation code. Thank you.
% Author: Dong Han (dong.han@uconn.edu), 01/31/2022.
% =========================================================================

% -------------------------------------------------------------------------
% Input: 
% PPG_raw_buffer: should be 30-sec segment.
% fs_PPG_raw: the sampling frequency of the PPG_raw_buffer.
% -------------------------------------------------------------------------
%% Preparation of PPG signal:
addpath('.\func')
[PPG_buffer,fs_PPG] = my_func_prep_PPG_buffer(PPG_raw_buffer,fs_PPG_raw);

%% Method 1: implemented method 1-a
V_max_flag = true; % true == upper peak detection.
addpath('.\method_01_and_02');
output_upper_Shin_2009 = my_peak_compare_Shin_2009(PPG_buffer,fs_PPG,V_max_flag); % Implementation of Shin 2009 paper.

%% Method 2: implemented method 1-b
V_max_flag = false; % false == lower peak detection.
output_lower_Shin_2009 = my_peak_compare_Shin_2009(PPG_buffer,fs_PPG,V_max_flag); % Implementation of Shin 2009 paper.

%% Method 3 & 4: implemented method 2, it has two output peaks in ""output_Elgendi_1_2013""
delta = 0.5; % it was 0.1 as mentioned in the paper. But I think 0.5 works better (0.5 is in the billauer's website).
addpath('.\method_03_and_04');
[output_Elgendi_1_2013] = my_Elgendi_2013_method_I_peakdet(PPG_buffer, delta, fs_PPG);

%% Method 5: first derivative and adaptive thresholding method in Li et al. [4] and Elgendi's paper [3]
abpsig = resample(PPG_buffer,fs_abpsig,fs_PPG_buffer); % upsampling it to 125 Hz.
addpath('.\method_05');
[output_Elgendi_2_2013] = my_func_ppg_peakdet_method_05_Elgendi_2013_method_II(abpsig,fs_abpsig);

%% Method 6: implemented method 4
fs_abp = 250; % Hz.
abp = resample(PPG_buffer,fs_abp,fs_PPG); % upsampling it to 125 Hz.
addpath('.\method_06');
[output_Elgendi_3_2013] = my_Elgendi_2013_method_III_peakdet(abp,fs_abp);
            
%% Method 7: event-related moving averages with dynamic threshold method in Elgendi et al.'s paper [3] 
addpath('.\method_07');
[output_Elgendi_4_2013] = my_func_ppg_peakdet_method_07_Elgendi_2013_method_IV(-PPG_raw_buffer,fs_PPG_raw);

%% Method 8 & 9: peak detection on Stationary Wavelet Transform of PPG signal
fs_swt = 125; % Hz.
PPG_swt = resample(PPG_buffer,fs_swt,fs_PPG); % upsampling it to 125 Hz.
addpath('.\method_08_and_09');
[output_Vadrevu_1_2019,output_Vadrevu_2_2019] = my_Vadrevu_2019_peakdet(PPG_swt,fs_swt);","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","method_07/my_func_ppg_peakdet_method_07_Elgendi_2013_method_IV.m",".m","6505","156","function output_Elgendi_4_2013 = my_func_ppg_peakdet_method_07_Elgendi_2013_method_IV(raw_PPG,fs_PPG)
% =========================================================================
% This is my implementation of the method IV in this paper:
% Elgendi, Mohamed, et al. 
% ""Systolic peak detection in acceleration photoplethysmograms measured from 
% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
%
% Implemented by Dong Han on 03/02/2020.
%
% Please cite our paper if you used this code:
% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
% David D. McManus, and Ki H. Chon. 2022. 
% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
%
% Please cite our paper if you used our code. Thank you.
% =========================================================================
%% pre-processing - bandpass filtering
    [b, a] = butter(2,[0.5 8]/(fs_PPG/2)); % 2nd order bandpass filter 0.5-8Hz;
    filtered_PPG = filtfilt(b, a, raw_PPG); % zero-phase filter.
    filtered_PPG = filtered_PPG ./ std(filtered_PPG); % normalizing data is very important for my peak detection.
    filtered_PPG = filtered_PPG - mean(filtered_PPG);
    
    debugging_plot_flag = false; % only for plotting debugging figures. 
    
    % clip the signal by keeping the signal above zero.
    % I do not want to do this, so i will move all signal above zero.
    S_n = filtered_PPG;
% ---- Not following the paper to clip signal but move all signal above zero:
%     if min(S_n) < 0
%         Z_n = S_n - min(S_n); % elevate signal above zero.
%     else
%         % the minimum of S_n is still above zero, so do nothing.
%         Z_n = S_n;
%     end
% ---- Following the paper: only keep the positive value:
    Z_n = S_n;
    Z_n(Z_n < 0) = 0; 
%% pre-processing - squaring
    y_n = (Z_n).^2; % element-wise power.
%% feature extraction - generating potential blocks using two moving averages
    W_1 = round(0.111 * fs_PPG); % mentioned as the paper by brute-force search.
    % first moving average:
%     MA_peak = y_n; % for the beginning and ending signal, use the original signal.
%     for nn = 1+round(W_1/2):length(raw_PPG)-round(W_1/2)
%         temp_range = (nn-round(W_1/2)):(nn+round(W_1/2));
%         MA_peak(nn) = sum(y_n(temp_range))/W_1;
%     end
    MA_peak = movmean(y_n,W_1);
    
    % second moving average: 
    W_2 = round(0.667 * fs_PPG);
%     MA_beat = y_n;
%     for nn = 1+round(W_2/2):length(raw_PPG)-round(W_2/2)
%         temp_range = (nn-round(W_2/2)):(nn+round(W_2/2));
%         MA_beat(nn) = sum(y_n(temp_range))/W_2;
%     end
    MA_beat = movmean(y_n,W_2);
%% classification - thresholding
    beta = 0.02; % from the paper, by brute force search.
    z_bar = mean(y_n);
    alpha = beta * z_bar; % offset level.
    THR_1 = MA_beat + alpha;

    Blocks_Of_Interest = zeros(size(MA_peak)); % I initial it as zero.
    for nn = 1:length(MA_peak)
        if MA_peak(nn) > THR_1(nn) % I think it is THR_1(nn).
            Blocks_Of_Interest(nn) = 0.1;
        else
            % since I inital block of interest as zero, so I do not need to
            % assign zero again.
        end
    end
    
    % searh for onset and offset of each block.
    count_blocks = 0;
    block_onset = NaN(size(MA_peak));
    block_offset = NaN(size(MA_peak));
    if any(Blocks_Of_Interest > 0) % there is a block exist.
        for nn = 1:length(MA_peak)
            if nn == 1 && Blocks_Of_Interest(nn) > 0
               % the first point is a block;
               count_blocks = count_blocks + 1; % since the block start from zero, I have to add the counter first.
               block_onset(count_blocks,1) = nn;
            elseif nn == length(MA_peak) && Blocks_Of_Interest(nn) > 0
                % end with a block:
                % no need to add count_blocks;
                block_offset(count_blocks,1) = nn;
            else
                if nn > 1
                    if Blocks_Of_Interest(nn-1) == 0 && Blocks_Of_Interest(nn) > 0 % a jump means a new block.
                        count_blocks = count_blocks + 1;
                        block_onset(count_blocks,1) = nn;
                    elseif Blocks_Of_Interest(nn-1) > 0 && Blocks_Of_Interest(nn) == 0 % a drop means the end of previous block.
                        block_offset(count_blocks,1) = nn;
                    end
                end
            end
        end
    else
        % there is no block existed. Check why.
%        keyboard;
       HR_Elgendi_4_2013 = 0; % there is no peak location.
        S_peaks = 1;
    output_Elgendi_4_2013 = struct('filtered_PPG_Elgendi_4_2013',S_n,...
        'PPG_peak_loc_Elgendi_4_2013',S_peaks,...
        'HR_Elgendi_4_2013',HR_Elgendi_4_2013);
    return
    end
    
    block_onset(isnan(block_onset)) = []; % remove extra elements.
    block_offset(isnan(block_offset)) = []; % remove extra elements.
    if size(block_onset,1) ~= size(block_offset,1)
        % not same number of onset and offset, check here.
        keyboard;
    end
    
    if size(block_onset,1) ~= count_blocks
        keyboard;
    end
    S_peaks = NaN(count_blocks,1);
    THR_2 = W_1;
    
    for jj = 1:count_blocks
        block_idx = [block_onset(jj,1):block_offset(jj,1)];
        [~,I] = max(y_n(block_idx));
        S_peaks(jj,1) = block_onset(jj,1) + I - 1;
    end
    
    if debugging_plot_flag
        figure;
        plot(filtered_PPG);hold on;
        plot(S_peaks,y_n(S_peaks),'r.','markersize',10);
        plot(y_n);
        plot(MA_peak,'k:');
        plot(MA_beat,'r--');
        plot(THR_1,'g.-');
        plot(Blocks_Of_Interest*max(y_n)*10,'color',[0.5,0.5,0.5]); % grey color. I want to make block more obvious.
        
        legend('filtered PPG','peaks', 'squared PPG with clip to zero', 'MA peak', 'MA beat','THR 1', 'Blocks of Interest');
    end
    
    if isempty(S_peaks)
        HR_Elgendi_4_2013 = 0; % there is no peak location.
        S_peaks = 1;
    else
        HR_Elgendi_4_2013 = 60 * fs_PPG ./ diff(S_peaks); % calculate the HR.
    end
    
    output_Elgendi_4_2013 = struct('filtered_PPG_Elgendi_4_2013',S_n,...
        'PPG_peak_loc_Elgendi_4_2013',S_peaks,...
        'HR_Elgendi_4_2013',HR_Elgendi_4_2013);
end","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","method_01_and_02/my_peak_compare_Shin_2009.m",".m","21523","388","function [output_Shin_2009] = my_peak_compare_Shin_2009(raw_PPG,fs_PPG,V_max_flag)
% =========================================================================
% This function is the implementation of this paper:
% Shin, Hang Sik, Chungkeun Lee, and Myoungho Lee. 
% ""Adaptive threshold method for the peak detection of 
% photoplethysmographic waveform."" 
% Computers in biology and medicine 
% 39.12 (2009): 1145-1152.
% 
% Implemented by: Dong Han, on 02/10/2020.
%
% Please cite our paper if you used this code:
% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
% David D. McManus, and Ki H. Chon. 2022. 
% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
%
% Please cite our paper if you used our code. Thank you.
% =========================================================================
    debugging_plot_flag = false; % debugging plot. Can be false if don't want to plot anything.
%% Section 2.4 PPG frequency analysis and filtering.

    % (1): high pass >= 0.5 Hz.
    [b, a] = butter(6,[0.5 20]/(fs_PPG/2)); % bandpass filter 0.5-10Hz, changed from 0.5-20 to 0.5-9 Hz at 11/21/2018
    raw_PPG = filtfilt(b, a, raw_PPG); % -> AC component
    raw_PPG = raw_PPG ./ std(raw_PPG); % normalizing data is very important for my peak detection.
    raw_PPG = raw_PPG - mean(raw_PPG);
%% Section 2.5 & 2.6 Peak detection algorithm & Adaptive threshold detection

    % (1): bandpass filtering, no moving average filter or wavelet
    % decomposition.
    filtered_PPG = raw_PPG;
    Fs = fs_PPG;

    % % ===== interpolation to 1kHz of PPG: =====
    % x = 1:length(filtered_PPG);
    % v = filtered_PPG;
    % 
    % upsample_Fs = 250;
    % xq = 1:Fs/upsample_Fs:length(filtered_PPG);
    % vq1 = interp1(x,v,xq);
    % 
    % filtered_PPG = vq1;
    % Fs = upsample_Fs; % upsampled to 1000 Hz.

    % figure
    % plot(x,v,'o',xq,vq1,':.');
    % xlim([0 max(xq)]);
    % title('(Default) Linear Interpolation');

    % (2): V_max
    % slope_k: k-th slope amplitude;
    % s_r: slope changing rate (empirically: V_max = -0.6);
    % V_n_1: previous peak amplitude;
    % std_PPG: standard deviation of entire PPG signal;
    % Fs: sampling frequency.

    filtered_PPG = filtered_PPG(:);
    slope_k = NaN(size(filtered_PPG)); % should be a column vector.
    peak_loc = NaN(size(filtered_PPG)); % the array to store PPG peak index.
    pk_idx = 1; % the counter of peaks.
    %% Section 2.7: Peak Correction
    refractory_period = 0.6 * Fs; % sec * sampling frequency, initial refractory period is 0.6 sec.

    temp_win_left = round(0.15 * Fs); % sec * sampling frequency. This is the search region for local minima or maxima detection. chose 0.15 sec because 0.3 sec == 200 BPM.
    temp_win_right = round(0.15 * Fs);


    if V_max_flag % doing upper peak detection.
        s_r = -0.6; 
    else
        s_r = 0.6;%0.6; % not positive because my signal is zero mean.
        % I need to make all bottom signal positive, so I am moving them up.
    %     move_filter_amp = min(filtered_PPG) * (-1);
    %     filtered_PPG = filtered_PPG + move_filter_amp + std(raw_PPG); % move the lowest value more than zero.
    end


    slope_meet_PPG_flag = false; % mark if the slope meet PPG.
    slope_lower_PPG_flag = false; % mark if slope is lower than PPG, once PPG amp is lower than slope, mark it back.
    prev_slope = NaN; % First, I want to test not decreasing with PPG amplitude.
    if debugging_plot_flag % debugging plot
       figure;
       plot(filtered_PPG);
       hold on;
    end
    for kk = 1:length(filtered_PPG)
        % this is for debugging:
        if kk == 2
            my_stop = 1;
        end
        if kk == 1 % initial the slope value
            if V_max_flag
                slope_k(1,1) = 0.2 * max(filtered_PPG);
                std_PPG = std(filtered_PPG);
            else
                slope_k(1,1) = 0.2 * min(filtered_PPG); % since my signal is zero mean, I start from the negative amp. % I added what I moved.
                std_PPG = -std(filtered_PPG);
            end
    %         std_PPG = std(filtered_PPG);
            V_n_1 = slope_k(1,1);
        else
            if slope_meet_PPG_flag % slope has met PPG before.
                slope_k(kk,1) = filtered_PPG(kk,1);
                if V_max_flag % upper peak detection.
                    if kk < 2 % in the second point of signal
                        turn_point_flag = (slope_k(kk,1) < slope_k(kk-1,1)); % we met local maximum.
                    else
                        turn_point_flag = (slope_k(kk,1) < slope_k(kk-1,1)) & (slope_k(kk - 1,1) > slope_k(kk-2,1)); % we met local maximum.
                    end
                else
                    if kk < 2 % in the second point of signal
                        turn_point_flag = (slope_k(kk,1) > slope_k(kk-1,1)); % we met local minimum.
                    else
                        turn_point_flag = (slope_k(kk,1) > slope_k(kk-1,1)) & (slope_k(kk - 1,1) < slope_k(kk-2,1)); % we met local minimum.
                    end
                end

                if turn_point_flag % there is a turning point.
                    if pk_idx > 1 % not the first peak
                        % check local maxima or minima:
                        if (kk - temp_win_left) < 1
                            temp_left = 1;
                        else
                            temp_left = kk - temp_win_left;
                        end

                        if (kk + temp_win_right) > length(filtered_PPG)
                            temp_right = length(filtered_PPG);
                        else
                            temp_right = kk + temp_win_right;
                        end
                        temp_win = temp_left:temp_right;
                        local_m_check = filtered_PPG(temp_win);
                        if V_max_flag
                            temp_m_idx = find(local_m_check > slope_k(kk - 1,1)); % check if there is another maximum than detected, remember use k-1.
                        else
                            temp_m_idx = find(local_m_check < slope_k(kk - 1,1)); % check if there is another minimum than detected
                        end

                        if isempty(temp_m_idx) % there is no more max or min than this peak
                            if (kk - peak_loc(pk_idx-1,1) > refractory_period) % it is not the first peak, and the second peak is outside refractory period. It should be kk, because I have not assign the peak to the array.
                                peak_loc(pk_idx,1) = kk-1;
                                V_n_1 = filtered_PPG(peak_loc(pk_idx-1,1),1);% previous peak amplitude %slope_k(kk-1,1);
                                % update refractory period:
                                refractory_period = 0.6 * (kk - peak_loc(pk_idx-1,1)); % current index minus peak location. update the refractory peroid before updating the peak counting.
                                pk_idx = pk_idx + 1;

                                % reset slope meet flag:
                                slope_meet_PPG_flag = false;
                                slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs); 

                                % ---- for checking lower slope -------
                                temp_slope_check = s_r * ((V_n_1 + std_PPG) / Fs);
                                if V_max_flag
                                    if temp_slope_check > 0 % upper peaks should be decreasing with negative slope.
                                        temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
                                        slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
                                    end
                                else
                                    if temp_slope_check < 0 % upper peaks should be decreasing with negative slope.
                                        temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
                                        slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
                                    end
                                end
                                % -------------------------------------------
                                if V_max_flag
                                    temp_slope_below_PPG_flag = slope_k(kk,1) < filtered_PPG(kk,1); % upper peak detection, so slope below signal.
                                else
                                    temp_slope_below_PPG_flag = slope_k(kk,1) > filtered_PPG(kk,1); % lower peak detection, so slope above signal.
                                end
                                if temp_slope_below_PPG_flag % if slope is below PPG signal, we will reset slope value to PPG amplitude.
                                    slope_lower_PPG_flag = true; % slope is lower than PPG signal.
                                    prev_slope = slope_k(kk,1); % store the slope value now.
                                    slope_k(kk,1) = filtered_PPG(kk,1);
                                end
                                if debugging_plot_flag % debugging plot
                                    plot(kk,slope_k(kk,1),'r.');
                                end

                            else
                                if (kk - peak_loc(pk_idx-1,1) <= refractory_period) % it is because of the refractory period that cause the no peak. It should be kk, because I have not assign the peak to the array.                      
                                    slope_k(kk,1) = filtered_PPG(kk,1);% from the fig.3(c) in the paper, I see they are using the signal amplitude, not slope. 
                                    % no need to reset slope meet flag, waiting for
                                    % next turning point.
                                    if debugging_plot_flag % debugging plot
                                        plot(kk,slope_k(kk,1),'r.');
                                    end
                                end
                            end
                        else % there are more peaks higher then current kk peak.
                            if debugging_plot_flag % debugging plot
                                plot(kk,slope_k(kk,1),'r.');
                            end
                        end
                    else % the first peak, no need to check refractory period.
                                            % check local maxima or minima:
                        if (kk - temp_win_left) < 1
                            temp_left = 1;
                        else
                            temp_left = kk - temp_win_left;
                        end

                        if (kk + temp_win_right) > length(filtered_PPG)
                            temp_right = length(filtered_PPG);
                        else
                            temp_right = kk + temp_win_right;
                        end
                        temp_win = temp_left:temp_right;
                        local_m_check = filtered_PPG(temp_win);
                        if V_max_flag
                            temp_m_idx = find(local_m_check > slope_k(kk-1,1)); % check if there is another maximum than detected, always detect previous peak.
                        else
                            temp_m_idx = find(local_m_check < slope_k(kk-1,1)); % check if there is another minimum than detected
                        end

                        if isempty(temp_m_idx)
                            peak_loc(pk_idx,1) = kk-1;
                            if pk_idx > 1
                                V_n_1 = filtered_PPG(peak_loc(pk_idx-1,1),1);
                            else
                                V_n_1 = slope_k(kk-1,1);% previous peak amplitude %slope_k(kk-1,1);
                            end
                            pk_idx = pk_idx + 1;

                            % reset slope meet flag:
                            slope_meet_PPG_flag = false;
                            slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs); 
                            % ---- for checking lower slope -------
                            temp_slope_check = s_r * ((V_n_1 + std_PPG) / Fs);
                            if V_max_flag
                                if temp_slope_check > 0 % upper peaks should be decreasing with negative slope.
                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
                                end
                            else
                                if temp_slope_check < 0 % upper peaks should be decreasing with negative slope.
                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
                                end
                            end
                            % -------------------------------------------
                            if V_max_flag
                                temp_slope_below_PPG_flag = slope_k(kk,1) < filtered_PPG(kk,1); % upper peak detection, so slope below signal.
                            else
                                temp_slope_below_PPG_flag = slope_k(kk,1) > filtered_PPG(kk,1); % lower peak detection, so slope above signal.
                            end

                            if temp_slope_below_PPG_flag % if slope is below PPG signal, we will reset slope value to PPG amplitude.
                                slope_k(kk,1) = filtered_PPG(kk,1);
                            end
                                if debugging_plot_flag % debugging plot
                                    plot(kk,slope_k(kk,1),'r.');
                                end
                        else % there are more peaks higher then current kk peak.
                            if debugging_plot_flag % debugging plot
                                plot(kk,slope_k(kk,1),'r.');
                            end
                        end        
                        % no need to calculate refractory period, because there is only one peak, at least two peaks can give this correctly:
                    end
                else
                    % turning point did not meet, so keep decreasing or
                    % increasing the slope.
    %                 slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs); 
                    if debugging_plot_flag % debugging plot
                        plot(kk,slope_k(kk,1),'r.');
                    end
                end
            else % slope has not met PPG before. Keep decresing or increasing according to 'V_max_flag'.
    %             if slope_lower_PPG_flag % if there is a slope lower than PPG before:
    %                 slope_k(kk,1) = prev_slope;
    %             else
                    slope_k(kk,1) = slope_k(kk - 1,1) + s_r * ((V_n_1 + std_PPG) / Fs);
                            % ---- for checking lower slope -------
                            temp_slope_check = s_r * ((V_n_1 + std_PPG) / Fs);
                            if V_max_flag
                                if temp_slope_check > 0 % upper peaks should be decreasing with negative slope.
                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
                                end
                            else
                                if temp_slope_check < 0 % upper peaks should be decreasing with negative slope.
                                    temp_slope_check = -s_r * ((V_n_1 + std_PPG) / Fs);%-temp_slope_check;
                                    slope_k(kk,1) = slope_k(kk - 1,1) + temp_slope_check;
                                end
                            end
                            % -------------------------------------------

    %             end
    %             if slope_k(kk,1) < filtered_PPG(kk,1) % if slope is below PPG signal, we will reset slope value to PPG amplitude.
    %                 slope_lower_PPG_flag = true; % slope is lower than PPG signal.
    %                 prev_slope = slope_k(kk,1); % store the slope value now.
    %                 slope_k(kk,1) = filtered_PPG(kk,1);
    %             elseif slope_k(kk,1) > filtered_PPG(kk,1) % slope is higher.
    %                 slope_lower_PPG_flag = false;
    %                 prev_slope = NaN; % reset the prev value.

    %             end

    %             if slope_lower_PPG_flag ~= 1 % if slope was not lower than PPG.
    %                 % -------------- Check if two lines will meet -----------------
    %                 PPG_x1 = kk - 1;
    %                 PPG_x2 = kk;
    %                 PPG_y1 = filtered_PPG(kk-1,1);
    %                 PPG_y2 = filtered_PPG(kk,1);
    %                 slope = s_r;
    %                 slope_y2 = slope_k(kk,1);
    %                 slope_y1 = slope_k(kk-1,1);
    %                 [meet_x] = my_slope_meet_PPG(PPG_x1,PPG_x2,PPG_y1,PPG_y2,slope,slope_y2,slope_y1);
    % 
    %                 slope_meet_PPG_flag = (ceil(meet_x) == kk);%(slope_k(kk,1) - filtered_PPG(kk,1)) < 0.1; % 0.3 is a testing value. %slope_k(kk,1) == filtered_PPG(kk,1) % slope meets the PPG signal.
    %             end
                if V_max_flag
                    slope_meet_PPG_flag = ((slope_k(kk,1) < filtered_PPG(kk,1)) & slope_k(kk - 1,1) > filtered_PPG(kk - 1,1));
                else
                    slope_meet_PPG_flag = ((slope_k(kk,1) > filtered_PPG(kk,1)) & slope_k(kk - 1,1) < filtered_PPG(kk - 1,1)); % lower peak use inverse amplitude.
                end
                % -------------------------------------------------------------
                % I found I cannot use equal, because the PPG sampling
                % frequency is not so high.
                if slope_meet_PPG_flag
                    slope_k(kk,1) = filtered_PPG(kk,1); % starts from the next index, slope == PPG amplitude.
                else
                    % don't need to do anything.
                    if slope_lower_PPG_flag ~= 1 % there was no slope lower than PPG before.
                        if V_max_flag
                            slope_lower_PPG_flag = ((slope_k(kk,1) < filtered_PPG(kk,1)) & slope_k(kk - 1,1) == filtered_PPG(kk - 1,1)); % beginning part has same amplitude, but the ending part slope is lower.
                        else
                            slope_lower_PPG_flag = ((slope_k(kk,1) > filtered_PPG(kk,1)) & slope_k(kk - 1,1) == filtered_PPG(kk - 1,1)); % lower peak use inverse amplitude.
                        end
                        if slope_lower_PPG_flag
                            prev_slope = slope_k(kk,1); % store the slope value now.
                            slope_k(kk,1) = filtered_PPG(kk,1); % starts from the next index, slope == PPG amplitude.
                        end
                    else % there was slope lower than PPG before.

                        if V_max_flag
                            temp_PPG_below_slope_flag = filtered_PPG(kk,1) < prev_slope; % upper peak detection, so PPG below slope.
                        else
                            temp_PPG_below_slope_flag = filtered_PPG(kk,1) > prev_slope; % lower peak detection, so PPG above slope.
                        end

                        if temp_PPG_below_slope_flag % PPG is lower than prev slope.
                            slope_k(kk,1) = prev_slope; % stop tracking PPG amp.
                            slope_lower_PPG_flag = false; % reset the lower PPG flag.
                            prev_slope = NaN;
                        else
                            slope_k(kk,1) = filtered_PPG(kk,1); % keep tracking PPG amp.
                        end
                    end
                end
                if debugging_plot_flag % debugging plot
                    plot(kk,slope_k(kk,1),'r.');
                end
            end
        end

    end
    % ================== IMPORTANT: clean up NaN value ========================
    peak_loc(isnan(peak_loc)) = []; % remove empty peak loc.
    if V_max_flag % doing upper peak detection.

    else
        % moving signal back.
    %     filtered_PPG = filtered_PPG - move_filter_amp - std(raw_PPG); % move the lowest value more than zero.
    %     slope_k = slope_k - move_filter_amp - std(raw_PPG); % move the slope as well.
    end

    if debugging_plot_flag % debugging plot
        plot(peak_loc,filtered_PPG(peak_loc),'ko');
    end

    if isempty(peak_loc)
        HR_Shin_2009 = 0; % there is no peak location.
        peak_loc = 1;
    else
        HR_Shin_2009 = 60 * Fs ./ diff(peak_loc); % calculate the HR.
    end

    output_Shin_2009 = struct('PPG_peak_loc_Shin_2009',peak_loc,...
        'slope_Shin_2009',slope_k,...
        'filtered_PPG_Shin_2009',filtered_PPG,...
        'HR_Shin_2009',HR_Shin_2009); 
end","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","method_05/my_func_ppg_peakdet_method_05_Elgendi_2013_method_II.m",".m","11993","412","function [output_Elgendi_2_2013] = my_func_ppg_peakdet_method_05_Elgendi_2013_method_II(raw_PPG,fs_PPG) 
% -------------------------------------------------------------------------
% This peak detection function was mentioned in this paper:
% Elgendi, Mohamed, et al. 
% ""Systolic peak detection in acceleration photoplethysmograms measured from 
% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
% 
    [onsetp,peakp,dicron,abpsig] = delineator(raw_PPG,fs_PPG);
% -------------------------------------------------------------------------
    
    if isempty(peakp) % there is no peak detected:
        HR_Elgendi_2_2013 = 0; % there is no peak location.
        peakp = 1;
    else
        HR_Elgendi_2_2013 = 60 * fs_PPG ./ diff(peakp); % calculate the HR.
    end

    
    output_Elgendi_2_2013 = struct('PPG_peak_loc_Elgendi_2_2013',peakp,...
        'HR_Elgendi_2_2013',HR_Elgendi_2_2013,...
        'filtered_PPG_Elgendi_2_2013',abpsig);
end

function [onsetp,peakp,dicron,abpsig] = delineator(abpsig,abpfreq)
% Below was copied from Mathwords File Exchange ""Pulse Waveform Delineator"": 
% https://www.mathworks.com/matlabcentral/fileexchange/29484-pulse-waveform-delineator

% This program is intended to delineate the fiducial points of pulse waveforms
% Inputs:
%   abpsig: input as original pulse wave signals;
%   abpfreq: input as the sampling frequency;
% Outputs:
%   onsetp: output fiducial points as the beginning of each beat;
%   peakp: output fiducial points as systolic peaks;
%   dicron: output fiducial points as dicrotic notches;

% Its delineation is based on the self-adaptation in pulse waveforms, but
% not in the differentials.

% Reference:
%   BN Li, MC Dong & MI Vai (2010) 
%   On an automatic delineator for arterial blood pressure waveforms
%   Biomedical Signal Processing and Control 5(1) 76-81.

% LI Bing Nan @ University of Macau, Feb 2007
%   Revision 2.0.5, Apr 2009

%Initialization
peakIndex=0;
onsetIndex=0;
dicroIndex=0;
stepWin=2*abpfreq;
closeWin=floor(0.1*abpfreq);    %invalide for pulse beat > 200BPM

sigLen=length(abpsig);

peakp=[];
onsetp=[];
dicron=[];

%lowpass filter at first
coh=25;                     %cutoff frequency is 25Hz
coh=coh*2/abpfreq;
od=3;                       %3rd order bessel filter
[B,A]=besself(od,coh);
abpsig=filter(B,A,abpsig);
abpsig=10*abpsig;

abpsig=smooth(abpsig);

%Compute differentials
ttp=diff(abpsig);
diff1(2:sigLen)=ttp;
diff1(1)=diff1(2);
diff1=100*diff1;
clear ttp;
diff1=smooth(diff1);

if sigLen>12*abpfreq
    tk=10;
elseif sigLen>7*abpfreq
    tk=5;
elseif sigLen>4*abpfreq
    tk=2;
else
    tk=1;
end

%Seek avaerage threshold in original signal
if tk>1             %self-learning threshold with interval sampling
    tatom=floor(sigLen/(tk+2));
    for ji=1:tk       %search the slopes of abp waveforms
        sigIndex=ji*tatom;
        tempIndex=sigIndex+abpfreq;
        [tempMin,jk,tempMax,jl]=seeklocales(abpsig,sigIndex,tempIndex);
        tempTH(ji)=tempMax-tempMin;
    end
    abpMaxTH=mean(tempTH);
else
    [tempMin,jk,tempMax,jl]=seeklocales(abpsig,closeWin,sigLen);
    abpMaxTH=tempMax-tempMin;
end
clear j*;
clear t*;

abpMaxLT=0.4*abpMaxTH;

%Seek pulse beats by MinMax method
% diffIndex=1;
diffIndex=closeWin;             %Avoid filter distortion

while diffIndex<sigLen
    tempMin=abpsig(diffIndex);   %Initialization
    tempMax=abpsig(diffIndex);
    tempIndex=diffIndex;
    tpeakp=diffIndex;        %Avoid initial error
    tonsetp=diffIndex;      %Avoid initial error

    while tempIndex<sigLen
        %If no pulses within 2s, then adjust threshold and retry
        if (tempIndex-diffIndex)>stepWin
%             tempIndex=diffIndex-closeWin;
            tempIndex=diffIndex;
            abpMaxTH=0.6*abpMaxTH;
            if abpMaxTH<=abpMaxLT
                abpMaxTH=2.5*abpMaxLT;
            end
            break;
        end

        if (diff1(tempIndex-1)*diff1(tempIndex+1))<=0  %Candidate fiducial points
            if (tempIndex+5)<=sigLen
                jk=tempIndex+5;
            else
                jk=sigLen;
            end
            if (tempIndex-5)>=1
                jj=tempIndex-5;
            else
                jj=1;
            end

            %Artifacts of oversaturated or signal loss?
            if (jk-tempIndex)>=5
                for ttk=tempIndex:jk
                    if diff1(ttk)~=0
                        break;
                    end
                end
                if ttk==jk
                    break;          %Confirm artifacts
                end
            end

            if diff1(jj)<0          %Candidate onset
                if diff1(jk)>0
                    [tempMini,tmin,ta,tb]=seeklocales(abpsig,jj,jk);
                    if abs(tmin-tempIndex)<=2
                        tempMin=tempMini;
                        tonsetp=tmin;
                    end
                end
            elseif diff1(jj)>0      %Candidate peak
                if diff1(jk)<0
                    [tc,td,tempMaxi,tmax]=seeklocales(abpsig,jj,jk);
                    if abs(tmax-tempIndex)<=2
                        tempMax=tempMaxi;
                        tpeakp=tmax;
                    end
                end
            end

            if ((tempMax-tempMin)>0.4*abpMaxTH)   %evaluation
                if ((tempMax-tempMin)<2*abpMaxTH)
                    if tpeakp>tonsetp
                        %If more zero-crossing points, further refine!
                        ttempMin=abpsig(tonsetp);
                        ttonsetp=tonsetp;
                        for ttk=tpeakp:-1:(tonsetp+1)
                            if abpsig(ttk)<ttempMin
                                ttempMin=abpsig(ttk);
                                ttonsetp=ttk;
                            end
                        end
                        tempMin=ttempMin;
                        tonsetp=ttonsetp;
                            
                        if peakIndex>0
                            %If pulse period less than eyeclose, then artifact
                            if (tonsetp-peakp(peakIndex))<(3*closeWin)
                                %too many fiducial points, then reset
                                tempIndex=diffIndex;                                
                                abpMaxTH=2.5*abpMaxLT;
                                break;
                            end
                            
                            %If pulse period bigger than 2s, then artifact
                            if (tpeakp-peakp(peakIndex))>stepWin
                                peakIndex=peakIndex-1;
                                onsetIndex=onsetIndex-1;
                                if dicroIndex>0
                                    dicroIndex=dicroIndex-1;
                                end
                            end

                            if peakIndex>0
                                %new pulse beat
                                peakIndex=peakIndex+1;
                                peakp(peakIndex)=tpeakp;
                                onsetIndex=onsetIndex+1;
                                onsetp(onsetIndex)=tonsetp;

                                tf=onsetp(peakIndex)-onsetp(peakIndex-1);

                                to=floor(abpfreq./20);   %50ms
                                tff=floor(0.1*tf);
                                if tff<to
                                    to=tff;
                                end
                                to=peakp(peakIndex-1)+to;

                                te=floor(abpfreq./2);   %500ms
                                tff=floor(0.5*tf);
                                if tff<te
                                    te=tff;
                                end
                                te=peakp(peakIndex-1)+te;
                                % Dong added on 05/07/2020:
                                % For MIMIC III PACPVC 3_2, ii = 25.
                                if te > length(diff1)
                                    te = length(diff1);
                                end
                                tff=seekdicrotic(diff1(to:te));
                                if tff==0
                                    tff=te-peakp(peakIndex-1);
                                    tff=floor(tff/3);
                                end
                                dicroIndex=dicroIndex+1;
                                dicron(dicroIndex)=to+tff;

                                tempIndex=tempIndex+closeWin;
                                break;
                            end
                        end
                        
                        if  peakIndex==0   %new pulse beat
                            peakIndex=peakIndex+1;
                            peakp(peakIndex)=tpeakp;
                            onsetIndex=onsetIndex+1;
                            onsetp(onsetIndex)=tonsetp;

                            tempIndex=tempIndex+closeWin;
                            break;
                        end
                    end
                end
            end
        end

        tempIndex=tempIndex+1;      %step forward
    end

%     diffIndex=tempIndex+closeWin;    %for a new beat
    diffIndex=tempIndex+1;
end

if isempty(peakp),return;end
%Compensate the offsets of lowpass filter
sigLen=length(peakp);
for diffIndex=1:sigLen          %avoid edge effect
    tempp(diffIndex)=peakp(diffIndex)-od;
end
ttk=tempp(1);
if ttk<=0
    tempp(1)=1;
end 
clear peakp;
peakp=tempp;
clear tempp;

sigLen=length(onsetp);
for diffIndex=1:sigLen
    tempp(diffIndex)=onsetp(diffIndex)-od;
end
ttk=tempp(1);
if ttk<=0
    tempp(1)=1;
end 
clear onsetp;
onsetp=tempp;
clear tempp;

if isempty(dicron),return;end
sigLen=length(dicron);
for diffIndex=1:sigLen
    if dicron(diffIndex)~=0
        tempp(diffIndex)=dicron(diffIndex)-od;
    else
        tempp(diffIndex)=0;
    end
end
clear dicron;
dicron=tempp;
clear tempp;
end

function [mini,minip,maxi,maxip]=seeklocales(tempsig,tempbegin,tempend)
tempMin=tempsig(tempbegin);
tempMax=tempsig(tempbegin);
minip=tempbegin;
maxip=tempbegin;
for j=tempbegin:tempend
    if tempsig(j)>tempMax
        tempMax=tempsig(j);
        maxip=j;
    elseif tempsig(j)<tempMin
        tempMin=tempsig(j);
        minip=j;
    end
end

mini=tempMin;
maxi=tempMax;
end

function [dicron]=seekdicrotic(tempdiff)
izcMin=0;
izcMax=0;
itemp=3;
tempLen=length(tempdiff)-3;

dicron=0;

tempdiff=smooth(tempdiff);

while itemp<=tempLen
    if (tempdiff(itemp)*tempdiff(itemp+1))<=0
        if tempdiff(itemp-2)<0
            if tempdiff(itemp+2)>=0
                izcMin=izcMin+1;
                tzcMin(izcMin)=itemp;
            end
        end

%         if tempdiff(itemp-2)>0
%             if tempdiff(itemp+2)<=0
%                 izcMax=izcMax+1;
%                 tzcMax(izcMax)=itemp;
%             end
%         end
    end

    itemp=itemp+1;
end

if izcMin==0     %big inflection
    itemp=3;
    tempMin=tempdiff(itemp);
    itempMin=itemp;
    
    while itemp<tempLen
        if tempdiff(itemp)<tempMin
            tempMin=tempdiff(itemp);
            itempMin=itemp;
        end
        itemp=itemp+1;
    end

    itemp=itempMin+1;
    while itemp<tempLen
        if tempdiff(itemp+1)<=tempdiff(itemp-1)
            dicron=itemp;
            return;
        end
        itemp=itemp+1;
    end
elseif izcMin==1
    dicron=tzcMin(izcMin);
    return;
else
    itemp=tzcMin(1);
    tempMax=tempdiff(itemp);
    itempMax=itemp;
    
    while itemp<tempLen
        if tempdiff(itemp)>tempMax
            tempMax=tempdiff(itemp);
            itempMax=itemp;
        end
        itemp=itemp+1;
    end

    for itemp=izcMin:-1:1
        if tzcMin(itemp)<itempMax
            dicron=tzcMin(itemp);
            return;
        end
    end
end
end

function [diap]=seekdiap(tempabp)
diap=0;

[tt,ti]=max(tempabp);
if ti==0
    diap=floor(length(tempabp)./2);
else
    diap=ti;
end
end
","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","func/my_func_standardizing_PPG.m",".m","422","11","function PPG_buffer = my_func_standardizing_PPG(PPG_buffer)
% Standardizing PPG into zero-mean and uni-variance.
    var_sig_PPG = var(PPG_buffer);
    if var_sig_PPG == 0
        univar_sig_PPG = PPG_buffer;
    else
        univar_sig_PPG = sqrt(1/var_sig_PPG) * PPG_buffer;
    end
    zeromean_sig_PPG = univar_sig_PPG - mean(univar_sig_PPG);
    PPG_buffer = zeromean_sig_PPG; % univariance for PPG 30 sec segment
end","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","func/my_func_prep_PPG_buffer.m",".m","554","17","function [PPG_buffer,fs_PPG] = my_func_prep_PPG_buffer(PPG_raw_buffer,fs_PPG)
    % Resample PPG to 50 Hz.
    if fs_PPG ~= 50 % Hz
        PPG_down = resample(PPG_raw_buffer,50,fs_PPG);
        fs_PPG = 50;
    else
        PPG_down = PPG_raw_buffer;
    end

    PPG_buffer = PPG_down(:); % Make sure PPG is column vector
    % Standardizing PPG in sub-function.
    PPG_buffer = my_func_standardizing_PPG(PPG_buffer);

    % Filter signal.
    [b, a] = butter(6,[0.5 20]/(fs_PPG/2)); % Bandpass filter.
    PPG_buffer = filtfilt(b, a, PPG_buffer);
end","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","method_06/my_revise_run_wabp.m",".m","4330","109","function [r,ssf,my_avg0,A] = my_revise_run_wabp(abp,fs_abp)
% Below was copied from Erick Andres Perez Alday's Github repository 
% "" physionetchallenges / matlab-classifier-2020 "": 
% https://github.com/physionetchallenges/matlab-classifier-2020/blob/master/Tools/PhysioNet-Cardiovascular-Signal-Toolbox-master/Tools/BP_Tools/run_wabp.m
% WABP  ABP waveform onset detector.
%   r = run_wabp(abp) obtains the onset time (in samples) 
%       of each beat in the ABP waveform.
%
%   In:   ABP (125Hz sampled)
%   Out:  Onset sample time
% 
%   Usage:
%   - ABP waveform must have units of mmHg
%
%   Written by James Sun (xinsun@mit.edu) on Nov 19, 2005.  This ABP onset
%   detector is adapted from Dr. Wei Zong's wabp.c.
%
%   LICENSE:    
%       This software is offered freely and without warranty under 
%       the GNU (v3 or later) public license. See license file for
%       more information

% Dong changed: input should be 250 Hz for filtering.
%% Input checks
    % if nargin ~=1
    %     error('exactly 1 argment needed');
    % end

    if size(abp,2)~=1
        error('Input must be a <nx1> vector');
    end

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    % scale physiologic ABP
    offset   = 1600;
    scale    = 20;
    Araw     = abp*scale-offset;

    % LPF
    A = filter([1 0 0 0 0 -2 0 0 0 0 1],[1 -2 1],Araw)/24+30;
    A = (A(4:end)+offset)/scale; % Takes care of 4 sample group delay

    % ------- Dong changed this: -------
    A = A ./ std(A); % normalizing data is very important for my peak detection.
    A = A - mean(A);

    % Slope-sum function
    dypos          = diff(A);
    dypos(dypos<0) = 0;
    % ssf            = [0; 0; conv(ones(16,1),dypos)];
    w = 16/125*fs_abp; % 125 Hz to 250 Hz.
    ssf            = [0; 0; conv(ones(w,1),dypos)];

    % Decision rule
    first_8sec = 8*fs_abp;
    % avg0       = sum(ssf(1:1000))/1000;   % average of 1st 8 seconds (1000 samples) of SSF
    avg0       = sum(ssf(1:first_8sec))/first_8sec;
    Threshold0 = 3*avg0;                  % initial decision threshold

    % ignoring ""learning period"" for now
    lockout    = 0;    % lockout >0 means we are in refractory
    timer      = 0;
    % z          = zeros(100000,1);
    z          = zeros(fs_abp*800,1);
    counter    = 0;

    % Dong: copied from wabp.c, 02/27/2020. % Dong change here. 02/27/2020.
    TmDEF = 0.25; %5;% Dong change here. 02/27/2020.
    max_min_thres = 0.1; %10;% Dong change here. 02/27/2020.
    my_avg0 = zeros(size(abp));% Dong change here. 02/27/2020.
    step_adjust_thres = 0.025; % it was 0.1 % Dong change here. 02/27/2020.
    % for t = 50:length(ssf)-17
    for t = round(0.4*fs_abp):length(ssf)-w-1
        lockout = lockout - 1;
        timer   = timer   + 1;      % Timer used for counting time after previous ABP pulse

        if (lockout<1) & (ssf(t)>avg0+TmDEF) %(ssf(t)>avg0+5)  % Not in refractory and SSF has exceeded threshold here % Dong change here. 02/27/2020.
            timer = 0;
            maxSSF = max(ssf(t:t+w));  % Find local max of SSF
            minSSF = min(ssf(t-w:t));  % Find local min of SSF
            if maxSSF > (minSSF + max_min_thres) %(minSSF + 10)% Dong change here. 02/27/2020.
                onset = 0.01*maxSSF ;  % Onset is at the time in which local SSF just exceeds 0.01*maxSSF

                tt       = t-w:t;
                dssf     = ssf(tt) - ssf(tt-1);
                BeatTime = find(dssf<onset,1,'last')+t-w-1;
                counter  = counter+1;

                if isempty(BeatTime)
                    counter = counter-1;
                else
                    z(counter) = BeatTime;
                end
                Threshold0 = Threshold0 + step_adjust_thres*(maxSSF - Threshold0);  % adjust threshold
                avg0 = Threshold0 / 3;        % adjust avg

                lockout = round(32/125*fs_abp);   % lock so prevent sensing right after detection (refractory period)
            end
        end

        if timer > round(312/125*fs_abp)  % Lower threshold if no pulse detection for a while
            Threshold0 = Threshold0 - 0.1; %Threshold0 - 1; % Dong change here. 02/27/2020.
            avg0       = Threshold0/3;
        end
        my_avg0(t,1) = avg0+TmDEF; % % Dong change here. 02/27/2020.
    end
    r = z(find(z))-2;
end","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","method_06/my_Elgendi_2013_method_III_peakdet.m",".m","1028","22","function [output_Elgendi_3_2013] = my_Elgendi_2013_method_III_peakdet(raw_PPG,fs_PPG)
% -------------------------------------------------------------------------
% This peak detection function was mentioned in this paper:
% Elgendi, Mohamed, et al. 
% ""Systolic peak detection in acceleration photoplethysmograms measured from 
% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
% 
    [r,ssf,my_avg0,A] = my_revise_run_wabp(raw_PPG,fs_PPG);
% -------------------------------------------------------------------------
    if isempty(r)
        HR_Elgendi_3_2013 = 0; % there is no peak location.
        r = 1;
    else
        HR_Elgendi_3_2013 = 60 * fs_PPG ./ diff(r); % calculate the HR.
    end
    A = [A;0;0;0;]; % add zero
    A(1:6) = A(7); % first six plots are all high amplitude.
    output_Elgendi_3_2013 = struct('PPG_peak_loc_Elgendi_3_2013',r,...
        'HR_Elgendi_3_2013',HR_Elgendi_3_2013,...
        'filtered_PPG_Elgendi_3_2013',A,...
        'thres_Elgendi_3_2013',my_avg0);
end","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","method_03_and_04/my_Elgendi_2013_method_I_peakdet.m",".m","3762","111","function [output_Elgendi_1_2013] = my_Elgendi_2013_method_I_peakdet(raw_PPG, delta, fs_PPG)
% -------------------------------------------------------------------------
% Dong add this on 02/25/2020, based on this paper:
% Elgendi, Mohamed, et al. 
% ""Systolic peak detection in acceleration photoplethysmograms measured from 
% emergency responders in tropical conditions."" PLoS One 8.10 (2013): e76585.
% 
% (1): bandpass filter (0.5-8Hz)
    [b, a] = butter(6,[0.5 8]/(fs_PPG/2)); % bandpass filter 0.5-10Hz, changed from 0.5-20 to 0.5-9 Hz at 11/21/2018
    raw_PPG = filtfilt(b, a, raw_PPG); % -> AC component
    raw_PPG = raw_PPG ./ std(raw_PPG); % normalizing data is very important for my peak detection.
    raw_PPG = raw_PPG - mean(raw_PPG);
    
    debugging_plot_flag = false; % only for plotting debugging figures. 
% -------------------------------------------------------------------------
% Below code is copied from: http://billauer.co.il/peakdet.html
% PEAKDET Detect peaks in a vector
%        [MAXTAB, MINTAB] = PEAKDET(V, DELTA) finds the local
%        maxima and minima (""peaks"") in the vector V.
%        MAXTAB and MINTAB consists of two columns. Column 1
%        contains indices in V, and column 2 the found values.
%      
%        With [MAXTAB, MINTAB] = PEAKDET(V, DELTA, X) the indices
%        in MAXTAB and MINTAB are replaced with the corresponding
%        X-values.
%
%        A point is considered a maximum peak if it has the maximal
%        value, and was preceded (to the left) by a value lower by
%        DELTA.

% Eli Billauer, 3.4.05 (Explicitly not copyrighted).
% This function is released to the public domain; Any use is allowed.
    maxtab = [];
    mintab = [];

    raw_PPG = raw_PPG(:); % Just in case this wasn't a proper vector

    % if nargin < 3
      x = (1:length(raw_PPG))';
    % else 
    %   x = x(:);
    %   if length(raw_PPG)~= length(x)
    %     error('Input vectors v and x must have same length');
    %   end
    % end

    if (length(delta(:)))>1
      error('Input argument DELTA must be a scalar');
    end

    if delta <= 0
      error('Input argument DELTA must be positive');
    end

    mn = Inf; mx = -Inf;
    mnpos = NaN; mxpos = NaN;

    lookformax = 1;

    for i=1:length(raw_PPG)
      this = raw_PPG(i);
      if this > mx, mx = this; mxpos = x(i); end
      if this < mn, mn = this; mnpos = x(i); end

      if lookformax
        if this < mx-delta
          maxtab = [maxtab ; mxpos mx];
          mn = this; mnpos = x(i);
          lookformax = 0;
        end  
      else
        if this > mn+delta
          mintab = [mintab ; mnpos mn];
          mx = this; mxpos = x(i);
          lookformax = 1;
        end
      end
    end



    if isempty(maxtab)
        HR_Elgendi_1_max_2009 = 0; % there is no peak location.
        peak_loc_max = 1;
    else
        peak_loc_max = maxtab(:,1);
        HR_Elgendi_1_max_2009 = 60 * fs_PPG ./ diff(peak_loc_max); % calculate the HR.
    end

    if isempty(mintab)
        HR_Elgendi_1_min_2009 = 0; % there is no peak location.
        peak_loc_min = 1;
    else
        peak_loc_min = mintab(:,1);
        HR_Elgendi_1_min_2009 = 60 * fs_PPG ./ diff(peak_loc_min); % calculate the HR.
    end

    output_Elgendi_1_2013 = struct('filtered_PPG_Elgendi_1_2013',raw_PPG,...
        'PPG_peak_loc_Elgendi_1_max_2013',peak_loc_max,...
        'PPG_peak_loc_Elgendi_1_min_2013',peak_loc_min,...
        'HR_Elgendi_1_max_2013',HR_Elgendi_1_max_2009,...
        'HR_Elgendi_1_min_2013',HR_Elgendi_1_min_2009);


    if debugging_plot_flag % debugging plot
        figure;
        plot(x,raw_PPG);hold on;
        plot(peak_loc_max,raw_PPG(peak_loc_max),'ro');
        plot(peak_loc_min,raw_PPG(peak_loc_min),'go');
    end
end","MATLAB"
"Biosensors","Cassey2016/PPG_Peak_Detection","method_08_and_09/my_Vadrevu_2019_peakdet.m",".m","10598","329","function [output_Vadrevu_1_2019,output_Vadrevu_2_2019] = my_Vadrevu_2019_peakdet(PPG_buffer,fs_PPG)
% =========================================================================
% This is my implementation of this paper:
%
% Vadrevu, Simhadri, and M. Sabarimalai Manikandan. 
% ""A robust pulse onset and peak detection method for automated PPG signal 
% analysis system."" IEEE Transactions on Instrumentation and Measurement 
% 68.3 (2018): 807-817.
%
% Implemented by Dong Han on 05/03/2020.
%
% Please cite our paper if you used this code:
% Han, Dong, Syed K. Bashar, Jesús Lázaro, Fahimeh Mohagheghian, 
% Andrew Peitzsch, Nishat Nishita, Eric Ding, Emily L. Dickson, 
% Danielle DiMezza, Jessica Scott, Cody Whitcomb, Timothy P. Fitzgibbons, 
% David D. McManus, and Ki H. Chon. 2022. 
% ""A Real-Time PPG Peak Detection Method for Accurate Determination of 
% Heart Rate during Sinus Rhythm and Cardiac Arrhythmia"" 
% Biosensors 12, no. 2: 82. https://doi.org/10.3390/bios12020082 
%
% Please cite our paper if you used our code. Thank you.
% =========================================================================
    debug_flag = false; % decide to plot the paper figure or not.
    %% A. Stationary Wavelet Transform of PPG signal.

    % first, for the input length, you can know the maximum wavelet
    % decomposition level you can get:
    TYPE = '1D'; % extension method.
    MODE = 'zpd'; % zero extension.
    X = PPG_buffer;

    % based on your input signal length, you have to extend your input signal
    % to MATLAB suggested length.
    LEN = 45;%18; % 18 for fs_PPG 50, 45 for fs_PPG 125; for 30 sec input.
    YEXT = wextend(TYPE,MODE,X,LEN); % required by swt.
    sig = YEXT;
    % s = PPG_buffer;
    sLen = length(sig);
    wname = 'bior1.5';
    L = wmaxlev(sLen,wname);

    % [swa,swd] = swt(s,3,'bior1.5'); % the author mentioned wavelet biorthogonal 1.5 (bior1.5)
    [swa,swd] = swt(sig,L,wname); % the author mentioned wavelet biorthogonal 1.5 (bior1.5)
    s1 = swd(3,:) + swd(4,:); 
    s1 = s1(:); % make sure it is column vector.
    s2 = swd(5,:) + swd(6,:) + swd(7,:);
    s2 = s2(:); % make sure it is column vector.

    if debug_flag
        % if you want to debug the result.
        figure;
        t_plot = [1:length(sig)]'./fs_PPG; %
        subplot(5,1,1);
        plot(t_plot,sig);
        xlim([0 t_plot(end)])
        ylabel('Orig');
        title('Fig.3 in TIM 2019 paper');

        subplot(5,1,2)
        plot(t_plot,(swd(1,:) + swd(2,:)))
        xlim([0 t_plot(end)])
        ylabel('s_0');

        subplot(5,1,3);
        plot(t_plot,s1);
        xlim([0 t_plot(end)])
        ylabel('s_1');

        subplot(5,1,4);
        plot(t_plot,s2);
        xlim([0 t_plot(end)])
        ylabel('s_2');

        subplot(5,1,5);
        plot(t_plot,swa(7,:));
        xlim([0 t_plot(end)])
        ylabel('a_7');
    end
    %% B. Multiscale Sum and Products:
    p = s1 .* s2;
    p = p(:);

    if debug_flag
        % if you want to debug the result.
        figure;
        ax(1) = subplot(4,1,1);
        plot(t_plot,sig);
        xlim([0 t_plot(end)])
        ylabel('Orig');
        title('Fig.4 in TIM 2019 paper');

        ax(2) = subplot(4,1,2);
        p1 = swd(1,:) .* swd(2,:) .* swd(3,:) .* swd(4,:) .* swd(5,:) .* swd(6,:) .* swd(7,:); 
        plot(t_plot,p1);
        xlim([0 t_plot(end)])
        ylabel('p_1');

        ax(3) = subplot(4,1,3);
        p1 = swd(3,:) .* swd(4,:) .* swd(5,:) .* swd(6,:) .* swd(7,:); 
        plot(t_plot,p1);
        xlim([0 t_plot(end)])
        ylabel('p_2');

        ax(4) = subplot(4,1,4);
        plot(t_plot,p);
        xlim([0 t_plot(end)])
        ylabel('p');

        linkaxes(ax,'x');
    end
    %% C. Shannon Entropy Envelope Extraction
    eta = 0.01 + std(p);
    p_tilda = abs(p);
    p_tilda(p_tilda < eta) = 0;
    p_tilda = p_tilda(:);

    % normalize p_tilda:
    norm_p_tilda = (p_tilda - min(p_tilda)) ./ (max(p_tilda) - min(p_tilda));
    norm_p_tilda = norm_p_tilda(:);

    se = NaN(size(norm_p_tilda));

    for tttt = 1:size(norm_p_tilda,1)
        if norm_p_tilda(tttt) == 0
            % from MATLAB page: https://www.mathworks.com/help/wavelet/ref/wentropy.html
            %  log(0) = 0
            % 0log(0) = 0.
            se(tttt) = 0;
        else
            se(tttt) = -1 * norm_p_tilda(tttt) .* log(norm_p_tilda(tttt));
        end
    end

    % % method 1: CONV twice:
    filt_Len = floor(0.2 * fs_PPG); % 0.4 is better. 05/04/2020.
    % h = ones(filt_Len,1)/filt_Len;   % A third-order filter has length 4
    % s = conv(se,h,'same'); % return the same size as se
    % s = conv(s,h,'same'); % conv twice

    % method 2: FILTFILT.
    % for 4020, ii = 2, PPG is zero.
    if any(isnan(se))
        % any sample is NaN.
        new_se = se;
        new_se(isnan(new_se)) = [];
        if isempty(new_se)
            % nothing left after removing NaN.

                HR_Vadrevu_1_2019 = 0; % there is no peak location.
                onset_zx = 1;

                HR_Vadrevu_2_2019 = 0; % there is no peak location.
                peak_zx = 1;

                filter_PPG = PPG_buffer;
            output_Vadrevu_1_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
                'PPG_peak_loc_Vadrevu_1_2019',onset_zx,...
                'HR_Vadrevu_1_2019',HR_Vadrevu_1_2019);

                output_Vadrevu_2_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
                'PPG_peak_loc_Vadrevu_2_2019',peak_zx,...
                'HR_Vadrevu_2_2019',HR_Vadrevu_2_2019);
            return
        else
            % part of data is NaN, maybe I should fill zeros in it?
            keyboard;
        end
    end
    b = ones(filt_Len,1);
    a = -1;
    s = filtfilt(b, a, se); % -> AC component


    %% D. Pulse Peak and Onset Determination.
    % 1. Gaussian derivative kernel:
    sigma_1 = floor(0.05 * fs_PPG); % 0.05 mentioned in the paper.
    M = floor(2 * fs_PPG); % 2 mentioned in the paper.
    g = gausswin(M,sigma_1); % size should be 250 if Fs = 125.
    h_d = diff(g); % g(m+1) - g(m).
    z = conv(s,h_d,'same');

    % % My conv function did not work.
    % temp_z = zeros(size(s,1),1);
    % for nnnn = 1:size(s,1)
    %     for mmmm = 1:size(g,1)-1
    %         if (nnnn-mmmm+1 > 0)
    % %             h_d(mmmm) = g(mmmm+1) - g(mmmm);
    %         temp_z(nnnn) = temp_z(nnnn) + s(mmmm) * h_d(nnnn-mmmm+1);
    %         end
    %     end
    % end

    DownZCi = @(v) find(v(1:end-1) >= 0 & v(2:end) < 0); % Returns Down Zero-Crossing Indices. https://www.mathworks.com/matlabcentral/answers/267222-easy-way-of-finding-zero-crossing-of-a-function
    zx = DownZCi(z); % negative zero crossing point.

    % peak correction algorithm for onset:
    search_intv = floor(0.1 * fs_PPG / 2); % w/2
    onset_zx = NaN(size(zx));
    for zz = 1:size(zx,1)
        temp_zx = zx(zz);
        if temp_zx - search_intv > 0 % not exceed signal limit.
            if temp_zx + search_intv <= size(sig,1)
                temp_PPG = sig(temp_zx - search_intv : temp_zx + search_intv);
                [~,I] = min(temp_PPG);
                if isempty(I) ~= 1
                    adj_loc = temp_zx - search_intv + I - 1;
                else
                    % no local minimum.
                    adj_loc = temp_zx; 
                end
                onset_zx(zz) = adj_loc;
            else
                % right interval exceed signal length.
                onset_zx(zz) = zx(zz);
            end
        else
            % left interval exceed index 1.
            onset_zx(zz) = zx(zz);
        end
    end

    % find peak:
    peak_zx = NaN(size(onset_zx,1)-1,1); % one sample smaller.
    for zz = 2:size(onset_zx,1)
        temp_onset_1 = onset_zx(zz-1);
        temp_onset_2 = onset_zx(zz);
        temp_PPG = sig(temp_onset_1:temp_onset_2);
        [~,I] = max(temp_PPG);
        if isempty(I) ~= 1
           peak_zx(zz-1) = temp_onset_1 + I - 1; % peak is one sample size smaller.
        else
            peak_zx(zz-1) = onset_zx(zz);
        end
    end

    % prepare to output signal:
    filter_PPG = z(LEN+1:end-LEN);
    remove_left = find(onset_zx < LEN+1);
    if isempty(remove_left) ~= 1
        onset_zx(remove_left) = [];
    end
    remove_right = find(onset_zx > size(z,1) - LEN);
    if isempty(remove_right) ~= 1
        onset_zx(remove_right) = [];
    end
    onset_zx = onset_zx - LEN; % shifted.

    remove_left = find(peak_zx < LEN+1);
    if isempty(remove_left) ~= 1
        peak_zx(remove_left) = [];
    end
    remove_right = find(peak_zx > size(z,1) - LEN);
    if isempty(remove_right) ~= 1
        peak_zx(remove_right) = [];
    end
    peak_zx = peak_zx - LEN;

    if debug_flag
        % if you want to debug the result.
        figure;
        ax(1) = subplot(7,1,1);
        plot(t_plot,sig);
        xlim([0 t_plot(end)])
        ylabel('Orig');
        title('Fig.5 in TIM 2019 paper');

        ax(2) = subplot(7,1,2);
        plot(t_plot,p);
        xlim([0 t_plot(end)])
        ylabel('p');

        ax(3) = subplot(7,1,3);
        plot(t_plot,norm_p_tilda);
        xlim([0 t_plot(end)])
        ylabel('p_th');

        ax(4) = subplot(7,1,4);
        plot(t_plot,se);
        xlim([0 t_plot(end)])
        ylabel('se');

        ax(5) = subplot(7,1,5);
        plot(t_plot,s);
        xlim([0 t_plot(end)])
        ylabel('s');

        ax(6) = subplot(7,1,6);
        plot(t_plot,z);
        hold on;
        plot(t_plot(zx),z(zx),'ro');
        xlim([0 t_plot(end)]);
        ylabel('z');


        ax(7) = subplot(7,1,7);
        plot(t_plot,sig);
        hold on;
        plot(t_plot(onset_zx),sig(onset_zx),'go');
        plot(t_plot(peak_zx),sig(peak_zx),'ro');
        xlim([0 t_plot(end)])
        ylabel('orig with peak');

        linkaxes(ax,'x');
    end

    if isempty(onset_zx)
        HR_Vadrevu_1_2019 = 0; % there is no peak location.
        onset_zx = 1;
    else
        HR_Vadrevu_1_2019 = 60 * fs_PPG ./ diff(onset_zx); % calculate the HR.
    end
    
    if isempty(peak_zx)
        HR_Vadrevu_2_2019 = 0; % there is no peak location.
        peak_zx = 1;
    else
        HR_Vadrevu_2_2019 = 60 * fs_PPG ./ diff(peak_zx); % calculate the HR.
    end
    
    output_Vadrevu_1_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
        'PPG_peak_loc_Vadrevu_1_2019',onset_zx,...
        'HR_Vadrevu_1_2019',HR_Vadrevu_1_2019);

        output_Vadrevu_2_2019 = struct('filtered_PPG_Vadrevu_2019',filter_PPG,...
        'PPG_peak_loc_Vadrevu_2_2019',peak_zx,...
        'HR_Vadrevu_2_2019',HR_Vadrevu_2_2019);
    
end
","MATLAB"