haha commit!

src/AbstractAnalysis.cpp

@@ -0,0 +1,7 @@
+/*
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "AbstractAnalysis.h"

src/AbstractAnalysis.h

@@ -0,0 +1,59 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "ofxControlPanel.h"
+#include <string>
+
+//#define ANALYSIS_PATH "data/analysis/"
+#define ANALYSIS_PATH "analysis/"
+
+#define STATE_STOP  0xDEADBEEF
+
+class AbstractAnalysis {
+    
+public:
+    AbstractAnalysis(string name) : _name(name) {;}
+    virtual ~AbstractAnalysis(){;}
+    
+    // generic function to set up the camera
+    virtual void setup(int camWidth, int camHeight){_cam_w = camWidth; _cam_h = camHeight;}    
+    
+    // the runnable function in the thread 
+    virtual void synthesize() = 0;   // this means that this function needs to be overwritten by children that inherit this class       
+    
+    // throwing the 
+    virtual void gui_attach(ofxControlPanel* gui){_gui = gui;}
+    virtual void gui_detach(){;}
+    
+    
+    //    virtual void draw(ofPixels _pixels) = 0;
+    //    virtual void draw(ofPixels)=0;
+    // how to get the pixels into the analysis classes?!?  -j
+    
+    // ofx
+    virtual void draw() = 0;    
+    
+    // this is what's called a Pure Virtual Function - not sure if you can pass ofPixels through this? 
+    
+    /*
+     When a virtual function is called, the implementation is chosen based not on the static type of the pointer 
+     or reference, but on the type of the object being pointed to, which can vary at run time
+     So this Pure Virtual Function will be called based on the kind of object or class that instantiated it(?) 
+     */
+    
+    
+public:
+    string  _name;    
+
+protected:    
+    ofxControlPanel*    _gui;
+    int                 _cam_w, _cam_h;  
+    
+    int             _state;
+    
+    friend class AnalysisAdaptor;
+};

src/AnalysisAdaptor.h

@@ -0,0 +1,39 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Thread.h"
+#include "Poco/RunnableAdapter.h"
+
+using Poco::Thread;
+using Poco::RunnableAdapter;
+
+class AnalysisAdaptor
+{
+public:
+    AnalysisAdaptor(AbstractAnalysis* analysis) : _analysis(analysis) {;}
+    virtual ~AnalysisAdaptor(){ delete _runnable; }
+    
+    void start()
+    {
+        _runnable = new RunnableAdapter<AbstractAnalysis>(*_analysis, &AbstractAnalysis::synthesize);
+        _worker.start(*_runnable);
+    }
+    
+    void stop() 
+    {
+        _analysis->_state = STATE_STOP;
+        _worker.join();
+    }
+    
+protected:
+    AbstractAnalysis*                   _analysis;
+    Thread                              _worker;    //   
+    RunnableAdapter<AbstractAnalysis>*  _runnable;    
+};
+

src/CamFrameRateAnalysis.cpp

@@ -0,0 +1,133 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "CamFrameRateAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+
+void CamFrameRateAnalysis::setup(int camWidth, int camHeight)
+{    
+    // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    
+    _frame_cnt = 0;
+    _frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
+     c = 0;
+}
+
+
+void CamFrameRateAnalysis::synthesize()
+{
+    
+    Timer* save_timer;
+    
+    TimerCallback<CamFrameRateAnalysis> save_callback(*this, &CamFrameRateAnalysis::save_cb);
+    
+    // RUN ROUTINE 
+    for(int i = 0; i < NUM_RUN; i++) {
+        
+        _run_cnt = i;
+        
+        cout << "RUN NUM = " << i;
+        
+        save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
+        save_timer->start(save_callback);        
+        _RUN_DONE = false;
+        _frame_cnt = 0; _save_cnt = 0;
+        
+        while(!_RUN_DONE)
+            Thread::sleep(3);
+        
+        save_timer->stop();        
+    }
+}
+
+void CamFrameRateAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    
+}
+
+void CamFrameRateAnalysis::gui_detach()
+{
+    
+}
+
+//void CamFrameRateAnalysis::draw(ofPixels _pixels)   //trying to figure out how to get pixels from the RefractiveIndex.cpp 
+
+
+// this runs at frame rate = 33 ms for 30 FPS
+void CamFrameRateAnalysis::draw()
+{
+    /// *** TODO  *** ///
+    // still need to deal with latency frames here - i.e.: there are frames 
+    /// *** TODO  *** ///
+    float totalTime=_frame_cnt_max/2;
+    
+    float numSteps=10;
+    
+    vector<float>stepLengths;
+    
+    
+    //c must increase until frame_cnt_max * 0.5 and then decrease afterwards
+    
+    
+    if (_frame_cnt < _frame_cnt_max)
+    {
+        ofSetColor(c, c, c);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+        c  = 255.0 * (_frame_cnt_max - _frame_cnt)/(_frame_cnt_max);
+        cout<<_frame_cnt<<endl;
+    }
+    _frame_cnt++;
+    
+    
+}
+
+// this runs at save_cb timer rate = DELTA_T_SAVE
+void CamFrameRateAnalysis::save_cb(Timer& timer)
+{
+    _save_cnt++;
+    
+    //cout << "c_last... " << c << endl;    
+    string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
+    string thisLocation = RefractiveIndex::_location;
+    
+    
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path+"/"+file_name, OF_IMAGE_QUALITY_BEST);    
+    
+    if(_save_cnt >= NUM_SAVE_PER_RUN)
+        _RUN_DONE = true;
+    
+}

src/CamFrameRateAnalysis.h

@@ -0,0 +1,44 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+#define DELTA_T_SAVE        1000/30  //timer call back needs to be at main app frame rate ie 1000/30
+#define NUM_PHASE           1
+//#define TIME_PER_RUN        3*1000
+#define NUM_RUN             1
+//#define SYNTH_TIME          TIME_PER_RUN *NUM_RUN //the number of millis it takes for the whole sequence
+#define NUM_SAVE_PER_RUN    100    //this must be equal to the number of frames it takes for the whole analysis to draw - ie  _frame_cnt_max
+
+
+class CamFrameRateAnalysis : public AbstractAnalysis
+{
+public:
+    CamFrameRateAnalysis(): AbstractAnalysis("CAM_NOISE"){;}
+    virtual ~CamFrameRateAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void save_cb(Poco::Timer& timer);
+    
+protected:
+    
+    bool    _RUN_DONE;
+    int     _run_cnt, _save_cnt;
+    float   c, _frame_cnt, _frame_cnt_max;
+    string _whole_file_path;
+    
+};

src/CamNoiseAnalysis.cpp

@@ -0,0 +1,138 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "CamNoiseAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+
+void CamNoiseAnalysis::setup(int camWidth, int camHeight)
+{    
+    // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    else{
+        
+        cout<<"dir exists"<<endl;
+    }
+    
+    _frame_cnt = 0;
+    _frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
+    c = 0;
+}
+
+
+void CamNoiseAnalysis::synthesize()
+{
+    
+    Timer* save_timer;
+    
+    TimerCallback<CamNoiseAnalysis> save_callback(*this, &CamNoiseAnalysis::save_cb);
+    
+    // RUN ROUTINE 
+    for(int i = 0; i < NUM_RUN; i++) {
+        
+        _run_cnt = i;
+        
+        cout << "RUN NUM = " << i;
+        
+        save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
+        save_timer->start(save_callback);        
+        _RUN_DONE = false;
+        _frame_cnt = 0; _save_cnt = 0;
+        
+        while(!_RUN_DONE)
+            Thread::sleep(3);
+        
+        save_timer->stop();        
+    }
+}
+
+void CamNoiseAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    
+}
+
+void CamNoiseAnalysis::gui_detach()
+{
+    
+}
+
+//void CamNoiseAnalysis::draw(ofPixels _pixels)   //trying to figure out how to get pixels from the RefractiveIndex.cpp 
+
+
+// this runs at frame rate = 33 ms for 30 FPS
+void CamNoiseAnalysis::draw()
+{
+    /// *** TODO  *** ///
+    // still need to deal with latency frames here - i.e.: there are frames 
+    /// *** TODO  *** ///
+    
+    float _number_of_grey_levels=5;
+    
+    float _frames_per_level = _frame_cnt_max / _number_of_grey_levels;
+    ofColor someColor;
+    
+    for(int i=0;i<=_number_of_grey_levels;i++){
+        if (_frame_cnt>= _frames_per_level *( i-1) && +_frame_cnt < _frames_per_level * (i) ) {
+            //set colour to current grey level
+            c=255-( 255.0 * ( i /_number_of_grey_levels));
+            someColor.set(c);
+            
+        }
+        ofSetColor(someColor);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+
+
+ 
+    _frame_cnt++;
+    
+    
+}
+
+// this runs at save_cb timer rate = DELTA_T_SAVE
+void CamNoiseAnalysis::save_cb(Timer& timer)
+{
+    _save_cnt++;
+    
+    string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
+    string thisLocation = RefractiveIndex::_location;
+    
+    
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path+"/"+file_name, OF_IMAGE_QUALITY_BEST);    
+    
+    if(_save_cnt >= NUM_SAVE_PER_RUN)
+        _RUN_DONE = true;
+    
+}

src/CamNoiseAnalysis.h

@@ -0,0 +1,42 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+#define DELTA_T_SAVE        100  //the milisecond timing 
+#define NUM_PHASE           1
+#define NUM_RUN             1
+#define NUM_SAVE_PER_RUN    100
+
+
+class CamNoiseAnalysis : public AbstractAnalysis
+{
+public:
+    CamNoiseAnalysis(): AbstractAnalysis("CAM_NOISE"){;}
+    virtual ~CamNoiseAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void save_cb(Poco::Timer& timer);
+    
+protected:
+    
+    bool    _RUN_DONE;
+    int     _run_cnt, _save_cnt;
+    float   c, _frame_cnt, _frame_cnt_max;
+    string _whole_file_path;
+    
+};

src/ColorMultiAnalysis.cpp

@@ -0,0 +1,154 @@
+/*
+ - copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
+ - all rights reserved.
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "ColorMultiAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+
+
+void ColorMultiAnalysis::setup(int camWidth, int camHeight)
+{
+    // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    _frame_cnt = 0;
+    _frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
+    
+    c = 0;
+}
+
+void ColorMultiAnalysis::synthesize()
+{
+    
+    Timer* save_timer;
+    
+    TimerCallback<ColorMultiAnalysis> save_callback(*this, &ColorMultiAnalysis::save_cb);
+    
+    // RUN ROUTINE 
+    for(int i = 0; i < NUM_RUN; i++) {
+        
+        _run_cnt = i;
+        
+        cout << "RUN NUM = " << i;
+        
+        save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
+        save_timer->start(save_callback);        
+        _RUN_DONE = false;
+        _frame_cnt = 0; _save_cnt = 0;
+        
+        while(!_RUN_DONE)
+            Thread::sleep(3);
+        
+        save_timer->stop();        
+    }
+
+}
+
+void ColorMultiAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    gui->addToggle("GO", "GO", 0);
+    gui->addButtonSlider("animation time limit", "ANIMATION_TIME_LIMIT", 10, 1, 3000, TRUE);    
+    
+}
+
+void ColorMultiAnalysis::gui_detach()
+{
+    
+}
+
+void ColorMultiAnalysis::draw()
+{
+
+        
+        if (_frame_cnt < _frame_cnt_max)
+        {
+            ofColor aColor;
+            aColor.setHsb(c, 255, 255);
+            ofSetColor(aColor);
+            ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+            //how far are we as a percent of _frame_count_max
+            c  = 255.0 * (_frame_cnt_max - _frame_cnt)/(_frame_cnt_max);
+        }
+        _frame_cnt++;
+        
+
+}
+
+
+// this runs at save_cb timer rate = DELTA_T_SAVE
+void ColorMultiAnalysis::save_cb(Timer& timer)
+{
+    _save_cnt++;
+    
+    // UPDATE THE COLOR ON THE SCREEN
+    //float c_last = c;    
+    
+    cout << "COLORMULTIANALYSIS::saving...\n";
+    cout << "c_last... " << c << endl;    
+    string file_name = ofToString(_save_cnt,2)+"_"+ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
+
+    cout<<_whole_file_path<<endl;
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+    
+    if(_save_cnt >= NUM_SAVE_PER_RUN){
+        _RUN_DONE = true;
+    }
+    
+}

src/ColorMultiAnalysis.h

@@ -0,0 +1,34 @@
+#define DELTA_T_SAVE        100  //the milisecond timing 
+#define NUM_PHASE           1
+#define NUM_RUN             1
+#define NUM_SAVE_PER_RUN    100
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+class ColorMultiAnalysis : public AbstractAnalysis
+{
+public:
+    ColorMultiAnalysis(): AbstractAnalysis("COLOR_MULTI"){;}
+    virtual ~ColorMultiAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void save_cb(Poco::Timer& timer);
+    
+protected:
+    
+    bool    _RUN_DONE;
+    int     _run_cnt, _save_cnt;
+    float   c, _frame_cnt, _frame_cnt_max;
+    string _whole_file_path;
+};

src/ColorSingleAnalysis.cpp

@@ -0,0 +1,137 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "ColorSingleAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+
+void ColorSingleAnalysis::setup(int camWidth, int camHeight)
+{    
+    // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
+    
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    _frame_cnt = 0;
+    _frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
+    r = 0;
+    g = 0;
+    b = 0;
+}
+
+
+void ColorSingleAnalysis::synthesize()
+{
+    
+    Timer* save_timer;
+    
+    TimerCallback<ColorSingleAnalysis> save_callback(*this, &ColorSingleAnalysis::save_cb);
+    
+    // RUN ROUTINE 
+    for(int i = 0; i < NUM_RUN; i++) {
+        
+        _run_cnt = i;
+        
+        cout << "RUN NUM = " << i;
+        
+        save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
+        save_timer->start(save_callback);        
+        _RUN_DONE = false;
+        _frame_cnt = 0; _save_cnt = 0;
+        
+        while(!_RUN_DONE)
+            Thread::sleep(3);
+        
+        save_timer->stop();        
+    }
+}
+
+void ColorSingleAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    
+}
+
+void ColorSingleAnalysis::gui_detach()
+{
+    
+}
+
+
+void ColorSingleAnalysis::draw()
+{
+
+    float one_third_of_frame_count_max=_frame_cnt_max/3;
+    if (_frame_cnt < one_third_of_frame_count_max){
+        r=255.0;
+        g=0.0;
+        b=0.0;
+        ofSetColor(r,g,b);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+    if (_frame_cnt >= one_third_of_frame_count_max && _frame_cnt < 2*one_third_of_frame_count_max){
+        r=0.0;
+        g=255.0;
+        b=0.0;
+        ofSetColor(r,g,b);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+    if (_frame_cnt >= 2*one_third_of_frame_count_max && _frame_cnt < _frame_cnt_max){
+        r=0.0;
+        g=0.0;
+        b=255.0;
+        ofSetColor(r,g,b);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+    
+    _frame_cnt++;
+    
+    
+}
+
+// this runs at save_cb timer rate = DELTA_T_SAVE
+void ColorSingleAnalysis::save_cb(Timer& timer)
+{
+    _save_cnt++;
+
+    
+    cout << "ColorSingleAnalysis::saving...\n";
+    string file_name =ofToString(_frame_cnt,2)+"_"+ofToString((int)r,2)+"_"+ofToString((int)g,2)+"_"+ofToString((int)b,2)+"_"+ofToString(_run_cnt,2)+".jpg";
+    
+    
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path+"/"+file_name, OF_IMAGE_QUALITY_BEST);    
+    cout<<_whole_file_path+"/"+file_name<<endl;
+
+    if(_save_cnt >= NUM_SAVE_PER_RUN)
+        _RUN_DONE = true;
+        
+}

src/ColorSingleAnalysis.h

@@ -0,0 +1,42 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+#define DELTA_T_SAVE        100  //the milisecond timing 
+#define NUM_PHASE           1
+#define NUM_RUN             1
+#define NUM_SAVE_PER_RUN    100
+
+
+class ColorSingleAnalysis : public AbstractAnalysis
+{
+public:
+    ColorSingleAnalysis(): AbstractAnalysis("COLOR_SINGLE"){;}
+    virtual ~ColorSingleAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void save_cb(Poco::Timer& timer);
+    
+protected:
+    
+    bool    _RUN_DONE;
+    int     _run_cnt, _save_cnt;
+    float   r,g,b, _frame_cnt, _frame_cnt_max;
+    string _whole_file_path;
+    
+};

src/DiffNoiseAnalysis.cpp

@@ -0,0 +1,137 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "DiffNoiseAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+
+void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
+{    
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    
+    _frame_cnt = 0;
+    _frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
+    c = 0;
+}
+
+
+void DiffNoiseAnalysis::synthesize()
+{
+    
+    Timer* save_timer;
+    
+    TimerCallback<DiffNoiseAnalysis> save_callback(*this, &DiffNoiseAnalysis::save_cb);
+    
+    // RUN ROUTINE 
+    for(int i = 0; i < NUM_RUN; i++) {
+        
+        _run_cnt = i;
+        
+        cout << "RUN NUM = " << i;
+        
+        save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
+        save_timer->start(save_callback);        
+        _RUN_DONE = false;
+        _frame_cnt = 0; _save_cnt = 0;
+        
+        while(!_RUN_DONE)
+            Thread::sleep(3);
+        
+        save_timer->stop();        
+    }
+}
+
+void DiffNoiseAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    
+}
+
+void DiffNoiseAnalysis::gui_detach()
+{
+    
+}
+
+//void DiffNoiseAnalysis::draw(ofPixels _pixels)   //trying to figure out how to get pixels from the RefractiveIndex.cpp 
+
+
+// this runs at frame rate = 33 ms for 30 FPS
+void DiffNoiseAnalysis::draw()
+{
+    /// *** TODO  *** ///
+    // still need to deal with latency frames here - i.e.: there are frames 
+    /// *** TODO  *** ///
+    ofColor aColour;
+    
+    c = ofRandom(0,255);
+    aColour.setHsb(c, 255, 255); 
+    if (_frame_cnt < _frame_cnt_max)
+    {
+        ofSetColor(aColour);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+        
+    }
+    _frame_cnt++;
+    
+    
+}
+
+// this runs at save_cb timer rate = DELTA_T_SAVE
+void DiffNoiseAnalysis::save_cb(Timer& timer)
+{
+    
+    
+    float rand10 = ofRandom(0,10);
+    
+    if (rand10 > 5.0) {
+    
+    cout << "DiffNoiseAnalysis::saving...\n";
+    cout << "c_last... " << c << endl;    
+    cout<<"rand10... " <<rand10<<endl;
+    
+    string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
+    string thisLocation = RefractiveIndex::_location;
+    
+    //RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera 
+    //    fileName = imageSaveFolderPath+whichAnalysis+"_"+ofToString(100.0*i*scanLineSpeed/ofGetHeight(),2)+"%_"+ofToString(i)+".jpg";
+    //ofSaveImage(vectorOfPixels[i], fileName, OF_IMAGE_QUALITY_BEST);
+    
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path+"/"+file_name, OF_IMAGE_QUALITY_BEST);  
+    
+    }
+    _save_cnt++;
+    if(_save_cnt >= NUM_SAVE_PER_RUN)
+        _RUN_DONE = true;
+    
+}

src/DiffNoiseAnalysis.h

@@ -0,0 +1,42 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+#define DELTA_T_SAVE        1000/30  //timer call back needs to be at main app frame rate ie 1000/30
+#define NUM_PHASE           1
+#define NUM_RUN             1
+#define NUM_SAVE_PER_RUN    100 //this analysis actually necessarily saves a random quantity of frames = about half this number
+
+
+class DiffNoiseAnalysis : public AbstractAnalysis
+{
+public:
+    DiffNoiseAnalysis(): AbstractAnalysis("DIFF_NOISE"){;}
+    virtual ~DiffNoiseAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void save_cb(Poco::Timer& timer);
+    
+protected:
+    
+    bool    _RUN_DONE;
+    int     _run_cnt, _save_cnt;
+    float   c, _frame_cnt, _frame_cnt_max;
+    string _whole_file_path;
+    
+};

src/IResponseAnalysis.cpp

@@ -0,0 +1,130 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "IResponseAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+
+void IResponseAnalysis::setup(int camWidth, int camHeight)
+{    
+    // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    
+    _frame_cnt = 0;
+    _frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
+    c = 0;
+}
+
+
+void IResponseAnalysis::synthesize()
+{
+    
+    Timer* save_timer;
+    
+    TimerCallback<IResponseAnalysis> save_callback(*this, &IResponseAnalysis::save_cb);
+    
+    // RUN ROUTINE 
+    for(int i = 0; i < NUM_RUN; i++) {
+        
+        _run_cnt = i;
+        
+        cout << "RUN NUM = " << i;
+        
+        save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
+        save_timer->start(save_callback);        
+        _RUN_DONE = false;
+        _frame_cnt = 0; _save_cnt = 0;
+        
+        while(!_RUN_DONE)
+            Thread::sleep(3);
+        
+        save_timer->stop();        
+    }
+}
+
+void IResponseAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    
+}
+
+void IResponseAnalysis::gui_detach()
+{
+    
+}
+
+//void IResponseAnalysis::draw(ofPixels _pixels)   //trying to figure out how to get pixels from the RefractiveIndex.cpp 
+
+
+// this runs at frame rate = 33 ms for 30 FPS
+void IResponseAnalysis::draw()
+{
+    /// *** TODO  *** ///
+    // still need to deal with latency frames here - i.e.: there are frames 
+    /// *** TODO  *** ///
+    
+    if (_frame_cnt < _frame_cnt_max)
+    {
+        ofSetColor(c, c, c);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+        c  = 255.0 * (_frame_cnt_max - _frame_cnt)/(_frame_cnt_max);
+    }
+    _frame_cnt++;
+    
+    
+}
+
+// this runs at save_cb timer rate = DELTA_T_SAVE
+void IResponseAnalysis::save_cb(Timer& timer)
+{
+    _save_cnt++;
+    
+    // UPDATE THE COLOR ON THE SCREEN
+    //float c_last = c;    
+    
+    cout << "IResponseAnalysis::saving...\n";
+    cout << "c_last... " << c << endl;    
+    string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
+    string thisLocation = RefractiveIndex::_location;
+    
+    //RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera 
+    //    fileName = imageSaveFolderPath+whichAnalysis+"_"+ofToString(100.0*i*scanLineSpeed/ofGetHeight(),2)+"%_"+ofToString(i)+".jpg";
+    //ofSaveImage(vectorOfPixels[i], fileName, OF_IMAGE_QUALITY_BEST);
+    
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path+"/"+file_name, OF_IMAGE_QUALITY_BEST);    
+    
+    if(_save_cnt >= NUM_SAVE_PER_RUN)
+        _RUN_DONE = true;
+    
+}

src/IResponseAnalysis.h

@@ -0,0 +1,42 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+#define DELTA_T_SAVE        100  //the milisecond timing 
+#define NUM_PHASE           1
+#define NUM_RUN             1
+#define NUM_SAVE_PER_RUN    100
+
+
+class IResponseAnalysis : public AbstractAnalysis
+{
+public:
+    IResponseAnalysis(): AbstractAnalysis("I_RESPONSE"){;}
+    virtual ~IResponseAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void save_cb(Poco::Timer& timer);
+    
+protected:
+    
+    bool    _RUN_DONE;
+    int     _run_cnt, _save_cnt;
+    float   c, _frame_cnt, _frame_cnt_max;
+    string _whole_file_path;
+    
+};

src/LatencyTestAnalysis.cpp

@@ -0,0 +1,148 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "LatencyTestAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+
+void LatencyTestAnalysis::setup(int camWidth, int camHeight)
+{    
+    // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    
+    _frame_cnt = 0;
+    _frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
+    c = 0;
+}
+
+
+void LatencyTestAnalysis::synthesize()
+{
+    
+    Timer* save_timer;
+    
+    TimerCallback<LatencyTestAnalysis> save_callback(*this, &LatencyTestAnalysis::save_cb);
+    
+    // RUN ROUTINE 
+    for(int i = 0; i < NUM_RUN; i++) {
+        
+        _run_cnt = i;
+        
+        cout << "RUN NUM = " << i;
+        
+        save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
+        save_timer->start(save_callback);        
+        _RUN_DONE = false;
+        _frame_cnt = 0; _save_cnt = 0;
+        
+        while(!_RUN_DONE)
+            Thread::sleep(3);
+        
+        save_timer->stop();        
+    }
+}
+
+void LatencyTestAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    
+}
+
+void LatencyTestAnalysis::gui_detach()
+{
+    
+}
+
+//void LatencyTestAnalysis::draw(ofPixels _pixels)   //trying to figure out how to get pixels from the RefractiveIndex.cpp 
+
+
+// this runs at frame rate = 33 ms for 30 FPS
+void LatencyTestAnalysis::draw()
+{
+    /// *** TODO  *** ///
+    // still need to deal with latency frames here - i.e.: there are frames 
+    /// *** TODO  *** ///
+    
+    if (_frame_cnt < _frame_cnt_max/3)
+    {
+        c  = 0;
+
+        ofSetColor(c, c, c);
+        cout<<"1st third"<<endl;
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+    if (_frame_cnt >= _frame_cnt_max/3 && _frame_cnt < 2*( _frame_cnt_max/3))
+    {
+        c  = 255;
+        cout<<"2nd third"<<endl;
+
+        ofSetColor(c, c, c);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+    if (_frame_cnt >= 2*( _frame_cnt_max/3) && _frame_cnt < _frame_cnt_max)
+    {
+        c  = 0;
+        cout<<"3rd third"<<endl;
+
+        ofSetColor(c, c, c);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+    _frame_cnt++;
+    
+    
+}
+
+// this runs at save_cb timer rate = DELTA_T_SAVE
+void LatencyTestAnalysis::save_cb(Timer& timer)
+{
+    _save_cnt++;
+    
+    // UPDATE THE COLOR ON THE SCREEN
+    //float c_last = c;    
+    
+    cout << "LatencyTestAnalysis::saving...\n";
+    cout << "c_last... " << c << endl;    
+    string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
+    string thisLocation = RefractiveIndex::_location;
+    
+    //RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera 
+    //    fileName = imageSaveFolderPath+whichAnalysis+"_"+ofToString(100.0*i*scanLineSpeed/ofGetHeight(),2)+"%_"+ofToString(i)+".jpg";
+    //ofSaveImage(vectorOfPixels[i], fileName, OF_IMAGE_QUALITY_BEST);
+    
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path+"/"+file_name, OF_IMAGE_QUALITY_BEST);    
+    
+    if(_save_cnt >= NUM_SAVE_PER_RUN)
+        _RUN_DONE = true;
+    
+}

src/LatencyTestAnalysis.h

@@ -0,0 +1,42 @@
+/*
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+#define DELTA_T_SAVE        100  //the milisecond timing 
+#define NUM_PHASE           1
+#define NUM_RUN             1
+#define NUM_SAVE_PER_RUN    100
+
+
+class LatencyTestAnalysis : public AbstractAnalysis
+{
+public:
+    LatencyTestAnalysis(): AbstractAnalysis("LATENCY_TEST"){;}
+    virtual ~LatencyTestAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void save_cb(Poco::Timer& timer);
+    
+protected:
+    
+    bool    _RUN_DONE;
+    int     _run_cnt, _save_cnt;
+    float   c, _frame_cnt, _frame_cnt_max;
+    string _whole_file_path;
+    
+};

src/ShadowScapesAnalysis.cpp

@@ -0,0 +1,154 @@
+/*
+ - copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
+ - all rights reserved.
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "ShadowScapesAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+#include "RefractiveIndex.h"
+
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+#define STATE_SCAN      0
+#define STATE_ANALYSIS  1
+
+void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
+{
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    
+    //directories have to be created one level at a time hence repeated calls
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+    _speed = 300;
+}
+
+void ShadowScapesAnalysis::synthesize()
+{
+    int w;
+    if(_dir == H) w = ofGetWidth();
+    else if(_dir == V) w = ofGetHeight();
+    _step = ((w / _speed) * 1000) / 50;
+    _line = 0;
+    Timer scan_timer(0, 50);
+    
+    TimerCallback<ShadowScapesAnalysis> strobe_callback(*this, &ShadowScapesAnalysis::scan_cb);
+    
+    _state = STATE_SCAN;
+    
+    scan_timer.start(strobe_callback);
+    
+    while(_state != STATE_ANALYSIS)
+        Thread::sleep(5);
+    
+    scan_timer.stop();
+    // do analysis here
+    // go back to the files i've saved and do the math here -     
+
+    while(_state != STATE_STOP)
+        Thread::sleep(100);
+    
+}
+
+void ShadowScapesAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    gui->addToggle("GO", "GO", 0);
+    gui->addButtonSlider("animation time limit", "ANIMATION_TIME_LIMIT", 10, 1, 3000, TRUE);    
+    
+}
+
+void ShadowScapesAnalysis::gui_detach()
+{
+    
+    
+}
+
+
+// the animation draw - and the output draw 
+void ShadowScapesAnalysis::draw()
+{
+    
+    static int _pos;
+    
+    if(_state == STATE_ANALYSIS) {
+        ofSetColor(0, 200, 0);               
+        ofRect(0, 0, ofGetWidth(), ofGetHeight());         
+        return;
+    }
+    
+    if(_state == STATE_SCAN) {
+        if(_pos != _line) {
+            //take snap??
+            _pos = _line;
+        }
+        ofSetColor(255, 255,  255); 
+        
+        if(_dir == H) ofRect(_pos, 0, 50, ofGetHeight());
+        else if(_dir == V) ofRect(0, _pos, ofGetWidth(), 50);
+        
+    }
+    
+    
+}
+
+
+void ShadowScapesAnalysis::scan_cb(Timer& timer)
+{
+    cout << "ShadowScapesAnalysis::scan_cb\n";
+    
+    _line += _step;
+    
+    if((_dir == H && _line >= ofGetWidth()) || 
+       (_dir == V && _line >= ofGetHeight())) { 
+        _state = STATE_ANALYSIS;
+    }
+    
+    
+}

src/ShadowScapesAnalysis.h

@@ -0,0 +1,69 @@
+/*
+ - copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
+ - all rights reserved.
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+enum shadow_type {
+    H, V, D,
+};
+
+class ShadowScapesAnalysis : public AbstractAnalysis
+{
+public:
+    ShadowScapesAnalysis(shadow_type dir): AbstractAnalysis("SHADOWSCAPE"), _dir(dir){;}
+    virtual ~ShadowScapesAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void scan_cb(Poco::Timer& timer);
+    
+protected:
+    
+    int     _line;  
+    int     _speed; // pix per second
+    int     _step;
+    shadow_type _dir;
+    
+    string _whole_file_path;
+    
+};

src/StrobeAnalysis.cpp

@@ -0,0 +1,142 @@
+/*
+ - copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
+ - all rights reserved.
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#include "StrobeAnalysis.h"
+#include "ofMain.h"
+
+#include "Poco/Timer.h"
+#include "Poco/Thread.h"
+#include "RefractiveIndex.h"
+using Poco::Timer;
+using Poco::TimerCallback;
+using Poco::Thread;
+
+#define STATE_STROBE    0
+#define STATE_ANALYSIS  1
+
+void StrobeAnalysis::setup(int camWidth, int camHeight)
+{
+    //AbstractAnalysis::setup(camWidth, camHeight);    
+    //_lastTime = ofGetElapsedTimeMillis();  
+    // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
+    
+    time_t rawtime;
+    struct tm * timeinfo;
+    
+    time ( &rawtime );
+    timeinfo = localtime ( &rawtime );
+    string time = asctime(timeinfo);
+    
+    cout<<"time"<<time<<endl;
+    
+    ofDirectory dir;
+    _whole_file_path= string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/"+time;
+    
+    
+    //directories have to be created one level at a time hence repeated calls
+
+    if(!dir.doesDirectoryExist(_whole_file_path)){
+        
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/", true,false); 
+        dir.createDirectory(string(ANALYSIS_PATH)+RefractiveIndex::_location+"/"+ _name+"/", true,false); 
+        dir.createDirectory(_whole_file_path, true,false);
+        
+    }
+}
+
+void StrobeAnalysis::synthesize()
+{
+    Timer strobe_timer(0, 70);
+    
+    TimerCallback<StrobeAnalysis> strobe_callback(*this, &StrobeAnalysis::strobe_cb);
+    
+    _state = STATE_STROBE;
+    _darkness = true;
+    _strobe_cnt = 0; 
+    
+    strobe_timer.start(strobe_callback);
+        
+    while(_state != STATE_ANALYSIS)
+        Thread::sleep(5);
+    
+    strobe_timer.stop();
+    
+    // do analysis here
+    
+    while(_state != STATE_STOP)
+        Thread::sleep(100);
+}
+
+void StrobeAnalysis::gui_attach(ofxControlPanel* gui)
+{
+    gui->addToggle("GO", "GO", 0);
+    gui->addButtonSlider("animation time limit", "ANIMATION_TIME_LIMIT", 10, 1, 3000, TRUE);    
+    
+}
+
+void StrobeAnalysis::gui_detach()
+{
+    
+}
+
+void StrobeAnalysis::draw()
+{
+    if(_state == STATE_ANALYSIS) {
+        ofSetColor(0, 200, 0);               
+        ofRect(0, 0, ofGetWidth(), ofGetHeight());         
+        return;
+    }
+    
+    if(_darkness) {
+        ofSetColor(0, 0, 0);               
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    } else {
+        ofSetColor(255, 255, 255);
+        ofRect(0, 0, ofGetWidth(), ofGetHeight()); 
+    }
+
+}
+
+
+void StrobeAnalysis::strobe_cb(Timer& timer)
+{
+    cout << "IResponseAnalysis::saving...\n";
+    _strobe_cnt++;
+    
+    _darkness = !_darkness;
+        
+    if(_strobe_cnt >= 20) { 
+        _state = STATE_ANALYSIS;
+    }
+
+
+}

src/StrobeAnalysis.h

@@ -0,0 +1,61 @@
+/*
+ - copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
+ - all rights reserved.
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ ~ author: dviid
+ ~ contact: dviid@labs.ciid.dk 
+ */
+
+#pragma once
+
+#include "AbstractAnalysis.h"
+
+#include "Poco/Timer.h"
+
+class StrobeAnalysis : public AbstractAnalysis
+{
+public:
+    StrobeAnalysis(): AbstractAnalysis("STROBE"){;}
+    virtual ~StrobeAnalysis(){;}
+    
+public:
+    
+    void setup(int camWidth, int camHeight);
+    void synthesize();
+    void gui_attach(ofxControlPanel* gui);
+    void gui_detach();
+    
+    void draw();
+    
+    void strobe_cb(Poco::Timer& timer);
+    
+protected:
+    
+    int     _strobe_cnt;  
+    bool    _darkness;
+    string _whole_file_path;
+};