post future everything commit

1) Live/interactive version of one or two of the algorithms. I'd vote
for IResponse, RelaxRate and ColorMulti as the ones to do live on the
laptop.  David is looking at this...

2) The frame skipping issue remains.  I looked at this while travelling
today, but couldn't figure it out.  We're still saving out meshes at
about half the rate of them being created.

3) The following three analyses do exactly the same thing currently,
and it would be good if they had something approaching a real analysis
happening.  Right now it's just a simple z-map in black and white with
some noise on top and lighting... kind of pretty but bit boring
currently:
	ShapeFromShadingAnalysis
	CamNoiseAnalysis
	ShadowScapesAnalysis

.gitignore

@@ -1,2 +1,8 @@
 
 src/.DS_Store
+.DS_Store
+Project.xcconfig
+bin/
+openFrameworks-Info.plist
+opencvExample.xcodeproj/
+config.refindx

config.refindx

@@ -1,45 +0,0 @@
-<!-- THIS FILE NEEDS TO GO IN THE APPLICATION /data/ folder -->
-
-<config>
-	<camera>
-		<id>1</id>
-		<width>640</width>
-		<height>480</height>
-	</camera>
-	<display>
-		<fps>30</fps>
-    </display>
-	<locale>
-		<name>SWANSEA</name>
-	</locale>
-
-    <analysis_NUM_RUN>
-        <NUM_RUN_shadowscapes>          3      </NUM_RUN_shadowscapes>
-        <NUM_RUN_relaxrate>             3      </NUM_RUN_relaxrate>
-        <NUM_RUN_iresponse>             3      </NUM_RUN_iresponse>
-        <NUM_RUN_shapefromshading>      3      </NUM_RUN_shapefromshading>
-        <NUM_RUN_strobe>                5      </NUM_RUN_strobe>
-        <NUM_RUN_camnoise>              5      </NUM_RUN_camnoise>
-        <NUM_RUN_colorsingle>           5      </NUM_RUN_colorsingle>
-        <NUM_RUN_colormulti>            5      </NUM_RUN_colormulti>
-        <NUM_RUN_diffnoise>             3      </NUM_RUN_diffnoise>
-    </analysis_NUM_RUN>
-
-    <analysis_time>
-        <acquiretime_shadowscapes>      30      </acquiretime_shadowscapes>
-        <acquiretime_relaxrate>         30      </acquiretime_relaxrate>
-        <acquiretime_iresponse>         30      </acquiretime_iresponse>
-        <acquiretime_shapefromshading>  30      </acquiretime_shapefromshading>
-        <acquiretime_strobe>            30      </acquiretime_strobe>
-        <acquiretime_camnoise>          30      </acquiretime_camnoise>
-        <acquiretime_colorsingle>       40      </acquiretime_colorsingle>
-        <acquiretime_colormulti>        40      </acquiretime_colormulti>
-        <acquiretime_diffnoise>         30      </acquiretime_diffnoise>
-    </analysis_time>
-    
-    <relaxrate>
-        <treshold>51</treshold>
-        <maxblobs>25</maxblobs>
-    </relaxrate>
-    
-</config>

example/RefractiveIndex.cpp

@@ -19,7 +19,7 @@
 #define CAMERA_ACQU_WIDTH   640
 #define CAMERA_ACQU_HEIGHT  480
 
-#define LOCATION            "MIDDLESBOROUGH"
+#define LOCATION            "MANCHESTER"
 
 #define ISTATE_UNDEF        0xEEEE
 #define ISTATE_START        0xAAAA
@@ -27,8 +27,10 @@
 #define ISTATE_TRANSITION   0xCCCC
 #define ISTATE_END          0xDDDD
 
+
 int _state = ISTATE_UNDEF;
 
+int              RefractiveIndex::_mode;
 ofPixels         RefractiveIndex::_pixels;
 ofVideoGrabber   RefractiveIndex::_vidGrabber;
 int              RefractiveIndex::_vid_w, RefractiveIndex::_vid_h, RefractiveIndex::_vid_id;
@@ -40,6 +42,10 @@ ofxXmlSettings   RefractiveIndex::XML;
 
 void RefractiveIndex::setup()
 {
+    camDist=1000;
+    
+    ofBackground(0, 0, 0);
+    ofSetBackgroundAuto(false);
     bool save_config = false;
     
     cout << "Loading configuration..." << endl;
@@ -50,6 +56,10 @@ void RefractiveIndex::setup()
         XML.loadFile("config.refindx");
     }
     
+    // <mode>
+    string m = XML.getValue("config:mode", "analysing");
+    _mode = (m == "analysing" ? MODE_ANALYSING : (m == "drawing" ? MODE_DRAWING : MODE_ANALYSING));
+        
     // <camera>
     _vid_id = XML.getValue("config:camera:id", CAMERA_ID);
     cout << "_vid_id: " << _vid_id << endl;
@@ -82,8 +92,10 @@ void RefractiveIndex::setup()
     cout << "* cam width = " << _vid_w << endl;
     cout << "* cam height = " << _vid_h << endl;
     
-    _vid_stream_open = false;    
+    if(_mode == MODE_ANALYSING) {
-    setup_camera();
+        _vid_stream_open = false;    
+        setup_camera();
+    }
     
     cout << "RRRRRREADY!" << endl;        
 
@@ -93,30 +105,27 @@ void RefractiveIndex::setup()
     //void ofPixels::allocate(int w, int h, ofImageType type)    
     _pixels.allocate(_vid_w, _vid_h, OF_IMAGE_COLOR); 
     
-    
     //TODO:  whichever one of these is first - it always runs twice ?
     
-    _analysisVector.push_back(new ShadowScapesAnalysis(V)); 
+    _analysisVector.push_back(new ShadowScapesAnalysis(V));  //1
-    _analysisVector.push_back(new ShadowScapesAnalysis(H));
+    _analysisVector.push_back(new ShadowScapesAnalysis(H));  //2
-    _analysisVector.push_back(new ShadowScapesAnalysis(D));
+    _analysisVector.push_back(new ShadowScapesAnalysis(D));  //3
 	    
-    _analysisVector.push_back(new RelaxRateAnalysis());
+    _analysisVector.push_back(new RelaxRateAnalysis());   //4
 	
+    _analysisVector.push_back(new IResponseAnalysis());   //5
     
-    _analysisVector.push_back(new IResponseAnalysis());
+    _analysisVector.push_back(new ShapeFromShadingAnalysis());   //6
     
-    _analysisVector.push_back(new ShapeFromShadingAnalysis());
+    _analysisVector.push_back(new StrobeAnalysis());   //7
     
-    _analysisVector.push_back(new StrobeAnalysis());
+    _analysisVector.push_back(new CamNoiseAnalysis());    //8
     
-    _analysisVector.push_back(new CamNoiseAnalysis());
+    _analysisVector.push_back(new ColorSingleAnalysis());    //9
     
-    _analysisVector.push_back(new ColorSingleAnalysis());
+    _analysisVector.push_back(new ColorMultiAnalysis());    //0
-    
-    _analysisVector.push_back(new ColorMultiAnalysis());
-    
-    _analysisVector.push_back(new DiffNoiseAnalysis());	
     
+    _analysisVector.push_back(new DiffNoiseAnalysis());	  //Q
     
     //_currentAnalysisIndx = 0;
     //_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++); 
@@ -125,12 +134,12 @@ void RefractiveIndex::setup()
     _currentAnalysis = NULL;
     _state = ISTATE_UNDEF;
   
+    
 }
 
 void RefractiveIndex::analysis_cb(string & analysis)
 {
     assert(analysis == _currentAnalysis->_name);
-    
     _state = ISTATE_STOP;    
 }
 
@@ -140,6 +149,17 @@ void RefractiveIndex::start_analysis()
     _analysisAdapator = new AnalysisAdaptor(_currentAnalysis);
     _currentAnalysis->setup(_vid_w, _vid_h);
     _analysisAdapator->start();    
+    
+    //allocate fbo for HD
+    fbo.allocate(1920,1080);
+
+    //    fbo.allocate( _currentAnalysis->_mesh_size_multiplier *_vid_w,_currentAnalysis->_mesh_size_multiplier * _vid_h);
+    //camera.setPosition((fbo.getWidth()/2), fbo.getHeight()/2,_currentAnalysis->_mesh_size_multiplier *500);
+    camera.setPosition(0, (fbo.getHeight()/2)+150,  _currentAnalysis->_mesh_size_multiplier*500);
+    camera.setFov(65.0);
+    camera.setOrientation(ofVec3f(-2,0,0));
+    _meshRotation=0;
+
 }
 
 void RefractiveIndex::stop_analysis()
@@ -173,10 +193,14 @@ void RefractiveIndex::state_analysis()
             break;
         case ISTATE_STOP:
             stop_analysis(); // blocking
-            _state = ISTATE_TRANSITION;
+            if(_mode == MODE_DRAWING)
+                _state = ISTATE_UNDEF;
+            else
+                _state = ISTATE_TRANSITION;
             break;
         case ISTATE_END:
-            stop_camera();
+            if(_mode == MODE_ANALYSING)
+                stop_camera();
             ::exit(1);
             break;
         case ISTATE_UNDEF:
@@ -199,8 +223,52 @@ void RefractiveIndex::draw()
     // black
     ofBackground(0, 0, 0);
    
-    if(_currentAnalysis)
+    if(_currentAnalysis){
+        
         _currentAnalysis->draw();
+       
+        if(_currentAnalysis->meshIsComplete){
+            
+            fbo.begin();
+            ofClear(0,0,0);
+
+            glShadeModel(GL_SMOOTH);  
+            
+            
+            camera.begin();
+            
+                //this is a hack, I don't know how to colour the fbo with black pixels so I'm drawing a massive black rectangle in the  background
+                /*
+                ofPushMatrix();
+                    ofTranslate(0, 0,-500);
+                    ofSetColor(0, 0, 0);
+                    ofRect(-fbo.getWidth(), -fbo.getHeight(), fbo.getWidth()*3, fbo.getHeight()*3);                
+                    ofPopMatrix();
+                ofSetColor(255);
+                */
+                //float xDiff= (fbo.getWidth()- 1.55*(_currentAnalysis->_mesh_size_multiplier * _vid_w))/2;
+                float xDiff= (fbo.getWidth()- 1.33333*(_currentAnalysis->_mesh_size_multiplier * _vid_w))/2;
+                float yDiff= (fbo.getHeight()-(_currentAnalysis->_mesh_size_multiplier * _vid_h))/2;
+                
+                ofTranslate(xDiff,yDiff,-_currentAnalysis->zPlaneAverage );
+                    //ofScale(1.33333,1.0,1.0);
+                    //_currentAnalysis->aMesh.drawVertices();     // TODO: tom - why do you have the vertices drawing here? 
+                    _currentAnalysis->aMesh.drawFaces();
+                    _currentAnalysis->aMesh.draw();
+                
+            camera.end();
+            fbo.end();
+
+            ofPixels pixels;
+            fbo.readToPixels(pixels);
+          
+            ofSaveImage(pixels,_currentAnalysis->meshFileName, OF_IMAGE_QUALITY_BEST);
+            //saving jpgs doesn't work - pngs only!
+            // PNG is fine - better for Final Cut anyway! 
+
+            ofDisableBlendMode() ;  
+        }
+    }
 }
 
 void RefractiveIndex::setup_camera()

example/RefractiveIndex.h

@@ -10,6 +10,11 @@
 
 #include "ofxOpenCv.h"
 #include "ofxXmlSettings.h"
+#include "ofxOpenCv.h"
+
+
+#define MODE_DRAWING        0xEEFF
+#define MODE_ANALYSING      0xFFEE
 
 class RefractiveIndex : public ofBaseApp
 {
@@ -51,10 +56,15 @@ protected:
     AnalysisAdaptor*            _analysisAdapator;
     vector<AbstractAnalysis*>   _analysisVector;    
     
+    float                         _meshRotation;
+    float                           camDist;
+    ofEasyCam                     cam;
 public:    
     // acquisition
     static ofPixels         _pixels;    
     static ofVideoGrabber   _vidGrabber;
+    static int              _mode;
+    
     vector<string>          videoSourceList;    
     static int              _vid_w, _vid_h, _vid_id;
     static bool             _vid_stream_open;
@@ -63,5 +73,8 @@ public:
     // this should be in xml
     static string           _location;
     static ofxXmlSettings   XML;  // made this static so we can access RUN_NUM in the analyses 
+    ofCamera    camera;
+    ofPixels    keepOnScreen;
+    ofFbo fbo;
    
 };

example/main.cpp

@@ -1,8 +1,8 @@
 #include "ofAppGlutWindow.h"
 #include "RefractiveIndex.h"
 
-#define SCREEN_WIDTH        800
+#define SCREEN_WIDTH        1280
-#define SCREEN_HEIGHT       600
+#define SCREEN_HEIGHT       800
 
 int main() {
     

src/AbstractAnalysis.cpp

@@ -3,29 +3,76 @@
 #include "AbstractAnalysis.h"
 #include "RefractiveIndex.h"
 #include "ofxFileHelper.h"
+#include "ofSystemUtils.h"
+
+void AbstractAnalysis::setup(int camWidth, int camHeight) {
+    
+    meshIsComplete=false;
+    imageForContourAvailable=false;
+    
+    _cam_w = camWidth; _cam_h = camHeight;
+    if(RefractiveIndex::_mode == MODE_DRAWING) {
+        ofFileDialogResult r = ofSystemLoadDialog("choooose da folda", true);
+        if(!r.bSuccess) {
+            ofSystemAlertDialog("OOOOPS.... ERROR...");
+            return;
+        }
+                
+        _whole_file_path_analysis = r.filePath;
+        _whole_file_path_synthesis = r.filePath + "/darwings";        
+    }
+
+}
 
 // this is the main threaded loop for a given analysis
 void AbstractAnalysis::do_synthesize() {
     
-    for(int i = 0; i < NUM_RUN; i++) {
+    switch(RefractiveIndex::_mode)
+    {
+        case MODE_ANALYSING:
+        {
+            for(int i = 0; i < NUM_RUN; i++) {
                 
-        cout << "NUM_RUN: " << i << endl;
+                cout << "NUM_RUN: " << i << endl;
                 
-        _saved_filenames_analysis.clear();  
+                _saved_filenames_analysis.clear();  
-        _saved_filenames_synthesis.clear(); 
+                _saved_filenames_synthesis.clear(); 
                 
-        _state = STATE_ACQUIRING;
+                _state = STATE_ACQUIRING;
-        acquire();
+                acquire();
-        if(_state == STATE_STOP) goto exit;
+                if(_state == STATE_STOP) goto exit;
-        _state = STATE_SYNTHESISING;
+                _state = STATE_SYNTHESISING;
-        synthesise();
+                synthesise();
-        if(_state == STATE_STOP) goto exit;
+                if(_state == STATE_STOP) goto exit;
-        _state = STATE_DISPLAY_RESULTS;
+                _state = STATE_DISPLAY_RESULTS;
-        displayresults();
+                displayresults();
+                cleanup();
+            }                    
+        }
+            
+        case MODE_DRAWING:
+        {            
+
+
+            ofxFileHelper fileHelperDrawing;
+            if(!fileHelperDrawing.doesDirectoryExist(_whole_file_path_synthesis)){
+                fileHelperDrawing.makeDirectory(_whole_file_path_synthesis);
+            }            
+            
+            read_dir_create_list(_whole_file_path_analysis);
+            _state = STATE_SYNTHESISING;
+            synthesise();
+            if(_state == STATE_STOP) goto exit;
+            _state = STATE_DISPLAY_RESULTS;
+            displayresults();
+            cleanup();            
+        }
     }
     
-    exit:    
+exit:    
+    cleanup();
     ofNotifyEvent(_synthesize_cb, _name);    
+    
 }
 
 void AbstractAnalysis::create_dir_allocate_images()
@@ -110,10 +157,38 @@ void AbstractAnalysis::create_dir_allocate_images()
     myGrayImage1.setUseTexture(false);
     myGrayImage1.allocate(RefractiveIndex::_vid_w, RefractiveIndex::_vid_h, OF_IMAGE_GRAYSCALE);
     
+
     //////////////////////////////END ALLOCATE IMAGES //////////////////////////////////////////////////  
 
 }
 
+bool cmp_file(string f0, string f1)
+{
+    int v0 = atoi(f0.substr(0, f0.find("_")).c_str());
+    int v1 = atoi(f1.substr(0, f1.find("_")).c_str());    
+    return v0 < v1;
+}
+
+void AbstractAnalysis::read_dir_create_list(string folder_path)
+{
+    File dir(folder_path);
+    
+    if(dir.exists() && dir.isDirectory()) {
+        vector<string> list;
+        dir.list(list);   
+        
+        std::sort(list.begin(), list.end(), cmp_file);
+        
+        for(int i = 0; i < list.size(); i++) {
+            string filepath = folder_path + "/" + list[i]; 
+            _saved_filenames_analysis.push_back(filepath);
+                        
+            cout << list[i] << endl; 
+            
+        }                
+    }
+}
+
 void AbstractAnalysis::saveImageAnalysis(string filename)
 {
     
@@ -153,7 +228,6 @@ void AbstractAnalysis::saveImageSynthesis(string filename, ofxCvImage* newPixels
     
 #ifdef TARGET_OSX   
 
-
     ofSaveImage(newPixels->getPixelsRef(), _whole_file_path_synthesis+"/"+filename, OF_IMAGE_QUALITY_BEST);
     
 #elif defined(TARGET_WIN32)    
@@ -179,5 +253,5 @@ void AbstractAnalysis::saveImageSynthesis(string filename, ofxCvImage* newPixels
     
     _saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+filename);
             
-}
     
+}

src/AbstractAnalysis.h

@@ -25,7 +25,7 @@ public:
     virtual ~AbstractAnalysis(){;}
     
     // generic function to set up the camera
-    virtual void setup(int camWidth, int camHeight){_cam_w = camWidth; _cam_h = camHeight;}  
+    virtual void setup(int camWidth, int camHeight);  
 
     // this is the main threaded loop for a given analysis
     void do_synthesize();
@@ -37,6 +37,8 @@ protected:
     
     virtual void create_dir_allocate_images();
     
+    virtual void read_dir_create_list(string folder_path);
+    
     virtual void saveImageAnalysis(string filename);
     virtual void saveImageSynthesis(string filename, ofxCvImage* newPixels, ofImageType newType);
     
@@ -49,11 +51,33 @@ protected:
     // display the results from disk
     virtual void displayresults() = 0;   
     
+    // display the results from disk
+    virtual void cleanup() {;}   
+    
+        
 public:
     string  _name;       
+    string  _draw_directory;
     
     // event
     ofEvent<string> _synthesize_cb;    
+    bool    meshIsComplete;
+    bool    imageForContourAvailable;
+    ofMesh  aMesh;
+    ofLight light;
+    ofLight lightStatic; 
+    
+    string  meshFileName;
+    //difference between our image size and the size of the fbo
+    float   widthScaleFactor;
+    float   heightScaleFactor;
+    ofImage  contourImage;
+    ofPixels meshPix;
+    ofPixels publicColorImage;
+    float    zPlaneAverage;
+    
+    //added Tom 1/5/12 defines the stretch we make to the mesh to make it fit HD proportions
+    float           _mesh_size_multiplier;
     
 protected:    
     int             _cam_w, _cam_h;          

src/CamNoiseAnalysis.cpp

@@ -15,10 +15,68 @@ using Poco::Thread;
 
 void CamNoiseAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_camnoise", NUMBER_RUNS);
     cout << "NUM_RUN CamNoiseAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
 
+    
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    _mesh_size_multiplier   = 8;
+    vertexSubsampling       = 1;
+    chooseColour            = 6;
+    multiplier              = 4.0;
+    
+    ofSetLineWidth(5.0f);
+    glPointSize(5.0f);
+    
+    glEnable(GL_DEPTH_TEST);
+    
+    //blendMode = OF_BLENDMODE_ADD;
+    //blendMode = OF_BLENDMODE_MULTIPLY;
+    //blendMode = OF_BLENDMODE_SUBTRACT;
+    //blendMode = OF_BLENDMODE_ALPHA;
+    blendMode = OF_BLENDMODE_SCREEN;
+    
+    //meshMode = OF_PRIMITIVE_TRIANGLES;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_STRIP;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_FAN;
+   // meshMode = OF_PRIMITIVE_LINES;
+    //meshMode = OF_PRIMITIVE_LINE_STRIP;
+    meshMode = OF_PRIMITIVE_POINTS;
+    
+    ///setup light    
+    ofEnableLighting();    
+    GLfloat light_ambient[] = {0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_diffuse[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_specular[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };  
+    
+    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);  
+    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);  
+    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);  
+    glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
+    
+    glEnable(GL_LIGHT0);  
+    
+    GLfloat light_ambient1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_diffuse1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_specular1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_position1[] = { -1.0, 1.0, 1.0, 0.0 };  
+    
+    glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient1);  
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse1);  
+    glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular1);  
+    glLightfv(GL_LIGHT1, GL_POSITION, light_position1);  
+    
+    glEnable(GL_LIGHT1);     
+    glPointSize(9.0f);
+    glEnable(GL_POINT_SMOOTH);
+    glCullFace(GL_BACK);
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_camnoise", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME CamNoiseAnalysis " << acq_run_time << endl;
@@ -80,7 +138,6 @@ void CamNoiseAnalysis::setup(int camWidth, int camHeight)
 	cvGrayImage2.clear();
     cvGrayDiff2.clear();
 
-    cvConvertorImage.clear();
 
     cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
@@ -89,9 +146,6 @@ void CamNoiseAnalysis::setup(int camWidth, int camHeight)
     cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-
 }
 
 
@@ -128,10 +182,25 @@ void CamNoiseAnalysis::synthesise()
     //cout << "CamNoiseAnalysis::saving synthesis...\n";
     if(_state == STATE_STOP) return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    _returnAveragePixelValues();
+    vector<vector<float> > averagePixelBrightnessesForEachLevel = averagePixelValuesForAllLevels;
+    float lightLevel=0;
+    float pLightLevel=0;
+    cout<<_listOfLightLevels.size()<<" "<<averagePixelBrightnessesForEachLevel.size()<<" these should be the same";
     
+    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+        vector<string> fileNameParts= ofSplitString(_saved_filenames_analysis[i], "_");
+        
+        lightLevel = ofToFloat(fileNameParts[fileNameParts.size()-2]);
         //cout << "CamNoiseAnalysis::synthesis FOR LOOP...\n";
         
+        //find which list of average pixel values is for THIS light level
+        int _averagePixelVectorIndex;
+        for (int j=0; j<_listOfLightLevels.size(); j+=3) {
+            if(lightLevel==_listOfLightLevels[j]){
+                _averagePixelVectorIndex=j;
+            }
+        }
         //cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
 
         if(_state == STATE_STOP) return;
@@ -142,63 +211,118 @@ void CamNoiseAnalysis::synthesise()
         }
 
         if(image1.loadImage(_saved_filenames_analysis[i])){
-            //cout << "LOADED image1!!!" << endl;
+            //    cout << "LOADED image1!!!" << endl;
-            //if(image5.loadImage(_saved_filenames_analysis[i+1])){
+            if(image5.loadImage(_saved_filenames_analysis[i+1])){
                 
-            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
                 
-            cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
+             /*   cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-            //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
+                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
                 
-            cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
+                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
-            // cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
+                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
-            //added by tom we weren't actually setting cvgrayimage1 anywhere
-           // cvGrayImage1.setFromPixels(cvColorImage1.getPixels(),cvColorImage1.width,cvColorImage1.height);
-            //cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-//cvGrayImage1=cvColorImage1;
                 
-            cvGrayImage1.erode();
+                //cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-            cvGrayImage1.erode();
+                //cvGrayDiff1.erode();
-            cvGrayImage1.erode();
-            cvGrayImage1.blur();
-            cvGrayImage1.contrastStretch();
-           /* cvColorImage1.erode();
-            cvColorImage1.erode();
-            cvColorImage1.erode();
-            cvColorImage1.blur();
-            cvColorImage1.contrastStretch();*/
                 
-            /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+                cvGrayImage1.dilate();
-            string file_name;
+                cvGrayImage1.blur(5);
+                cvGrayImage1.contrastStretch();
                 
-            file_name = ofToString(_synth_save_cnt, 2)+"_CamNoiseAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+                cvColorImage1.setFromGrayscalePlanarImages(cvGrayImage1, cvGrayImage1, cvGrayImage1);
+                //cvColorImage2.setFromGrayscalePlanarImages(cvGrayImage2, cvGrayImage2, cvGrayImage2);
+                
+                //cvPyrMeanShiftFiltering(cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), 1, 1);
+                //cvPyrMeanShiftFiltering(cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), 1, 1);
+                
+                //cvFloatImage1 = cvColorImage1;
+                //cvGrayImage1 = cvColorImage1;
                 
                 
-            //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+                //cvSmooth( cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), CV_GAUSSIAN, 5, 5);
-            // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+                //cvSmooth( cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), CV_GAUSSIAN, 5, 5);
                 
+                //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
+                //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
                 
-            //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
+                //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
-            //ofImage image;
+                //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
-            //image.allocate(cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);
                 
-            //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
+                // convert the CV image 
-            //image.setUseTexture(false);
+                image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+                image5.setFromPixels(cvColorImage2.getPixelsRef());  
+                */
+                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                if(!_gotFirstImage){
+                    cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                    _background=image1;
+                    _gotFirstImage=true;
+                }
                 
-            //image.setFromPixels(cvGrayImage1.getPixels(), cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);
+                //subtract background begin///////////////
-            //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
                 
-            //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
+                ofPixels imagePixels1       = image1.getPixelsRef();
+                ofPixels imagePixels2       = image5.getPixelsRef();
+                ofPixels backgroundPixels   = _background.getPixelsRef();
                 
-            // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
+                //DIFFERENCING SUBSEQUENT IMAGES
-            cvConvertorImage.setFromGrayscalePlanarImages(cvGrayImage1,cvGrayImage1,cvGrayImage1);
+                /*
-            //cvConvertorImage.setFromGrayscalePlanarImages(cvColorImage1,cvColorImage1,cvColorImage1);
+                 for(int i=0;i<imagePixels1.size();i++){
-            saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
+                 //unsigned char val=imagePixels1[i];
-            _synth_save_cnt++;
+                 // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                 if(imagePixels1[i]-imagePixels2[i]>0){
+                 imagePixels1[i]-=imagePixels2[i];
+                 }
+                 else{
+                 imagePixels1[i]=0;
+                 }
+                 }
+                 */ 
                 
+                //DIFFERENCING THE BACKGROUND
+                /*
+                 for(int i=0;i<imagePixels1.size();i++){
+                 //unsigned char val=imagePixels1[i];
+                 // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                 if(imagePixels1[i]-backgroundPixels[i]>0){
+                 imagePixels1[i]-=backgroundPixels[i];
+                 }
+                 else{
+                 imagePixels1[i]=0;
+                 }
+                 }
+                 */
                 
-            //}
+                //update the images with their new background subtracted selves
+                image1.setFromPixels(imagePixels1);
+                
+                //flag the main app that we aren't read yet
+                meshIsComplete=false;
+                
+                //make a mesh - this mesh will be drawn in the main app
+                setMeshFromPixels(_returnDepthsAtEachPixel(image1, averagePixelBrightnessesForEachLevel[_averagePixelVectorIndex], _background), image1, image1, aMesh);
+                
+                //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+                
+                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+                //string file_name;
+                
+                //with jpgs this was refusing to save out
+                meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_CamNoiseAnalysis_"+ofToString(_run_cnt,2)+".png";
+                _saved_filenames_synthesis.push_back(meshFileName);
+                
+                //file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+                
+                //flag that we are finished  
+                meshIsComplete=true;
+                _synth_save_cnt++;
+                
+            }
+        } else {
+            cout<<"couldn't load image from "<<_saved_filenames_analysis[i]<<endl;
         }
+
     }
 
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
@@ -432,3 +556,533 @@ void CamNoiseAnalysis::save_cb(Timer& timer)
 
     saveImageAnalysis(file_name);
 }
+
+
+
+void CamNoiseAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //to do 
+    
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    mesh.setMode(meshMode);
+    
+    ofColor meshColour=ofColor(255,255,255);
+    
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==2){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==3){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==4){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            int randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter)    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) +1 ]));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==5){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            int randomJitter2 = 0;
+            int randomJitter = 0;
+            
+            ofColor currentSecondImageColor;
+            ofColor currentSecondImageBW;
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*((y)+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp() ); 
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter)+1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    if(chooseColour==6){
+        
+        for(int i=0;i<sPixels.size();i++){
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x++;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y++;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+
+}
+
+
+vector<float> CamNoiseAnalysis::_returnDepthsAtEachPixel(ofImage &image1, vector<float> averageDepths, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    int inc=0;
+    if(chooseComparison==1){
+        //for each pixel...
+        float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            
+            ofColor imageColor2 = imagePixels1.getColor(x+1, y+1);
+            
+            ofColor imageColor3 = imagePixels1.getColor(x+2, y+2);
+            
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+            if(i<100){
+                
+              //  cout<<" average: "<<averageDepths[inc]<<" actual: "<<imageColor1.getBrightness()<<" ";
+            }
+           // int thisDiff=imageColor1.getBrightness();
+            
+            int thisDiff=-(imageColor1.getBrightness() - averageDepths[inc] );
+            //int thisDiff=abs(imageColor1.getLightness());
+            //int thisDiff=-abs(imageColor1.r);
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            differences.push_back(multiplier * thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+            inc++;
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}
+
+
+void CamNoiseAnalysis:: _returnAveragePixelValues(){
+    
+    
+    //second number in 15_204.00_2.jpg is the light level
+    
+    float lightLevel=0;
+    float pLightLevel=0;
+    float numberOfImagesActuallyLoaded=0;
+    vector<float> averagePixelValuesForOneLevel;
+
+    for (int j=0; j<RefractiveIndex::_vid_w*RefractiveIndex::_vid_h; j++) {
+        averagePixelValuesForOneLevel.push_back(0.0);
+    }
+    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+        
+        
+        if(_state == STATE_STOP) return;
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
+            //couldn't load image
+            cout << "didn't load image" << endl;
+        }
+        
+        if(image1.loadImage(_saved_filenames_analysis[i])){
+
+            //split file name by under score
+            vector<string> fileNameParts= ofSplitString(_saved_filenames_analysis[i], "_");
+            
+            lightLevel = ofToFloat(fileNameParts[fileNameParts.size()-2]);
+           // cout<<" lightLevel "<<lightLevel;
+
+            ofPixels image1Pixels=image1.getPixelsRef();
+            
+            int x=0;
+            int y=0;
+            int inc=0;
+            for (int j=0; j<image1Pixels.size(); j+=3) {
+                ofColor color=image1Pixels.getColor(x, y);
+                averagePixelValuesForOneLevel[inc]+= color.getBrightness();
+                x++;
+                inc++;
+                if(x>=image1Pixels.getWidth()){ 
+                    x=0;
+                    y++;
+                }
+            }
+           // _listOfLightLevels}
+            numberOfImagesActuallyLoaded++;
+            
+            //if this is a new light level advance
+            if (lightLevel!=pLightLevel) {
+                
+                ///check that this light level is not already in our list
+                
+                
+             _listOfLightLevels.push_back(lightLevel);
+                
+                for (int j=0; j<averagePixelValuesForOneLevel.size(); j++) {
+                    averagePixelValuesForOneLevel[j]/=numberOfImagesActuallyLoaded;
+                    //cout<<" "<<averagePixelValuesForOneLevel[j]<<" ";
+                }
+                averagePixelValuesForAllLevels.push_back(averagePixelValuesForOneLevel);
+                for (int j=0; j<averagePixelValuesForOneLevel.size(); j++) {
+                    averagePixelValuesForOneLevel[j]=0;
+                }
+
+                pLightLevel=lightLevel;
+                numberOfImagesActuallyLoaded=0;
+
+            }
+
+        }
+    }
+    
+    for(int j=0;j<_listOfLightLevels.size();j++){
+        //cout<<_listOfLightLevels[j]<<" lightlevel ";
+    }
+    
+}

src/CamNoiseAnalysis.h

@@ -61,7 +61,29 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
-    //this is the temporary container to allow us to convert and save out greyscale images
+   
-    ofxCvColorImage         cvConvertorImage;
+    //mesh making function
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+    
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, vector<float> averageDepths, ofImage &backgroundImage);
+    
+    //returns a vector of floats for each distinct light level
+   void _returnAveragePixelValues();
+    //this vector of vectors will be returned
+    vector<vector<float> > averagePixelValuesForAllLevels;
+    
+    vector<float> _listOfLightLevels;
+    
+    int vertexSubsampling;
+    
+    int chooseColour;
+    ofPrimitiveMode meshMode;
+    ofBlendMode blendMode;
+    float multiplier;
+    
+    bool _gotFirstImage;
+    ofImage _background;
+
     
 };

src/ColorMultiAnalysis.cpp

@@ -14,10 +14,20 @@ using Poco::Thread;
 
 void ColorMultiAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_colormulti", NUMBER_RUNS);
     cout << "NUM_RUN ColorMultiAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
     
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    
+    _mesh_size_multiplier=8;
+    vertexSubsampling = 1;
+    chooseColour=1;
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_colormulti", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME ColorMultiAnalysis " << acq_run_time << endl;
@@ -139,6 +149,7 @@ void ColorMultiAnalysis::synthesise()
             cout << "didn't load image" << endl;
         } 
         
+        
         if(image1.loadImage(_saved_filenames_analysis[i])){
             //cout << "LOADED image1!!!" << endl;
             //if(image5.loadImage(_saved_filenames_analysis[i+1])){
@@ -148,47 +159,91 @@ void ColorMultiAnalysis::synthesise()
             cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
             //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
             
-            cvColorImage1.blur(5);
+            //cvColorImage1.blur(1);
-            cvColorImage1.erode();
+            //cvColorImage1.erode();
-            cvColorImage1.erode();
+            
-            cvColorImage1.dilate();
+            //cvColorImage1.dilate();
-            cvColorImage1.blur(5);
+            //cvColorImage1.dilate();
-            cvColorImage1.dilate();
+            //cvColorImage1.dilate();
-            cvColorImage1.dilate();
+            //cvColorImage1.dilate();
-            cvColorImage1.dilate();
+            
-            cvColorImage1.dilate();
+            //cvFloatImage1 = cvColorImage1;
+            //cvGrayImage1 = cvColorImage1;
+
+            cvSmooth( cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), CV_GAUSSIAN, 15, 15);
+            cvXorS( cvColorImage1.getCvImage(), cvScalarAll(2), cvColorImage1.getCvImage(), 0 );
+            
+            //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
+            //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
+            
+            //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
+            //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
+            
+            // convert the CV image 
+            image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+            
+            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+            if(!_gotFirstImage){
+                cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                _background=image1;
+                _gotFirstImage=true;
+            }
+            
+            //subtract background begin///////////////
+            
+            ofPixels imagePixels1       = image1.getPixelsRef();
+            //ofPixels imagePixels2       = image5.getPixelsRef();
+            ofPixels backgroundPixels   = _background.getPixelsRef();
+            
+            for(int i=0;i<imagePixels1.size();i++){
+                //unsigned char val=imagePixels1[i];
+                // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                if(imagePixels1[i]-backgroundPixels[i]>0){
+                    imagePixels1[i]-=backgroundPixels[i];
+                }
+                else{
+                    imagePixels1[i]=0;
+                }
+            }
+            
+            //update the images with their new background subtracted selves
+            image1.setFromPixels(imagePixels1);
+            
+            //flag the main app that we aren't read yet
+            meshIsComplete=false;
+            
+            //make a mesh - this mesh will be drawn in the main app
+            setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+            
+            //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
             
             /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-            string file_name;
+            //string file_name;
             
-            file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+            //with jpgs this was refusing to save out
+            meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".png";
+            _saved_filenames_synthesis.push_back(meshFileName);
             
+            //file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
             
-            //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+            //flag that we are finished  
-            // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+            meshIsComplete=true;
-            
-            
-            //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-            //ofImage image;
-            //image.allocate(cvColorImage1.width, cvColorImage1.height, OF_IMAGE_COLOR);
-            
-            //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-            //image.setUseTexture(false);  
-           
-            //image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height,OF_IMAGE_COLOR);
-            //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-            
-            //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-            
-            // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-            saveImageSynthesis(file_name, &cvColorImage1, OF_IMAGE_COLOR);
             _synth_save_cnt++;
             
             // }
         }
     }
     
+    // TOM'S fix of why the last file gets overwritten again and again - but seems to prevent the files being written to the screen.
+    /*
+        _RUN_DONE = true;
+    */
+    
+    meshIsComplete=false;
+    _synth_save_cnt=0;
+    
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+    
     while(!_RUN_DONE && _state != STATE_STOP)
         Thread::sleep(3);
 }
@@ -224,6 +279,27 @@ void ColorMultiAnalysis::displayresults()
 void ColorMultiAnalysis::draw()
 {
     
+    ofEnableSmoothing();
+    
+    ofEnableLighting(); 
+    ofEnableSeparateSpecularLight();     
+    light.enable();
+	
+    light.setPosition(200,200,-150);
+    lightStatic.enable();
+    
+    glEnable(GL_DEPTH_TEST);
+    
+    ofSetLineWidth(2.0f);
+    //glPointSize(4.0f);
+    
+    ofEnableBlendMode ( OF_BLENDMODE_ADD );
+    //ofEnableBlendMode ( OF_BLENDMODE_MULTIPLY );
+    //ofEnableBlendMode ( OF_BLENDMODE_SUBTRACT );
+    //ofEnableBlendMode ( OF_BLENDMODE_ALPHA );
+    //ofEnableBlendMode ( OF_BLENDMODE_SCREEN );
+
+    
     switch (_state) {
         case STATE_ACQUIRING:
         {
@@ -409,8 +485,156 @@ void ColorMultiAnalysis::draw()
 void ColorMultiAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;
-            
     string file_name = ofToString(_save_cnt,2)+"_"+ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
-
     saveImageAnalysis(file_name);    
 }
+
+
+void ColorMultiAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    
+    mesh.setMode(OF_PRIMITIVE_TRIANGLES);
+    //mesh.setMode(OF_PRIMITIVE_TRIANGLE_STRIP);
+    //mesh.setMode(OF_PRIMITIVE_TRIANGLE_FAN);
+    //mesh.setMode(OF_PRIMITIVE_LINES);
+    //mesh.setMode(OF_PRIMITIVE_LINE_STRIP);
+    //mesh.setMode(OF_PRIMITIVE_LINE_LOOP);
+    //mesh.setMode(OF_PRIMITIVE_POINTS);
+    
+    /*
+     OF_PRIMITIVE_TRIANGLES,
+     OF_PRIMITIVE_TRIANGLE_STRIP,
+     OF_PRIMITIVE_TRIANGLE_FAN,
+     OF_PRIMITIVE_LINES,
+     OF_PRIMITIVE_LINE_STRIP,
+     OF_PRIMITIVE_LINE_LOOP,
+     OF_PRIMITIVE_POINTS
+     
+     */
+    
+    ofColor meshColour=ofColor(255,255,255);
+    
+   
+    
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+}
+
+
+
+vector<float> ColorMultiAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    
+    if(chooseComparison==1){
+        //for each pixel...
+        //float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            //float _distanceToCentre=ofDist(imagePixels1.getWidth()/2, imagePixels1.getHeight()/2, x, y);
+            //float _presumedBrightness=ofMap(sqrt(_maxPossibleDistanceToCentre)-sqrt(_distanceToCentre), 0,  sqrt(_maxPossibleDistanceToCentre), 0, 255);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+            
+            int thisDiff=-abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getLightness());
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            float multiplier=15.0*((thisDiff)/255.0);
+            
+            differences.push_back(multiplier* thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}

src/ColorMultiAnalysis.h

@@ -59,4 +59,17 @@ protected:
     ofxCvColorImage         cvConvertorImage;
     
     
+    //mesh making function
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+    
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    
+    int vertexSubsampling;
+    int chooseColour;
+    
+    bool _gotFirstImage;
+    ofImage _background;
+
+
 };

src/ColorSingleAnalysis.cpp

@@ -1,9 +1,11 @@
 #include "ColorSingleAnalysis.h"
 #include "ofMain.h"
-
 #include "Poco/Timer.h"
 #include "Poco/Thread.h"
 
+#include <string>
+#include <iostream>
+
 #include "RefractiveIndex.h"
 
 using Poco::Timer;
@@ -15,14 +17,24 @@ using Poco::Thread;
 
 void ColorSingleAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_colorsingle", NUMBER_RUNS);
     cout << "NUM_RUN ColorSingleAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
     
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    _mesh_size_multiplier=8;
+    vertexSubsampling = 1;
+    chooseColour=1;
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_colorsingle", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME ColorSingleAnalysis " << acq_run_time << endl;
 
+    
     //int acq_run_time = 25;   // 20 seconds of acquiring per run
     
     DELTA_T_SAVE = 1*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
@@ -45,6 +57,7 @@ void ColorSingleAnalysis::setup(int camWidth, int camHeight)
     b = 0;
     
     fileNameTag = "";
+    fileNameColor = "";
     
     _show_image = false;
     _image_shown = false;
@@ -95,13 +108,11 @@ void ColorSingleAnalysis::setup(int camWidth, int camHeight)
     cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
     cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);    
-    
 }
 
 
 void ColorSingleAnalysis::acquire()
 {
-
     Timer* save_timer;
 
     TimerCallback<ColorSingleAnalysis> save_callback(*this, &ColorSingleAnalysis::save_cb);
@@ -124,8 +135,6 @@ void ColorSingleAnalysis::acquire()
 
     save_timer->stop();
 
-  
-    // }
 }
 
 void ColorSingleAnalysis::synthesise()
@@ -148,56 +157,126 @@ void ColorSingleAnalysis::synthesise()
         } 
         
         if(image1.loadImage(_saved_filenames_analysis[i])){
-            //cout << "LOADED image1!!!" << endl;
+                //cout << "LOADED image1!!!" << endl;
-            //if(image5.loadImage(_saved_filenames_analysis[i+1])){
+                //if(image5.loadImage(_saved_filenames_analysis[i+1])){
                 
                 ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
 
+            
+                cout << "_saved_filenames_analysis[i].find(RED): " << _saved_filenames_analysis[i].find("RED") << endl;                
+            
+                if(_saved_filenames_analysis[i].find("RED")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameColor = "RED";
+                    cout<<"FOUND RED"<<endl;
+                } else if (_saved_filenames_analysis[i].find("GREEN")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameColor = "GREEN";
+                    cout<<"FOUND GREEN"<<endl;
+                } else if(_saved_filenames_analysis[i].find("BLUE")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameColor = "BLUE";
+                    cout<<"FOUND BLUE"<<endl;
+                } else if(_saved_filenames_analysis[i].find("FADING")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameColor = "FADING";
+                    cout<<"FOUND FADING"<<endl;
+                }
+                          
                 cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
                 //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
                 
-                cvColorImage1.blur(5);
+                cvColorImage1.blur(1);
-                cvColorImage1.erode();
+            
-                cvColorImage1.erode();
+                //cvSmooth( cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), CV_GAUSSIAN, 9, 9 );
-                cvColorImage1.dilate();
+                
-                cvColorImage1.blur(5);
-                cvColorImage1.erode();
-                cvColorImage1.erode();
-                cvColorImage1.erode();
                 cvColorImage1.erode();
                 
+                cvSmooth( cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), CV_GAUSSIAN, 3, 3 );
+            
+                //cvColorImage1.erode();
+            
+                //cvColorImage1.dilate();
+                //cvColorImage1.dilate();
+                //cvColorImage1.dilate();
+                //cvColorImage1.dilate();
+            
+                //cvFloatImage1 = cvColorImage1;
+                //cvGrayImage1 = cvColorImage1;
+            
+                //cvXorS( cvColorImage1.getCvImage(), cvScalarAll(255), cvColorImage1.getCvImage(), 0 );
+                
+                //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
+                //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
+            
+                //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
+                //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
+            
+                // convert the CV image 
+                image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+            
+                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                if(!_gotFirstImage){
+                    cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                    _background=image1;
+                    _gotFirstImage=true;
+                }
+                
+                //subtract background begin///////////////
+                
+                ofPixels imagePixels1       = image1.getPixelsRef();
+                ofPixels imagePixels2       = image5.getPixelsRef();
+                ofPixels backgroundPixels   = _background.getPixelsRef();
+                
+                for(int i=0;i<imagePixels1.size();i++){
+                    //unsigned char val=imagePixels1[i];
+                    // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                    if(imagePixels1[i]-backgroundPixels[i]>0){
+                        imagePixels1[i]-=backgroundPixels[i];
+                    }
+                    else{
+                        imagePixels1[i]=0;
+                    }
+                }
+            
+                //update the images with their new background subtracted selves
+                image1.setFromPixels(imagePixels1);
+                
+                //flag the main app that we aren't read yet
+                meshIsComplete=false;
+        
+                //make a mesh - this mesh will be drawn in the main app
+                setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+            
+                //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+            
                 /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
+                //string file_name;
                 
-                file_name = ofToString(_synth_save_cnt, 2)+"_ColorSingleAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+                //with jpgs this was refusing to save out
+                meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_ColorSingleAnalysis_"+ofToString(_run_cnt,2)+".png";
+                _saved_filenames_synthesis.push_back(meshFileName);
             
+                //file_name = ofToString(_synth_save_cnt, 2)+"_ColorSingleAnalysis_"+ofToString(_run_cnt,2)+".jpg";
             
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+                //flag that we are finished  
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+                meshIsComplete=true;
-                
-                
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                //ofImage image;
-                //image.allocate(cvColorImage1.width, cvColorImage1.height, OF_IMAGE_COLOR);
-                
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-                //image.setUseTexture(false);  
-                
-                //image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height,OF_IMAGE_COLOR);
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-            
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-                
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-            
-                saveImageSynthesis(file_name, &cvColorImage1, OF_IMAGE_COLOR);
                 _synth_save_cnt++;
             
            // }
         }
     }
     
+    // TOM'S fix of why the last file gets overwritten again and again - but seems to prevent the files being written to the screen.
+    /*
+     _RUN_DONE = true;
+     */
+    
+    meshIsComplete=false;
+    _synth_save_cnt=0;
+    
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+    
     while(!_RUN_DONE && _state != STATE_STOP)
         Thread::sleep(3);
     
@@ -234,12 +313,31 @@ void ColorSingleAnalysis::displayresults()
 
 void ColorSingleAnalysis::draw()
 {
+    ofEnableSmoothing();
+
+    ofEnableLighting(); 
+    ofEnableSeparateSpecularLight();     
+    light.enable();
+	
+    light.setPosition(200,200,-150);
+    lightStatic.enable();
+    
+    glEnable(GL_DEPTH_TEST);
+    
+    ofSetLineWidth(1.0f);
+    glPointSize(1.0f);
+    
+    ofEnableBlendMode ( OF_BLENDMODE_ADD );
+    //ofEnableBlendMode ( OF_BLENDMODE_MULTIPLY );
+    //ofEnableBlendMode ( OF_BLENDMODE_SUBTRACT );
+    //ofEnableBlendMode ( OF_BLENDMODE_ALPHA );
+    //ofEnableBlendMode ( OF_BLENDMODE_SCREEN );
+    
     
     switch (_state) {
         case STATE_ACQUIRING:
         {
 
-            
             if (_frame_cnt < _frame_cnt_max)
             {
                     
@@ -431,3 +529,278 @@ void ColorSingleAnalysis::save_cb(Timer& timer)
     
     saveImageAnalysis(file_name);
 }
+
+
+
+void ColorSingleAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+   
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    //mesh.setMode(OF_PRIMITIVE_TRIANGLES);
+    //mesh.setMode(OF_PRIMITIVE_TRIANGLE_STRIP);
+    //mesh.setMode(OF_PRIMITIVE_TRIANGLE_FAN);
+    //mesh.setMode(OF_PRIMITIVE_LINES);
+    //mesh.setMode(OF_PRIMITIVE_LINE_STRIP);
+    //mesh.setMode(OF_PRIMITIVE_LINE_LOOP);
+    mesh.setMode(OF_PRIMITIVE_POINTS);
+  
+    /*
+     OF_PRIMITIVE_TRIANGLES,
+     OF_PRIMITIVE_TRIANGLE_STRIP,
+     OF_PRIMITIVE_TRIANGLE_FAN,
+     OF_PRIMITIVE_LINES,
+     OF_PRIMITIVE_LINE_STRIP,
+     OF_PRIMITIVE_LINE_LOOP,
+     OF_PRIMITIVE_POINTS
+     
+     */
+    
+    ofColor meshColour=ofColor(255,255,255, 255);
+    
+      //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==2){
+                
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+             
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+      
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==3){
+        
+        ofColor currentSecondImageColor;
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            if(fileNameColor=="RED")
+            {
+                currentSecondImageColor.r=255;
+                currentSecondImageColor.g=0;
+                currentSecondImageColor.b=0;
+                currentSecondImageColor.a=255;
+                
+            } else if(fileNameColor=="GREEN")
+            {
+                currentSecondImageColor.r=0;
+                currentSecondImageColor.g=255;
+                currentSecondImageColor.b=0;
+                currentSecondImageColor.a=255;
+                
+            } else if(fileNameColor=="BLUE")
+            {
+                currentSecondImageColor.r=0;
+                currentSecondImageColor.g=0;
+                currentSecondImageColor.b=255;
+                currentSecondImageColor.a=255;
+                
+            } else if(fileNameColor=="FADING")
+            {
+                currentSecondImageColor.r= 255;
+                currentSecondImageColor.g= 255;
+                currentSecondImageColor.b= 255;
+                currentSecondImageColor.a= 255;
+            }
+                       
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+           
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor( currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            //x++;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //y++;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+}
+
+
+vector<float> ColorSingleAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    
+    if(chooseComparison==1){
+        //for each pixel...
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+        
+            int thisDiff;
+            
+            if(fileNameColor=="RED")
+            {   
+                //thisDiff=abs(imageColor1.r);
+
+                thisDiff=abs(255-imageColor1.r);
+            } else if(fileNameColor=="GREEN")
+            {
+                //thisDiff=abs(imageColor1.g);                
+
+                thisDiff=abs(255-imageColor1.g);  
+                
+            } else if(fileNameColor=="BLUE")
+            {
+                //thisDiff=abs(imageColor1.b);
+
+                thisDiff=abs(255-imageColor1.b);
+            
+            } else if(fileNameColor=="FADING") {
+            
+                //thisDiff=imageColor1.getBrightness();
+                thisDiff=255-imageColor1.getBrightness();
+
+            }
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            float multiplier=8.0;
+            
+            differences.push_back(multiplier* thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}

src/ColorSingleAnalysis.h

@@ -1,4 +1,4 @@
-/*
+    /*
  ~ author: dviid
  ~ contact: dviid@labs.ciid.dk 
  */
@@ -32,6 +32,7 @@ protected:
 
     bool    _RUN_DONE;
     string  fileNameTag;
+    string  fileNameColor;
     float   r,g,b;
     
     int     _run_cnt, _save_cnt, _fade_cnt, _synth_save_cnt, _anim_cnt;
@@ -60,10 +61,24 @@ protected:
     ofxCvGrayscaleImage 	cvGrayImage3;
     ofxCvGrayscaleImage 	cvGrayImage4;
     
+    ofxCvFloatImage       	cvFloatImage1;
+    
     ofxCvContourFinder      cvContourFinder1;
     
     //this is the temporary container to allow us to convert and save out greyscale images
     ofxCvColorImage         cvConvertorImage;
     
     
+    //mesh making function
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    
+    int vertexSubsampling;
+    int chooseColour;
+    
+    bool _gotFirstImage;
+    ofImage _background;
+
 };

src/DiffNoiseAnalysis.cpp

@@ -15,10 +15,35 @@ using Poco::Thread;
 
 void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_diffnoise", NUMBER_RUNS);
+ 
     cout << "NUM_RUN DiffNoiseAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
     
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    _mesh_size_multiplier   = 10;
+    vertexSubsampling       = 1;
+    chooseColour            = 5;
+    multiplier              = 4.0;
+
+    blendMode = OF_BLENDMODE_ADD;
+    //blendMode = OF_BLENDMODE_MULTIPLY;
+    //blendMode = OF_BLENDMODE_SUBTRACT;
+    //blendMode = OF_BLENDMODE_ALPHA;
+    //blendMode = OF_BLENDMODE_SCREEN;
+        
+    meshMode = OF_PRIMITIVE_TRIANGLES;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_STRIP;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_FAN;
+    //meshMode = OF_PRIMITIVE_LINES;
+    //meshMode = OF_PRIMITIVE_LINE_STRIP;
+    //meshMode = OF_PRIMITIVE_POINTS;
+    
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_diffnoise", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME DiffNoiseAnalysis " << acq_run_time << endl;
@@ -89,7 +114,6 @@ void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
     cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
     cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
 }
 
 
@@ -149,45 +173,133 @@ void DiffNoiseAnalysis::synthesise()
             cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
             //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
         
-            cvColorImage1.invert();
+            //cvColorImage1.erode();
-            cvColorImage1.blur(5);
+            //cvColorImage1.dilate();
-            cvColorImage1.erode();
-            cvColorImage1.erode();
-            cvColorImage1.blur(5);
-            cvColorImage1.erode();
-            cvColorImage1.erode();
                      
-            //////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+            //cvColorImage1.blur(5);
-            string file_name;
+            //cvColorImage2.blur(5);
+            cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
+            //cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
                 
-            file_name = ofToString(_synth_save_cnt, 2)+"_DiffNoiseAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+            //cvGrayImage1.convertToRange(0.0, 255.0);
+            //cvGrayImage2.convertToRange(0.0, 255.0);
+                
+            //cvGrayImage1.adaptiveThreshold( 200, 0);
+            //cvGrayImage2.adaptiveThreshold( 200, 0);
+                
+            //cvGrayImage1.contrastStretch();
+            //cvGrayImage2.contrastStretch();
+            
+            //cvGrayImage1.brightnessContrast(1.0,0.5);
+            //cvGrayImage2.brightnessContrast(1.0,0.5);
+               
+            cvColorImage1.setFromGrayscalePlanarImages(cvGrayImage1, cvGrayImage1, cvGrayImage1);
+            //cvColorImage2.setFromGrayscalePlanarImages(cvGrayImage2, cvGrayImage2, cvGrayImage2);
+                
+            cvPyrMeanShiftFiltering(cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), 1, 1);
+            //cvPyrMeanShiftFiltering(cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), 1, 1);
+                
+            //cvFloatImage1 = cvColorImage1;
+            //cvGrayImage1 = cvColorImage1;
+            
+            //cvXorS( cvColorImage1.getCvImage(), cvScalarAll(150), cvColorImage1.getCvImage(), 0 );
+            //cvXorS( cvColorImage2.getCvImage(), cvScalarAll(150), cvColorImage1.getCvImage(), 0 );
+            //cvSmooth( cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), CV_GAUSSIAN, 5, 5);
+            //cvSmooth( cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), CV_GAUSSIAN, 5, 5);
+                
+            //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
+            //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
+            
+            //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
+            //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
             
                 
-            //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+             // convert the CV image 
-            // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+            image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+            //image5.setFromPixels(cvColorImage2.getPixelsRef()); 
                 
+            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+            if(!_gotFirstImage){
+                cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                _background=image1;
+                _gotFirstImage=true;
+            }
             
-            //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
+            //subtract background begin///////////////
-            //ofImage image;
-            //image.allocate(cvColorImage1.width, cvGrayImage1.height, OF_IMAGE_COLOR);
             
-            //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
+            ofPixels imagePixels1       = image1.getPixelsRef();
-            //image.setUseTexture(false);  
+            //ofPixels imagePixels2       = image5.getPixelsRef();
+            ofPixels backgroundPixels   = _background.getPixelsRef();
             
-            //image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height, OF_IMAGE_COLOR);
+                //DIFFERENCING SUBSEQUENT IMAGES
-            //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+                 /*
+            for(int i=0;i<imagePixels1.size();i++){
+                //unsigned char val=imagePixels1[i];
+                // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                if(imagePixels1[i]-imagePixels2[i]>0){
+                    imagePixels1[i]-=imagePixels2[i];
+                }
+                else{
+                    imagePixels1[i]=0;
+                }
+            }
                  
-            //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
+                */ 
+                    //DIFFERENCING THE BACKGROUND
+                /*
+            for(int i=0;i<imagePixels1.size();i++){
+                //unsigned char val=imagePixels1[i];
+                // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                if(imagePixels1[i]-backgroundPixels[i]>0){
+                    imagePixels1[i]-=backgroundPixels[i];
+                }
+                else{
+                    imagePixels1[i]=0;
+                }
+            }
+              */                
              
-            // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
+            //update the images with their new background subtracted selves
-            saveImageSynthesis(file_name, &cvColorImage1, OF_IMAGE_COLOR);
+            image1.setFromPixels(imagePixels1);
+            
+            //flag the main app that we aren't read yet
+            meshIsComplete=false;
+            
+            //make a mesh - this mesh will be drawn in the main app
+            setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+            
+            //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+            
+            /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+            //string file_name;
+            
+            //with jpgs this was refusing to save out
+            meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_DiffNoiseAnalysis_"+ofToString(_run_cnt,2)+".png";
+            _saved_filenames_synthesis.push_back(meshFileName);
+            
+            //file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+            
+            //flag that we are finished  
+            meshIsComplete=true;
             _synth_save_cnt++;
             
-            // }
+            //}
+        } else {
+            cout<<"couldn't load image from "<<_saved_filenames_analysis[i]<<endl;
         }
+        
     }
     
+    // TOM'S fix of why the last file gets overwritten again and again - but seems to prevent the files being written to the screen.
+    /*
+    _RUN_DONE = true;
+    */
+    
+     meshIsComplete=false;
+    _synth_save_cnt=0;
+    
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+    
     while(!_RUN_DONE && _state != STATE_STOP)
         Thread::sleep(3);
     
@@ -227,6 +339,26 @@ void DiffNoiseAnalysis::displayresults()
 // this runs at frame rate = 33 ms for 30 FPS
 void DiffNoiseAnalysis::draw()
 {    
+    ofEnableSmoothing();
+    
+    ofEnableLighting(); 
+    ofEnableSeparateSpecularLight();         
+    light.setPointLight();
+
+    light.enable();	
+    lightStatic.enable();
+
+    light.setPosition(ofGetWidth()/2,ofGetHeight()/2,5);
+
+    lightStatic.setPosition(ofGetWidth()/2,ofGetHeight()/2,-1);
+    
+    glEnable(GL_DEPTH_TEST);
+    
+    ofSetLineWidth(1.0f);
+    glPointSize(5.0f);
+    
+    ofEnableBlendMode(blendMode);
+
     switch (_state) {
         case STATE_ACQUIRING:
         {
@@ -273,7 +405,6 @@ void DiffNoiseAnalysis::draw()
                     }        
                 }
                 
-                
                 if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt <= _frame_cnt_max) {
                     
                     for (int i=1; i < ofGetHeight() ; i=i+rectSize)
@@ -434,3 +565,408 @@ void DiffNoiseAnalysis::save_cb(Timer& timer)
 
     saveImageAnalysis(file_name);
 }
+
+
+void DiffNoiseAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    mesh.setMode(meshMode);
+    
+    ofColor meshColour=ofColor(255,255,255);
+        
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==2){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==3){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+
+    if(chooseColour==4){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            int randomJitter = ofRandom(0,5);
+        
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter)    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+        
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) +1 ]));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==5){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            int randomJitter2 = 0;
+            int randomJitter = 0;
+
+            ofColor currentSecondImageColor;
+            ofColor currentSecondImageBW;
+        
+            currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*((y)+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+
+            mesh.addColor(currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+
+            mesh.addColor( currentSecondImageBW.clamp() );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+
+            mesh.addColor(  currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+
+            mesh.addColor(  currentSecondImageBW.clamp() ); 
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter)+1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+}
+
+
+vector<float> DiffNoiseAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    
+    if(chooseComparison==1){
+        //for each pixel...
+        float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            float _distanceToCentre=ofDist(imagePixels1.getWidth()/2, imagePixels1.getHeight()/2, x, y);
+            float _presumedBrightness=ofMap(sqrt(_maxPossibleDistanceToCentre)-sqrt(_distanceToCentre), 0,  sqrt(_maxPossibleDistanceToCentre), 0, 255);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+            
+            int thisDiff=-abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getLightness());
+            //int thisDiff=-abs(imageColor1.r);
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            differences.push_back(multiplier * thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}

src/DiffNoiseAnalysis.h

@@ -63,4 +63,20 @@ protected:
     //this is the temporary container to allow us to convert and save out greyscale images
     ofxCvColorImage         cvConvertorImage;
     
+    
+    //mesh making function
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+    
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    
+    int vertexSubsampling;
+    int chooseColour;
+    ofPrimitiveMode meshMode;
+    ofBlendMode blendMode;
+    float multiplier;
+    
+    bool _gotFirstImage;
+    ofImage _background;
+
 };

src/IResponseAnalysis.cpp

@@ -15,14 +15,27 @@ using Poco::Thread;
 
 void IResponseAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+        
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_iresponse", NUMBER_RUNS);
     cout << "NUM_RUN IResponseAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
 
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    
+    _mesh_size_multiplier=4;
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_iresponse", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME IResponseAnalysis " << acq_run_time << endl;
 
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    
+    _mesh_size_multiplier=8;
     
     //int acq_run_time = 20;   // 20 seconds of acquiring per run
     
@@ -78,8 +91,6 @@ void IResponseAnalysis::setup(int camWidth, int camHeight)
 	cvGrayImage2.clear();
     cvGrayDiff2.clear();
      
-    cvConvertorImage.clear();    
-    
     cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
@@ -87,15 +98,10 @@ void IResponseAnalysis::setup(int camWidth, int camHeight)
     cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
 }
 
-
 void IResponseAnalysis::acquire()
 {
-
     Timer* save_timer;
     TimerCallback<IResponseAnalysis> save_callback(*this, &IResponseAnalysis::save_cb);
 
@@ -123,6 +129,7 @@ void IResponseAnalysis::acquire()
 
 void IResponseAnalysis::synthesise()
 {
+    cout<<"SYNTHESISING IRESPONSE";
  
     //cout << "IResponseAnalysis::saving synthesis...\n";
     if(_state == STATE_STOP) return;
@@ -142,58 +149,66 @@ void IResponseAnalysis::synthesise()
         
         if(image1.loadImage(_saved_filenames_analysis[i])){
              //cout << "LOADED image1!!!" << endl;
-            if(image5.loadImage(_saved_filenames_analysis[i+1])){
+            //if(image5.loadImage(_saved_filenames_analysis[i+1])){
                 
                 ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                if(!_gotFirstImage){
+                    cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                    _background=image1;
+                    _gotFirstImage=true;
+                }
                 
-                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
+                //subtract background begin///////////////
-                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
 
-                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
+                ofPixels imagePixels1       = image1.getPixelsRef();
-                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
+                //ofPixels imagePixels2       = image5.getPixelsRef();
+                ofPixels backgroundPixels   = _background.getPixelsRef();
 
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
+                //background subtraction// 
-                cvGrayDiff1.erode();
+                /*
-                cvGrayDiff1.contrastStretch();
+                for(int i=0;i<imagePixels1.size();i++){
-                //cvGrayDiff1.blur(5);
+                    //unsigned char val=imagePixels1[i];
-                //cvGrayDiff1.dilate();
+                    // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
-                //cvGrayDiff1.contrastStretch();
+                    if(imagePixels1[i]-backgroundPixels[i]>0){
+                        imagePixels1[i]-=backgroundPixels[i];
+                    }
+                    else{
+                        imagePixels1[i]=0;
+                    }
+                }
+               */
+                //update the images with their new background subtracted selves
+                image1.setFromPixels(imagePixels1);
 
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+                //flag the main app that we aren't read yet
-                string file_name;
+                meshIsComplete=false;
+                //make a mesh - this mesh will be drawn in the main app
+                setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
                 
-                file_name = ofToString(_synth_save_cnt, 2)+"_IResponseSynthesis_"+ofToString(_run_cnt,2)+".jpg";
+                 //meshPix=make3DZmap(image1, image5, _background);
+                //with jpgs this was refusing to save out
+                meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_IResponseSynthesis_"+ofToString(_run_cnt,2)+".png";
+                _saved_filenames_synthesis.push_back(meshFileName);
 
-                
+                //flag that we are finished  
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+                meshIsComplete=true;
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-                
-                
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                //ofImage image;
-                //image.allocate(cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-                //image.setUseTexture(false);  
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-                
-                
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
-                
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
                 _synth_save_cnt++;
+                
             }
-        }
+        //}
     }
 
+    // TOM'S fix of why the last file gets overwritten again and again - but seems to prevent the files being written to the screen.
+    /*
+     _RUN_DONE = true;
+     */
+    
+    meshIsComplete=false;
+    _synth_save_cnt=0;
+    
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
     while(!_RUN_DONE && _state != STATE_STOP)
         Thread::sleep(3);
-    
-    
 }
 
 
@@ -401,3 +416,125 @@ void IResponseAnalysis::save_cb(Timer& timer)
         
     saveImageAnalysis(file_name);
 }
+
+void IResponseAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    mesh.setMode(OF_PRIMITIVE_TRIANGLES);
+    
+    ofColor meshColour=ofColor(255,0,0);
+    
+    int chooseColour=1  ;
+    
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+         
+    if(chooseColour==1){
+        
+            for(int i=0;i<sPixels.size();i++){
+                mesh.addColor(  currentSecondImage.getColor(x, y+1));
+                mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+              
+                mesh.addColor(  currentSecondImage.getColor(x, y));
+                mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+                
+                mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+                mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+              
+                mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+                mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+              
+                mesh.addColor(  currentSecondImage.getColor(x, y));
+                mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+                
+                mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+                mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+
+                x++;
+                if(x>=currentSecondImage.getWidth()-1){
+                    x=0;
+                    y++;
+                    //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                    if(y>=currentSecondImage.getHeight()-1){
+                        break;
+                    }
+                }
+            }
+    }
+}
+
+vector<float> IResponseAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+        for(int i=0;i<imagePixels1.size();i++){
+            thesePixels[i]=0;
+        }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //the current version compares how bright this pixel is with how bright it would be following inverse square fall off from centre
+    if(chooseComparison==1){
+        //for each pixel...
+        float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            float _distanceToCentre=ofDist(imagePixels1.getWidth()/2, imagePixels1.getHeight()/2, x, y);
+            
+            float _presumedBrightness=ofMap(sqrt(_maxPossibleDistanceToCentre)-sqrt(_distanceToCentre), 0,  sqrt(_maxPossibleDistanceToCentre), 0, 255);
+           
+            //float _presumedBrightness=255;
+            
+            int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            float multiplier=4.0;
+            
+            differences.push_back(multiplier * thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}
+
+

src/IResponseAnalysis.h

@@ -59,7 +59,11 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
-    //this is the temporary container to allow us to convert and save out greyscale images
+    //mesh making function
-    ofxCvColorImage         cvConvertorImage;
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
-    
+    //returns ofPixels but these pixels actually hold depth data.
+    //ofPixels make3DZmap(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    bool _gotFirstImage;
+    ofImage _background;
 };

src/RelaxRateAnalysis.cpp

@@ -17,10 +17,34 @@ using Poco::Thread;
 
 void RelaxRateAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_relaxrate", NUMBER_RUNS);
     cout << "NUM_RUN RelaxRateAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
     
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    _mesh_size_multiplier   = 8;
+    vertexSubsampling_x       = 1; //must be at least '1'
+    vertexSubsampling_y       = 5; //must be at least '1'
+    chooseColour            = 2;
+    multiplier              = 4.0;
+    
+    //blendMode = OF_BLENDMODE_ADD;
+    //blendMode = OF_BLENDMODE_MULTIPLY;
+    blendMode = OF_BLENDMODE_SUBTRACT;
+    //blendMode = OF_BLENDMODE_ALPHA;
+    //blendMode = OF_BLENDMODE_SCREEN;
+    
+    //meshMode = OF_PRIMITIVE_TRIANGLES;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_STRIP;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_FAN;
+    //meshMode = OF_PRIMITIVE_LINES;
+    meshMode = OF_PRIMITIVE_LINE_STRIP;
+    //meshMode = OF_PRIMITIVE_POINTS;
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_relaxrate", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME RelaxRateAnalysis " << acq_run_time << endl;
@@ -75,9 +99,6 @@ void RelaxRateAnalysis::setup(int camWidth, int camHeight)
     image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-    //cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
-    
     // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
     // that we're getting in OSX/Windows and is maybe crashing Windows
     // http://forum.openframeworks.cc/index.php?topic=1867.0
@@ -98,6 +119,7 @@ void RelaxRateAnalysis::setup(int camWidth, int camHeight)
 	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
+        
 }
 
 
@@ -130,61 +152,193 @@ void RelaxRateAnalysis::acquire()
 
 void RelaxRateAnalysis::synthesise()
 {
-    //cout << "IResponseAnalysis::saving synthesis...\n";
+    // cout << "RelaxRate::saving synthesis...\n";
     if(_state == STATE_STOP) return;
     
-    cvContourFinderVect.clear();
+    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
         
-    for(float i=1;i<_saved_filenames_analysis.size();i++){
+        //    cout << "StrobeAnalysis::synthesis FOR LOOP...\n";
+        
+        //    cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
         
         if(_state == STATE_STOP) return;
         
-        if(image1.loadImage(_saved_filenames_analysis[i])){
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
-                
+            //couldn't load image
-            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+            //        cout << "didn't load image" << endl;
-            
-            cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);            
-            cvColorImage1.convertToGrayscalePlanarImage(cvGrayDiff1, 1);
-            
-            cvGrayDiff1.threshold(_treshold);
-            
-            rfiCvContourFinder* cf = new rfiCvContourFinder();
-            
-            cf->findContours(cvGrayDiff1, 20, (image1.width * image1.height) / 4, _maxblobs, true);
-            
-            cvContourFinderVect.push_back(cf);
-            
         } 
+        
+        if(image1.loadImage(_saved_filenames_analysis[i])){
+            //cout << "LOADED image1!!!" << endl;
+            if(image5.loadImage(_saved_filenames_analysis[i+1])){
+                
+                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                
+                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
+                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
+                
+                //cvColorImage1.erode();
+                //cvColorImage1.erode();
+                //cvColorImage1.dilate();
+                
+                cvColorImage1.blur(1);
+                cvColorImage2.blur(1);
+                
+                //cvXorS( cvColorImage1.getCvImage(), cvScalarAll(150), cvColorImage1.getCvImage(), 0 );
+                //cvXorS( cvColorImage2.getCvImage(), cvScalarAll(150), cvColorImage1.getCvImage(), 0 );
+                
+                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
+                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
+                
+                //cvGrayImage1.convertToRange(0.0, 255.0);
+                //cvGrayImage2.convertToRange(0.0, 255.0);
+                
+                //cvGrayImage1.adaptiveThreshold( 200, 0);
+                //cvGrayImage2.adaptiveThreshold( 200, 0);
+                
+                //cvGrayImage1.contrastStretch();
+                //cvGrayImage2.contrastStretch();
+                
+                cvGrayDiff1.absDiff(cvGrayImage1, cvGrayImage2);
+                
+                //cvGrayDiff1.brightnessContrast(1.0,0.5);
+                
+                //cvGrayImage1.brightnessContrast(1.0,0.5);
+                //cvGrayImage2.brightnessContrast(1.0,0.5);
+                
+                cvColorImage1.setFromGrayscalePlanarImages(cvGrayImage1, cvGrayImage1, cvGrayImage1);
+                //cvColorImage2.setFromGrayscalePlanarImages(cvGrayImage2, cvGrayImage2, cvGrayImage2);
+                
+                //cvPyrMeanShiftFiltering(cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), 1, 1);
+                //cvPyrMeanShiftFiltering(cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), 1, 1);
+                
+                //cvFloatImage1 = cvColorImage1;
+                //cvGrayImage1 = cvColorImage1;
+                
+                
+                //cvSmooth( cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), CV_GAUSSIAN, 5, 5);
+                //cvSmooth( cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), CV_GAUSSIAN, 5, 5);
+                
+                //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
+                //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
+                
+                //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
+                //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
+                
+                // convert the CV image 
+                image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+                image5.setFromPixels(cvColorImage2.getPixelsRef()); 
+                
+                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                if(!_gotFirstImage){
+                    cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                    _background=image1;
+                    _gotFirstImage=true;
+                }
+                
+                //subtract background begin///////////////
+                
+                ofPixels imagePixels1       = image1.getPixelsRef();
+                ofPixels imagePixels2       = image5.getPixelsRef();
+                ofPixels backgroundPixels   = _background.getPixelsRef();
+                
+                //DIFFERENCING SUBSEQUENT IMAGES
+                /*
+                 for(int i=0;i<imagePixels1.size();i++){
+                 //unsigned char val=imagePixels1[i];
+                 // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                 if(imagePixels1[i]-imagePixels2[i]>0){
+                 imagePixels1[i]-=imagePixels2[i];
+                 }
+                 else{
+                 imagePixels1[i]=0;
+                 }
+                 }
+                 */ 
+                
+                //DIFFERENCING THE BACKGROUND
+                
+                for(int i=0;i<imagePixels1.size();i++){
+                    //unsigned char val=imagePixels1[i];
+                    // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                    if(imagePixels1[i]-backgroundPixels[i]>0){
+                        imagePixels1[i]-=backgroundPixels[i];
+                    }
+                    else{
+                        imagePixels1[i]=0;
+                    }
+                }
+                
+                //update the images with their new background subtracted selves
+                image1.setFromPixels(imagePixels1);
+                
+                //flag the main app that we aren't read yet
+                meshIsComplete=false;
+                
+                //make a mesh - this mesh will be drawn in the main app
+                setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+                
+                //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+                
+                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+                //string file_name;
+                
+                //with jpgs this was refusing to save out
+                meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_RelaxRateAnalysis_"+ofToString(_run_cnt,2)+".png";
+                _saved_filenames_synthesis.push_back(meshFileName);
+                
+                //file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+                
+                //flag that we are finished  
+                meshIsComplete=true;
+                _synth_save_cnt++;
+                
+            }
+        } else {
+            cout<<"couldn't load image from "<<_saved_filenames_analysis[i]<<endl;
+        }
+        
     }
     
+    // TOM'S fix of why the last file gets overwritten again and again - but seems to prevent the files being written to the screen.
+    /*
+     _RUN_DONE = true;
+     */
+    
+    meshIsComplete=false;
+    _synth_save_cnt=0;
+    
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+    
     while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);
+        Thread::sleep(10);
     
 }
-
 void RelaxRateAnalysis::displayresults()
 {
         
-    cvContourFinderVectDisplay.clear();
+    for(float i=1;i<_saved_filenames_synthesis.size();i++){
-    
-    for(int i=1;i<cvContourFinderVect.size();i++){
         
         if(_state == STATE_STOP) return;
         
-        
+        //    cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
-        //cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
         
         while(!_image_shown){
             Thread::sleep(2);
-            if(_state == STATE_STOP) return;
             //cout << "!_image_shown" << endl;
         }
         
-        cvContourFinderVectDisplay.push_back(cvContourFinderVect[i]);    
+        if(!image3.loadImage(_saved_filenames_synthesis[i])){
-        _show_image = true;
+            //couldn't load image
-        _image_shown = false;
+            //      cout << "didn't load image" << endl;
+        } 
         
+        if(image3.loadImage(_saved_filenames_synthesis[i])){
+            image3.loadImage(_saved_filenames_synthesis[i]);
+            //cout << "_show_image = true;" << endl;
+            _show_image = true;
+            _image_shown = false;
+        }
     }
     
 }
@@ -194,10 +348,29 @@ void RelaxRateAnalysis::displayresults()
 void RelaxRateAnalysis::draw()
 {
 
+    ofEnableSmoothing();
+    
+    ofEnableLighting(); 
+    ofEnableSeparateSpecularLight();         
+    light.setPointLight();
+    
+    light.enable();	
+    lightStatic.enable();
+    light.setPosition(ofGetWidth()/2,ofGetHeight()/2,5);
+    lightStatic.setPosition(ofGetWidth()/2,ofGetHeight()/2,-1);
+    
+    glEnable(GL_DEPTH_TEST);
+    
+    ofSetLineWidth(2.0f);
+    glPointSize(1.0f);
+    
+    ofEnableBlendMode(blendMode);
+        
     switch (_state) {
         case STATE_ACQUIRING:
         {
             
+            
             if (_frame_cnt < _frame_cnt_max)
             {
                 
@@ -227,6 +400,7 @@ void RelaxRateAnalysis::draw()
             
         case STATE_SYNTHESISING:
         {
+            
             // display animation of something while the synthesis in on-going...
             
             //cout << "RelaxRateAnalysis = STATE_SYNTHESISING...\n";
@@ -356,3 +530,435 @@ void RelaxRateAnalysis::save_cb(Timer& timer)
     
     
 }
+
+void RelaxRateAnalysis::cleanup()
+{
+}
+
+
+void RelaxRateAnalysis::clearcfindervect()
+{
+    for(int i = 0; i < cvContourFinderVect.size(); i++) {
+        rfiCvContourFinder* f = cvContourFinderVect[i];
+
+        // maybe it's erase here?  http://forum.openframeworks.cc/index.php/topic,3016.0.html
+        // cvContourFinderVect.erase(i);
+        
+        delete f;        
+    }
+    cvContourFinderVect.clear();
+    
+}
+
+void RelaxRateAnalysis::clearcfindervectdisplay()
+{
+    cvContourFinderVectDisplay.clear();
+}
+
+
+
+
+void RelaxRateAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    mesh.setMode(meshMode);
+    
+    ofColor meshColour=ofColor(255,255,255);
+    
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling_x;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling_y;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==2){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling_x;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling_y;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==3){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling_x;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling_y;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==4){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            int randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter)    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) +1 ]));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            x=x+vertexSubsampling_x;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling_y;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==5){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            int randomJitter2 = 0;
+            int randomJitter = 0;
+            
+            ofColor currentSecondImageColor;
+            ofColor currentSecondImageBW;
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*((y)+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW.clamp() );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp() ); 
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter)+1 ]));
+            
+            x=x+vertexSubsampling_x;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling_y;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+}
+
+
+vector<float> RelaxRateAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    
+    if(chooseComparison==1){
+        //for each pixel...
+        float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            float _distanceToCentre=ofDist(imagePixels1.getWidth()/2, imagePixels1.getHeight()/2, x, y);
+            float _presumedBrightness=ofMap(sqrt(_maxPossibleDistanceToCentre)-sqrt(_distanceToCentre), 0,  sqrt(_maxPossibleDistanceToCentre), 0, 255);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+            
+            int thisDiff=-abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getLightness());
+            //int thisDiff=-abs(imageColor1.r);
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            differences.push_back(multiplier * thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}
+

src/RelaxRateAnalysis.h

@@ -23,6 +23,7 @@ public:
     void acquire();
     void synthesise(); 
     void displayresults();
+    void cleanup();
 
     void draw();
     
@@ -30,6 +31,9 @@ public:
     
 protected:
     
+    void clearcfindervect();
+    void clearcfindervectdisplay();
+    
     bool    _RUN_DONE;
     float     _flip, _level;
     int     _run_cnt, _save_cnt, _synth_save_cnt, _anim_cnt;
@@ -39,6 +43,7 @@ protected:
     int     _maxblobs;
     
     bool _show_image, _image_shown;
+    
     ofImage         image1;
     ofImage         image2; 
     ofImage         image3;
@@ -61,7 +66,25 @@ protected:
     ofxCvGrayscaleImage 	cvGrayImage3;
     ofxCvGrayscaleImage 	cvGrayImage4;
     
+    
     vector<rfiCvContourFinder*>      cvContourFinderVect;
     vector<rfiCvContourFinder*>      cvContourFinderVectDisplay;
     
+    //mesh making function
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+    
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    
+    int vertexSubsampling_x;
+    int vertexSubsampling_y;
+    int chooseColour;
+    ofPrimitiveMode meshMode;
+    ofBlendMode blendMode;
+    float multiplier;
+    
+    bool _gotFirstImage;
+    ofImage _background;
+    
+
 };

src/ShadowScapesAnalysis.cpp

@@ -19,10 +19,63 @@ using Poco::Thread;
 
 void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_shadowscapes", NUMBER_RUNS);
     cout << "NUM_RUN ShadowScapesAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
     
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    _mesh_size_multiplier   = 8;
+    vertexSubsampling       = 1;
+    chooseColour            = 5;
+    multiplier              = 4.0;
+    
+    ofSetLineWidth(5.0f);
+    glPointSize(5.0f);
+    glEnable(GL_DEPTH_TEST);
+    
+    //blendMode = OF_BLENDMODE_ADD;
+    //blendMode = OF_BLENDMODE_MULTIPLY;
+    //blendMode = OF_BLENDMODE_SUBTRACT;
+    blendMode = OF_BLENDMODE_ALPHA;
+    //blendMode = OF_BLENDMODE_SCREEN;
+    
+    //meshMode = OF_PRIMITIVE_TRIANGLES;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_STRIP;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_FAN;
+    meshMode = OF_PRIMITIVE_LINES;
+    //meshMode = OF_PRIMITIVE_LINE_STRIP;
+    //meshMode = OF_PRIMITIVE_POINTS;
+    
+    ///setup light    
+    ofEnableLighting();    
+    GLfloat light_ambient[] = {0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_diffuse[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_specular[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };  
+    
+    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);  
+    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);  
+    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);  
+    glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
+    
+    glEnable(GL_LIGHT0);  
+    
+    GLfloat light_ambient1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_diffuse1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_specular1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_position1[] = { -1.0, 1.0, 1.0, 0.0 };  
+    
+    glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient1);  
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse1);  
+    glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular1);  
+    glLightfv(GL_LIGHT1, GL_POSITION, light_position1);  
+    
+    glEnable(GL_LIGHT1);     
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_shadowscapes", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME ShadowScapesAnalysis " << acq_run_time << endl;
@@ -86,7 +139,6 @@ void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
 	cvGrayImage2.clear();
     cvGrayDiff2.clear();
        
-    cvConvertorImage.clear();    
     
     cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
@@ -96,7 +148,6 @@ void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
 	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
 }
 
@@ -140,7 +191,7 @@ void ShadowScapesAnalysis::synthesise()
         } 
         
         if(image1.loadImage(_saved_filenames_analysis[i])){
-            
+            //    cout << "LOADED image1!!!" << endl;
             if(image5.loadImage(_saved_filenames_analysis[i+1])){
                 
                 ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
@@ -148,57 +199,108 @@ void ShadowScapesAnalysis::synthesise()
                 cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
                 cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
                 
-                //cvGrayImage1 = cvColorImage1;
-                //cvGrayImage2 = cvColorImage2;
-                
                 cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
                 cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
                 
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
+                //cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.erode();
+                //cvGrayDiff1.erode();
-                cvGrayDiff1.contrastStretch();
+                
-                cvGrayDiff1.blur(5);
+                cvGrayImage1.dilate();
-                cvGrayDiff1.dilate();
+                cvGrayImage1.blur(5);
+                cvGrayImage1.contrastStretch();
                 
                 /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
+                cvColorImage1.setFromGrayscalePlanarImages(cvGrayImage1, cvGrayImage1, cvGrayImage1);
+                //cvColorImage2.setFromGrayscalePlanarImages(cvGrayImage2, cvGrayImage2, cvGrayImage2);
                 
-                if(_dir == H) {
+                //cvPyrMeanShiftFiltering(cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), 1, 1);
-                    file_name = ofToString(_synth_save_cnt, 2)+"_H_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
+                //cvPyrMeanShiftFiltering(cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), 1, 1);
+                
+                //cvFloatImage1 = cvColorImage1;
+                //cvGrayImage1 = cvColorImage1;
+                
+                
+                //cvSmooth( cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), CV_GAUSSIAN, 5, 5);
+                //cvSmooth( cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), CV_GAUSSIAN, 5, 5);
+                
+                //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
+                //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
+                
+                //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
+                //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
+                
+                // convert the CV image 
+                image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+                image5.setFromPixels(cvColorImage2.getPixelsRef());  
+                
+                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                if(!_gotFirstImage){
+                    cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                    _background=image1;
+                    _gotFirstImage=true;
                 }
                 
-                if(_dir == V) {
+                //subtract background begin///////////////
-                    file_name = ofToString(_synth_save_cnt, 2)+"_V_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
-                }    
                 
-                if(_dir == D) {
+                ofPixels imagePixels1       = image1.getPixelsRef();
-                    file_name = ofToString(_synth_save_cnt, 2)+"_D_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
+                ofPixels imagePixels2       = image5.getPixelsRef();
-                }
+                ofPixels backgroundPixels   = _background.getPixelsRef();
                 
+                //DIFFERENCING SUBSEQUENT IMAGES
+                /*
+                 for(int i=0;i<imagePixels1.size();i++){
+                 //unsigned char val=imagePixels1[i];
+                 // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                 if(imagePixels1[i]-imagePixels2[i]>0){
+                 imagePixels1[i]-=imagePixels2[i];
+                 }
+                 else{
+                 imagePixels1[i]=0;
+                 }
+                 }
+                 */ 
                 
+                //DIFFERENCING THE BACKGROUND
+                /*
+                 for(int i=0;i<imagePixels1.size();i++){
+                 //unsigned char val=imagePixels1[i];
+                 // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                 if(imagePixels1[i]-backgroundPixels[i]>0){
+                 imagePixels1[i]-=backgroundPixels[i];
+                 }
+                 else{
+                 imagePixels1[i]=0;
+                 }
+                 }
+                 */
                 
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+                //update the images with their new background subtracted selves
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+                image1.setFromPixels(imagePixels1);
                 
+                //flag the main app that we aren't read yet
+                meshIsComplete=false;
                 
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
+                //make a mesh - this mesh will be drawn in the main app
-                //ofImage image;
+                setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
-                //image.allocate(cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
                 
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
+                //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
-                //image.setUseTexture(false);  
                 
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
+                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+                //string file_name;
         
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
+                //with jpgs this was refusing to save out
+                meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_ShadowScapeAnalysis_"+ofToString(_run_cnt,2)+".png";
+                _saved_filenames_synthesis.push_back(meshFileName);
                 
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
+                //file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
                 
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
+                //flag that we are finished  
+                meshIsComplete=true;
                 _synth_save_cnt++;
+                
             }
+        } else {
+            cout<<"couldn't load image from "<<_saved_filenames_analysis[i]<<endl;
         }
     }
     
@@ -439,6 +541,9 @@ void ShadowScapesAnalysis::draw()
             
             // display results of the synthesis
             _RUN_DONE = true;
+            
+            // clear allocated memory...? 
+            
             break;
         }
             
@@ -471,3 +576,413 @@ void ShadowScapesAnalysis::save_cb(Timer& timer)
     saveImageAnalysis(file_name);
         
 }
+
+
+
+
+void ShadowScapesAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    mesh.setMode(meshMode);
+    
+    ofColor meshColour=ofColor(255,255,255);
+    
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==2){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==3){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==4){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            int randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter)    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) +1 ]));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==5){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            int randomJitter2 = 0;
+            int randomJitter = 0;
+            
+            ofColor currentSecondImageColor;
+            ofColor currentSecondImageBW;
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*((y)+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp() ); 
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter)+1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+}
+
+
+vector<float> ShadowScapesAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    
+    if(chooseComparison==1){
+        //for each pixel...
+        float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            
+            ofColor imageColor2 = imagePixels1.getColor(x+1, y+1);
+            
+            ofColor imageColor3 = imagePixels1.getColor(x+2, y+2);
+            
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+            
+            int thisDiff=-abs(imageColor1.getBrightness()+ofRandom(-50,50));
+            //int thisDiff=abs(imageColor1.getLightness());
+            //int thisDiff=-abs(imageColor1.r);
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            differences.push_back(multiplier * thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}
+

src/ShadowScapesAnalysis.h

@@ -66,7 +66,20 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
-    //this is the temporary container to allow us to convert and save out greyscale images
+    //mesh making function
-    ofxCvColorImage         cvConvertorImage;    
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+    
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    
+    int vertexSubsampling;
+    int chooseColour;
+    ofPrimitiveMode meshMode;
+    ofBlendMode blendMode;
+    float multiplier;
+    
+    bool _gotFirstImage;
+    ofImage _background;
+
 
 };

src/ShapeFromShadingAnalysis.cpp

@@ -15,10 +15,62 @@ using Poco::Thread;
 
 void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
 {       
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_shapefromshading", NUMBER_RUNS);
     cout << "NUM_RUN ShapeFromShadingAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
     
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    _mesh_size_multiplier   = 8;
+    vertexSubsampling       = 1;
+    chooseColour            = 5;
+    multiplier              = 3.0;
+    
+    ofSetLineWidth(5.0f);
+    glPointSize(5.0f);
+
+    //blendMode = OF_BLENDMODE_ADD;
+    //blendMode = OF_BLENDMODE_MULTIPLY;
+    //blendMode = OF_BLENDMODE_SUBTRACT;
+    blendMode = OF_BLENDMODE_ALPHA;
+    //blendMode = OF_BLENDMODE_SCREEN;
+    
+    //meshMode = OF_PRIMITIVE_TRIANGLES;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_STRIP;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_FAN;
+    meshMode = OF_PRIMITIVE_LINES;
+    //meshMode = OF_PRIMITIVE_LINE_STRIP;
+    //meshMode = OF_PRIMITIVE_POINTS;
+    
+    ///setup light    
+    ofEnableLighting();    
+    GLfloat light_ambient[] = {0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_diffuse[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_specular[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };  
+    
+    glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);  
+    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);  
+    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);  
+    glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
+    
+    glEnable(GL_LIGHT0);  
+    
+    GLfloat light_ambient1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_diffuse1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_specular1[] = { 0.5, 0.5, 0.5, 0.5 };  
+    GLfloat light_position1[] = { -1.0, 1.0, 1.0, 0.0 };  
+    
+    glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient1);  
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse1);  
+    glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular1);  
+    glLightfv(GL_LIGHT1, GL_POSITION, light_position1);  
+    
+    glEnable(GL_LIGHT1);  
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_shapefromshading", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME ShapeFromShadingAnalysis " << acq_run_time << endl;
@@ -164,6 +216,24 @@ void ShapeFromShadingAnalysis::synthesise()
         //    cout << "LOADED image1!!!" << endl;
             if(image5.loadImage(_saved_filenames_analysis[i+1])){
                 
+                if(_saved_filenames_analysis[i].find("QUAD1")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameQuad = "QUAD1";
+                    cout<<"FOUND QUAD1"<<endl;
+                } else if (_saved_filenames_analysis[i].find("QUAD2")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameQuad = "QUAD2";
+                    cout<<"FOUND QUAD2"<<endl;
+                } else if(_saved_filenames_analysis[i].find("QUAD3")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameQuad = "QUAD3";
+                    cout<<"FOUND QUAD3"<<endl;
+                } else if(_saved_filenames_analysis[i].find("QUAD4")<_saved_filenames_analysis[i].length())
+                {
+                    fileNameQuad = "QUAD4";
+                    cout<<"FOUND QUAD4"<<endl;
+                }
+                
                 ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
                 
                 cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
@@ -172,42 +242,132 @@ void ShapeFromShadingAnalysis::synthesise()
                 cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
                 cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
                 
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
+                //cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.erode();
+                //cvGrayDiff1.erode();
-                cvGrayDiff1.contrastStretch();
+                
-                //cvGrayDiff1.blur(5);
+                cvGrayImage1.dilate();
-                //cvGrayDiff1.dilate();
+                cvGrayImage1.blur(5);
-                //cvGrayDiff1.contrastStretch();
+                cvGrayImage1.contrastStretch();
                 
                 /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
+                cvColorImage1.setFromGrayscalePlanarImages(cvGrayImage1, cvGrayImage1, cvGrayImage1);
+                //cvColorImage2.setFromGrayscalePlanarImages(cvGrayImage2, cvGrayImage2, cvGrayImage2);
                 
-                file_name = ofToString(_synth_save_cnt, 2)+"_ShapeFromShadingSynthesis_"+ofToString(_run_cnt,2)+".jpg";
+                //cvPyrMeanShiftFiltering(cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), 1, 1);
+                //cvPyrMeanShiftFiltering(cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), 1, 1);
+                
+                //cvFloatImage1 = cvColorImage1;
+                //cvGrayImage1 = cvColorImage1;
                 
                 
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+                //cvSmooth( cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), CV_GAUSSIAN, 5, 5);
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+                //cvSmooth( cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), CV_GAUSSIAN, 5, 5);
                 
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
+                //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
-                //ofImage image;
+                //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
-                //image.allocate(cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
                 
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
+                //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
-                //image.setUseTexture(false);  
+                //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
                 
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
+                // convert the CV image 
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+                image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+                image5.setFromPixels(cvColorImage2.getPixelsRef());  
                 
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
+                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+                if(!_gotFirstImage){
+                    cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                    _background=image1;
+                    _gotFirstImage=true;
+                }
+                
+                //subtract background begin///////////////
+                
+                ofPixels imagePixels1       = image1.getPixelsRef();
+                ofPixels imagePixels2       = image5.getPixelsRef();
+                ofPixels backgroundPixels   = _background.getPixelsRef();
+                
+                //DIFFERENCING SUBSEQUENT IMAGES
+                /*
+                 for(int i=0;i<imagePixels1.size();i++){
+                 //unsigned char val=imagePixels1[i];
+                 // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                 if(imagePixels1[i]-imagePixels2[i]>0){
+                 imagePixels1[i]-=imagePixels2[i];
+                 }
+                 else{
+                 imagePixels1[i]=0;
+                 }
+                 }
+                 */ 
+                
+                //DIFFERENCING THE BACKGROUND
+                /*
+                for(int i=0;i<imagePixels1.size();i++){
+                    //unsigned char val=imagePixels1[i];
+                    // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+                    if(imagePixels1[i]-backgroundPixels[i]>0){
+                        imagePixels1[i]-=backgroundPixels[i];
+                    }
+                    else{
+                        imagePixels1[i]=0;
+                    }
+                }
+                */
+                
+                //update the images with their new background subtracted selves
+                image1.setFromPixels(imagePixels1);
+                
+                //flag the main app that we aren't read yet
+                meshIsComplete=false;
+                
+                //make a mesh - this mesh will be drawn in the main app
+                setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+                
+                //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+                
+                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+                //string file_name;
+                
+                if(fileNameQuad=="QUAD1")
+                {       
+                    
+                    //with jpgs this was refusing to save out
+                    meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_ShapeFromShadingAnalysis_"+fileNameQuad+"_"+ofToString(_run_cnt,2)+".png";
+                    _saved_filenames_synthesis.push_back(meshFileName);
                     
                     
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
+                } else if(fileNameQuad=="QUAD2")
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
+                {
                     
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
+                    //with jpgs this was refusing to save out
+                   meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_ShapeFromShadingAnalysis_"+fileNameQuad+"_"+ofToString(_run_cnt,2)+".png";
+                    _saved_filenames_synthesis.push_back(meshFileName);
+                    
+                } else if(fileNameQuad=="QUAD3")
+                {
+                    
+                    //with jpgs this was refusing to save out
+                   meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_ShapeFromShadingAnalysis_"+fileNameQuad+"_"+ofToString(_run_cnt,2)+".png";
+                    _saved_filenames_synthesis.push_back(meshFileName);
+                
+                } else if(fileNameQuad=="QUAD4") {
+                    
+                    
+                    //with jpgs this was refusing to save out
+                    meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_ShapeFromShadingAnalysis_"+fileNameQuad+"_"+ofToString(_run_cnt,2)+".png";
+                    _saved_filenames_synthesis.push_back(meshFileName);
+        
+                }
+
+                //file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+                
+                //flag that we are finished  
+                meshIsComplete=true;
                 _synth_save_cnt++;
 
             }
+        } else {
+            cout<<"couldn't load image from "<<_saved_filenames_analysis[i]<<endl;
         }
     }
     
@@ -248,6 +408,48 @@ void ShapeFromShadingAnalysis::displayresults()
 void ShapeFromShadingAnalysis::draw()
 {
     
+    //rotate light around origin ofviewspace    
+    float xx=cos(ofGetElapsedTimef()*0.4)*150;    
+    float yy=sin(ofGetElapsedTimef()*0.4)*150;    
+    float zz=0;
+    
+    if(fileNameQuad=="QUAD1")
+    {       
+        
+        GLfloat light_position[] = { 1000, 1000, 20, 0.0 };  
+        GLfloat light_position1[] = { 1000, 1000, 20, 0.0 };  
+        glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
+        glLightfv(GL_LIGHT1, GL_POSITION, light_position1);  
+        
+    } else if(fileNameQuad=="QUAD2")
+    {
+    
+        GLfloat light_position[] = { 1000, -1000, 20, 0.0 };  
+        GLfloat light_position1[] = { 1000, -1000, 20, 0.0 };  
+        glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
+        glLightfv(GL_LIGHT1, GL_POSITION, light_position1);  
+
+        
+    } else if(fileNameQuad=="QUAD3")
+    {
+      
+        GLfloat light_position[] = {-1000, 1000, 20, 0.0 };  
+        GLfloat light_position1[] = { -1000, 1000, 20, 0.0 };  
+        glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
+        glLightfv(GL_LIGHT1, GL_POSITION, light_position1);  
+
+        
+    } else if(fileNameQuad=="QUAD4") 
+    {
+        GLfloat light_position[] = { -1000, -1000, 20, 0.0 };  
+        GLfloat light_position1[] = { -1000, -1000, 20, 0.0 };  
+        glLightfv(GL_LIGHT0, GL_POSITION, light_position);  
+        glLightfv(GL_LIGHT1, GL_POSITION, light_position1);  
+
+    }
+
+    
+    
     switch (_state) {
         case STATE_ACQUIRING:
         {
@@ -596,3 +798,412 @@ void ShapeFromShadingAnalysis::save_cb(Timer& timer)
     
     saveImageAnalysis(file_name);
 }
+
+
+
+void ShapeFromShadingAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    mesh.setMode(meshMode);
+    
+    ofColor meshColour=ofColor(255,255,255);
+    
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==2){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==3){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==4){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            int randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter)    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) +1 ]));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==5){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            int randomJitter2 = 0;
+            int randomJitter = 0;
+            
+            ofColor currentSecondImageColor;
+            ofColor currentSecondImageBW;
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*((y)+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp() ); 
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter)+1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+}
+
+
+vector<float> ShapeFromShadingAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    
+    if(chooseComparison==1){
+        //for each pixel...
+        float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            
+            ofColor imageColor2 = imagePixels1.getColor(x+1, y+1);
+            
+            ofColor imageColor3 = imagePixels1.getColor(x+2, y+2);
+            
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+        
+            int thisDiff=-abs(imageColor1.getBrightness()+ofRandom(-50,50));
+            //int thisDiff=abs(imageColor1.getLightness());
+            //int thisDiff=-abs(imageColor1.r);
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            differences.push_back(multiplier * thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}
+

src/ShapeFromShadingAnalysis.h

@@ -31,6 +31,8 @@ public:
 protected:
     
     string quad;
+    string fileNameQuad;
+    
     bool    _RUN_DONE;
     float     _flip, _level;
     int _animation_cnt1;
@@ -82,4 +84,19 @@ protected:
     //this is the temporary container to allow us to convert and save out greyscale images
     ofxCvColorImage         cvConvertorImage;
     
+    
+    //mesh making function
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+    
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    
+    int vertexSubsampling;
+    int chooseColour;
+    ofPrimitiveMode meshMode;
+    ofBlendMode blendMode;
+    float multiplier;
+    
+    bool _gotFirstImage;
+    ofImage _background;
 };

src/StrobeAnalysis.cpp

@@ -15,10 +15,34 @@ using Poco::Thread;
 
 void StrobeAnalysis::setup(int camWidth, int camHeight)
 {
+    AbstractAnalysis::setup(camWidth, camHeight);
+    
     NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_strobe", NUMBER_RUNS);
     cout << "NUM_RUN StrobeAnalysis " << NUM_RUN << endl;
     //NUM_RUN = 5;
     
+    //flag for main sketch
+    meshIsComplete=false;
+    _gotFirstImage=false;
+    _mesh_size_multiplier   = 8;
+    vertexSubsampling       = 3;
+    chooseColour            = 2;
+    multiplier              = 4.0;
+    
+    //blendMode = OF_BLENDMODE_ADD;
+    //blendMode = OF_BLENDMODE_MULTIPLY;
+    blendMode = OF_BLENDMODE_SUBTRACT;
+    //blendMode = OF_BLENDMODE_ALPHA;
+    //blendMode = OF_BLENDMODE_SCREEN;
+    
+    //meshMode = OF_PRIMITIVE_TRIANGLES;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_STRIP;
+    //meshMode = OF_PRIMITIVE_TRIANGLE_FAN;
+    meshMode = OF_PRIMITIVE_LINES;
+    //meshMode = OF_PRIMITIVE_LINE_STRIP;
+    //meshMode = OF_PRIMITIVE_POINTS;
+
+    
     int acq_run_time;   // 10 seconds of acquiring per run
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_strobe", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME StrobeAnalysis " << acq_run_time << endl;
@@ -79,8 +103,6 @@ void StrobeAnalysis::setup(int camWidth, int camHeight)
 	cvGrayImage2.clear();
     cvGrayDiff2.clear();
 
-    cvConvertorImage.clear();    
-    
     cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
@@ -89,7 +111,6 @@ void StrobeAnalysis::setup(int camWidth, int camHeight)
 	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 
 }
 
@@ -143,60 +164,150 @@ void StrobeAnalysis::synthesise()
         } 
         
         if(image1.loadImage(_saved_filenames_analysis[i])){
-    //        cout << "LOADED image1!!!" << endl;
+            //cout << "LOADED image1!!!" << endl;
             if(image5.loadImage(_saved_filenames_analysis[i+1])){
             
-                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
+            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
             
-                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
+            cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
+            cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
             
-                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
+            //cvColorImage1.erode();
-                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
+            //cvColorImage1.erode();
+                //cvColorImage1.dilate();
             
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
+            cvColorImage1.blur(1);
-                cvGrayDiff1.dilate();
+            cvColorImage2.blur(1);
-                cvGrayDiff1.dilate();
-                cvGrayDiff1.contrastStretch();
             
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+            //cvXorS( cvColorImage1.getCvImage(), cvScalarAll(150), cvColorImage1.getCvImage(), 0 );
-                string file_name;
+            //cvXorS( cvColorImage2.getCvImage(), cvScalarAll(150), cvColorImage1.getCvImage(), 0 );
                 
-                file_name = ofToString(_synth_save_cnt, 2)+"_StrobeAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+            cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
+            cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
+            
+            //cvGrayImage1.convertToRange(0.0, 255.0);
+            //cvGrayImage2.convertToRange(0.0, 255.0);
+            
+            //cvGrayImage1.adaptiveThreshold( 200, 0);
+            //cvGrayImage2.adaptiveThreshold( 200, 0);
+            
+            //cvGrayImage1.contrastStretch();
+            //cvGrayImage2.contrastStretch();
+            
+            cvGrayDiff1.absDiff(cvGrayImage1, cvGrayImage2);
+
+            cvGrayDiff1.brightnessContrast(1.0,0.5);
+            
+            //cvGrayImage1.brightnessContrast(1.0,0.5);
+            //cvGrayImage2.brightnessContrast(1.0,0.5);
+            
+            cvColorImage1.setFromGrayscalePlanarImages(cvGrayImage1, cvGrayImage1, cvGrayImage1);
+            //cvColorImage2.setFromGrayscalePlanarImages(cvGrayImage2, cvGrayImage2, cvGrayImage2);
+            
+            //cvPyrMeanShiftFiltering(cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), 1, 1);
+            //cvPyrMeanShiftFiltering(cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), 1, 1);
+            
+            //cvFloatImage1 = cvColorImage1;
+            //cvGrayImage1 = cvColorImage1;
             
            
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
+            //cvSmooth( cvColorImage1.getCvImage(), cvColorImage1.getCvImage(), CV_GAUSSIAN, 5, 5);
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+            //cvSmooth( cvColorImage2.getCvImage(), cvColorImage2.getCvImage(), CV_GAUSSIAN, 5, 5);
             
+            //cvCanny(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 100, 100, 3);
+            //cvLaplace(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0);
             
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
+            //cvGrayImage1 = cvCreateImage(cvSize(image1.width, image1.height),IPL_DEPTH_16S,1);
-                //ofImage image;
+            //cvSobel(cvGrayImage1.getCvImage(), cvGrayImage1.getCvImage(), 0, 1, 3);
-                //image.allocate(cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);    
             
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
+            // convert the CV image 
-                //image.setUseTexture(false);  
+            image1.setFromPixels(cvColorImage1.getPixelsRef()); 
+            image5.setFromPixels(cvColorImage2.getPixelsRef()); 
             
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height,OF_IMAGE_GRAYSCALE);
+            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+            if(!_gotFirstImage){
+                cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
+                _background=image1;
+                _gotFirstImage=true;
+            }
             
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
+            //subtract background begin///////////////
             
+            ofPixels imagePixels1       = image1.getPixelsRef();
+            ofPixels imagePixels2       = image5.getPixelsRef();
+            ofPixels backgroundPixels   = _background.getPixelsRef();
             
+            //DIFFERENCING SUBSEQUENT IMAGES
+            /*
+             for(int i=0;i<imagePixels1.size();i++){
+             //unsigned char val=imagePixels1[i];
+             // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+             if(imagePixels1[i]-imagePixels2[i]>0){
+             imagePixels1[i]-=imagePixels2[i];
+             }
+             else{
+             imagePixels1[i]=0;
+             }
+             }
+            */ 
              
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
+            //DIFFERENCING THE BACKGROUND
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
             
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
+             for(int i=0;i<imagePixels1.size();i++){
-                _synth_save_cnt++;
+             //unsigned char val=imagePixels1[i];
+             // cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
+             if(imagePixels1[i]-backgroundPixels[i]>0){
+             imagePixels1[i]-=backgroundPixels[i];
+             }
+             else{
+             imagePixels1[i]=0;
+             }
+             }
             
+            //update the images with their new background subtracted selves
+            image1.setFromPixels(imagePixels1);
+            
+            //flag the main app that we aren't read yet
+            meshIsComplete=false;
+            
+            //make a mesh - this mesh will be drawn in the main app
+            setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+            
+            //setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1, image1, aMesh);
+            
+            /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
+            //string file_name;
+            
+            //with jpgs this was refusing to save out
+            meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_StrobeAnalysis_"+ofToString(_run_cnt,2)+".png";
+            _saved_filenames_synthesis.push_back(meshFileName);
+            
+            //file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+            
+            //flag that we are finished  
+            meshIsComplete=true;
+            _synth_save_cnt++;
             
             }
+        } else {
+            cout<<"couldn't load image from "<<_saved_filenames_analysis[i]<<endl;
         }
+        
     }
     
+    // TOM'S fix of why the last file gets overwritten again and again - but seems to prevent the files being written to the screen.
+    /*
+     _RUN_DONE = true;
+     */
+    
+    meshIsComplete=false;
+    _synth_save_cnt=0;
+    
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+    
     while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3); 
+        Thread::sleep(10);
+
 }
 
 void StrobeAnalysis::displayresults()
@@ -233,6 +344,27 @@ void StrobeAnalysis::displayresults()
 void StrobeAnalysis::draw()
 {
     
+    ofEnableSmoothing();
+    
+    ofEnableLighting(); 
+    ofEnableSeparateSpecularLight();         
+    light.setPointLight();
+    
+    light.enable();	
+    lightStatic.enable();
+    
+    light.setPosition(ofGetWidth()/2,ofGetHeight()/2,5);
+    
+    lightStatic.setPosition(ofGetWidth()/2,ofGetHeight()/2,-1);
+    
+    glEnable(GL_DEPTH_TEST);
+    
+    ofSetLineWidth(1.0f);
+    glPointSize(5.0f);
+    
+    ofEnableBlendMode(blendMode);
+
+    
     switch (_state) {
         case STATE_ACQUIRING:
         {
@@ -251,7 +383,6 @@ void StrobeAnalysis::draw()
                     ofRect(0, 0, ofGetWidth(), ofGetHeight());
                     //cout <<  "FADE IN STROBE TIME " << endl;
 
-                    
                 }
                 
                 if (_frame_cnt >= _fade_in_frames && _frame_cnt < (_frame_cnt_max-_fade_in_frames)){
@@ -283,6 +414,7 @@ void StrobeAnalysis::draw()
                 }         
     
                 ofDisableAlphaBlending();
+                
             } else {
                 //_state = STATE_SYNTHESISING;
                 _RUN_DONE = true;
@@ -425,3 +557,408 @@ void StrobeAnalysis::save_cb(Timer& timer)
     
     saveImageAnalysis(file_name);
 }
+
+void StrobeAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
+    int x=0;
+    int y=0;
+    
+    //get rid of all previous vectors and colours
+    mesh.clear();
+    mesh.setMode(meshMode);
+    
+    ofColor meshColour=ofColor(255,255,255);
+    
+    //the average z position of the matrix - used later to centre the mesh on the z axis when drawing
+    float zPlaneAverage=0;
+    
+    for(int i=0;i<sPixels.size();i++){
+        zPlaneAverage+=sPixels[i];
+    }
+    if (sPixels.size()!=0) {
+        zPlaneAverage/=sPixels.size();
+        //cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
+    }
+    
+    else{
+        cout<<"DEPTH FLOAT ARRAY IS EMPTY";
+    }
+    
+    if(chooseColour==1){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y+1));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x, y));
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            mesh.addColor(  currentSecondImage.getColor(x+1, y)   );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==2){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y+1);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x+1, y);
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==3){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            mesh.addColor(  currentSecondImageColor);
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==4){
+        
+        for(int i=0;i<sPixels.size();i++){
+            ofColor currentSecondImageColor;
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            int randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter)    ]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*((y+randomJitter)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+randomJitter),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            mesh.addColor(  currentSecondImageColor.getBrightness());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x+randomJitter)+1),_mesh_size_multiplier*(y+randomJitter),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) +1 ]));
+            
+            ofSeedRandom();
+            
+            currentSecondImageColor.r = ofRandom(0,255);
+            currentSecondImageColor.g = ofRandom(0,255);
+            currentSecondImageColor.b = ofRandom(0,255);
+            
+            randomJitter = ofRandom(0,5);
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+    if(chooseColour==5){
+        
+        for(int i=0;i<sPixels.size();i++){
+            
+            int randomJitter2 = 0;
+            int randomJitter = 0;
+            
+            ofColor currentSecondImageColor;
+            ofColor currentSecondImageBW;
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*((y)+1),- sPixels[ (currentSecondImage.getWidth()*(y+randomJitter+1))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ] ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1 ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y+1);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor( currentSecondImageBW.clamp() );
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*((y)+1),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)+1))+(x+randomJitter)+1]   ));
+            
+            currentSecondImageColor =  currentSecondImage.getColor(x, y);            
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp());
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter) ]  ));
+            
+            currentSecondImageColor = currentSecondImage.getColor(x+1, y);
+            currentSecondImageBW.r = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.g = currentSecondImageColor.getBrightness()+randomJitter2;
+            currentSecondImageBW.b = currentSecondImageColor.getBrightness()+randomJitter2;
+            
+            mesh.addColor(  currentSecondImageBW.clamp() ); 
+            mesh.addVertex(ofVec3f(_mesh_size_multiplier*((x)+1),_mesh_size_multiplier*(y),- sPixels[(currentSecondImage.getWidth()*((y+randomJitter)))+(x+randomJitter)+1 ]));
+            
+            x=x+vertexSubsampling;
+            if(x>=currentSecondImage.getWidth()-1){
+                x=0;
+                y=y+vertexSubsampling;
+                //something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
+                if(y>=currentSecondImage.getHeight()-1){
+                    break;
+                }
+            }
+        }
+    }
+    
+}
+
+
+vector<float> StrobeAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
+    
+    ofPixels imagePixels1 = image1.getPixelsRef();
+    //ofPixels imagePixels2 = image2.getPixelsRef();
+    ofPixels backgroundPixels = backgroundImag.getPixelsRef();
+    vector<float> differences;
+    
+    ofPixels difference;
+    
+    //this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly? 
+    unsigned char * thesePixels = new unsigned char[imagePixels1.getWidth()*imagePixels1.getHeight()*3];
+    
+    for(int i=0;i<imagePixels1.size();i++){
+        thesePixels[i]=0;
+    }
+    
+    int x=0;
+    int y=0;
+    
+    int chooseComparison=1;
+    
+    //comparison here to find out how close each color is to pure RED / GREEN / BLUE
+    
+    if(chooseComparison==1){
+        //for each pixel...
+        float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
+        
+        for(int i=0;i<imagePixels1.size();i+=3){
+            
+            ofColor imageColor1 = imagePixels1.getColor(x, y);
+            //ofColor colourImage2 = imagePixels2.getColor(x, y);
+            
+            float _distanceToCentre=ofDist(imagePixels1.getWidth()/2, imagePixels1.getHeight()/2, x, y);
+            float _presumedBrightness=ofMap(sqrt(_maxPossibleDistanceToCentre)-sqrt(_distanceToCentre), 0,  sqrt(_maxPossibleDistanceToCentre), 0, 255);
+            
+            //int thisDiff=abs(imageColor1.getHue());
+            //int thisDiff=abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getBrightness()-_presumedBrightness);
+            
+            int thisDiff=-abs(imageColor1.getBrightness());
+            //int thisDiff=abs(imageColor1.getLightness());
+            //int thisDiff=-abs(imageColor1.r);
+            
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            
+            //red hue: 0
+            //green hue: 120 
+            //blue hue: 240
+            
+            differences.push_back(multiplier * thisDiff);
+            
+            thesePixels[i]=thisDiff;
+            thesePixels[i+1]=thisDiff;
+            thesePixels[i+2]=thisDiff;
+            x++;
+            
+            if(x>=imagePixels1.getWidth()){
+                x=0;
+                y++;
+            }
+        }
+    }
+    
+    //difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
+    return differences;
+}
+

src/StrobeAnalysis.h

@@ -65,7 +65,20 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
-    //this is the temporary container to allow us to convert and save out greyscale images
+    //mesh making function
-    ofxCvColorImage         cvConvertorImage;    
+    void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
+    
+    //depth map function
+    vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
+    
+    int vertexSubsampling;
+    int chooseColour;
+    ofPrimitiveMode meshMode;
+    ofBlendMode blendMode;
+    float multiplier;
+    
+    bool _gotFirstImage;
+    ofImage _background;
+
 
 };