# HG changeset patch
# User Robert Tubb <rt300@eecs.qmul.ac.uk>
# Date 1417010645 0
# Node ID 3af380769779c257c2d5d9a1a8301cf3e29b31dc
# Parent  93317878abefb55ffd49f135c5fc8565179a9c2c
small fixes, logging now sensible.

diff -r 93317878abef -r 3af380769779 ExpMessageOrganiser.mm
--- a/ExpMessageOrganiser.mm	Tue Nov 25 18:37:54 2014 +0000
+++ b/ExpMessageOrganiser.mm	Wed Nov 26 14:04:05 2014 +0000
@@ -27,6 +27,7 @@
     controlPanel->showValueIndicators(true);
     
     okToGetMidi = true;
+    controlPanel->setActive(true); 
 }
 
 
diff -r 93317878abef -r 3af380769779 MessageOrganiser.mm
--- a/MessageOrganiser.mm	Tue Nov 25 18:37:54 2014 +0000
+++ b/MessageOrganiser.mm	Wed Nov 26 14:04:05 2014 +0000
@@ -39,6 +39,7 @@
     
     return mids;
 }
+//----------------------------------------------------------------------------------
 // could template for ui element type??
 void MessageOrganiser::mapButtonToAction(UIElement* control, int mappingID){
     UICallbackFunction callbackF;
@@ -47,25 +48,26 @@
     currentMapping.insert(std::pair<int,UIElement*>(mappingID,control));
 }
 
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::setControlPanel(SliderPanel* p){ // a bit specific??
     controlPanel = p;
     
 };
+//----------------------------------------------------------------------------------
 void MessageOrganiser::setBottomPanel(ButtonPanel * ntb){
     bottomPanel = ntb;
 };
-
+//----------------------------------------------------------------------------------
 
 void MessageOrganiser::setIconPanel(IconPanel * ip){
     presetIconPanel = ip;
 }
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::setInstructionPanel(TextPanel * ip){
     instructionPanel = ip;
     instructionPanel->show();
 }
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::setSeqNumPanel(TextPanel * snp){
     seqNumPanel = snp;
 }
@@ -91,13 +93,14 @@
     bottomPanel->hide();
     controlPanel->hide();
 }
+//----------------------------------------------------------------------------------
 void MessageOrganiser::showMyPanels(){
     presetIconPanel->show();
     instructionPanel->show();
     bottomPanel->show();
     controlPanel->show();
 }
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::triggerCandidateSound(){
     // log event
     sendSynthValuesAgain(); // TODO AAAARG too slow???
@@ -105,7 +108,7 @@
     eventLogger.logEvent(CANDIDATE_PLAYED);
 
 }
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::paramChangeCallback(int mappingID, int value){
     
     if(onlyChangeCandidateOnTrigger){
@@ -120,16 +123,18 @@
     
     eventLogger.logEvent(CANDIDATE_PARAM_ADJUSTED, evtData);
 };
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::sendSynthValuesAgain(){
     candidateSynth.sendAllParams();
     targetSynth.sendAllParams();
 };
-
+//----------------------------------------------------------------------------------
 
 void MessageOrganiser::setAllSlidersToValues(vector<int> values){
     controlPanel->setValues(values);
 }
+
+//----------------------------------------------------------------------------------
 // we want to set UI object
 void MessageOrganiser::setUIToParam(int index, int value){
     
@@ -154,7 +159,7 @@
     }
     
 };
-
+//----------------------------------------------------------------------------------
 
 void MessageOrganiser::mapControlToParam(UIElement* control, int mappingID){
     
@@ -198,7 +203,7 @@
     
     eventLogger.logEvent(CONTROL_LIST,typeListLog);
 };
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::mapXYToParams(ButtronXY* control, int mappingIDX, int mappingIDY){
     UICallbackFunction callback;
     
@@ -215,7 +220,7 @@
     control->setLabel(candidateSynth.getNameForMappingID(mappingIDX), candidateSynth.getNameForMappingID(mappingIDY));
     
 };
-
+//----------------------------------------------------------------------------------
 
 void MessageOrganiser::mapControlToParam(UIElement* control, string paramName){
     // get mapping ID from synth
@@ -223,12 +228,12 @@
     mapControlToParam(control, mappingID);
     control->setLabel(paramName);
 };
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::buttonPressCallback(int mappingID, int value){
     
 };
 
-
+//----------------------------------------------------------------------------------
 void MessageOrganiser::setSlidersToTarget(){
     // this will actually show sliders with target vals - for "memorisation" purposes mwa heh heh
     // get target values
@@ -254,6 +259,7 @@
         
     }
 }
+//----------------------------------------------------------------------------------
 void MessageOrganiser::setCandidateAndSlidersToRandom(){
     vector<int> rands;
     for(int i = 0; i < candidateSynth.getNumParams(); i++){
@@ -265,10 +271,14 @@
     candidateSynth.setAllParams(rands);
     
 }
+//----------------------------------------------------------------------------------
 
 
 void MessageOrganiser::midiFromLeap(int ctl_num, int ctl_val){
-    
+    static long int howManyLogged;
+    static vector<int> lastLoggedVals = zeros<int>(6);
+    static vector<int> newVals = zeros<int>(6);
+    static long long lastLogTime;
     
     if (!okToGetMidi){
         return;
@@ -286,10 +296,24 @@
 
     setUIToParam(ctl_num, ctl_val);
     
-    vector<int> evtData;
-    evtData.push_back(mids[ctl_num]); // or just index?
-    evtData.push_back(ctl_val);
+    // wait for a certain distance travelled AND time then record?
+    newVals[ctl_num] = ctl_val;
+    long long newLogTime = ofGetSystemTime();
     
-    eventLogger.logEvent(CANDIDATE_PARAM_ADJUSTED, evtData);
+    if (euclideanDistance(newVals, lastLoggedVals) > MIN_LOG_DIST && newLogTime - lastLogTime > 20){
+        eventLogger.logEvent(CANDIDATE_PARAM_ADJUSTED_ALL, newVals);
+        
+        lastLoggedVals = newVals;
+        howManyLogged++;
+    }else{
+        cout << "skipped! so far logged " << howManyLogged << endl;
+    }
+
     
-}
\ No newline at end of file
+}
+
+
+//----------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------
\ No newline at end of file
diff -r 93317878abef -r 3af380769779 SequenceController.h
--- a/SequenceController.h	Tue Nov 25 18:37:54 2014 +0000
+++ b/SequenceController.h	Wed Nov 26 14:04:05 2014 +0000
@@ -14,7 +14,7 @@
 #include "presetManager.h"
 #include "TrainingScoreManager.h"
 #define MIN_TARGETS_IN_SEQUENCE 1
-#define MAX_TARGETS_IN_SEQUENCE 2
+#define MAX_TARGETS_IN_SEQUENCE 7
 #define MIN_TEMPO   80
 #define MAX_TEMPO   400
 #define NUM_TEMPO_STEPS 12
@@ -128,6 +128,7 @@
     void generateSteps();
     void generateCountIn(int countInLength);
     void generateARun(int run, int numInSequence);
+    void generateAnEasyRun(int run, int numInSequence = 1);
     void generateASoundOnlyRun(int run, int numInSequence);
     vector<int> randomSequence(int numInSequence);
     vector<int> nonRandomSequence(int numInSequence);
diff -r 93317878abef -r 3af380769779 SequenceController.mm
--- a/SequenceController.mm	Tue Nov 25 18:37:54 2014 +0000
+++ b/SequenceController.mm	Wed Nov 26 14:04:05 2014 +0000
@@ -202,6 +202,8 @@
         
         if (soundOnlyMode){
             generateASoundOnlyRun(run, numInSequence);
+        }else if(numInSequence == 1){
+            generateAnEasyRun(run);
         }else{
             generateARun(run, numInSequence);
         }
@@ -252,7 +254,154 @@
     
     return stepPresetIndices;
 }
+//-------------------------------------------------------------------
 
+void SequenceController::generateAnEasyRun(int run, int numInSequence){
+    float curTempo = MIN_TEMPO;
+    int seqNo = 0;
+    AnimStep nextStep;
+    for(int tempoLevel = 0; tempoLevel < NUM_TEMPO_STEPS; tempoLevel++){
+        
+        
+        
+        // first we have a preparation count in
+        nextStep.presetIndex = -1; // minus one means "blank"
+        nextStep.runNumber = run;
+        nextStep.seqNumber = seqNo;
+        nextStep.whichInSequence = 0;
+        nextStep.tempo = curTempo;
+        nextStep.showsGuides = true;
+        nextStep.type = AnimStep::PREVIEW_NEUTRAL_COUNT;
+        nextStep.showsResultsAtEnd = false;
+        steps.push_back(nextStep);
+        
+        // generate a sequence of random preset indices
+        vector<int> stepPresetIndices = randomSequence(numInSequence);
+        nextStep.thisSequence = stepPresetIndices;
+        
+        // MAKE PREVIEW
+        int n = 0;
+        for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
+            // put loader
+            
+            nextStep.presetIndex = *si;
+            nextStep.runNumber = run;
+            nextStep.seqNumber = seqNo;
+            nextStep.whichInSequence = n;
+            nextStep.tempo = curTempo;
+            nextStep.showsGuides = true;
+            nextStep.showsIcons = true;
+            nextStep.showsResultsAtEnd = false;
+            nextStep.type = AnimStep::PREVIEW_MOVE;
+            steps.push_back(nextStep);
+            
+            if (SPACER_BARS){
+                nextStep.type = AnimStep::PREVIEW_HIT;
+                steps.push_back(nextStep);
+            }
+            n++;
+        }
+        
+        // move back to neutral
+        nextStep.presetIndex = -1;
+        nextStep.type = AnimStep::PREVIEW_MOVE;
+        nextStep.showsResultsAtEnd = false;
+        steps.push_back(nextStep);
+        
+        // make GUIDED sequence (1)
+        n = 0;
+        for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
+            // put loader
+            
+            nextStep.presetIndex = *si;
+            nextStep.runNumber = run;
+            nextStep.seqNumber = seqNo;
+            nextStep.whichInSequence = n;
+            nextStep.tempo = curTempo;
+            nextStep.showsGuides = true;
+            nextStep.showsIcons = true;
+            nextStep.showsResultsAtEnd = true;
+            nextStep.type = AnimStep::GUIDED_MOVE;
+            steps.push_back(nextStep);
+            
+            if (SPACER_BARS){
+                nextStep.type = AnimStep::GUIDED_HIT;
+                steps.push_back(nextStep);
+            }
+            n++;
+        }
+        // move back to neutral
+        nextStep.presetIndex = -1;
+        nextStep.type = AnimStep::GUIDED_MOVE;
+        nextStep.showsResultsAtEnd = false;
+        steps.push_back(nextStep);
+        
+        // make GUIDED sequence (2)
+        n = 0;
+        for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
+            // put loader
+            
+            nextStep.presetIndex = *si;
+            nextStep.runNumber = run;
+            nextStep.seqNumber = seqNo;
+            nextStep.whichInSequence = n;
+            nextStep.tempo = curTempo;
+            nextStep.showsGuides = true;
+            nextStep.showsIcons = true;
+            nextStep.showsResultsAtEnd = true;
+            nextStep.type = AnimStep::GUIDED_MOVE;
+            steps.push_back(nextStep);
+            
+            if (SPACER_BARS){
+                nextStep.type = AnimStep::GUIDED_HIT;
+                steps.push_back(nextStep);
+            }
+            n++;
+        }
+        // move back to neutral
+        nextStep.presetIndex = -1;
+        nextStep.type = AnimStep::GUIDED_MOVE;
+        nextStep.showsResultsAtEnd = false;
+        steps.push_back(nextStep);
+        
+        // make matching sequence with icon seq help
+        n = 0;
+        for(auto si = stepPresetIndices.begin(); si < stepPresetIndices.end(); si++){
+            // put loader
+            
+            nextStep.presetIndex = *si;
+            nextStep.whichInSequence = n;
+            
+            nextStep.showsGuides = false;
+            nextStep.showsIcons = true;
+            nextStep.type = AnimStep::MATCHING_MOVE;
+            nextStep.showsResultsAtEnd = true;
+            steps.push_back(nextStep);
+            
+            if (SPACER_BARS){
+                nextStep.type = AnimStep::MATCHING_HIT;
+                steps.push_back(nextStep);
+                
+            }
+            n++;
+            
+        }
+        
+        nextStep.type = AnimStep::MATCHING_HIT;
+        nextStep.showsResultsAtEnd = false;
+        steps.push_back(nextStep);
+        
+        steps.back().isLastOfSeq = true;
+        curTempo += tempoInc;
+        seqNo++;
+        cout << endl;
+        
+    }
+    // ANIM nextStep.setAsBlankCounter();
+    nextStep.type = AnimStep::MATCHING_NEUTRAL_COUNT;
+    steps.push_back(nextStep);
+    
+}
 //-------------------------------------------------------------------
 void SequenceController::generateASoundOnlyRun(int run, int numInSequence){
     
diff -r 93317878abef -r 3af380769779 TestController.h
--- a/TestController.h	Tue Nov 25 18:37:54 2014 +0000
+++ b/TestController.h	Wed Nov 26 14:04:05 2014 +0000
@@ -150,22 +150,7 @@
     bool isPractice(){
         return !scored;
     };
-    float euclideanDistance(vector<int> v1, vector<int> v2) const{
-        if (v1.size() != v2.size()){
-            cout << "ERROR ERROR: vectors must be same length for Mr Euclid";
-            return 0.;
-        }
-        vector<float> diff;
-        
-        std::transform(v1.begin(), v1.end(), v2.begin(), v1.begin(), difference<float>());
-        // sqr diff
-        
-        std::transform(v1.begin(), v1.end(), v1.begin(),squared<float>());
-        float ans = std::accumulate(v1.begin(),v1.end(),0.0);
-        
-        return sqrt(ans);
-        
-    };
+
     
     TestResult getScoreForAnswer(vector<int> answer, TimerMillisec timeTaken) const {
         TestResult result;
diff -r 93317878abef -r 3af380769779 TrainingMessageOrganiser.mm
--- a/TrainingMessageOrganiser.mm	Tue Nov 25 18:37:54 2014 +0000
+++ b/TrainingMessageOrganiser.mm	Wed Nov 26 14:04:05 2014 +0000
@@ -117,6 +117,7 @@
     bottomPanel->show();
     seqNumPanel->hide();
     eventLogger.logEvent(FINISHED_RUN);
+    eventLogger.saveSessionToFile();
 }
 void TrainingMessageOrganiser::lastOfAll(){
     candidateSynth.stopMetronome();
@@ -126,6 +127,7 @@
     middlePanel->setText("FINISHED BLOCK!");
     middlePanel->show();
     bottomPanel->show();
+    eventLogger.saveSessionToFile();
 }
 
 void TrainingMessageOrganiser::logNewStep(AnimStep newStep){
@@ -373,8 +375,7 @@
     }
 
     vector<int> newTargetValues = currentTargetPreset->getValues();
-    eventLogger.logEvent(NEW_TARGET, newTargetValues); // massively redundant info assuming we have saved presets...
-    
+  
     targetSynth.setAllParamsWithoutSend(newTargetValues);
     
     
@@ -519,10 +520,12 @@
                                                        Preset * targetPreset,
                                                        vector<int> startingPosition,
                                                        vector<int> currentPosition){
+    // targetParams, startPosition, answer, timeAllowed
     TrainingTestResult result =
-    trainingScoreManager.getScoreForAnswer(currentPosition,
+    
+    trainingScoreManager.getScoreForAnswer(targetPreset->getValues(),
                                            startingPosition,
-                                           targetPreset->getValues(),
+                                           currentPosition,
                                            newStep.getTimeBetweenTicks());
     
     sequenceController.saveResultForCurrentStep(result);
diff -r 93317878abef -r 3af380769779 TrainingScoreManager.h
--- a/TrainingScoreManager.h	Tue Nov 25 18:37:54 2014 +0000
+++ b/TrainingScoreManager.h	Wed Nov 26 14:04:05 2014 +0000
@@ -128,7 +128,10 @@
         details.push_back(result.score); // 10 x throughput
         
         eventLogger.logEvent(TRAINING_RESULT, details);
-        
+        details.clear();
+        details.insert(details.begin(), targetParams.begin(), targetParams.end());
+        details.insert(details.end(), answer.begin(), answer.end());
+        eventLogger.logEvent(TARGET_AND_MATCH, details);
         
         return result;
     }
@@ -150,22 +153,7 @@
         cout << "TP:  " << TP << endl;
         return TP;
     }
-    float euclideanDistance(vector<int> v1, vector<int> v2) const{
-        if (v1.size() != v2.size()){
-            cout << "ERROR ERROR: vectors must be same length for Mr Euclid";
-            return 0.;
-        }
-        vector<float> diff;
-        
-        std::transform(v1.begin(), v1.end(), v2.begin(), v1.begin(), difference<float>());
-        // sqr diff
-        
-        std::transform(v1.begin(), v1.end(), v1.begin(),squared<float>());
-        float ans = std::accumulate(v1.begin(),v1.end(),0.0);
-        
-        return sqrt(ans);
-        
-    };
+
     int totalScored;
     
 };
diff -r 93317878abef -r 3af380769779 UI code/3DboxGL.h
--- a/UI code/3DboxGL.h	Tue Nov 25 18:37:54 2014 +0000
+++ b/UI code/3DboxGL.h	Wed Nov 26 14:04:05 2014 +0000
@@ -12,12 +12,12 @@
 #include <iostream>
 #include "3Dbox.h"
 #include "UIElement.h"
-
+#include "algorithms.h"
 
 //Universal function which sets normals for the triangle meshvoid
 void setNormals( ofMesh &mesh );
 
-float euclideanDistance(vector<float> v1, vector<float> v2);
+//float euclideanDistance(vector<float> v1, vector<float> v2);
 
 class Leap3DBoxGL : public Leap3DBox {
 public:
diff -r 93317878abef -r 3af380769779 algorithms.h
--- a/algorithms.h	Tue Nov 25 18:37:54 2014 +0000
+++ b/algorithms.h	Wed Nov 26 14:04:05 2014 +0000
@@ -64,3 +64,5 @@
         return a*a;
     };
 };
+
+float euclideanDistance(vector<int> v1, vector<int> v2);
diff -r 93317878abef -r 3af380769779 algorithms.mm
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/algorithms.mm	Wed Nov 26 14:04:05 2014 +0000
@@ -0,0 +1,26 @@
+//
+//  algorithms.mm
+//  riftathon
+//
+//  Created by Robert Tubb on 26/11/2014.
+//
+//
+
+#include <stdio.h>
+#include "algorithms.h"
+float euclideanDistance(vector<int> v1, vector<int> v2) {
+    if (v1.size() != v2.size()){
+        cout << "ERROR ERROR: vectors must be same length for Mr Euclid";
+        return 0.;
+    }
+    vector<float> diff;
+    
+    std::transform(v1.begin(), v1.end(), v2.begin(), v1.begin(), difference<float>());
+    // sqr diff
+    
+    std::transform(v1.begin(), v1.end(), v1.begin(),squared<float>());
+    float ans = std::accumulate(v1.begin(),v1.end(),0.0);
+    
+    return sqrt(ans);
+    
+};
\ No newline at end of file
diff -r 93317878abef -r 3af380769779 eventLogger.h
--- a/eventLogger.h	Tue Nov 25 18:37:54 2014 +0000
+++ b/eventLogger.h	Wed Nov 26 14:04:05 2014 +0000
@@ -31,7 +31,7 @@
 #define EVENT_THIN_FACTOR 30
 #define EVENT_LOG_FILENAME "log.json"
 #define UPLOAD_CHUNK_SIZE 1000
-#define SAVE_CHUNK_SIZE 10000
+#define SAVE_CHUNK_SIZE 30000 // this is "too big" and must be saved, usually run end will save
 #define APP_CREATION_TIME 0   // ignore this, pointless
 #define PROGRAM_NAME "RIFTATHON"
 #define PROGRAM_VERSION 0.1
@@ -80,6 +80,8 @@
                 NEW_START_POS,
                 FINISH_POS,
                 FINISHED_RUN,
+                CANDIDATE_PARAM_ADJUSTED_ALL,
+                TARGET_AND_MATCH,
     
     
 };
@@ -169,8 +171,8 @@
     bool questionnaireCompleted;
     bool questionnaireUploaded;
     
-    unsigned int deviceID;
-    unsigned int totalInteractionTime, savedInteractionTime, sessionTime, sessionStartTime;
+    unsigned long long deviceID;
+    unsigned long long totalInteractionTime, savedInteractionTime, sessionTime, sessionStartTime;
     string userName; // not unique
     string questionnaireComments;
 // constr
diff -r 93317878abef -r 3af380769779 eventLogger.mm
--- a/eventLogger.mm	Tue Nov 25 18:37:54 2014 +0000
+++ b/eventLogger.mm	Wed Nov 26 14:04:05 2014 +0000
@@ -391,7 +391,7 @@
         //uploadEventLog(true);
     }
     
-    // new riftathon save as we go
+    // new riftathon save as we go NEVER REACHES HERE?
     if (theEvents.size() > SAVE_CHUNK_SIZE){
         saveSessionToFile();
     }
@@ -555,6 +555,7 @@
     logFile << jlogs;
     logFile.close();
     nextLogFileIndex++;
+    theEvents.clear();
 }
 
 string EventLogger::nextLogFileIndexString(){
diff -r 93317878abef -r 3af380769779 globalVariables.h
--- a/globalVariables.h	Tue Nov 25 18:37:54 2014 +0000
+++ b/globalVariables.h	Wed Nov 26 14:04:05 2014 +0000
@@ -32,6 +32,7 @@
 
 #define TOTAL_NUM_PARAMS 6
 #define TARGET_SCORE_CC_BAND 7 // number of cc vals per target band in dartboard
+#define MIN_LOG_DIST 4  // how far we go before control adjustment is logged
 typedef enum {TOUCH_DOWN, TOUCH_MOVED, TOUCH_UP} touchType;
 typedef enum {INTRO,QUESTIONNAIRE, HELP, TEST_IN_PROGRESS, SCORE_AND_HINT, COUNT_DOWN, READY_FOR_NEXT} interfaceType;
 
diff -r 93317878abef -r 3af380769779 testApp.mm
--- a/testApp.mm	Tue Nov 25 18:37:54 2014 +0000
+++ b/testApp.mm	Wed Nov 26 14:04:05 2014 +0000
@@ -84,7 +84,7 @@
     
 	// open an outgoing connection to HOST:PORT for OSC
 	// sender.setup( OSC_HOST, OSC_PORT );
-    ofSetFrameRate(60);
+    ofSetFrameRate(40);
     props = new UIProps();
 
 }