added triangular mesh and scaling for z axis.

make sure you add the config.refindx to your environment

.gitignore

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

README

@@ -1,10 +1,10 @@
 WARNING: WORK IN PROGRESS...
 
-configuring OpenFrameworks
------------------
+configuring OpenFrameworks under Xcode
+---------------------------------------
 
 these files are configured according to OpenFrameworks addons - http://ofxaddons.com/howto
 
 (1) drag-drop "ReflectiveIndex" folder into your OpenFrameworks project
-(2) Install depedencies: {ofxDirList, ofxControlPanel, ofxXmlSettings};  
+(2) Install depedencies: {ofxXmlSettings, ofxOpenCV, ofxFileHelper};  
 (3) Press Play!

example/RefractiveIndex.cpp

@@ -15,11 +15,11 @@
 
 #include "ofxXmlSettings.h"
 
-#define CAMERA_ID           1
+#define CAMERA_ID           0
 #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,9 @@ ofxXmlSettings   RefractiveIndex::XML;
 
 void RefractiveIndex::setup()
 {
+    camDist=1000;
+
+    //camera.setOrientation(ofVec3f(1,-1,1));
     bool save_config = false;
     
     cout << "Loading configuration..." << endl;
@@ -50,6 +55,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 +91,10 @@ void RefractiveIndex::setup()
     cout << "* cam width = " << _vid_w << endl;
     cout << "* cam height = " << _vid_h << endl;
     
+    if(_mode == MODE_ANALYSING) {
         _vid_stream_open = false;    
         setup_camera();
+    }
     
     cout << "RRRRRREADY!" << endl;        
 
@@ -116,6 +127,7 @@ void RefractiveIndex::setup()
     
     _analysisVector.push_back(new DiffNoiseAnalysis());	
     
+
     //_currentAnalysisIndx = 0;
     //_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++); 
     //_state = ISTATE_START;
@@ -123,6 +135,7 @@ void RefractiveIndex::setup()
     _currentAnalysis = NULL;
     _state = ISTATE_UNDEF;
   
+    
 }
 
 void RefractiveIndex::analysis_cb(string & analysis)
@@ -138,6 +151,16 @@ 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);
+    _meshRotation=0;
+    
+    
 }
 
 void RefractiveIndex::stop_analysis()
@@ -171,9 +194,13 @@ void RefractiveIndex::state_analysis()
             break;
         case ISTATE_STOP:
             stop_analysis(); // blocking
+            if(_mode == MODE_DRAWING)
+                _state = ISTATE_UNDEF;
+            else
                 _state = ISTATE_TRANSITION;
             break;
         case ISTATE_END:
+            if(_mode == MODE_ANALYSING)
                 stop_camera();
             ::exit(1);
             break;
@@ -197,8 +224,46 @@ void RefractiveIndex::draw()
     // black
     ofBackground(0, 0, 0);
    
-    if(_currentAnalysis)
+    if(_currentAnalysis){
         _currentAnalysis->draw();
+       
+    
+        if(_currentAnalysis->meshIsComplete){
+            
+            fbo.begin();
+            glShadeModel(GL_SMOOTH);  
+            ofClear(0,0,0);
+            
+            camera.begin();
+            ofSetColor(0, 0, 0);
+            //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);
+            ofRect(-fbo.getWidth(), -fbo.getHeight(), fbo.getWidth()*3, fbo.getHeight()*3);
+            
+            
+            ofPopMatrix();
+            ofSetColor(255);
+            
+            float xDiff= (fbo.getWidth()- (_currentAnalysis->_mesh_size_multiplier *_vid_w))/2;
+            float yDiff= (fbo.getHeight()- (_currentAnalysis->_mesh_size_multiplier *_vid_h))/2;
+
+            
+            ofTranslate(xDiff,yDiff,-_currentAnalysis->zPlaneAverage );
+            _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!
+
+        }
+       
+    }
 }
 
 void RefractiveIndex::setup_camera()
@@ -394,5 +459,7 @@ void RefractiveIndex::keyPressed  (int key)
 
 void RefractiveIndex::exit()
 {
+    if(_currentAnalysis)
+        _analysisAdapator->stop();    
     stop_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;
+    ofLight light;
 };

src/AbstractAnalysis.cpp

@@ -3,13 +3,37 @@
 #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() {
     
+    switch(RefractiveIndex::_mode)
+    {
+        case MODE_ANALYSING:
+        {
             for(int i = 0; i < NUM_RUN; i++) {
                 
-        cout << "i NUM_RUN" << i << endl;
+                cout << "NUM_RUN: " << i << endl;
                 
                 _saved_filenames_analysis.clear();  
                 _saved_filenames_synthesis.clear(); 
@@ -22,13 +46,36 @@ void AbstractAnalysis::do_synthesize() {
                 if(_state == STATE_STOP) goto exit;
                 _state = STATE_DISPLAY_RESULTS;
                 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:    
+    cleanup();
     ofNotifyEvent(_synthesize_cb, _name);    
+    
 }
 
-void AbstractAnalysis::create_dir()
+void AbstractAnalysis::create_dir_allocate_images()
 {
     // HERE IS WHERE WE SETUP THE DIRECTORY FOR ALL THE SAVED IMAGES
     
@@ -92,7 +139,121 @@ void AbstractAnalysis::create_dir()
         fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH+RefractiveIndex::_location+"/"+_name+"/"+replaceTime);
         
     }
-    
     //////////////////////////////END DIRECTORY CREATION //////////////////////////////////////////////////  
+    
+    
+    //////////////////////////////ALLOCATE IMAGES //////////////////////////////////////////////////  
+    
+    myColorImage1.clear();
+    myColorImage1.setUseTexture(false);
+    myColorImage1.allocate(RefractiveIndex::_vid_w, RefractiveIndex::_vid_h, OF_IMAGE_COLOR);
+
+    myColorImage2.clear();
+    myColorImage2.setUseTexture(false);
+    myColorImage2.allocate(RefractiveIndex::_vid_w, RefractiveIndex::_vid_h, OF_IMAGE_COLOR);
+    
+    
+    myGrayImage1.clear();
+    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)
+{
+    
+    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
+    
+    if (RefractiveIndex::_vidGrabber.isFrameNew())
+    {
+        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
+    } else {
+        return;
+    }
+        
+#ifdef TARGET_OSX   
+    
+    ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+filename, OF_IMAGE_QUALITY_BEST);
+    
+#elif defined(TARGET_WIN32)    
+    
+    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
+    unsigned char * somePixels;
+    ofPixels appPix = RefractiveIndex::_pixels;
+    somePixels = appPix.getPixels();
+    myColorImage1.setUseTexture(false);
+    myColorImage1.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
+    myColorImage1.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+filename);
+    myColorImage1.clear();
+    
+#endif
+    
+    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+filename);
+    
+}
+
+
+void AbstractAnalysis::saveImageSynthesis(string filename, ofxCvImage* newPixels, ofImageType newType)
+{
+    
+#ifdef TARGET_OSX   
+    
+
+    ofSaveImage(newPixels->getPixelsRef(), _whole_file_path_synthesis+"/"+filename, OF_IMAGE_QUALITY_BEST);
+    
+#elif defined(TARGET_WIN32)    
+    
+    if (newType == OF_IMAGE_COLOR){
+       myColorImage2.setUseTexture(false);
+       myColorImage2.setFromPixels(newPixels->getPixels(), newPixels->getWidth(), newPixels->getHeight(), OF_IMAGE_COLOR);
+       myColorImage2.saveImage(_whole_file_path_synthesis+"/"+filename);
+    }
+
+    if (newType == OF_IMAGE_GRAYSCALE){
+        myGrayImage1.setUseTexture(false);
+        
+        // THIS IS HOW YOU HAVE TO SAVE OUT THE GREYSCALE IMAGES on WINDOWS FOR SOME REASON --> i.e.: as an OF_IMAGE_COLOR
+        // But they don't save properly - they're spatially translated and generally f'd up
+        myGrayImage1.setFromPixels(newPixels->getPixels(), newPixels->getWidth(), newPixels->getHeight(), OF_IMAGE_COLOR);
+        myGrayImage1.setImageType(OF_IMAGE_COLOR);
+        myGrayImage1.saveImage(_whole_file_path_synthesis+"/"+filename);
+        //myGrayImage1.clear();
+    }
+        
+#endif
+    
+    _saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+filename);
+            
+    
 }
 

src/AbstractAnalysis.h

@@ -7,6 +7,7 @@
 
 #include "ofMain.h"
 #include "ofEvents.h"
+#include "ofxOpenCv.h"
 #include <string>
 
 #define ANALYSIS_PATH "analysis/"
@@ -24,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();
@@ -34,7 +35,12 @@ public:
         
 protected:
     
-    virtual void create_dir();
+    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);
     
     // acquire images - all the children (see - do_synthesize)
     virtual void acquire() = 0;   
@@ -45,11 +51,30 @@ 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;
+    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;          
@@ -59,6 +84,10 @@ protected:
     
     int             _state;
     
+    ofImage         myColorImage1;
+    ofImage         myColorImage2;
+    ofImage         myGrayImage1;
+    
     //int             _run_cnt;
     
     float           DELTA_T_SAVE;

src/CamNoiseAnalysis.cpp

@@ -15,15 +15,17 @@ using Poco::Thread;
 
 void CamNoiseAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
-    cout << "NUM_RUN CamNoiseAnalysis " << NUM_RUN << endl;
+    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;
 
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_camnoise", ACQUIRE_TIME);
+    acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_camnoise", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME CamNoiseAnalysis " << acq_run_time << endl;
 
+
     //int acq_run_time = 20;   // 20 seconds of acquiring per run
 
     DELTA_T_SAVE = 2*(10*acq_run_time/2);       // for 20 seconds, we want this to be around 200 files
@@ -40,11 +42,17 @@ void CamNoiseAnalysis::setup(int camWidth, int camHeight)
     int anim_time = 10;   // 10 seconds
     _anim_cnt_max = anim_time*ofGetFrameRate();  // e.g.: 30 frames per second = 150 frames
 
-    //create_dir();
+    //create_dir_allocate_images();
 
     _show_image = false;
     _image_shown = false;
 
+    image1.clear();
+    image2.clear();
+    image3.clear();
+    image4.clear();
+    image5.clear();
+
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
@@ -54,9 +62,28 @@ void CamNoiseAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
 
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+
+    cvColorImage2.clear();
+	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);
@@ -65,6 +92,8 @@ void CamNoiseAnalysis::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);
+
 }
 
 
@@ -77,7 +106,7 @@ void CamNoiseAnalysis::acquire()
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
     _run_cnt++;
     _RUN_DONE = false;
-    create_dir();
+    create_dir_allocate_images();
 
     // RUN ROUTINE
     // for(int i = 0; i < NUM_RUN; i++) {
@@ -123,15 +152,23 @@ void CamNoiseAnalysis::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);
+            //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();
             cvGrayImage1.erode();
             cvGrayImage1.erode();
             cvGrayImage1.blur();
             cvGrayImage1.contrastStretch();
+           /* cvColorImage1.erode();
+            cvColorImage1.erode();
+            cvColorImage1.erode();
+            cvColorImage1.blur();
+            cvColorImage1.contrastStretch();*/
 
             /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
             string file_name;
@@ -144,18 +181,24 @@ void CamNoiseAnalysis::synthesise()
 
 
             //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-            ofImage image;
+            //ofImage image;
             //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? ***//
-            image.setUseTexture(false);  
+            //image.setUseTexture(false);
 
-            image.setFromPixels(cvGrayImage1.getPixels(), cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);
-            image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+            //image.setFromPixels(cvGrayImage1.getPixels(), cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);
+            //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
 
-            _saved_filenames_synthesis.push_back(_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(cvGrayImage1,cvGrayImage1,cvGrayImage1);
+            //cvConvertorImage.setFromGrayscalePlanarImages(cvColorImage1,cvColorImage1,cvColorImage1);
+            saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
             _synth_save_cnt++;
 
+
             //}
         }
     }
@@ -363,7 +406,7 @@ void CamNoiseAnalysis::draw()
                 ofEnableAlphaBlending();
 
                 ofSetColor(255, 255, 255);
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
+                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
                 image2.draw(0,0, ofGetWidth(), ofGetHeight());
 
                 ofDisableAlphaBlending();
@@ -387,39 +430,7 @@ void CamNoiseAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;
 
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "CamNoiseAnalysis::saving...\n";
-    
     string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
 
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
-
+    saveImageAnalysis(file_name);
 }

src/CamNoiseAnalysis.h

@@ -60,4 +60,8 @@ protected:
     ofxCvGrayscaleImage 	cvGrayImage4;
     
     ofxCvContourFinder      cvContourFinder1;
+    
+    //this is the temporary container to allow us to convert and save out greyscale images
+    ofxCvColorImage         cvConvertorImage;
+    
 };

src/ColorMultiAnalysis.cpp

@@ -14,13 +14,14 @@ using Poco::Thread;
 
 void ColorMultiAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
-    cout << "NUM_RUN ColorMultiAnalysis " << NUM_RUN << endl;
+    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;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_colormulti", ACQUIRE_TIME);
+    acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_colormulti", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME ColorMultiAnalysis " << acq_run_time << endl;
 
     //int acq_run_time = 35;  
@@ -30,7 +31,7 @@ void ColorMultiAnalysis::setup(int camWidth, int camHeight)
     
     _frame_cnt_max = acq_run_time*ofGetFrameRate();  // e.g.: 30 frames per second * 20 seconds = 600 frames
     
-    //create_dir();
+    //create_dir_allocate_images();
     
     _frame_cnt = 0;
     _run_cnt = 0;
@@ -40,12 +41,15 @@ void ColorMultiAnalysis::setup(int camWidth, int camHeight)
     int anim_time = 10;   // 10 seconds
     _anim_cnt_max = anim_time*ofGetFrameRate();  // e.g.: 30 frames per second = 150 frames
         
-    //for an ofxOpenCv.h image i would like to use..."
-    //image3.allocate(RefractiveIndex::_vid_w, RefractiveIndex::_vid_h);
-   
     _show_image = false;
     _image_shown = false;
     
+    image1.clear();
+    image2.clear();
+    image3.clear();  
+    image4.clear();
+    image5.clear();
+    
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
@@ -55,9 +59,28 @@ void ColorMultiAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
     
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+    
+    cvColorImage2.clear();
+	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);
@@ -66,6 +89,8 @@ void ColorMultiAnalysis::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);
+
 }
 
 void ColorMultiAnalysis::acquire()
@@ -77,7 +102,7 @@ void ColorMultiAnalysis::acquire()
     _run_cnt++;
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
     _RUN_DONE = false;
-    create_dir();
+    create_dir_allocate_images();
     
     // RUN ROUTINE
     //for(int i = 0; i < NUM_RUN; i++) {
@@ -146,17 +171,19 @@ void ColorMultiAnalysis::synthesise()
             
             
             //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-            ofImage image;
+            //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.setUseTexture(false);  
            
-            image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height,OF_IMAGE_COLOR);
-            image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+            //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);
             
-            _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++;
             
             // }
@@ -383,42 +410,9 @@ void ColorMultiAnalysis::draw()
 // this runs at save_cb timer rate = DELTA_T_SAVE
 void ColorMultiAnalysis::save_cb(Timer& timer)
 {
-  
     _save_cnt++;
             
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "ColorMultiAnalysis::saving...\n";
-    
     string file_name = ofToString(_save_cnt,2)+"_"+ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
 
-
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
-    
+    saveImageAnalysis(file_name);    
 }

src/ColorMultiAnalysis.h

@@ -55,4 +55,8 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
+    //this is the temporary container to allow us to convert and save out greyscale images
+    ofxCvColorImage         cvConvertorImage;
+    
+
 };

src/ColorSingleAnalysis.cpp

@@ -15,13 +15,14 @@ using Poco::Thread;
 
 void ColorSingleAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
-    cout << "NUM_RUN ColorSingleAnalysis " << NUM_RUN << endl;
+    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;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_colorsingle", ACQUIRE_TIME);
+    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
@@ -31,7 +32,7 @@ void ColorSingleAnalysis::setup(int camWidth, int camHeight)
     
     _frame_cnt_max = acq_run_time*ofGetFrameRate();  // e.g.: 30 frames per second * 20 seconds = 600 frames
     
-    //create_dir();
+    //create_dir_allocate_images();
     
     _run_cnt = 0;
     _frame_cnt = 0;
@@ -50,6 +51,12 @@ void ColorSingleAnalysis::setup(int camWidth, int camHeight)
     _show_image = false;
     _image_shown = false;
     
+    image1.clear();
+    image2.clear();
+    image3.clear();  
+    image4.clear();
+    image5.clear();
+    
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
@@ -59,9 +66,28 @@ void ColorSingleAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
     
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+    
+    cvColorImage2.clear();
+	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);
@@ -69,6 +95,9 @@ void ColorSingleAnalysis::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);
+    
 }
 
 
@@ -82,7 +111,7 @@ void ColorSingleAnalysis::acquire()
     _run_cnt++;
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
     _RUN_DONE = false;
-    create_dir();
+    create_dir_allocate_images();
     
     // RUN ROUTINE
     //for(int i = 0; i < NUM_RUN; i++) {
@@ -129,16 +158,6 @@ void ColorSingleAnalysis::synthesise()
                 cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
                 //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
                 
-                //cvGrayImage1 = cvColorImage1;
-                //cvGrayImage2 = cvColorImage2;
-                
-                //cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                //cvGrayDiff1.erode();
-                //cvGrayDiff1.contrastStretch();
-                //cvGrayDiff1.blur(5);
-                //cvGrayDiff1.dilate();
-                //cvGrayDiff1.contrastStretch();
-            
                 cvColorImage1.blur(5);
                 cvColorImage1.erode();
                 cvColorImage1.erode();
@@ -160,16 +179,20 @@ void ColorSingleAnalysis::synthesise()
                 
                 
                 //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                ofImage image;
+                //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.setUseTexture(false);  
                 
-                image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height,OF_IMAGE_COLOR);
-                image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+                //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);
+                //_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++;
             
            // }
@@ -406,40 +429,7 @@ void ColorSingleAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;
     
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "ColorSingleAnalysis::saving...\n";
-    
     string file_name =ofToString(_save_cnt,2)+"_"+fileNameTag+"_"+ofToString(_run_cnt,2)+".jpg";
     
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-        
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
-
-
+    saveImageAnalysis(file_name);
 }

src/ColorSingleAnalysis.h

@@ -62,4 +62,8 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
+    //this is the temporary container to allow us to convert and save out greyscale images
+    ofxCvColorImage         cvConvertorImage;
+    
+
 };

src/DiffNoiseAnalysis.cpp

@@ -15,13 +15,14 @@ using Poco::Thread;
 
 void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
-    cout << "NUM_RUN DiffNoiseAnalysis " << NUM_RUN << endl;
+    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;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:diffnoise_shadow", ACQUIRE_TIME);
+    acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_diffnoise", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME DiffNoiseAnalysis " << acq_run_time << endl;
     
     //int acq_run_time = 20;   // 20 seconds of acquiring per run
@@ -31,7 +32,7 @@ void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
     
     _frame_cnt_max = acq_run_time*ofGetFrameRate();  // e.g.: 30 frames per second * 20 seconds = 600 frames
     
-    //create_dir();
+    //create_dir_allocate_images();
     
     _run_cnt = 0;
     _frame_cnt = 0;
@@ -44,8 +45,11 @@ void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
     _show_image = false;
     _image_shown = false;
     
-    //for an ofxOpenCv.h image i would like to use..."
-    //image3.allocate(RefractiveIndex::_vid_w, RefractiveIndex::_vid_h);
+    image1.clear();
+    image2.clear();
+    image3.clear();  
+    image4.clear();
+    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
@@ -56,9 +60,28 @@ void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
     
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+    
+    cvColorImage2.clear();
+	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);
@@ -66,6 +89,9 @@ void DiffNoiseAnalysis::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);
+    
 }
 
 
@@ -77,7 +103,7 @@ void DiffNoiseAnalysis::acquire()
     _run_cnt++;
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
     _RUN_DONE = false;
-    create_dir();
+    create_dir_allocate_images();
     
     // RUN ROUTINE
     //for(int i = 0; i < NUM_RUN; i++) {
@@ -144,16 +170,19 @@ void DiffNoiseAnalysis::synthesise()
             
             
             //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-            ofImage image;
+            //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? ***//
-            image.setUseTexture(false);  
+            //image.setUseTexture(false);  
             
-            image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height,OF_IMAGE_COLOR);
-            image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+            //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);
+            //_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++;
             
             // }
@@ -403,39 +432,7 @@ void DiffNoiseAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;
             
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "DiffNoiseAnalysis::saving...\n";
-    
     string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
 
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
-
+    saveImageAnalysis(file_name);
 }

src/DiffNoiseAnalysis.h

@@ -59,4 +59,8 @@ protected:
     ofxCvGrayscaleImage 	cvGrayImage4;
     
     ofxCvContourFinder      cvContourFinder1;
+    
+    //this is the temporary container to allow us to convert and save out greyscale images
+    ofxCvColorImage         cvConvertorImage;
+    
 };

src/IResponseAnalysis.cpp

@@ -15,15 +15,23 @@ using Poco::Thread;
 
 void IResponseAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
-    cout << "NUM_RUN IResponseAnalysis " << NUM_RUN << endl;
+    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;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_iresponse", ACQUIRE_TIME);
+    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=4;
+    
+
     //int acq_run_time = 20;   // 20 seconds of acquiring per run
     
     DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
@@ -31,7 +39,7 @@ void IResponseAnalysis::setup(int camWidth, int camHeight)
     
     _frame_cnt_max = acq_run_time*ofGetFrameRate();  // e.g.: 30 frames per second * 20 seconds = 600 frames
     
-    //create_dir();
+    //create_dir_allocate_images();
     _synth_save_cnt = 0;
     _run_cnt = 0;
     _frame_cnt = 0;
@@ -43,6 +51,12 @@ void IResponseAnalysis::setup(int camWidth, int camHeight)
     _show_image = false;
     _image_shown = false;
     
+    image1.clear();
+    image2.clear();
+    image3.clear();  
+    image4.clear();
+    image5.clear();
+    
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
@@ -52,9 +66,28 @@ void IResponseAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
     
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+    
+    cvColorImage2.clear();
+	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);
@@ -63,6 +96,7 @@ void IResponseAnalysis::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);
     
 }
 
@@ -76,7 +110,7 @@ void IResponseAnalysis::acquire()
     _run_cnt++;
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
     _RUN_DONE = false;
-    create_dir();
+    create_dir_allocate_images();
 
     // RUN ROUTINE
     //for(int i = 0; i < NUM_RUN; i++) {
@@ -97,6 +131,8 @@ void IResponseAnalysis::acquire()
 
 void IResponseAnalysis::synthesise()
 {
+    cout<<"SYNTHESISING IRESPONSE";
+    
  
     //cout << "IResponseAnalysis::saving synthesis...\n";
     if(_state == STATE_STOP) return;
@@ -119,42 +155,46 @@ void IResponseAnalysis::synthesise()
             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);
-                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
+                //subtract background begin///////////////
 
-                cvGrayImage1 = cvColorImage1;
-                cvGrayImage2 = cvColorImage2;
+                ofPixels imagePixels1 = image1.getPixelsRef();
+                ofPixels imagePixels2 = image5.getPixelsRef();
+                ofPixels backgroundPixels = _background.getPixelsRef();
 
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.erode();
-                cvGrayDiff1.contrastStretch();
-                //cvGrayDiff1.blur(5);
-                //cvGrayDiff1.dilate();
-                //cvGrayDiff1.contrastStretch();
+                for(int i=0;i<imagePixels1.size();i++){
                     
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
+                    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;
+                    }
                   
-                file_name = ofToString(_synth_save_cnt, 2)+"_IResponseSynthesis_"+ofToString(_run_cnt,2)+".jpg";
+                }
+               
+                //update the images with their new background subtracted selves
+                image1.setFromPixels(imagePixels1);
 
                 
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+                //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);
+                 //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);
 
-                
-                //<---- 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);
+                //flag that we are finished  
+                meshIsComplete=true;
                 _synth_save_cnt++;
                 
             }
@@ -346,7 +386,7 @@ void IResponseAnalysis::draw()
                 ofEnableAlphaBlending();
                 
                 ofSetColor(255, 255, 255);
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
+                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
                 image2.draw(0,0, ofGetWidth(), ofGetHeight());
             
                 ofDisableAlphaBlending();
@@ -369,38 +409,176 @@ void IResponseAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;
     
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "IResponseAnalysis::saving...\n";
-    
     string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
         
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
+    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>=479){
+                        break;
+                    }
+                }
+             }
+    }
+    /*else{
+           for(int i=0;i<somePixels.getWidth()*(somePixels.getHeight()-1);i++){      
+               
+        
+               ofVec3f U;
+               ofVec3f V;
+                              //tri 1
+               U =ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- somePixels.getColor(x, y).getBrightness() ).operator-  ( ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- somePixels.getColor(x, y).getBrightness()  ) );
+               V =ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- somePixels.getColor(x+1, y+1).getBrightness()   ).operator-(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- somePixels.getColor(x, y).getBrightness()   ));
+               
+               ofVec3f normal;
+               float mult=5.2;
+               normal = ofVec3f( (U.y*V.z)-(U.z-V.y)   , (U.z*V.x)-(U.x*V.z)    , (U.x*V.y)-(U.y*V.x)  );
+               
+                 mesh.addColor(meshColour);
+                 mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- mult*(1+somePixels.getColor(x, y+1).getBrightness() )  ));
+               
+                 mesh.addColor(meshColour);
+                 mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- mult*(1+somePixels.getColor(x, y).getBrightness() )  ));
+
+                 mesh.addColor(meshColour);
+                 mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- mult*(1+somePixels.getColor(x+1, y+1).getBrightness())   ));
+               
+               mesh.addNormal(normal);
+               
+               //tri 2
+               U =ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*y,- somePixels.getColor(x, y).getBrightness()   ).operator-(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- somePixels.getColor(x+1, y+1).getBrightness() )  );
+               V =ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- somePixels.getColor(x+1, y).getBrightness()   ).operator-(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- somePixels.getColor(x+1, y+1).getBrightness() )  );
+               
+               normal = ofVec3f( (U.y*V.z)-(U.z-V.y)   , (U.z*V.x)-(U.x*V.z)    , (U.x*V.y)-(U.y*V.x)  );
+               
+                 mesh.addColor(meshColour);
+                 mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- mult*(1+somePixels.getColor(x+1, y+1).getBrightness())   ));
+                 //       mesh.addColor( ofColor(255,10,10)   );
+
+                 mesh.addColor(meshColour);
+                 mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*y,- mult*(1+somePixels.getColor(x, y).getBrightness() )  ));
+
+                 mesh.addColor(meshColour);
+                 mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,-mult*(1+ somePixels.getColor(x+1, y).getBrightness())   ));
+               
+               mesh.addNormal(normal);
+
+                x++;
+                if(x>=somePixels.getWidth()-1){
+                    x=0;
+                    y++;
+                    if(y>=479){
+                       break;
+                   }
+                }
+             }*/
+         
+     // add colour from current second image of two - this is a hang over from when i was comparing two image
+        
+
+}
+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 colourImage1 = 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(colourImage1.getBrightness()-_presumedBrightness);
+            //cout<<thisDiff<< " thisDiff "<<endl;
+            float multiplier=2.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

@@ -58,4 +58,15 @@ protected:
     ofxCvGrayscaleImage 	cvGrayImage4;
     
     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);
+    //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

@@ -12,18 +12,28 @@ using Poco::Thread;
 
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
+#define TRESHOLD        80
+#define MAXBLOBS        15
 
 void RelaxRateAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
-    cout << "NUM_RUN RelaxRateAnalysis " << NUM_RUN << endl;
+    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;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_relaxrate", ACQUIRE_TIME);
+    acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_relaxrate", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME RelaxRateAnalysis " << acq_run_time << endl;
     
+    _treshold = RefractiveIndex::XML.getValue("config:relaxrate:treshold", TRESHOLD);
+    cout << "TRESHOLD RelaxRateAnalysis " << _treshold << endl;
+    
+    _maxblobs = RefractiveIndex::XML.getValue("config:relaxrate:maxblobs", MAXBLOBS);
+    cout << "MAXBLOBS RelaxRateAnalysis " << _maxblobs << endl;
+
+    
     //int acq_run_time = 20;   // 20 seconds of acquiring per run
     
     DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
@@ -31,7 +41,7 @@ void RelaxRateAnalysis::setup(int camWidth, int camHeight)
     
     _frame_cnt_max = acq_run_time*ofGetFrameRate();  // e.g.: 30 frames per second * 20 seconds = 600 frames
     
-    //create_dir();
+    //create_dir_allocate_images();
     
     _run_cnt = 0;
     _level = 0;
@@ -46,26 +56,19 @@ void RelaxRateAnalysis::setup(int camWidth, int camHeight)
     _show_image = false;
     _image_shown = false;
     
-    //  images use for drawing the synthesized files to the screen ///
+    image1.clear();
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
-    image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-    
-    //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
+    cvColorImage1.clear();
+    cvGrayDiff1.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);
         
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
 }
 
 
@@ -78,7 +81,7 @@ void RelaxRateAnalysis::acquire()
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
     _RUN_DONE = false;
 
-    create_dir();
+    create_dir_allocate_images();
     
     // RUN ROUTINE
     //for(int i = 0; i < NUM_RUN; i++) {
@@ -101,60 +104,28 @@ void RelaxRateAnalysis::synthesise()
     //cout << "IResponseAnalysis::saving synthesis...\n";
     if(_state == STATE_STOP) return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    cvContourFinderVect.clear();    
     
-        //cout << "IResponseAnalysis::synthesis FOR LOOP...\n";
     
-        //cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+    for(float i=1;i<_saved_filenames_analysis.size();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])){
-            //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.convertToGrayscalePlanarImage(cvGrayDiff1, 1);
             
-                cvGrayImage1 = cvColorImage1;
-                cvGrayImage2 = cvColorImage2;
+            cvGrayDiff1.threshold(_treshold);
             
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.erode();
-                cvGrayDiff1.contrastStretch();
-                cvGrayDiff1.blur(5);
+            rfiCvContourFinder* cf = new rfiCvContourFinder();
             
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
+            cf->findContours(cvGrayDiff1, 20, (image1.width * image1.height) / 4, _maxblobs, true);
             
-                file_name = ofToString(_synth_save_cnt, 2)+"_RelaxRateAnalysis_"+ofToString(_run_cnt,2)+".jpg";
+            cvContourFinderVect.push_back(cf);
             
-                
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-                // 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);
-                _synth_save_cnt++;
-            }
         }
     }
     
@@ -167,29 +138,38 @@ void RelaxRateAnalysis::synthesise()
 void RelaxRateAnalysis::displayresults()
 {
         
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
+    //cvContourFinderVectDisplay.clear();
+    clearcfindervectdisplay();
+    
+    for(int i=1;i<cvContourFinderVect.size();i++){
+        
+        if(_state == STATE_STOP){
+            clearcfindervectdisplay();
+            clearcfindervect();
+            return;
+        }        
         
-        if(_state == STATE_STOP) return;
         
         //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;
         }
         
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
-            //couldn't load image
-            // cout << "didn't load image" << endl;
-        } 
-        
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
-            //cout << "_show_image = true;" << endl;
+        cvContourFinderVectDisplay.push_back(cvContourFinderVect[i]);    
         _show_image = true;
         _image_shown = false;
+        
     }     
-    }
+    
+    clearcfindervectdisplay();
+    clearcfindervect();
+    
+        
+    //cvContourFinderVectDisplay.clear();
+    //cvContourFinderVect.clear();
     
     
 }
@@ -202,9 +182,7 @@ void RelaxRateAnalysis::draw()
     switch (_state) {
         case STATE_ACQUIRING:
         {
-            /// *** TODO  *** ///
-            // still need to deal with latency frames here - i.e.: there are frames
-            /// *** TODO  *** ///
+            
             
             if (_frame_cnt < _frame_cnt_max)
             {
@@ -235,6 +213,7 @@ void RelaxRateAnalysis::draw()
             
         case STATE_SYNTHESISING:
         {
+            
             // display animation of something while the synthesis in on-going...
             
             //cout << "RelaxRateAnalysis = STATE_SYNTHESISING...\n";
@@ -287,7 +266,7 @@ void RelaxRateAnalysis::draw()
                     }
                 }
                 
-                cout << "_anim_cnt = " << _anim_cnt << endl;
+                //cout << "_anim_cnt = " << _anim_cnt << endl;
                 
                 if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
 
@@ -335,15 +314,10 @@ void RelaxRateAnalysis::draw()
             
             if (_show_image)
             {  
-                //cout << "_show_image...\n" << endl;
+                for(int i=0;i<cvContourFinderVectDisplay.size();i++){
+                    cvContourFinderVectDisplay[i]->draw(0,0, ofGetWidth(), ofGetHeight());
+                }
 
-                ofEnableAlphaBlending();
-                
-                ofSetColor(255, 255, 255);
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
-                
-                ofDisableAlphaBlending();
             }
             
             // display results of the synthesis
@@ -363,37 +337,34 @@ void RelaxRateAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;
     
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    //cout << "RelaxRateAnalysis::saving...\n";
-    
     string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
     
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
+    saveImageAnalysis(file_name);
     
     
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
 }
+
+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();
+}
+

src/RelaxRateAnalysis.h

@@ -5,8 +5,12 @@
 
 #include "Poco/Timer.h"
 
+#include "rfiCvContourFinder.h"
+
 #include "ofxOpenCv.h"
 
+
+
 class RelaxRateAnalysis : public AbstractAnalysis
 {
 public:
@@ -19,6 +23,7 @@ public:
     void acquire();
     void synthesise(); 
     void displayresults();
+    void cleanup();
 
     void draw();
     
@@ -26,34 +31,24 @@ public:
     
 protected:
     
+    void clearcfindervect();
+    void clearcfindervectdisplay();
+    
     bool    _RUN_DONE;
     float     _flip, _level;
     int     _run_cnt, _save_cnt, _synth_save_cnt, _anim_cnt;
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
     
+    int     _treshold;
+    int     _maxblobs;
+    
     bool _show_image, _image_shown;
+    
     ofImage                 image1;    
-    ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
-    
     ofxCvColorImage         cvColorImage1;    
-    ofxCvColorImage         cvColorImage2;
-    ofxCvColorImage         cvColorImage3;
-    ofxCvColorImage         cvColorImage4;
-    ofxCvColorImage         cvColorImage5;
-    ofxCvColorImage         cvColorImage6;
-    
     ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
     
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
+    vector<rfiCvContourFinder*>      cvContourFinderVect;
+    vector<rfiCvContourFinder*>      cvContourFinderVectDisplay;
 
 };

src/ShadowScapesAnalysis.cpp

@@ -19,12 +19,14 @@ using Poco::Thread;
 
 void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
+    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;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_shadowscapes", ACQUIRE_TIME);
+    acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_shadowscapes", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME ShadowScapesAnalysis " << acq_run_time << endl;
     
     int screenSpan;
@@ -39,8 +41,6 @@ void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
 
     DELTA_T_SAVE = 3*(10*acq_run_time/2);   // for 20 seconds, we want this to be around 100 files
                                             // or 5 times per second = every 200 ms
-    //DELTA_T_SAVE = 1;
-    //create_dir();  // this makes both synth and analysis folder structures
     
     _scanLineWidth = 100.0;
     _run_cnt = 0;
@@ -53,6 +53,12 @@ void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
     _show_image = false;
     _image_shown = false;
     
+    image1.clear();
+    image2.clear();
+    image3.clear();  
+    image4.clear();
+    image5.clear();
+        
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
@@ -62,9 +68,28 @@ void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
     
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+    
+    cvColorImage2.clear();
+	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);
@@ -72,6 +97,9 @@ void ShadowScapesAnalysis::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 ShadowScapesAnalysis::acquire()
@@ -85,9 +113,7 @@ void ShadowScapesAnalysis::acquire()
     _line = 0;
     _RUN_DONE = false;
 
-    create_dir();
-    
-    //cout << "RUN NUM = " << i;
+    create_dir_allocate_images();
    
     save_timer.start(save_callback);
       
@@ -96,8 +122,6 @@ void ShadowScapesAnalysis::acquire()
     
     save_timer.stop();
 
-    //}
-
 }
 
 void ShadowScapesAnalysis::synthesise()
@@ -126,8 +150,11 @@ void ShadowScapesAnalysis::synthesise()
                 cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
                 cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
                 
-                cvGrayImage1 = cvColorImage1;
-                cvGrayImage2 = cvColorImage2;
+                //cvGrayImage1 = cvColorImage1;
+                //cvGrayImage2 = cvColorImage2;
+                
+                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
+                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
       
                 cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
                 cvGrayDiff1.erode();
@@ -151,24 +178,28 @@ void ShadowScapesAnalysis::synthesise()
                 }
                 
                 
+                
                 //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
                 // 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;
+                //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.setUseTexture(false);  
                 
+                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
+                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
 
-                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);
                                
-                _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++;
-                
             }
         }
     }
@@ -205,41 +236,6 @@ void ShadowScapesAnalysis::displayresults()
         }
     }
 
-    
-    // THE OLD SHIT /// 
-/*
-    for(float i=1;i<_saved_filenames_synthesis.size()-1;i++){
-        
-       // cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
-        
-        if(_state == STATE_STOP) return;
-        
-        while(!_image_shown){
-            Thread::sleep(2);
-            //cout << "!_image_shown" << endl;
-        }
-        
-        if(!image1.loadImage(_saved_filenames_synthesis[i])){
-            //couldn't load image
-            cout << "didn't load image" << endl;
-        } 
-        
-            
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-            
-            image1.loadImage(_saved_filenames_analysis[i]);
-            cout << "loaded filenames[i] -  " << _saved_filenames_analysis[i] << endl;
-        
-            image2.setFromPixels(image1.getPixels(),image1.width,image1.height, OF_IMAGE_COLOR);
-          
-            //cout << "_show_image = true;" << endl;
-            _show_image = true;
-            _image_shown = false;
-
-        }
-    }
-*/
-    
 }
 
 
@@ -419,7 +415,6 @@ void ShadowScapesAnalysis::draw()
         {
             //cout << "STATE_DISPLAY_RESULTS...\n" << endl;
             
-            
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -435,7 +430,8 @@ void ShadowScapesAnalysis::draw()
                 ofEnableAlphaBlending();
                 
                     ofSetColor(255, 255, 255);
-                    image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
+                
+                    image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
                     image2.draw(0,0, ofGetWidth(), ofGetHeight());
                 
                 ofDisableAlphaBlending();
@@ -445,6 +441,9 @@ void ShadowScapesAnalysis::draw()
             
             // display results of the synthesis
             _RUN_DONE = true;
+            
+            // clear allocated memory...? 
+            
             break;
         }
             
@@ -460,17 +459,6 @@ void ShadowScapesAnalysis::save_cb(Timer& timer)
     
     _save_cnt++;
         
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "ShadowScapesAnalysis::saving analysis...\n";
-    
     string file_name;
     
     if(_dir == H) {
@@ -485,26 +473,6 @@ void ShadowScapesAnalysis::save_cb(Timer& timer)
         file_name = ofToString(_save_cnt, 2)+"_D_"+ofToString(_line, 2)+"_"+ofToString(_run_cnt,2)+".jpg";
     }
         
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
+    saveImageAnalysis(file_name);
         
 }

src/ShadowScapesAnalysis.h

@@ -66,4 +66,7 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
+    //this is the temporary container to allow us to convert and save out greyscale images
+    ofxCvColorImage         cvConvertorImage;    
+
 };

src/ShapeFromShadingAnalysis.cpp

@@ -15,16 +15,17 @@ using Poco::Thread;
 
 void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
 {       
+    AbstractAnalysis::setup(camWidth, camHeight);
     
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
+    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_shapefromshading", NUMBER_RUNS);
     cout << "NUM_RUN ShapeFromShadingAnalysis " << NUM_RUN << endl;
-
     //NUM_RUN = 5;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_shapefromshading", ACQUIRE_TIME);
+    acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_shapefromshading", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME ShapeFromShadingAnalysis " << acq_run_time << endl;
 
+
     //int acq_run_time = 20;   // 20 seconds of acquiring per run
     
     DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
@@ -32,7 +33,7 @@ void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
     
     _frame_cnt_max = acq_run_time*ofGetFrameRate();  // e.g.: 30 frames per second * 20 seconds = 600 frames
     
-    //create_dir();
+    //create_dir_allocate_images();
     _synth_save_cnt = 0;
     _run_cnt = 0;
     _frame_cnt = 0;
@@ -41,10 +42,15 @@ void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
     int anim_time = 5;   // 10 seconds
     _anim_cnt_max = anim_time*ofGetFrameRate();  // e.g.: 30 frames per second = 150 frames
     
-    
     _show_image = false;
     _image_shown = false;
     
+    image1.clear();
+    image2.clear();
+    image3.clear();  
+    image4.clear();
+    image5.clear();
+    
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
@@ -54,9 +60,28 @@ void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
     
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+    
+    cvColorImage2.clear();
+	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);
@@ -65,6 +90,8 @@ void ShapeFromShadingAnalysis::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);
+
 }
 
 
@@ -78,7 +105,7 @@ void ShapeFromShadingAnalysis::acquire()
     _run_cnt++;
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;    
     _RUN_DONE = false;
-    create_dir();
+    create_dir_allocate_images();
     
     _animation_cnt1 = 0;
     _animation_cnt2 = 0;
@@ -144,8 +171,8 @@ void ShapeFromShadingAnalysis::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.erode();
@@ -163,18 +190,23 @@ void ShapeFromShadingAnalysis::synthesise()
                 //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
                 // 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;
+                //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.setUseTexture(false);  
                
-                image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+                //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);
+                //_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++;
                 
             }
@@ -537,7 +569,7 @@ void ShapeFromShadingAnalysis::draw()
                 ofEnableAlphaBlending();
                 
                 ofSetColor(255, 255, 255);
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
+                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
                 image2.draw(0,0, ofGetWidth(), ofGetHeight());
                 
                 ofDisableAlphaBlending();
@@ -562,39 +594,7 @@ void ShapeFromShadingAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;
             
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "ShapeFromShadingAnalysis::saving...\n";
-    
     string file_name = ofToString(_save_cnt,2)+"_"+ quad +"_"+ofToString(_run_cnt,2)+".jpg";
     
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-    
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
-
+    saveImageAnalysis(file_name);
 }

src/ShapeFromShadingAnalysis.h

@@ -78,4 +78,8 @@ protected:
     ofxCvGrayscaleImage 	cvGrayImage4;
     
     ofxCvContourFinder      cvContourFinder1;
+    
+    //this is the temporary container to allow us to convert and save out greyscale images
+    ofxCvColorImage         cvConvertorImage;
+    
 };

src/StrobeAnalysis.cpp

@@ -15,13 +15,14 @@ using Poco::Thread;
 
 void StrobeAnalysis::setup(int camWidth, int camHeight)
 {
-    NUM_RUN = RefractiveIndex::XML.getValue("config:analysis:NUM_RUN", NUMBER_RUNS);
-    cout << "NUM_RUN StrobeAnalysis " << NUM_RUN << endl;
+    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;
     
     int acq_run_time;   // 10 seconds of acquiring per run
-    acq_run_time = RefractiveIndex::XML.getValue("config:analysis:acquiretime_strobe", ACQUIRE_TIME);
+    acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_strobe", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME StrobeAnalysis " << acq_run_time << endl;
 
     //int acq_run_time = 25;   // 20 seconds of acquiring per run
@@ -35,7 +36,7 @@ void StrobeAnalysis::setup(int camWidth, int camHeight)
 
     // The British Health and Safety Executive recommend that a net flash rate for a bank of strobe lights does not exceed 5 flashes per second, at which only 5% of photosensitive epileptics are at risk. It also recommends that no strobing effect continue for more than 30 seconds, due to the potential for discomfort and disorientation.
     
-    //create_dir();
+    //create_dir_allocate_images();
     _synth_save_cnt = 0;
     _run_cnt = 0;
     
@@ -45,6 +46,12 @@ void StrobeAnalysis::setup(int camWidth, int camHeight)
     _show_image = false;
     _image_shown = false;
     
+    image1.clear();
+    image2.clear();
+    image3.clear();  
+    image4.clear();
+    image5.clear();
+    
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
@@ -54,9 +61,28 @@ void StrobeAnalysis::setup(int camWidth, int camHeight)
     image4.setUseTexture(false);
     image5.setUseTexture(false);
     
+    image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
+    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
+    cvColorImage1.clear();
+	cvGrayImage1.clear();
+    cvGrayDiff1.clear();
+    
+    cvColorImage2.clear();
+	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);
@@ -65,6 +91,8 @@ 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);
+
 }
 
 
@@ -77,7 +105,7 @@ void StrobeAnalysis::acquire()
     _frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0;  _strobe_cnt = 0, _synth_save_cnt = 0;
     _run_cnt++;
     _RUN_DONE = false;
-    create_dir();
+    create_dir_allocate_images();
     
     // RUN ROUTINE
     //for(int i = 0; i < NUM_RUN; i++) {
@@ -125,8 +153,8 @@ void StrobeAnalysis::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.dilate();
@@ -144,18 +172,26 @@ void StrobeAnalysis::synthesise()
                 
                 
                 //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                ofImage image;
+                //ofImage image;
                 //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? ***//
-                image.setUseTexture(false);  
+                //image.setUseTexture(false);  
                 
-                image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height,OF_IMAGE_GRAYSCALE);
-                image.saveImage(_whole_file_path_synthesis+"/"+file_name);
+                //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);
+                //_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++;
                 
+                
             }
         }
     }
@@ -362,7 +398,7 @@ void StrobeAnalysis::draw()
                 ofEnableAlphaBlending();
                 
                 ofSetColor(255, 255, 255);
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
+                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
                 image2.draw(0,0, ofGetWidth(), ofGetHeight());
                 
                 ofDisableAlphaBlending();
@@ -387,39 +423,7 @@ void StrobeAnalysis::save_cb(Timer& timer)
 {
     _save_cnt++;    
     
-    RefractiveIndex::_vidGrabber.grabFrame();  // get a new frame from the camera
-    
-    if (RefractiveIndex::_vidGrabber.isFrameNew())
-    {
-        RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
-    } else {
-        return;
-    }
-    
-    //cout << "StrobeAnalysis::saving...\n";
-    
     string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(_strobe_on) +"_"+ofToString(_run_cnt,2)+".jpg";
     
-    
-    //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-    //ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-    
-    
-    //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-    unsigned char * somePixels;
-    ofPixels appPix = RefractiveIndex::_pixels;
-    somePixels = new unsigned char [appPix.getWidth()*appPix.getHeight()*3];
-    somePixels = appPix.getPixels();
-
-    ofImage myImage;
-    //myImage.allocate(appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    
-    //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-    myImage.setUseTexture(false);
-    
-    myImage.setFromPixels(somePixels,appPix.getWidth(),appPix.getHeight(), OF_IMAGE_COLOR);
-    myImage.saveImage(ofToDataPath("")+ _whole_file_path_analysis+"/"+file_name);
-    
-    _saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
-
+    saveImageAnalysis(file_name);
 }

src/StrobeAnalysis.h

@@ -65,4 +65,7 @@ protected:
     
     ofxCvContourFinder      cvContourFinder1;
     
+    //this is the temporary container to allow us to convert and save out greyscale images
+    ofxCvColorImage         cvConvertorImage;    
+
 };

src/rficv/rfiCvContourFinder.cpp

@@ -0,0 +1,211 @@
+
+#include "rfiCvContourFinder.h"
+
+
+
+//--------------------------------------------------------------------------------
+static bool sort_carea_compare( const CvSeq* a, const CvSeq* b) {
+	// use opencv to calc size, then sort based on size
+	float areaa = fabs(cvContourArea(a, CV_WHOLE_SEQ));
+	float areab = fabs(cvContourArea(b, CV_WHOLE_SEQ));
+
+    //return 0;
+	return (areaa > areab);
+}
+
+
+
+
+//--------------------------------------------------------------------------------
+rfiCvContourFinder::rfiCvContourFinder() {
+    _width = 0;
+    _height = 0;
+	myMoments = (CvMoments*)malloc( sizeof(CvMoments) );
+	reset();
+}
+
+//--------------------------------------------------------------------------------
+rfiCvContourFinder::~rfiCvContourFinder() {
+	free( myMoments );
+}
+
+//--------------------------------------------------------------------------------
+void rfiCvContourFinder::reset() {
+    cvSeqBlobs.clear();
+    blobs.clear();
+    nBlobs = 0;
+}
+
+//--------------------------------------------------------------------------------
+int rfiCvContourFinder::findContours( ofxCvGrayscaleImage&  input,
+									  int minArea,
+									  int maxArea,
+									  int nConsidered,
+									  bool bFindHoles,
+                                      bool bUseApproximation) {
+
+    // get width/height disregarding ROI
+    IplImage* ipltemp = input.getCvImage();
+    _width = ipltemp->width;
+    _height = ipltemp->height;
+
+	reset();
+
+	// opencv will clober the image it detects contours on, so we want to
+    // copy it into a copy before we detect contours.  That copy is allocated
+    // if necessary (necessary = (a) not allocated or (b) wrong size)
+	// so be careful if you pass in different sized images to "findContours"
+	// there is a performance penalty, but we think there is not a memory leak
+    // to worry about better to create mutiple contour finders for different
+    // sizes, ie, if you are finding contours in a 640x480 image but also a
+    // 320x240 image better to make two rfiCvContourFinder objects then to use
+    // one, because you will get penalized less.
+
+	if( inputCopy.getWidth() == 0 ) {
+        inputCopy.setUseTexture(false);
+		inputCopy.allocate( _width, _height );
+	} else if( inputCopy.getWidth() != _width || inputCopy.getHeight() != _height ) {
+        // reallocate to new size
+        inputCopy.clear();
+        inputCopy.setUseTexture(false);
+        inputCopy.allocate( _width, _height );
+	}
+
+    inputCopy.setROI( input.getROI() );
+    inputCopy = input;
+
+	CvSeq* contour_list = NULL;
+	contour_storage = cvCreateMemStorage( 1000 );
+	storage	= cvCreateMemStorage( 1000 );
+
+	CvContourRetrievalMode  retrieve_mode
+        = (bFindHoles) ? CV_RETR_LIST : CV_RETR_EXTERNAL;
+	cvFindContours( inputCopy.getCvImage(), contour_storage, &contour_list,
+                    sizeof(CvContour), retrieve_mode, bUseApproximation ? CV_CHAIN_APPROX_SIMPLE : CV_CHAIN_APPROX_NONE );
+	CvSeq* contour_ptr = contour_list;
+
+	// put the contours from the linked list, into an array for sorting
+	while( (contour_ptr != NULL) ) {
+		float area = fabs( cvContourArea(contour_ptr, CV_WHOLE_SEQ) );
+		if( (area > minArea) && (area < maxArea) ) {
+            cvSeqBlobs.push_back(contour_ptr);
+		}
+		contour_ptr = contour_ptr->h_next;
+	}
+
+
+	// sort the pointers based on size
+	if( cvSeqBlobs.size() > 1 ) {
+        sort( cvSeqBlobs.begin(), cvSeqBlobs.end(), sort_carea_compare );
+	}
+
+
+	// now, we have cvSeqBlobs.size() contours, sorted by size in the array
+    // cvSeqBlobs let's get the data out and into our structures that we like
+	for( int i = 0; i < MIN(nConsidered, (int)cvSeqBlobs.size()); i++ ) {
+		blobs.push_back( ofxCvBlob() );
+		float area = cvContourArea( cvSeqBlobs[i], CV_WHOLE_SEQ );
+		CvRect rect	= cvBoundingRect( cvSeqBlobs[i], 0 );
+		cvMoments( cvSeqBlobs[i], myMoments );
+
+		blobs[i].area                     = fabs(area);
+		blobs[i].hole                     = area < 0 ? true : false;
+		blobs[i].length 			      = cvArcLength(cvSeqBlobs[i]);
+		blobs[i].boundingRect.x           = rect.x;
+		blobs[i].boundingRect.y           = rect.y;
+		blobs[i].boundingRect.width       = rect.width;
+		blobs[i].boundingRect.height      = rect.height;
+		blobs[i].centroid.x 			  = (myMoments->m10 / myMoments->m00);
+		blobs[i].centroid.y 			  = (myMoments->m01 / myMoments->m00);
+
+		// get the points for the blob:
+		CvPoint           pt;
+		CvSeqReader       reader;
+		cvStartReadSeq( cvSeqBlobs[i], &reader, 0 );
+
+    	for( int j=0; j < cvSeqBlobs[i]->total; j++ ) {
+			CV_READ_SEQ_ELEM( pt, reader );
+            blobs[i].pts.push_back( ofPoint((float)pt.x, (float)pt.y) );
+		}
+		blobs[i].nPts = blobs[i].pts.size();
+
+	}
+
+    nBlobs = blobs.size();
+
+	// Free the storage memory.
+	// Warning: do this inside this function otherwise a strange memory leak
+	if( contour_storage != NULL ) { cvReleaseMemStorage(&contour_storage); }
+	if( storage != NULL ) { cvReleaseMemStorage(&storage); }
+
+	return nBlobs;
+
+}
+
+//--------------------------------------------------------------------------------
+void rfiCvContourFinder::draw( float x, float y, float w, float h ) {
+
+    float scalex = 0.0f;
+    float scaley = 0.0f;
+    if( _width != 0 ) { scalex = w/_width; } else { scalex = 1.0f; }
+    if( _height != 0 ) { scaley = h/_height; } else { scaley = 1.0f; }
+
+    if(bAnchorIsPct){
+        x -= anchor.x * w;
+        y -= anchor.y * h;
+    }else{
+        x -= anchor.x;
+        y -= anchor.y;
+    }
+
+    ofPushStyle();
+    glPushMatrix();
+    glTranslatef( x, y, 0.0 );
+    glScalef( scalex, scaley, 0.0 );
+	ofSetHexColor(0xFFFFFF);
+
+	for( int i=0; i<(int)blobs.size(); i++ ) {
+		ofNoFill();
+		ofBeginShape();
+		for( int j=0; j<blobs[i].nPts; j++ ) {
+			ofVertex( blobs[i].pts[j].x, blobs[i].pts[j].y );
+		}
+		ofEndShape();
+
+	}
+	glPopMatrix();
+	ofPopStyle();
+}
+
+
+//----------------------------------------------------------
+void rfiCvContourFinder::draw(const ofPoint & point){
+	draw(point.x, point.y);
+}
+
+//----------------------------------------------------------
+void rfiCvContourFinder::draw(const ofRectangle & rect){
+	draw(rect.x, rect.y, rect.width, rect.height);
+}
+
+//--------------------------------------------------------------------------------
+void rfiCvContourFinder::setAnchorPercent( float xPct, float yPct ){
+    anchor.x = xPct;
+    anchor.y = yPct;
+    bAnchorIsPct = true;
+}
+
+//--------------------------------------------------------------------------------
+void rfiCvContourFinder::setAnchorPoint( int x, int y ){
+    anchor.x = x;
+    anchor.y = y;
+    bAnchorIsPct = false;
+}
+
+//--------------------------------------------------------------------------------
+void rfiCvContourFinder::resetAnchor(){
+    anchor.set(0,0);
+    bAnchorIsPct = false;
+}
+
+

src/rficv/rfiCvContourFinder.h

@@ -0,0 +1,73 @@
+/*
+* rfiCvContourFinder.h
+*
+* Finds white blobs in binary images and identifies
+* centroid, bounding box, area, length and polygonal contour
+* The result is placed in a vector of ofxCvBlob objects.
+*
+*/
+
+#ifndef RFI_CV_CONTOUR_FINDER
+#define RFI_CV_CONTOUR_FINDER
+
+
+
+#include "ofxCvConstants.h"
+#include "ofxCvBlob.h"
+#include "ofxCvGrayscaleImage.h"
+#include <algorithm>
+
+class rfiCvContourFinder : public ofBaseDraws {
+
+  public:
+  
+    vector<ofxCvBlob>  blobs;
+    int                nBlobs;    // DEPRECATED: use blobs.size() instead
+      
+
+    rfiCvContourFinder();
+    virtual  ~rfiCvContourFinder();
+    
+	virtual float getWidth() { return _width; };    //set after first findContours call
+	virtual float getHeight() { return _height; };  //set after first findContours call
+    
+    virtual int  findContours( ofxCvGrayscaleImage& input,
+                               int minArea, int maxArea,
+                               int nConsidered, bool bFindHoles,
+                               bool bUseApproximation = true);
+                               // approximation = don't do points for all points 
+                               // of the contour, if the contour runs
+                               // along a straight line, for example...
+
+    virtual void  draw() { draw(0,0, _width, _height); };
+    virtual void  draw( float x, float y ) { draw(x,y, _width, _height); };
+    virtual void  draw( float x, float y, float w, float h );
+	virtual void  draw(const ofPoint & point);
+	virtual void  draw(const ofRectangle & rect);
+	virtual void setAnchorPercent(float xPct, float yPct);
+    virtual void setAnchorPoint(int x, int y);
+	virtual void resetAnchor();      
+    //virtual ofxCvBlob  getBlob(int num);
+
+
+
+  protected:
+
+    int  _width;
+    int  _height;
+    ofxCvGrayscaleImage     inputCopy;
+    CvMemStorage*           contour_storage;
+    CvMemStorage*           storage;
+    CvMoments*              myMoments;
+    vector<CvSeq*>          cvSeqBlobs;  //these will become blobs
+    
+    ofPoint  anchor;
+    bool  bAnchorIsPct;      
+
+    virtual void reset();
+
+};
+
+
+
+#endif