Extended quantitative data analysis by using name-value pairs for computation of multiple values.

Author: AnBenLa

AnalysisTest/Test.cpp

@@ -262,7 +262,7 @@ void single_user_analysis() {
 
 void synchrony_analysis(){
     std::vector<std::string> files;
-    std::string directory = "C:\\Users\\Anton-Lammert\\Downloads\\PilotNew";
+    std::string directory = "C:\\Users\\Anton-Lammert\\Downloads\\Test";
     if(!std::filesystem::exists(directory))
         return;
 
@@ -286,11 +286,19 @@ void synchrony_analysis(){
     int participant_a_hand_right = meta_information.get_old_uuid("/Lobby-HMDUser/Camera Offset/RightHand Controller");
     int avatar_hand_right = meta_information.get_old_uuid("/__STUDY__/VisualStimulus/HandWaving/StudyHMDAvatar/Camera Offset/RightHand Controller");
 
-    std::shared_ptr<QuantitativeTransformAnalysisRequest> quantitative_synchrony_request_1 = std::make_shared<QuantitativeSynchronyAnalysisRequest>(participant_a_hand_left, avatar_hand_right, 0.3f);
-    std::shared_ptr<QuantitativeTransformAnalysisRequest> quantitative_synchrony_request_2 = std::make_shared<QuantitativeSynchronyAnalysisRequest>(participant_a_hand_right, avatar_hand_right, 0.3f);
+    float sampling_rate = 0.25f;
+    std::shared_ptr<QuantitativeTransformAnalysisRequest> quantitative_synchrony_request_1 = std::make_shared<QuantitativeSynchronyAnalysisRequest>(participant_a_hand_left, avatar_hand_right, sampling_rate);
+    std::shared_ptr<QuantitativeTransformAnalysisRequest> quantitative_synchrony_request_2 = std::make_shared<QuantitativeSynchronyAnalysisRequest>(participant_a_hand_right, avatar_hand_right, sampling_rate);
+
+    std::shared_ptr<QuantitativeTransformAnalysisRequest> quantitative_velocity_request_1 = std::make_shared<QuantitativeVelocityAnalysisRequest>(participant_a_hand_left, sampling_rate);
+    std::shared_ptr<QuantitativeTransformAnalysisRequest> quantitative_velocity_request_2 = std::make_shared<QuantitativeVelocityAnalysisRequest>(participant_a_hand_right, sampling_rate);
+    std::shared_ptr<QuantitativeTransformAnalysisRequest> quantitative_velocity_request_3 = std::make_shared<QuantitativeVelocityAnalysisRequest>(avatar_hand_right, sampling_rate);
 
     manager.add_quantitative_analysis_request(quantitative_synchrony_request_1);
     manager.add_quantitative_analysis_request(quantitative_synchrony_request_2);
+    manager.add_quantitative_analysis_request(quantitative_velocity_request_1);
+    manager.add_quantitative_analysis_request(quantitative_velocity_request_2);
+    manager.add_quantitative_analysis_request(quantitative_velocity_request_3);
 
     manager.process_quantitative_analysis_requests_for_all_files();
 }

Src/Analysis/AnalysisManager.cpp

@@ -378,9 +378,7 @@ void AnalysisManager::add_quantitative_analysis_request(std::shared_ptr<Quantita
     quantitative_analysis_queries.push_back(request);
 }
 
-int AnalysisManager::process_quantitative_analysis_request(std::shared_ptr<QuantitativeAnalysisRequest> analysis_request,
-                                                       float *values, const std::string &file,
-                                                       const std::vector<TimeInterval> &intervals_to_investigate) const {
+std::vector<TimeBasedValue> AnalysisManager::process_quantitative_analysis_request(std::shared_ptr<QuantitativeAnalysisRequest> analysis_request, const std::string &file) const {
     std::ifstream transform_file(file + ".txt", std::ios::in | std::ios::binary);
     std::ifstream sound_file(file + "_sound.txt", std::ios::in | std::ios::binary);
     MetaInformation meta_info{file + ".recordmeta"};
@@ -431,25 +429,7 @@ int AnalysisManager::process_quantitative_analysis_request(std::shared_ptr<Quant
         Debug::Log("Reading sounds for analysis finished\n");
     }
 
-    result_values = analysis_request->get_result();
-    int i = 0;
-    for (auto &time_based_value: result_values) {
-        if (!intervals_to_investigate.empty()) {
-            for (auto const &interval_of_interest: intervals_to_investigate) {
-                if (interval_of_interest.contains(time_based_value.time)) {
-                    values[i] = time_based_value.time;
-                    // TODO: handle return of more return values
-                    values[i + 1] = time_based_value.values[0];
-                    i += 2;
-                }
-            }
-        } else {
-            values[i] = time_based_value.time;
-            values[i + 1] = time_based_value.values[0];
-            i += 2;
-        }
-    }
-    return result_values.size();
+    return analysis_request->get_result();
 }
 
 int AnalysisManager::process_quantitative_analysis_requests_for_all_files() {
@@ -499,21 +479,23 @@ void AnalysisManager::process_quantitative_analysis_requests_for_file(std::strin
     }
 
     for (auto request: adapted_queries) {
-        float values[5000];
-        int value_count = process_quantitative_analysis_request(request, values, file, intervals_of_interest);
-        std::cout << "Value count: " << value_count << "\n";
+        std::vector<TimeBasedValue> results = process_quantitative_analysis_request(request, file);
+        std::cout << "Value count: " << results.size() << "\n";
 
         out << "AnalysisQuery,";
         out << request->get_description(current_meta_information) << ",";
 
         out << "\n\n";
         out << "Time,";
-        out << "Value\n";
-
-        for (int i = 0; i < value_count; ++i) {
-            float time = values[i * 2];
-            float value = values[i * 2 + 1];
-            out << time << "," << value << "\n";
+        for(auto & value : results[0].values)
+            out << value.first << ",";
+        out << "\n";
+
+        for (int i = 0; i < results.size(); ++i) {
+            out << results[i].time << ",";
+            for(auto & value : results[i].values)
+                out << value.second << ",";
+            out << "\n";
         }
 
         out << "\n\n";

Src/Analysis/AnalysisManager.h

@@ -89,7 +89,7 @@ class AnalysisManager {
 
     void add_quantitative_analysis_request(std::shared_ptr<QuantitativeAnalysisRequest> request);
 
-    int process_quantitative_analysis_request(std::shared_ptr<QuantitativeAnalysisRequest> analysis_request, float* values, std::string const& file, std::vector<TimeInterval> const& intervals_to_investigate) const;
+    std::vector<TimeBasedValue> process_quantitative_analysis_request(std::shared_ptr<QuantitativeAnalysisRequest> analysis_request, std::string const& file) const;
 
     int process_quantitative_analysis_requests_for_all_files();
 

Src/Analysis/AnalysisStructs.h

@@ -40,14 +40,15 @@
 
 #include <algorithm>
 #include <vector>
+#include <string>
 
 enum TransformAnalysisType{
     ContainmentAnalysis, DistanceAnalysis, GazeAnalysis, RotationAnalysis, VelocityAnalysis, PositionAdjustmentAnalysis, SynchronyAnalysis
 };
 
 struct TimeBasedValue{
     float time;
-    std::vector<float> values;
+    std::vector<std::pair<std::string,float>> values;
 };
 
 struct TimeInterval{

Src/Analysis/QuantitativeAnalysis/TransformAnalysis/QuantitativeDistanceAnalysisRequest.cpp

@@ -84,7 +84,8 @@ void QuantitativeDistanceAnalysisRequest::process_request(std::shared_ptr<Transf
     if((t_data->id == id_a || t_data->id == id_b) && present_a && present_b && current_a.time >= current_b.time){
         glm::vec3 dir = current_b.global_position - current_a.global_position;
         if(current_t - last_value_time > 1.0f/temporal_sampling_rate){
-            values.push_back(TimeBasedValue{current_t, {glm::length(dir)}});
+            std::pair<std::string, float> dist = {"Distance",glm::length(dir)};
+            values.push_back(TimeBasedValue{current_t, {dist}});
             last_value_time = current_t;
         }
     }

Src/Analysis/QuantitativeAnalysis/TransformAnalysis/QuantitativeGazeAnalysisRequest.cpp

@@ -72,7 +72,10 @@ void QuantitativeGazeAnalysisRequest::process_request(std::shared_ptr<TransformD
        glm::mat4 TRS = translate * rotate * scale;
        glm::vec4 local_pos = glm::inverse(TRS) * glm::vec4{current_b.global_position,1.0f};
        if(current_t - last_value_time > 1.0f/temporal_sampling_rate){
-           values.push_back(TimeBasedValue{current_t, {local_pos.x/local_pos.w,local_pos.y/local_pos.w,local_pos.z,local_pos.w}});
+           std::pair<std::string, float> x = {"Pos b.x local in a",local_pos.x/local_pos.w};
+           std::pair<std::string, float> y = {"Pos b.y local in a",local_pos.y/local_pos.w};
+           std::pair<std::string, float> z = {"Pos b.z local in a",local_pos.z/local_pos.w};
+           values.push_back(TimeBasedValue{current_t, {x,y,z}});
            last_value_time = current_t;
        }
     }

Src/Analysis/QuantitativeAnalysis/TransformAnalysis/QuantitativeRotationAnalysisRequest.cpp

@@ -71,8 +71,8 @@ void QuantitativeRotationAnalysisRequest::process_request(std::shared_ptr<Transf
                         max_angle_diff = angle_diff_degrees;
                 }
             }
-
-            values.push_back(TimeBasedValue{t_data->time, {max_angle_diff}});
+            std::pair<std::string, float> angle_diff = {"Max angle diff", max_angle_diff};
+            values.push_back(TimeBasedValue{t_data->time, {angle_diff}});
             last_value_time = t_data->time;
         }
     }

Src/Analysis/QuantitativeAnalysis/TransformAnalysis/QuantitativeSynchronyAnalysisRequest.cpp

@@ -30,41 +30,61 @@ void QuantitativeSynchronyAnalysisRequest::process_request(std::shared_ptr<Trans
 
     if (t_data->time > current_t) {
         current_t = t_data->time;
-        while (recent_data_a.size() > 0 &&recent_data_a.front().time < current_t - temporal_sampling_rate) {
+        while (recent_data_a.size() > 0 &&recent_data_a.front().time < current_t - (1.0f/temporal_sampling_rate)) {
             recent_data_a.pop_front();
         }
-        while (recent_data_b.size() > 0 && recent_data_b.front().time < current_t - temporal_sampling_rate) {
+        while (recent_data_b.size() > 0 && recent_data_b.front().time < current_t - (1.0f/temporal_sampling_rate)) {
             recent_data_b.pop_front();
         }
-        std::vector<float> a_velocities;
-        if (recent_data_a.size() > 1) {
-            for (int i = 1; i < recent_data_a.size(); i++) {
-                TransformData last = recent_data_a[i - 1];
-                TransformData current = recent_data_a[i];
-                float pos_diff = glm::length(current.global_position - last.global_position);
-                float time_diff = current.time - last.time;
-                a_velocities.push_back(std::abs(pos_diff / time_diff));
+
+        if(recent_data_a.size() > 0 && std::abs(recent_data_a.front().time - current_t) > (1.0f/temporal_sampling_rate) - 0.01f) {
+            std::vector<float> a_velocities;
+            if (recent_data_a.size() > 1) {
+                for (int i = 1; i < recent_data_a.size(); i++) {
+                    TransformData last = recent_data_a[i - 1];
+                    TransformData current = recent_data_a[i];
+                    float pos_diff = glm::length(current.global_position - last.global_position);
+                    float time_diff = current.time - last.time;
+                    float velocity = std::abs(pos_diff / time_diff);
+                    if(velocity < 0.1f)
+                        velocity = 0.0f;
+                    a_velocities.push_back(velocity);
+                }
             }
-        }
 
-        std::vector<float> b_velocities;
-        if (recent_data_b.size() > 1) {
-            for (int i = 1; i < recent_data_b.size(); i++) {
-                TransformData last = recent_data_b[i - 1];
-                TransformData current = recent_data_b[i];
-                float pos_diff = glm::length(current.global_position - last.global_position);
-                float time_diff = current.time - last.time;
-                b_velocities.push_back(std::abs(pos_diff / time_diff));
+            std::vector<float> b_velocities;
+            if (recent_data_b.size() > 1) {
+                for (int i = 1; i < recent_data_b.size(); i++) {
+                    TransformData last = recent_data_b[i - 1];
+                    TransformData current = recent_data_b[i];
+                    float pos_diff = glm::length(current.global_position - last.global_position);
+                    float time_diff = current.time - last.time;
+                    float velocity = std::abs(pos_diff / time_diff);
+                    if(velocity < 0.1f)
+                        velocity = 0.0f;
+                    b_velocities.push_back(velocity);
+                }
             }
-        }
 
-        std::vector<float> a_ranks = rank_data(a_velocities);
-        std::vector<float> b_ranks = rank_data(b_velocities);
+            std::vector<float> a_ranks = rank_data(a_velocities);
+            std::vector<float> b_ranks = rank_data(b_velocities);
+
+            if(a_velocities.size() == b_velocities.size()) {
+                float pearson_corr = pearson_correlation(a_velocities, b_velocities);
+                float spearman_corr = pearson_correlation(a_ranks, b_ranks);
 
-        float spearman_corr = correlation(a_ranks, b_ranks);
-        if(current_t > last_value_time + (1.0f /temporal_sampling_rate)) {
-            values.push_back(TimeBasedValue{current_t, {spearman_corr}});
-            last_value_time = current_t;
+                if(std::isnan(pearson_corr))
+                    pearson_corr = 0.0f;
+                if(std::isnan(spearman_corr))
+                    spearman_corr = 0.0f;
+
+                if (current_t > last_value_time + (1.0f / temporal_sampling_rate)) {
+                    std::pair<std::string, float> s_corr = {"Spearman Correlation", spearman_corr};
+                    std::pair<std::string, float> p_corr = {"Pearson Correlation", pearson_corr};
+                    values.push_back(TimeBasedValue{current_t, {s_corr, p_corr}});
+                    last_value_time = current_t;
+                }
+            }
         }
     }
 }
@@ -115,23 +135,29 @@ std::vector<float> QuantitativeSynchronyAnalysisRequest::rank_data(std::vector<f
     return ranks;
 }
 
-float QuantitativeSynchronyAnalysisRequest::correlation(const std::vector<float> &a, const std::vector<float> &b) {
+float QuantitativeSynchronyAnalysisRequest::pearson_correlation(const std::vector<float> &a, const std::vector<float> &b) {
     if(a.size() != b.size() || a.empty()) {
         //Debug::Log("Error: Cannot calculate correlation between vectors of different sizes");
         return 0;
     }
     float sum_a = 0, sum_b = 0, sum_ab = 0, square_sum_a = 0, square_sum_b = 0;
 
     for (int i = 0; i < a.size(); i++) {
-        sum_a = sum_a + a[i];
-        sum_b = sum_b + b[i];
-        sum_ab = sum_ab + a[i] * b[i];
-        square_sum_a = square_sum_a + a[i] * a[i];
-        square_sum_b = square_sum_b + b[i] * b[i];
+        sum_a += a[i];
+        sum_b += b[i];
     }
 
-    float corr = (float) (a.size() * sum_ab - sum_a * sum_b) /
-                 sqrt((a.size() * square_sum_a - sum_a * sum_a) * (a.size() * square_sum_b - sum_b * sum_b));
+    float mean_a = sum_a / a.size();
+    float mean_b = sum_b / b.size();
 
-    return corr;
+    float top = 0.0f;
+    float bottom_l = 0.0f;
+    float bottom_r = 0.0f;
+
+    for(int i = 0; i < a.size(); ++i){
+        top += (a[i] - mean_a) * (b[i] - mean_b);
+        bottom_l += (a[i] - mean_a) * (a[i] - mean_a);
+        bottom_r += (b[i] - mean_b) * (b[i] - mean_b);
+    }
+    return top / (std::sqrt(bottom_l) * std::sqrt(bottom_r));
 }

Src/Analysis/QuantitativeAnalysis/TransformAnalysis/QuantitativeSynchronyAnalysisRequest.h

@@ -40,7 +40,7 @@ class QuantitativeSynchronyAnalysisRequest : public QuantitativeTransformAnalysi
 private:
     std::vector<float> rank_data(std::vector<float> const& data);
 
-    float correlation(std::vector<float> const& a, std::vector<float> const& b);
+    float pearson_correlation(std::vector<float> const& a, std::vector<float> const& b);
 };
 
 

Src/Analysis/QuantitativeAnalysis/TransformAnalysis/QuantitativeVelocityAnalysisRequest.cpp

@@ -90,7 +90,8 @@ void QuantitativeVelocityAnalysisRequest::process_request(std::shared_ptr<Transf
             float time_diff = last.time - previous.time;
             float current_velocity = std::abs(pos_diff / time_diff);
             if(last.time > last_value_time + (1.0f /temporal_sampling_rate)) {
-                values.push_back(TimeBasedValue{last.time, {current_velocity}});
+                std::pair<std::string, float> vel = {"Velocity",current_velocity};
+                values.push_back(TimeBasedValue{last.time, {vel}});
                 last_value_time = last.time;
             }
         }