Fix IDT issue by switching to a minimum gaze time-span instead of minum # of gazes. Additionally add a new parameter to IDT that determines the maximum gap between any two gazes in the window

Author: Joshua2000B

Options.qml

@@ -45,7 +45,7 @@ Popup {
         if(algSelection.currentIndex === 0) {
             rtn = rtn + "-" + windowSize.text + "-" + radius.text + "-" + peak.text
         } else if (algSelection.currentIndex === 1) {
-            rtn = rtn + "-" + durationWindow.text + "-" + dispersion.text
+            rtn = rtn + "-" + durationWindow.text + "-" + dispersion.text + "-" + maxGazeSpan.text
         } else if (algSelection.currentIndex === 2) {
             rtn = rtn + "-" + velocity.text + "-" + duration.text
         }
@@ -157,14 +157,14 @@ Popup {
 
         Text {
             id: durationWindowLabel
-            text: qsTr("Duration Window: ")
+            text: qsTr("Duration Window (ms): ")
         }
         TextField {
             id: durationWindow
             Layout.fillWidth: true
             //Int validator requires input to be a number >1 and <MAXINT
             validator: IntValidator {bottom: 1}
-            readonly property string defaultVal: "10"
+            readonly property string defaultVal: "100"
             text: defaultVal
         }
         Text {
@@ -178,6 +178,17 @@ Popup {
             readonly property string defaultVal: "125"
             text: defaultVal
         }
+        Text {
+            id: maxGazeSpanLabel
+            text: qsTr("Maximum Gaze Span (ms): ")
+        }
+        TextField {
+            id: maxGazeSpan
+            Layout.fillWidth: true
+            validator: IntValidator{bottom: 1}
+            readonly property string defaultVal: "1000"
+            text: defaultVal
+        }
         Item {
             // Filler element, fills the rest of the space in the layout to force the above elements to be closer to each other
             // rather than equally spaced in the entire layout space
@@ -249,6 +260,7 @@ Popup {
                 //IDT Algorithm Reset
                 durationWindow.text = durationWindow.defaultVal
                 dispersion.text = dispersion.defaultVal
+                maxGazeSpan.text = maxGazeSpan.defaultVal
 
                 //IVT Algorithm Reset
                 velocity.text = velocity.defaultVal

controller.cpp

@@ -449,7 +449,7 @@ void Controller::generateFixationData(QVector<QString> tasks, QString algSetting
             }
             else if(settings[0] == "IDT") {
                 //IDT-10-125 = IDT-duration_window-dispersion
-                algorithm = new IDTAlgorithm(gazes,settings[duration_window].toInt(),settings[dispersion].toInt());
+                algorithm = new IDTAlgorithm(gazes,settings[duration_window].toInt(),settings[dispersion].toInt(),settings[max_gaze_span].toInt());
             }
             else if(settings[0] == "IVT") {
                 //IVT-50-80 = IVT-velocity-duration

controller.h

@@ -51,7 +51,8 @@ enum basic {
 
 enum idt {
     duration_window = 1,
-    dispersion
+    dispersion,
+    max_gaze_span
 };
 
 enum ivt {

idtalgorithm.cpp

@@ -22,78 +22,67 @@ double computeGazeDifference(QVector<Gaze> gazes) {
     double final = (xmax - xmin) + (ymax - ymin);
     return final;
 }
+long long getLengthOfWindow(QVector<Gaze> gazes) {
+    if(gazes.size() <= 1) { return 0; }
+    return gazes[gazes.size() - 1].system_time - gazes[0].system_time;
+}
+bool isWindowConsistenlySpaced(QVector<Gaze> gazes, int maximum_space) {
+    for(int i = 0; i < gazes.size() - 1; ++i) {
+        if(gazes[i+1].system_time - gazes[i].system_time > maximum_space) {
+            return false;
+        }
+    }
+    return true;
+}
 
-IDTAlgorithm::IDTAlgorithm(QVector<Gaze> gazes, int _duration, int _dispersion) : FixationAlgorithm(gazes) {
+IDTAlgorithm::IDTAlgorithm(QVector<Gaze> gazes, int _duration, int _dispersion, int _max_gaze_span) : FixationAlgorithm(gazes) {
     duration_window = _duration;
     dispersion = _dispersion;
+    max_gaze_span = _max_gaze_span;
 }
 
 QVector<Fixation> IDTAlgorithm::generateFixations() {
 
     //This code follows the IDT Algorithm
+    QVector<Gaze> window;
+    int i = 0;
 
-    //QVector<Gaze> window;
-    while(session_gazes.size() != 0) { // While there are still points
-        // Initialize the window over the first points to not cover the duration threshold
-        QVector<Gaze> window;
-        int i = 0;
-        while(window.size() != duration_window && session_gazes.size() != 0) {
-            window.push_back(session_gazes[i]);
-            ++i;
-        }
+    while(getLengthOfWindow(window) < duration_window && i < session_gazes.size()) {
+        window.push_back(session_gazes[i]);
+        ++i;
+    }
 
-        // If dispersion of window points <= threshold
-        if(computeGazeDifference(window) <= dispersion) {
-            // Add additional points to the window until dispersion > threshold
-            while(computeGazeDifference(window) <= dispersion && i < session_gazes.size()) {
+    while(i < session_gazes.size()) {
+        if((computeGazeDifference(window) <= dispersion) && (getLengthOfWindow(window) >= duration_window)) {
+            while(computeGazeDifference(window) <= dispersion) {
+                if(i < session_gazes.size() - 1) {
+                    window.push_back(session_gazes[i]);
+                    ++i;
+                }
+                else { break; }
+            }
+            if(isWindowConsistenlySpaced(window,max_gaze_span)) {
+                fixations.push_back(computeFixationEstimate(window));
+                window.clear();
                 window.push_back(session_gazes[i]);
                 ++i;
             }
-            // Not a fixation ant the centroid of the windows points
-            fixations.push_back(computeFixationEstimate(window));
-            // Remove window points from points
-            for(int x = 0; x < window.size(); ++x) {
-                session_gazes.pop_front();
+            else {
+                window.pop_front();
             }
         }
+        else if(getLengthOfWindow(window) < duration_window) {
+            window.push_back(session_gazes[i]);
+            ++i;
+        }
         else {
-           session_gazes.pop_front();
+            window.pop_front();
+            if(getLengthOfWindow(window) < duration_window) {
+                window.push_back(session_gazes[i]);
+                ++i;
+            }
         }
     }
-//    QVector<Gaze> window;
-//    int i = 0;
-
-//    while(i < duration_window && i < session_gazes.size()) {
-//        window.push_back(session_gazes[i]);
-//        ++i;
-//    }
-
-//    while(i < session_gazes.size()) {
-//        if((computeGazeDifference(window) <= dispersion) && (window.size() >= duration_window)) {
-//            while(computeGazeDifference(window) <= dispersion) {
-//                if(i < session_gazes.size() - 1) {
-//                    window.push_back(session_gazes[i]);
-//                    ++i;
-//                }
-//                else { break; }
-//            }
-//            fixations.push_back(computeFixationEstimate(window));
-//            window.clear();
-//            window.push_back(session_gazes[i]);
-//            ++i;
-//        }
-//        else if(window.size() < duration_window) {
-//            window.push_back(session_gazes[i]);
-//            ++i;
-//        }
-//        else {
-//            window.pop_front();
-//            if(window.size() < duration_window) {
-//                window.push_back(session_gazes[i]);
-//                ++i;
-//            }
-//        }
-//    }
 
     return fixations;
 }
@@ -113,6 +102,6 @@ Fixation IDTAlgorithm::computeFixationEstimate(QVector<Gaze> fixation_points) {
 }
 
 QString IDTAlgorithm::generateFixationSettings() {
-    return "IDT," + QString::number(dispersion) + "," + QString::number(duration_window);
+    return "IDT," + QString::number(dispersion) + "," + QString::number(duration_window) + "," + QString::number(max_gaze_span);
 }
 

idtalgorithm.h

@@ -16,7 +16,7 @@
 
 class IDTAlgorithm : public FixationAlgorithm{
 public:
-    IDTAlgorithm(QVector<Gaze> gazes, int _duration, int _dispersion);
+    IDTAlgorithm(QVector<Gaze> gazes, int _duration, int _dispersion, int _max_gaze_span);
     ~IDTAlgorithm() {};
 
     QVector<Fixation> generateFixations() override;
@@ -27,6 +27,7 @@ class IDTAlgorithm : public FixationAlgorithm{
 
     int duration_window;
     int dispersion;
+    int max_gaze_span;
 };
 
 #endif // IDTALGORITHM_H