360_em_dataset/em_algorithms/I_S5T_single_view.m

% I_S5T_single_view.m
%
% This is a stripped down implememtation of the I_S5T algorithm that uses a
% single view (and thus fewer speed thresholds). The single view can be either
% FOV or eye+head (E+H). This implementation has resemblances to the I-VVT
% algorithm.
%
% input:
%   arffFile    - file to process
%   saccParams  - file holding the saccade parameters
%   typeOfMotion- 1 -> eye FOV, 2 -> E+H
%   outFile     - file to store detected eye movements
%   detectExtra - (optional) default: false. Detect blinks and OKN

function I_S5T_single_view(arffFile, saccParams, typeOfMotion, outFile, detectExtra, speedLow, speedMed)
    if (nargin < 4)
        detectExtra = false;
    end
    c_winDur = 100000; % 100ms
    c_speedLow = speedLow;
    c_speedMed = speedMed;
    c_headSpeedLow = 7;
    c_headSpeedMed = 30;
    c_confThres = 0.75;

    % primary labels
    c_prim_fix = 1;
    c_prim_sacc = 2;
    c_prim_sp = 3;
    c_prim_noise = 4;
    c_prim_attType = '{unassigned,fixation,saccade,SP,noise}';

    % secondary labels
    c_sec_unassigned = 0;
    c_sec_okn = 1;
    c_sec_vor = 2;
    c_sec_okn_vor = 3;
    c_sec_noise = 4;
    c_sec_head_purs = 5;
    c_sec_attType = '{unassigned,OKN,VOR,OKN+VOR,noise,head_pursuit}';

    [data, metadata, attributes, relation, comments] = LoadArff(arffFile);
    params = LoadParams(saccParams);
    sacc = DetectSaccades360(data, metadata, attributes, typeOfMotion, params);
    primData = zeros(size(data,1),1);
    primData(sacc) = c_prim_sacc;

    c_primAttName = 'primary_label';
    [data, attributes] = AddAttArff(data, attributes, primData, c_primAttName, c_prim_attType);
    primAttInd = GetAttPositionArff(attributes, c_primAttName);

    c_secAttName = 'secondary_label';
    secData = zeros(size(data,1),1);
    [data, attributes] = AddAttArff(data, attributes, secData, c_secAttName, c_sec_attType);
    secAttInd = GetAttPositionArff(attributes, c_secAttName);

    % get unassigned intervals
    ints = GetIntervalsIndexArff(data, attributes, c_primAttName, 0);

    % Classify intersaccadic intervals
    timeInd = GetAttPositionArff(attributes, 'time');
    [eyeFovVec, eyeHeadVec, headVec] = GetCartVectors(data, metadata, attributes);
    if (typeOfMotion == 1)
        gazeVec = eyeFovVec;
    elseif (typeOfMotion == 2)
        gazeVec = eyeHeadVec;
    end

    for ind=1:size(ints,1)
        winInts = GetWindowInts(ints(ind,1), ints(ind,2));
        for winInd=1:size(winInts,1)
            ClassifyInt(winInts(winInd,1), winInts(winInd,2));
        end
    end

    confInd = GetAttPositionArff(attributes, 'confidence');
    data(data(:,confInd) < c_confThres, primAttInd) = c_prim_noise;
    data(data(:,confInd) < c_confThres, secAttInd) = c_sec_noise;

    SaveArff(outFile, data, metadata, attributes, relation, comments);

    if (~detectExtra)
        return;
    end

    blinks =  DetectBlinks360(data, metadata, attributes, typeOfMotion, params);
    data(blinks, primAttInd) = c_prim_noise;

    okn = DetectOKN360(outFile, c_primAttName, c_prim_sacc);
    data(okn & data(:,secAttInd) == c_sec_unassigned, secAttInd) = c_sec_okn_vor; % put OKN+VOR because it is the most movement
    data(okn & data(:,secAttInd) == c_sec_vor, secAttInd) = c_sec_okn_vor;
    % assign label of OKN+VOR to OKN intervals that lay between OKN+VOR intervals
    ints = GetIntervalsIndexArff(data, attributes, c_secAttName, c_sec_okn);
    for ind=2:size(ints,1)-1
        if (data(ints(ind,1)-1,secAttInd) == c_sec_okn_vor && ...
            data(ints(ind,2)+1,secAttInd) == c_sec_okn_vor)
            data(ints(ind,1):ints(ind,2),secAttInd) = c_sec_okn_vor;
        end
    end

    SaveArff(outFile, data, metadata, attributes, relation, comments);

%
%-----------------------------------------------------------------------------------
%

    % this function returns the indices of non-overlappng windows of 100ms
    function [l_ints] = GetWindowInts(startInd, endInd)
        l_ints = zeros(0,2);
        l_prevInd = startInd;
        for l_ind=startInd:endInd
            if (data(l_ind,timeInd) - data(l_prevInd,timeInd) > c_winDur)
                l_ints = [l_ints; l_prevInd l_ind-1];
                l_prevInd = l_ind;
            end
        end
        
        if (data(endInd,timeInd) - data(l_prevInd,timeInd) > c_winDur / 2 || isempty(l_ints))
            l_ints = [l_ints; l_prevInd endInd];
        else
            l_ints(end,2) = endInd;
        end
    end

    function l_intType = ClassifyInt(startInd, endInd)
        if (startInd == endInd)
            ProcessOneSampleInt(startInd);
        end
        eyeSpeed = GetSpeed(gazeVec([startInd, endInd],:), data([startInd, endInd],timeInd));
        eyeSpeed = eyeSpeed(1);

        % cannot be used because we do not use head
        % adaptive eye speed thresholds
        % eye speed has to scale in proportion to head speed
        %speedLow = c_speedLow * (1 + headSpeed/c_headSpeedMed);
        %speedMed = c_speedMed * (1 + headSpeed/c_headSpeedMed);

        speedLow = c_speedLow;
        speedMed = c_speedMed;

        if (eyeSpeed < speedLow)
            data(startInd:endInd, primAttInd) = c_prim_fix;
        elseif (eyeSpeed < speedMed)
            data(startInd:endInd, primAttInd) = c_prim_sp;
        else
            data(startInd:endInd, primAttInd) = c_prim_noise;

        end
    end

    function ProcessOneSampleInt(index)
        if (index < size(data,1))
            data(index, primAttInd) = data(index+1, primAttInd);
        else
            data(index, primAttInd) = data(index-1, primAttInd);
        end
    end

end