calculate_gait_parameters.m

Go to the documentation of this file.

% =========================================================================== %
%> @brief calculates gait parameters from the processed data
%>
%> this function calculates the gait parameters from the processed data. the
%> gait parameters are calculated for each trial and then combined over all
%> trials. the gait parameters are:
%> - stride length
%> - step length
%> - step width
%>
%> @param basepath: (string) the basepath of the data, e.g. "D:/ETH_Data/"
%> @param ptp: (string) the participant to process, e.g. "SonE_01"
%> @param options the options for the processing:
%> - RECALCULATE: (logical) recalculate the gait parameters even if they are
%>   already calculated
%>
%> @retval none
%>
%> @copyright see the file @ref LICENSE in the root directory of the repository
% =========================================================================== %
function calculate_gait_parameters(basepath, ptp, options)
 
arguments
    basepath string
    ptp string
    options.RECALCULATE logical = true
    options.create_plots logical = false
end
 
% convert options
RECALCULATE = options.RECALCULATE;
 
% define the log
diary(fullfile(basepath, ptp, ptp + ".log"))
 
% get the participant number
ptp_num = regexp(ptp, "SonE_(\d+)|Pilot_(\d+)", "tokens");
ptp_num = str2double(ptp_num{1});
 
% log the start of the processing
log_entry("Start calculating gait parameters", ptp_num)
 
%% load the process info
filtering_done = false;
num_waited = 0;
while ~filtering_done
    proc_info = readstruct(fullfile(basepath, ptp, "proc_info.json"));
    
    if isfield(proc_info, "filtering_done")
        
        if proc_info.filtering_done
            filtering_done = proc_info.filtering_done;
        else
            
            log_entry("Filtering is not done yet. I'll wait for a bit.", ptp_num, 5)
            
            num_waited = num_waited + 1;
            
            if num_waited > 10
                log_entry("Something seems to be wrong. I'll stop waiting.", ptp_num, 2)
                
                error("I'm stuck in a waiting loop...")
            end
            pause(5) % wait for 5 seconds
        end
        
    else
        error("The filtering done field is missing");
    end
    
end
 
% ckeck if the gait parameters are already calculated
if isfield(proc_info, "gait_parameters_calculated") && ~RECALCULATE
    if proc_info.gait_parameters_calculated
        log_entry("Gait parameters are already calculated", ptp_num, 4)
        
        return
    end
end
 
% load the processed data
try
    load(fullfile(basepath, ptp, "temp", "processed_data.mat"), "result");
catch ME
    log_entry("The processed data could not be loaded", ptp_num, 2)
    
    % log the error
    log_entry(ME.message, ptp_num, 2)
    for i = 1:numel(ME.stack)
        log_entry(ME.stack(i).name + " (Line: " + string(ME.stack(i).line) + ")", ptp_num, 2)
    end
    
    error("The processed data could not be loaded")
end
 
% redefine the gait events
% until now, I only have the TO and HS events. Since the actual tempospatial
% parameters should be compared, I want to ensure that I catch a midstance
% moment. then I defiinitively have zero velocity detection in place. this
% will also not somehow "fake" better results, since the feet are not moving
% at this point. It will only reduce effects where the feet were already steady
% in reality but the filter has them in a steady state only a bit later.
%
% the midstance (MS) will be defined as the center between the HS and TO of the
% same stance phase. this will be done for both feet.
%
% yes, MS is not really an event but a period. since I only get one index per
% midstance period, I still call this moment the MS event.
 
% loop over all trials
trials = string(fieldnames(result.vicon))';
for trial = trials
    
    % get the gait events
    HS_l_idx = result.vicon.(trial).GaitEvents.HSleftlocs;
    TO_l_idx = result.vicon.(trial).GaitEvents.TOleftlocs;
    HS_r_idx = result.vicon.(trial).GaitEvents.HSrightlocs;
    TO_r_idx = result.vicon.(trial).GaitEvents.TOrightlocs;
    
    % make sure that the first HS is before the first TO
    while HS_l_idx(1) > TO_l_idx(1)
        TO_l_idx(1) = [];
        
        log_entry("Removed first left TO because it was before the first HS", ptp_num, 5)
    end
    while HS_r_idx(1) > TO_r_idx(1)
        TO_r_idx(1) = [];
        
        log_entry("Removed first right TO because it was before the first HS", ptp_num, 5)
    end
    
    % make sure that the last TO is after the last HS
    while TO_l_idx(end) < HS_l_idx(end)
        HS_l_idx(end) = [];
        
        log_entry("Removed last left HS because it was after the last TO", ptp_num, 5)
    end
    while TO_r_idx(end) < HS_r_idx(end)
        HS_r_idx(end) = [];
        
        log_entry("Removed last right HS because it was after the last TO", ptp_num, 5)
    end
    
    % make sure that the number of events is the same
    try
        assert(numel(HS_l_idx) == numel(TO_l_idx), "The number of left events is not the same")
        assert(numel(HS_r_idx) == numel(TO_r_idx), "The number of right events is not the same")
    catch ME
        log_entry(ME.message, ptp_num, 2)
        
        % log the error
        log_entry(ME.message, ptp_num, 2)
        for i = 1:numel(ME.stack)
            log_entry(ME.stack(i).name + " (Line: " + string(ME.stack(i).line) + ")", ptp_num, 2)
        end
        
        continue;
    end
    
    % calculate the midstance moment as the rounded mean of the HS and TO
    MS_l_idx = round((HS_l_idx + TO_l_idx) / 2);
    MS_r_idx = round((HS_r_idx + TO_r_idx) / 2);
    
    % store the new events
    result.gait_events.(trial).MS_l = MS_l_idx;
    result.gait_events.(trial).MS_r = MS_r_idx;
    result.gait_events.(trial).num_stance_l = numel(HS_l_idx);
    result.gait_events.(trial).num_stance_r = numel(HS_r_idx);
    
    log_entry("Gait events redefined", ptp_num, 5, trial)
    log_entry(sprintf("Number of stance phases: left: %d, right: %d", result.gait_events.(trial).num_stance_l, result.gait_events.(trial).num_stance_r), ptp_num, 5, trial)
    
end
 
log_entry("Gait events redefined", ptp_num, 4)
 
% get the walking axes
%> @note this is for the vison data. the axes of the jump sensor coming from
%> the filter are defined as follows:
%> - sagittal: x-axis, positive forwards
%> - longitudinal: z-axis, positive downwards
%> - lateral: y-axis, negative in sinister direction
try
    sag_axis = axis2num(proc_info.walking_axes.sagittal);
    %lon_axis = axis2num(proc_info.walking_axes.longitudinal); % not used yet
    lat_axis = axis2num(proc_info.walking_axes.lateral);
    %upwards = direction2num(proc_info.walking_axes.upwards); % not used yet
    forwards = direction2num(proc_info.walking_axes.forwards);
    sinister = direction2num(proc_info.walking_axes.sinister);
catch ME
    log_entry("The walking axes are not defined", ptp_num, 2)
    
    % log the error
    log_entry(ME.message, ptp_num, 2)
    for i = 1:numel(ME.stack)
        log_entry(ME.stack(i).name + " (Line: " + string(ME.stack(i).line) + ")", ptp_num, 2)
    end
    
    error("The walking axes are not defined")
    
end
 
% calculate the gait parameters
 
% variables to store total number of parameters over all trials
num_stride_length_l = 0;
num_stride_length_r = 0;
num_step_length_l = 0;
num_step_length_r = 0;
num_step_width_l = 0;
num_step_width_r = 0;
 
% loop over all trials
for trial = trials
    
    % get the gait events
    try
        MS_l_idx = result.gait_events.(trial).MS_l;
        MS_r_idx = result.gait_events.(trial).MS_r;
    catch
        error_filename = "error_" + ptp + "_" + trial + ".mat";
        save(fullfile(tempdir, error_filename), "result")
        log_entry("The gait events are not defined", ptp_num, 2)
        
        continue
    end
    
    % check if the gait events are alternately left and right
    MS_test = sort([MS_l_idx; MS_r_idx]);
    MS_test = MS_test(1:2:end);
    
    try
        if numel(MS_test) == numel(MS_l_idx)
            assert(all(MS_test == MS_l_idx), "The gait events are not alternating left and right")
            first_stance = "left";
        else
            assert(all(MS_test == MS_r_idx), "The gait events are not alternating left and right")
            first_stance = "right";
        end
    catch ME
        
        % log the error
        log_entry(ME.message, ptp_num, 2)
        for i = 1:numel(ME.stack)
            log_entry(ME.stack(i).name + " (Line: " + string(ME.stack(i).line) + ")", ptp_num, 2)
        end
        
        error("The gait events are not alternating left and right")
    end
    
    % last stance
    if MS_l_idx(end) > MS_r_idx(end)
        last_stance = "left";
    else
        last_stance = "right";
    end
    
    %% introduce sagital and lateral offsets
    % both sides were filtered independently. the filter always initializes
    % the position at zero. this leads to a shift in the sagital and lateral
    % axis.
    %
    % the sagital offset is introduced by shifting the right foot to minimize
    % the mean difference between the left and right foot. this is done by
    % fitting a linear function to the right foot and shifting it.
    %
    % for the lateral axis, the jump sensors cannot know the walking base.
    % therefore, the mean walking base is calculated from the VICON data and
    % then one sensor is shifted to introduce the same walking base.
    
    % sagital offset
    
    % shift the right foot to minimize the mean difference
    left_linear  = fit((1:MS_l_idx(end)-MS_l_idx(1)+1)', result.jump_filtered.(trial).l(MS_l_idx(1):MS_l_idx(end),1), "poly1");
    right_linear = fit((1:MS_l_idx(end)-MS_l_idx(1)+1)', result.jump_filtered.(trial).r(MS_l_idx(1):MS_l_idx(end),1), "poly1"); % the reference to the left foot is correct
    shift = left_linear.p2 - right_linear.p2;
    
    % shift the right foot
    result.jump_filtered.(trial).r(:, 1) = result.jump_filtered.(trial).r(:, 1) + shift;
    result.jump_filtered.(trial).right_shift_sagital = shift;
    
    % lateral offset
    
    % calculate the mean walking base from the VICON data
    num_steps = min(numel(MS_l_idx), numel(MS_r_idx));
    mean_base = mean(abs(...
        result.vicon.(trial).KinematicData.Marker.LF(MS_l_idx(1:num_steps), lat_axis) - ...
        result.vicon.(trial).KinematicData.Marker.RF(MS_r_idx(1:num_steps), lat_axis)), ...
        "omitmissing");
    
    % shift the right foot to the right
    result.jump_filtered.(trial).r(:, 2) = result.jump_filtered.(trial).r(:, 2) + mean_base * -sinister;
    result.jump_filtered.(trial).right_shift_lateral = mean_base;
    
    %% stride length
    % the stride length is defined as the distance between the same foot at
    % two consecutive midstance events. the distance is calculated in the
    % sagittal axis.
    stride_length_vicon_l = abs(diff(result.vicon.(trial).KinematicData.Marker.LF(MS_l_idx, sag_axis), 1, 1));
    stride_length_vicon_r = abs(diff(result.vicon.(trial).KinematicData.Marker.RF(MS_r_idx, sag_axis), 1, 1));
    stride_length_imu_l = abs(diff(result.jump_filtered.(trial).l(MS_l_idx, 1), 1, 1));
    stride_length_imu_r = abs(diff(result.jump_filtered.(trial).r(MS_r_idx, 1), 1, 1));
    
    result.gait_parameters.(trial).stride_length.l.vicon = stride_length_vicon_l;
    result.gait_parameters.(trial).stride_length.r.vicon = stride_length_vicon_r;
    result.gait_parameters.(trial).stride_length.l.imu = stride_length_imu_l;
    result.gait_parameters.(trial).stride_length.r.imu = stride_length_imu_r;
    
    num_stride_length_l = num_stride_length_l + numel(stride_length_vicon_l);
    num_stride_length_r = num_stride_length_r + numel(stride_length_vicon_r);
    
    %% step length
    % the step length is defined as the distance between two consecutive
    % midstance events of the opposite feet. the distance is calculated in the
    % sagittal axis.
    
    % left step length
    if first_stance == "left"
        idx_start_l = 2;
        idx_start_r = 1;
    else
        idx_start_l = 1;
        idx_start_r = 1;
    end
    num_steps_l = min(numel(MS_l_idx(idx_start_l:end)), numel(MS_r_idx(idx_start_r:end)));
    
    positions_vicon_l = result.vicon.(trial).KinematicData.Marker.LF(MS_l_idx(idx_start_l:idx_start_l+num_steps_l-1), sag_axis);
    positions_vicon_r = result.vicon.(trial).KinematicData.Marker.RF(MS_r_idx(idx_start_r:idx_start_r+num_steps_l-1), sag_axis);
    positions_imu_l = result.jump_filtered.(trial).l(MS_l_idx(idx_start_l:idx_start_l+num_steps_l-1), 1);
    positions_imu_r = result.jump_filtered.(trial).r(MS_r_idx(idx_start_r:idx_start_r+num_steps_l-1), 1);
    
    step_length_vicon_l = (positions_vicon_l - positions_vicon_r) * forwards;
    step_length_imu_l = positions_imu_l - positions_imu_r;
    
    % right step length
    if first_stance == "right"
        idx_start_l = 1;
        idx_start_r = 2;
    else
        idx_start_l = 1;
        idx_start_r = 1;
    end
    num_steps_r = min(numel(MS_l_idx(idx_start_l:end)), numel(MS_r_idx(idx_start_r:end)));
    
    positions_vicon_l = result.vicon.(trial).KinematicData.Marker.LF(MS_l_idx(idx_start_l:idx_start_l+num_steps_r-1), sag_axis);
    positions_vicon_r = result.vicon.(trial).KinematicData.Marker.RF(MS_r_idx(idx_start_r:idx_start_r+num_steps_r-1), sag_axis);
    positions_imu_l = result.jump_filtered.(trial).l(MS_l_idx(idx_start_l:idx_start_l+num_steps_r-1), 1);
    positions_imu_r = result.jump_filtered.(trial).r(MS_r_idx(idx_start_r:idx_start_r+num_steps_r-1), 1);
    
    step_length_vicon_r = (positions_vicon_r - positions_vicon_l) * forwards;
    step_length_imu_r = positions_imu_r - positions_imu_l;
    
    result.gait_parameters.(trial).step_length.l.vicon = step_length_vicon_l;
    result.gait_parameters.(trial).step_length.r.vicon = step_length_vicon_r;
    result.gait_parameters.(trial).step_length.l.imu = step_length_imu_l;
    result.gait_parameters.(trial).step_length.r.imu = step_length_imu_r;
    
    num_step_length_l = num_step_length_l + numel(step_length_vicon_l);
    num_step_length_r = num_step_length_r + numel(step_length_vicon_r);
    
    %% step width
    % the step width is defined as the lateral distance between the heels at
    % two consecutive midstance events.
    
    % get all vicon heel positions
    positions_vicon_l = result.vicon.(trial).KinematicData.Marker.LF(MS_l_idx, lat_axis);
    positions_vicon_r = result.vicon.(trial).KinematicData.Marker.RF(MS_r_idx, lat_axis);
    
    % get all imu heel positions
    positions_imu_l = result.jump_filtered.(trial).l(MS_l_idx, 2);
    positions_imu_r = result.jump_filtered.(trial).r(MS_r_idx, 2);
    
    % calculate the step width
    try
        if first_stance == "left" && last_stance == "left"
            % if the first and last stance are left, there must be one more left
            % stance than right stance.
            assert(numel(MS_l_idx) == numel(MS_r_idx) + 1, "The number of left and right stances is not correct")
            
            % vicon
            result.gait_parameters.(trial).step_width.r.vicon = abs(positions_vicon_l(1:end-1) - positions_vicon_r) * sinister;
            result.gait_parameters.(trial).step_width.l.vicon = abs(positions_vicon_l(2:end) - positions_vicon_r) * sinister;
            
            % imu
            result.gait_parameters.(trial).step_width.r.imu = abs(positions_imu_l(1:end-1) - positions_imu_r);
            result.gait_parameters.(trial).step_width.l.imu = abs(positions_imu_l(2:end) - positions_imu_r);
            
        elseif first_stance == "right" && last_stance == "right"
            % if the first and last stance are right, there must be one more right
            % stance than left stance.
            assert(numel(MS_l_idx) + 1 == numel(MS_r_idx), "The number of left and right stances is not correct")
            
            % vicon
            result.gait_parameters.(trial).step_width.r.vicon = abs(positions_vicon_l - positions_vicon_r(2:end)) * sinister;
            result.gait_parameters.(trial).step_width.l.vicon = abs(positions_vicon_l - positions_vicon_r(1:end-1)) * sinister;
            
            % imu
            result.gait_parameters.(trial).step_width.r.imu = abs(positions_imu_l - positions_imu_r(2:end));
            result.gait_parameters.(trial).step_width.l.imu = abs(positions_imu_l - positions_imu_r(1:end-1));
            
        elseif first_stance == "left" && last_stance == "right"
            % if the first stance is left and the last stance is right, the number
            % of stances must be the same.
            assert(numel(MS_l_idx) == numel(MS_r_idx), "The number of left and right stances is not correct")
            
            % vicon
            result.gait_parameters.(trial).step_width.r.vicon = abs(positions_vicon_l - positions_vicon_r) * sinister;
            result.gait_parameters.(trial).step_width.l.vicon = abs(positions_vicon_l(2:end) - positions_vicon_r(2:end)) * sinister;
            
            % imu
            result.gait_parameters.(trial).step_width.r.imu = abs(positions_imu_l - positions_imu_r);
            result.gait_parameters.(trial).step_width.l.imu = abs(positions_imu_l(2:end) - positions_imu_r(2:end));
            
        elseif first_stance == "right" && last_stance == "left"
            % if the first stance is right and the last stance is left, the number
            % of stances must be the same.
            assert(numel(MS_l_idx) == numel(MS_r_idx), "The number of left and right stances is not correct")
            
            % vicon
            result.gait_parameters.(trial).step_width.r.vicon = abs(positions_vicon_l(2:end) - positions_vicon_r(2:end)) * sinister;
            result.gait_parameters.(trial).step_width.l.vicon = abs(positions_vicon_l - positions_vicon_r) * sinister;
            
            % imu
            result.gait_parameters.(trial).step_width.r.imu = abs(positions_imu_l(2:end) - positions_imu_r(2:end));
            result.gait_parameters.(trial).step_width.l.imu = abs(positions_imu_l - positions_imu_r);
            
        else
            error("The first and last stance are not defined")
            
        end
        
        num_step_width_l = num_step_width_l + numel(result.gait_parameters.(trial).step_width.l.vicon);
        num_step_width_r = num_step_width_r + numel(result.gait_parameters.(trial).step_width.r.vicon);
        
    catch ME
        
        % log the error
        log_entry(ME.message, ptp_num, 2)
        for i = 1:numel(ME.stack)
            log_entry(ME.stack(i).name + " (Line: " + string(ME.stack(i).line) + ")", ptp_num, 2)
        end
        
        continue
        
    end
    
    proc_info.trials.(trial).gait_parameters_calculated = true;
    
    log_entry("Gait parameters calculated", ptp_num, 4, trial)
    
end
 
%% combine the gait parameters over all trials
 
% create a table for the combined gait parameters
% the table has the following variables:
% - ptp: the participant (e.g. "SonE_01")
% - trial: the trial name
% - stride_length_l_vicon: the stride length of the left foot from the vicon data
% - stride_length_r_vicon: the stride length of the right foot from the vicon data
% - step_length_l_vicon: the step length of the left foot from the vicon data
% - step_length_r_vicon: the step length of the right foot from the vicon data
% - step_width_l_vicon: the step width of the left foot from the vicon data
% - step_width_r_vicon: the step width of the right foot from the vicon data
% - stride_length_l_imu: the stride length of the left foot from the imu data
% - stride_length_r_imu: the stride length of the right foot from the imu data
% - step_length_l_imu: the step length of the left foot from the imu data
% - step_length_r_imu: the step length of the right foot from the imu data
% - step_width_l_imu: the step width of the left foot from the imu data
% - step_width_r_imu: the step width of the right foot from the imu data
% - number: the number of the step of the trial
combined = table('Size', [1500, 15], ...
    'VariableTypes', ["categorical", "categorical", repmat("double", 1, 13)], ...
    'VariableNames', ["ptp", "trial", "stride_length_l_vicon", "stride_length_r_vicon", ...
    "step_length_l_vicon", "step_length_r_vicon", "step_width_l_vicon", "step_width_r_vicon", ...
    "stride_length_l_imu", "stride_length_r_imu", "step_length_l_imu", "step_length_r_imu", ...
    "step_width_l_imu", "step_width_r_imu", "number"]);
 
% Preallocate double values with NaN
combined.stride_length_l_vicon(:) = NaN;
combined.stride_length_r_vicon(:) = NaN;
combined.step_length_l_vicon(:) = NaN;
combined.step_length_r_vicon(:) = NaN;
combined.step_width_l_vicon(:) = NaN;
combined.step_width_r_vicon(:) = NaN;
combined.stride_length_l_imu(:) = NaN;
combined.stride_length_r_imu(:) = NaN;
combined.step_length_l_imu(:) = NaN;
combined.step_length_r_imu(:) = NaN;
combined.step_width_l_imu(:) = NaN;
combined.step_width_r_imu(:) = NaN;
 
for trial = trials
    
    % make sure that the trial exists
    if ~isfield(result.gait_parameters, trial)
        continue
    end
    
    % get the first empty row
    idx = find(ismissing(combined.ptp), 1, "first");
    
    % save the highest number of samples
    max_n_samples = 0;
    
    % vicon
    % stride length left
    n_samples = numel(result.gait_parameters.(trial).stride_length.l.vicon);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.stride_length_l_vicon(idx:idx+n_samples-1) = result.gait_parameters.(trial).stride_length.l.vicon;
    
    % stride length right
    n_samples = numel(result.gait_parameters.(trial).stride_length.r.vicon);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.stride_length_r_vicon(idx:idx+n_samples-1) = result.gait_parameters.(trial).stride_length.r.vicon;
    
    % step length left
    n_samples = numel(result.gait_parameters.(trial).step_length.l.vicon);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_length_l_vicon(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_length.l.vicon;
    
    % step length right
    n_samples = numel(result.gait_parameters.(trial).step_length.r.vicon);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_length_r_vicon(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_length.r.vicon;
    
    % step width left
    n_samples = numel(result.gait_parameters.(trial).step_width.l.vicon);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_width_l_vicon(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_width.l.vicon;
    
    % step width right
    n_samples = numel(result.gait_parameters.(trial).step_width.r.vicon);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_width_r_vicon(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_width.r.vicon;
    
    % imu
    % stride length left
    n_samples = numel(result.gait_parameters.(trial).stride_length.l.imu);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.stride_length_l_imu(idx:idx+n_samples-1) = result.gait_parameters.(trial).stride_length.l.imu;
    
    % stride length right
    n_samples = numel(result.gait_parameters.(trial).stride_length.r.imu);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.stride_length_r_imu(idx:idx+n_samples-1) = result.gait_parameters.(trial).stride_length.r.imu;
    
    % step length left
    n_samples = numel(result.gait_parameters.(trial).step_length.l.imu);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_length_l_imu(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_length.l.imu;
    
    % step length right
    n_samples = numel(result.gait_parameters.(trial).step_length.r.imu);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_length_r_imu(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_length.r.imu;
    
    % step width left
    n_samples = numel(result.gait_parameters.(trial).step_width.l.imu);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_width_l_imu(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_width.l.imu;
    
    % step width right
    n_samples = numel(result.gait_parameters.(trial).step_width.r.imu);
    if n_samples > max_n_samples; max_n_samples = n_samples; end
    combined.step_width_r_imu(idx:idx+n_samples-1) = result.gait_parameters.(trial).step_width.r.imu;
    
    % participant
    combined.ptp(idx:idx+max_n_samples-1) = categorical(ptp);
    
    % trial name
    combined.trial(idx:idx+max_n_samples-1) = categorical(trial);
    
    % number
    combined.number(idx:idx+max_n_samples-1) = 1:max_n_samples;
    
end
 
% remove the empty rows
combined = rmmissing(combined, "MinNumMissing", 14);
 
% save into the result
result.gait_parameters.combined = combined;
 
% save the gait parameters
log_entry("Gait parameters combined over all trials", ptp_num, 4)
 
% save the processed data
save(fullfile(basepath, ptp, "processed_data.mat"), "result")
 
%% create a bland altman plot for the gait parameters
 
if options.create_plots
    
    % create the folder if it does not exist
    if ~isfolder(fullfile(basepath, ptp, "gait_parameters"))
        mkdir(fullfile(basepath, ptp, "gait_parameters"))
    end
    
    % stride length
    comparison_plot(...
        result.gait_parameters.combined.stride_length_l_vicon, ...
        result.gait_parameters.combined.stride_length_l_imu, ...
        result.gait_parameters.combined.number, ...
        fullfile(basepath, ptp, "gait_parameters", "stride_length_l.png"), ...
        title = "Stride Length Left of " + ptp);
    comparison_plot(...
        result.gait_parameters.combined.stride_length_r_vicon, ...
        result.gait_parameters.combined.stride_length_r_imu, ...
        result.gait_parameters.combined.number, ...
        fullfile(basepath, ptp, "gait_parameters", "stride_length_r.png"), ...
        title = "Stride Length Right of " + ptp);
    
    % step length
    comparison_plot(...
        result.gait_parameters.combined.step_length_l_vicon, ...
        result.gait_parameters.combined.step_length_l_imu, ...
        result.gait_parameters.combined.number, ...
        fullfile(basepath, ptp, "gait_parameters", "step_length_l.png"), ...
        title = "Step Length Left of " + ptp);
    comparison_plot(...
        result.gait_parameters.combined.step_length_r_vicon, ...
        result.gait_parameters.combined.step_length_r_imu, ...
        result.gait_parameters.combined.number, ...
        fullfile(basepath, ptp, "gait_parameters", "step_length_r.png"), ...
        title = "Step Length Right of " + ptp);
    
    % step width
    comparison_plot(...
        result.gait_parameters.combined.step_width_l_vicon, ...
        result.gait_parameters.combined.step_width_l_imu, ...
        result.gait_parameters.combined.number, ...
        fullfile(basepath, ptp, "gait_parameters", "step_width_l.png"), ...
        title = "Step Width Left of " + ptp);
    comparison_plot(...
        result.gait_parameters.combined.step_width_r_vicon, ...
        result.gait_parameters.combined.step_width_r_imu, ...
        result.gait_parameters.combined.number, ...
        fullfile(basepath, ptp, "gait_parameters", "step_width_r.png"), ...
        title = "Step Width Right of " + ptp);
    
    % log
    log_entry("Bland Altman plots created", ptp_num, 4)
    
end
 
% set the status to completed
proc_info.gait_parameters_calculated = true;
proc_info.gait_parameters_calculated_time = datetime("now", "Format", "yyyy-MM-dd HH:mm:ss");
writestruct(proc_info, fullfile(basepath, ptp, "proc_info.json"))
 
end