Compare commits
13 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
42d048ca04 | ||
|
5c5581f16e | ||
|
|
b5cebe9304 | ||
|
3649211943 | ||
|
|
bc19757de2 | ||
|
|
d798394793 | ||
|
|
bf8c630add | ||
|
|
935d6414b5 | ||
|
|
6b401b8424 | ||
|
|
3fd26c1eb4 | ||
|
|
c53eb2eb6c | ||
|
|
1d5d6abbde | ||
|
|
71e3a9a1db |
10
README
10
README
@ -1,10 +0,0 @@
|
||||
WARNING: WORK IN PROGRESS...
|
||||
|
||||
configuring OpenFrameworks
|
||||
-----------------
|
||||
|
||||
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};
|
||||
(3) Press Play!
|
||||
2
README.md
Normal file
2
README.md
Normal file
@ -0,0 +1,2 @@
|
||||
<img src="https://davidgauthier.info/rfi/img-resize/rfi3.jpg" width="100%">
|
||||
<img src="https://davidgauthier.info/rfi/img-resize/rfi4.jpg" width="100%">
|
||||
@ -1,5 +1,12 @@
|
||||
/*
|
||||
|
||||
////also the new shit////
|
||||
todo:
|
||||
(1) Look at warinings about the #define which get over written
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "RefractiveIndex.h"
|
||||
|
||||
@ -43,11 +50,9 @@ void RefractiveIndex::setup()
|
||||
bool save_config = false;
|
||||
|
||||
cout << "Loading configuration..." << endl;
|
||||
if(XML.loadFile("config.refindx") == false) {
|
||||
if(!XML.loadFile("../data/config.refindx")) {
|
||||
ofLog(OF_LOG_ERROR) << "error loading config - using default.";
|
||||
save_config = true;
|
||||
} else {
|
||||
XML.loadFile("config.refindx");
|
||||
}
|
||||
|
||||
// <camera>
|
||||
@ -66,7 +71,6 @@ void RefractiveIndex::setup()
|
||||
// display
|
||||
cout << "> display" << endl;
|
||||
ofSetFrameRate(fps);
|
||||
|
||||
if(fps > 30) {
|
||||
ofSetVerticalSync(FALSE);
|
||||
} else {
|
||||
@ -89,38 +93,35 @@ void RefractiveIndex::setup()
|
||||
|
||||
//getting a warning from the OFlog that the pixels aren't allocated
|
||||
//void ofPixels::allocate(int w, int h, ofImageType type)
|
||||
_pixels.allocate(_vid_w, _vid_h, OF_IMAGE_COLOR);
|
||||
|
||||
|
||||
//TODO: whichever one of these is first - it always runs twice ?
|
||||
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(V));
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(H));
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(D));
|
||||
//_analysisVector.push_back(new ShadowScapesAnalysis(V));
|
||||
//_analysisVector.push_back(new ShadowScapesAnalysis(H));
|
||||
//_analysisVector.push_back(new ShadowScapesAnalysis(D));
|
||||
|
||||
_analysisVector.push_back(new RelaxRateAnalysis());
|
||||
|
||||
_analysisVector.push_back(new IResponseAnalysis());
|
||||
//_analysisVector.push_back(new IResponseAnalysis());
|
||||
|
||||
_analysisVector.push_back(new ShapeFromShadingAnalysis());
|
||||
//_analysisVector.push_back(new ShapeFromShadingAnalysis());
|
||||
|
||||
_analysisVector.push_back(new StrobeAnalysis());
|
||||
//_analysisVector.push_back(new StrobeAnalysis());
|
||||
|
||||
_analysisVector.push_back(new CamNoiseAnalysis());
|
||||
//_analysisVector.push_back(new CamNoiseAnalysis());
|
||||
|
||||
_analysisVector.push_back(new ColorSingleAnalysis());
|
||||
//_analysisVector.push_back(new ColorSingleAnalysis());
|
||||
|
||||
_analysisVector.push_back(new ColorMultiAnalysis());
|
||||
//_analysisVector.push_back(new ColorMultiAnalysis());
|
||||
|
||||
_analysisVector.push_back(new DiffNoiseAnalysis());
|
||||
//_analysisVector.push_back(new DiffNoiseAnalysis());
|
||||
|
||||
//_currentAnalysisIndx = 0;
|
||||
//_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
|
||||
|
||||
//_state = ISTATE_START;
|
||||
_currentAnalysisIndx = 0;
|
||||
_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
|
||||
|
||||
_currentAnalysis = NULL;
|
||||
_state = ISTATE_UNDEF;
|
||||
_state = ISTATE_START;
|
||||
|
||||
}
|
||||
|
||||
@ -160,9 +161,7 @@ void RefractiveIndex::state_analysis()
|
||||
case ISTATE_TRANSITION:
|
||||
if(_currentAnalysisIndx >= _analysisVector.size()) {
|
||||
_currentAnalysisIndx = 0;
|
||||
_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
|
||||
_state = ISTATE_START;
|
||||
//_state = ISTATE_END;
|
||||
_state = ISTATE_END;
|
||||
} else {
|
||||
_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
|
||||
_state = ISTATE_START;
|
||||
@ -186,27 +185,18 @@ void RefractiveIndex::state_analysis()
|
||||
void RefractiveIndex::update()
|
||||
{
|
||||
state_analysis();
|
||||
|
||||
RefractiveIndex::_vidGrabber.grabFrame(); // get a new frame from the camera
|
||||
|
||||
if (_vidGrabber.isFrameNew())
|
||||
{
|
||||
_pixels = _vidGrabber.getPixelsRef(); //get ofPixels from the camera
|
||||
}
|
||||
}
|
||||
|
||||
void RefractiveIndex::draw()
|
||||
{
|
||||
// refractive mauve
|
||||
//ofBackground(113, 110, 136);
|
||||
|
||||
// black
|
||||
ofBackground(0, 0, 0);
|
||||
|
||||
//TODO: Needs to return to a black screen - not to exit...
|
||||
|
||||
// i.e.: operational sequence
|
||||
// 1) starts in a black screen
|
||||
// 2) we 'start' with keypress "s" the entire set of analyses
|
||||
// 3) at any point we need to be able to restart / stop-return-to-black / trigger each analysis individually
|
||||
// 4) should end in black screen as well
|
||||
// 5) final kill button
|
||||
|
||||
//ofRect(0,0,ofGetWidth(), ofGetHeight());
|
||||
|
||||
if(_currentAnalysis)
|
||||
_currentAnalysis->draw();
|
||||
}
|
||||
@ -215,19 +205,15 @@ void RefractiveIndex::setup_camera()
|
||||
{
|
||||
stop_camera();
|
||||
|
||||
_vidGrabber.setDeviceID(_vid_id);
|
||||
_vidGrabber.listDevices();
|
||||
|
||||
if(!_vidGrabber.initGrabber(_vid_w, _vid_h)) {
|
||||
ofLog(OF_LOG_ERROR) << "RefractiveIndex::setup_camera - could not initialise grabber";
|
||||
return;
|
||||
}
|
||||
|
||||
_vidGrabber.setVerbose(true);
|
||||
_vidGrabber.setUseTexture(false);
|
||||
_vidGrabber.listDevices();
|
||||
_vidGrabber.setVerbose(true);
|
||||
_vid_stream_open = true;
|
||||
cout << "CAMERA SETUP " << endl;
|
||||
return;
|
||||
_vidGrabber.setDeviceID(_vid_id);
|
||||
|
||||
}
|
||||
|
||||
@ -243,121 +229,6 @@ void RefractiveIndex::keyPressed (int key)
|
||||
{
|
||||
if( key =='f')
|
||||
ofToggleFullscreen();
|
||||
|
||||
/* TODO: complete the below... would be good to trigger the Analysis from keypresses if needed... */
|
||||
// currently this doesn't work... the save_cb's in the individual
|
||||
// tried to add a stop_analysis(); call but it blocks the whole programme
|
||||
|
||||
// i.e.: ask david how to shut off the prior Analysis if it's not finished running from here?
|
||||
|
||||
if(key == 'x')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysis = NULL;
|
||||
_state = ISTATE_UNDEF;
|
||||
}
|
||||
|
||||
else if(key == '1')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 0;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '2')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 1;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '3')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 2;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '4')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 3;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '5')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 4;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '6')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 5;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '7')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 6;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '8')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 7;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '9')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 8;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == '0')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 9;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
else if(key == 'q')
|
||||
{
|
||||
if(_currentAnalysis)
|
||||
_analysisAdapator->stop();
|
||||
_currentAnalysisIndx = 10;
|
||||
if(!_currentAnalysis)
|
||||
_state = ISTATE_TRANSITION;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
void RefractiveIndex::exit()
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
@ -8,7 +13,6 @@
|
||||
#include "AbstractAnalysis.h"
|
||||
#include "AnalysisAdaptor.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
class RefractiveIndex : public ofBaseApp
|
||||
{
|
||||
@ -62,4 +66,5 @@ public:
|
||||
// this should be in xml
|
||||
static string _location;
|
||||
|
||||
|
||||
};
|
||||
@ -1,27 +1,35 @@
|
||||
#include "ofAppGlutWindow.h"
|
||||
#include "RefractiveIndex.h"
|
||||
#include "ofxXmlSettings.h"
|
||||
|
||||
#define SCREEN_WIDTH 800
|
||||
#define SCREEN_HEIGHT 600
|
||||
/////////////////////////dis is the new shit///////////
|
||||
|
||||
/////////////////////////dis is the new shit///////////
|
||||
|
||||
/////////////////////////dis is the new shit///////////
|
||||
|
||||
/////////////////////////dis is the new shit///////////
|
||||
|
||||
|
||||
int main() {
|
||||
|
||||
ofAppGlutWindow window;
|
||||
|
||||
bool fullscreen;
|
||||
|
||||
//fullscreen = true;
|
||||
fullscreen = false;
|
||||
ofxXmlSettings XML;
|
||||
XML.loadFile("../data/config.refindx");
|
||||
bool fullscreen = (XML.getValue("config:display:fullscreen", "false") == "true" ? true : false);
|
||||
int screen_w = XML.getValue("config:display:width", SCREEN_WIDTH);
|
||||
int screen_h = XML.getValue("config:display:height", SCREEN_HEIGHT);
|
||||
|
||||
cout << "> display configuration" << endl;
|
||||
cout << "* fullscreen: " << (fullscreen ? "yes" : "no") << endl;
|
||||
|
||||
if(!fullscreen) {
|
||||
cout << "* screen width: " << SCREEN_WIDTH << endl;
|
||||
cout << "* screen height: " << SCREEN_HEIGHT << endl;
|
||||
cout << "* screen width: " << screen_w << endl;
|
||||
cout << "* screen height: " << screen_h << endl;
|
||||
}
|
||||
|
||||
ofSetupOpenGL(&window, SCREEN_WIDTH, SCREEN_HEIGHT, (fullscreen ? OF_FULLSCREEN : OF_WINDOW));
|
||||
ofSetupOpenGL(&window, screen_w, screen_h, (fullscreen ? OF_FULLSCREEN : OF_WINDOW));
|
||||
ofRunApp(new RefractiveIndex());
|
||||
|
||||
}
|
||||
|
||||
@ -1,28 +1,50 @@
|
||||
/* */
|
||||
/*
|
||||
- copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
|
||||
- all rights reserved.
|
||||
|
||||
+ redistribution and use in source and binary forms, with or without
|
||||
+ modification, are permitted provided that the following conditions
|
||||
+ are met:
|
||||
+ > redistributions of source code must retain the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer.
|
||||
+ > redistributions in binary form must reproduce the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer in
|
||||
+ the documentation and/or other materials provided with the
|
||||
+ distribution.
|
||||
|
||||
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
+ AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
||||
+ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
+ SUCH DAMAGE.
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "AbstractAnalysis.h"
|
||||
#include "RefractiveIndex.h"
|
||||
#include "ofxFileHelper.h"
|
||||
|
||||
|
||||
vector<ofMesh> AbstractAnalysis::meshes;
|
||||
|
||||
// this is the main threaded loop for a given analysis
|
||||
void AbstractAnalysis::do_synthesize() {
|
||||
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
cout << "i NUM_RUN" << i << endl;
|
||||
|
||||
_saved_filenames_analysis.clear();
|
||||
_state = STATE_ACQUIRING;
|
||||
acquire();
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_SYNTHESISING;
|
||||
synthesise();
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_DISPLAY_RESULTS;
|
||||
displayresults();
|
||||
}
|
||||
|
||||
exit:
|
||||
display_results();
|
||||
ofNotifyEvent(_synthesize_cb, _name);
|
||||
}
|
||||
|
||||
@ -49,29 +71,266 @@ void AbstractAnalysis::create_dir()
|
||||
}
|
||||
}
|
||||
|
||||
ofxFileHelper fileHelperAnalysis;
|
||||
ofxFileHelper fileHelperSynthesis;
|
||||
ofxFileHelper fileHelper;
|
||||
_whole_file_path = ofToDataPath("") + ANALYSIS_PATH + RefractiveIndex::_location + "/" + _name + "/"+replaceTime ;
|
||||
cout << "_whole_file_path = " << _whole_file_path << endl;
|
||||
|
||||
_whole_file_path_analysis = ANALYSIS_PATH + RefractiveIndex::_location + "/" + _name + "/"+replaceTime ;
|
||||
|
||||
//cout << "_whole_file_path_analysis = " << _whole_file_path_analysis << endl;
|
||||
|
||||
if(!fileHelperAnalysis.doesDirectoryExist(_whole_file_path_analysis)){
|
||||
fileHelperAnalysis.makeDirectory(ANALYSIS_PATH);
|
||||
fileHelperAnalysis.makeDirectory(ANALYSIS_PATH+RefractiveIndex::_location);
|
||||
fileHelperAnalysis.makeDirectory(ANALYSIS_PATH+RefractiveIndex::_location+"/"+_name);
|
||||
fileHelperAnalysis.makeDirectory(ANALYSIS_PATH+RefractiveIndex::_location+"/"+_name+"/"+replaceTime);
|
||||
}
|
||||
|
||||
_whole_file_path_synthesis = SYNTHESIS_PATH + RefractiveIndex::_location + "/" + _name + "/"+replaceTime;
|
||||
|
||||
if(!fileHelperSynthesis.doesDirectoryExist(_whole_file_path_synthesis)){
|
||||
fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH);
|
||||
fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH+RefractiveIndex::_location);
|
||||
fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH+RefractiveIndex::_location+"/"+_name);
|
||||
fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH+RefractiveIndex::_location+"/"+_name+"/"+replaceTime);
|
||||
if(!fileHelper.doesDirectoryExist(_whole_file_path)){
|
||||
fileHelper.makeDirectory(ANALYSIS_PATH);
|
||||
fileHelper.makeDirectory(ANALYSIS_PATH+RefractiveIndex::_location);
|
||||
fileHelper.makeDirectory(ANALYSIS_PATH+RefractiveIndex::_location+"/"+_name);
|
||||
fileHelper.makeDirectory(ANALYSIS_PATH+RefractiveIndex::_location+"/"+_name+"/"+replaceTime);
|
||||
}
|
||||
|
||||
//////////////////////////////END DIRECTORY CREATION //////////////////////////////////////////////////
|
||||
}
|
||||
ofPixels AbstractAnalysis::calculateListOfZValues(ofImage image1, ofImage image2, int whichComparison){
|
||||
//zScale is the mapping factor from pixel difference to shift on the zPlane
|
||||
int zScale=200;
|
||||
|
||||
ofPixels imagePixels1 = image1.getPixelsRef();
|
||||
ofPixels imagePixels2 = image2.getPixelsRef();
|
||||
|
||||
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];
|
||||
|
||||
//where are we in the image pixel array
|
||||
int x=0;
|
||||
int y=0;
|
||||
|
||||
//for each pixel...
|
||||
for(int i=0;i<imagePixels1.size();i+=3){
|
||||
|
||||
//get the colour of each image at this x y location - we will use these colours for comparison according to the below criteria
|
||||
ofColor colourImage1 = imagePixels1.getColor(x, y);
|
||||
ofColor colourImage2 = imagePixels2.getColor(x, y);
|
||||
|
||||
//COMPARE THIS PIXEL'S VALUES with the first image in the sequence
|
||||
int thisDiff;
|
||||
//compare Red
|
||||
if (whichComparison==1) {
|
||||
thisDiff=ofMap((colourImage1.r-colourImage2.r),-255,255,0,zScale);
|
||||
}
|
||||
//compare blue
|
||||
if (whichComparison==2) {
|
||||
thisDiff=ofMap((colourImage1.g-colourImage2.g),-255,255,0,zScale);
|
||||
}
|
||||
//compare green
|
||||
if (whichComparison==3) {
|
||||
thisDiff=ofMap((colourImage1.b-colourImage2.b),-255,255,0,zScale);
|
||||
}
|
||||
//compare hue
|
||||
if (whichComparison==4) {
|
||||
thisDiff=ofMap((colourImage1.getHue()-colourImage2.getHue()),-255,255,0,zScale);
|
||||
}
|
||||
//compare brightness
|
||||
if (whichComparison==5) {
|
||||
thisDiff=ofMap((colourImage1.getBrightness()-colourImage2.getBrightness()),-255,255,0,zScale);
|
||||
}
|
||||
thesePixels[i]=thisDiff;
|
||||
thesePixels[i+1]=thisDiff;
|
||||
thesePixels[i+2]=thisDiff;
|
||||
|
||||
x++;
|
||||
//new line
|
||||
if(x>imagePixels1.getWidth()){
|
||||
x=0;
|
||||
y++;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
|
||||
|
||||
return difference;
|
||||
|
||||
}
|
||||
|
||||
ofPixels AbstractAnalysis::calculateListOfZValues(ofImage image1, ofImage image2, int whichComparison, int colourValue){
|
||||
//zScale is the mapping factor from pixel difference to shift on the zPlane
|
||||
int zScale=200;
|
||||
|
||||
ofPixels imagePixels1 = image1.getPixelsRef();
|
||||
ofPixels imagePixels2 = image2.getPixelsRef();
|
||||
|
||||
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];
|
||||
|
||||
//where are we in the image pixel array
|
||||
int x=0;
|
||||
int y=0;
|
||||
|
||||
//for each pixel...
|
||||
//for(int i=0;i<imagePixels1.size();i+=3){
|
||||
for(int i=0;i<20;i+=3){
|
||||
|
||||
//get the colour of each image at this x y location - we will use these colours for comparison according to the below criteria
|
||||
ofColor colourImage1 = imagePixels1.getColor(x, y);
|
||||
ofColor colourImage2 = imagePixels2.getColor(x, y);
|
||||
|
||||
//COMPARE THIS PIXEL'S VALUES with the first image in the sequence
|
||||
int thisDiff;
|
||||
//compare Red
|
||||
if (whichComparison==1) {
|
||||
thisDiff=ofMap((colourImage1.r-colourImage2.r),-255,255,0,zScale);
|
||||
}
|
||||
//compare blue
|
||||
if (whichComparison==2) {
|
||||
thisDiff=ofMap((colourImage1.g-colourImage2.g),-255,255,0,zScale);
|
||||
}
|
||||
//compare green
|
||||
if (whichComparison==3) {
|
||||
thisDiff=ofMap((colourImage1.b-colourImage2.b),-255,255,0,zScale);
|
||||
}
|
||||
//compare hue
|
||||
if (whichComparison==4) {
|
||||
thisDiff=ofMap((colourImage1.getHue()-colourImage2.getHue()),-255,255,0,zScale);
|
||||
}
|
||||
//compare brightness
|
||||
if (whichComparison==5) {
|
||||
thisDiff=ofMap((colourImage1.getBrightness()-colourImage2.getBrightness()),-255,255,0,zScale);
|
||||
}
|
||||
thesePixels[i]=thisDiff;
|
||||
thesePixels[i+1]=thisDiff;
|
||||
thesePixels[i+2]=thisDiff;
|
||||
|
||||
x++;
|
||||
//new line
|
||||
if(x>imagePixels1.getWidth()){
|
||||
x=0;
|
||||
y++;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
|
||||
|
||||
return difference;
|
||||
|
||||
}
|
||||
|
||||
void AbstractAnalysis::setMeshFromPixels(ofPixels somePixels, ofImage currentSecondImage, ofMesh * someMesh){
|
||||
int x=0;
|
||||
int y=0;
|
||||
|
||||
//get rid of all previous vectors and colours - uncomment if re-setting the mesh on the fly - ie live rather than saving it first
|
||||
//someMesh->clear();
|
||||
|
||||
unsigned char * thesePixels =currentSecondImage.getPixels();
|
||||
|
||||
for(int i=0;i<somePixels.size();i+=3){
|
||||
someMesh->addVertex(ofVec3f(x,y,- somePixels.getColor(x, y).getBrightness() ));
|
||||
// add colour from current second image of two
|
||||
someMesh->addColor( currentSecondImage.getColor(x, y) );
|
||||
x++;
|
||||
if(x>somePixels.getWidth()){
|
||||
x=0;
|
||||
y++;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
vector<string>AbstractAnalysis:: getListOfImageFilePaths(string location, string whichAnalysis){
|
||||
|
||||
string path = ofToDataPath("")+"debug_analysis/"+location+"/"+whichAnalysis;
|
||||
//ofxDirList dirList;
|
||||
ofDirectory dirList;
|
||||
int numDirs = dirList.listDir(path);
|
||||
|
||||
vector<string>directoryNames;
|
||||
|
||||
//get the last folder alphabetically - this should probably change to do something fancy with date to find most recent but don't want to code that until we are sure
|
||||
string dirName=dirList.getName(numDirs-1);
|
||||
|
||||
|
||||
const char *results=dirName.c_str();
|
||||
|
||||
ofFile file=ofFile(path+"/"+dirName);
|
||||
vector<string>fileNamesToReturn;
|
||||
|
||||
|
||||
// get
|
||||
if(file.isDirectory()){
|
||||
dirList.listDir(path+"/"+dirName);
|
||||
//if there are no files, exit here
|
||||
if(dirList.size()==0){
|
||||
//if it's empty return an error warning
|
||||
fileNamesToReturn.push_back("NO FILE HERE!");
|
||||
cout<<"NO FILE HERE!";
|
||||
return fileNamesToReturn;
|
||||
}
|
||||
for (int i=0; i<dirList.size(); i++) {
|
||||
|
||||
string fname=dirList.getName(i);
|
||||
const char *results=fname.c_str();
|
||||
|
||||
//full path is what actually gets written into the vector
|
||||
string fullPath=path+"/"+dirName+"/"+fname;
|
||||
|
||||
|
||||
fileNamesToReturn.push_back(fullPath);
|
||||
}
|
||||
}
|
||||
else{
|
||||
cout<<"WARNING, DIRECTORY NOT FOUND";
|
||||
fileNamesToReturn.push_back("NO FILE HERE!");
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
return fileNamesToReturn;
|
||||
}
|
||||
int AbstractAnalysis::getRecordedValueFromFileName(string str){
|
||||
//split filename by underscore - there HAS to be a quicker way of doing things - its ONE LINE in java :(
|
||||
char * cstr, *p;
|
||||
vector<char *>tokens;
|
||||
//string str ("Please split this phrase into tokens");
|
||||
|
||||
//make char pointer array
|
||||
cstr = new char [str.size()+1];
|
||||
//copy string to char pointer array
|
||||
strcpy (cstr, str.c_str());
|
||||
|
||||
//tokenise char p array and put first results into pointer?
|
||||
p=strtok (cstr,"_");
|
||||
|
||||
while (p!=NULL)
|
||||
{
|
||||
p=strtok(NULL,"_");
|
||||
//push tokenised char into vector
|
||||
tokens.push_back(p);
|
||||
|
||||
}
|
||||
delete[] cstr;
|
||||
char *p1;
|
||||
//cstr = new char [str.size()+1];
|
||||
//strcpy (cstr, str.c_str());
|
||||
|
||||
p1=strtok (tokens[tokens.size()-2],".");
|
||||
|
||||
return ofToInt(p1);
|
||||
}
|
||||
|
||||
|
||||
void AbstractAnalysis::saveimage(string filename)
|
||||
{
|
||||
if(RefractiveIndex::_pixels.isAllocated()) {
|
||||
|
||||
string fname = _whole_file_path + "/" + filename;
|
||||
|
||||
cout << "saving - " << fname << endl;
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, fname, OF_IMAGE_QUALITY_BEST);
|
||||
|
||||
_saved_filenames.push_back(fname);
|
||||
|
||||
} else {
|
||||
ofLog(OF_LOG_ERROR) << "RefractiveIndex::_pixels NOT allocated...";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -10,13 +10,18 @@
|
||||
#include <string>
|
||||
|
||||
#define ANALYSIS_PATH "analysis/"
|
||||
#define SYNTHESIS_PATH "synthesis/"
|
||||
|
||||
#define STATE_ACQUIRING 0x1111
|
||||
#define STATE_SYNTHESISING 0x2222
|
||||
#define STATE_DISPLAY_RESULTS 0x3333
|
||||
#define STATE_STOP 0xDEADBEEF
|
||||
|
||||
#define COMPARE_RED 1
|
||||
#define COMPARE_BLUE 2
|
||||
#define COMPARE_GREEN 3
|
||||
#define COMPARE_HUE 4
|
||||
#define COMPARE_BRIGHTNESS 5
|
||||
|
||||
class AbstractAnalysis {
|
||||
|
||||
public:
|
||||
@ -25,16 +30,16 @@ public:
|
||||
|
||||
// generic function to set up the camera
|
||||
virtual void setup(int camWidth, int camHeight){_cam_w = camWidth; _cam_h = camHeight;}
|
||||
|
||||
// this is the main threaded loop for a given analysis
|
||||
void do_synthesize();
|
||||
|
||||
// show the results to the screen
|
||||
// ofx
|
||||
virtual void draw() = 0;
|
||||
|
||||
protected:
|
||||
|
||||
virtual void create_dir();
|
||||
virtual void saveimage(string filename);
|
||||
|
||||
// acquire images - all the children (see - do_synthesize)
|
||||
virtual void acquire() = 0;
|
||||
@ -42,8 +47,26 @@ protected:
|
||||
// analysis + synthesize images - all the children (see - do_synthesize)
|
||||
virtual void synthesise() = 0;
|
||||
|
||||
// display the results from disk
|
||||
virtual void displayresults() = 0;
|
||||
//added tom s 19/2 function runs a call back exactly like acquire.
|
||||
virtual void display_results() = 0;
|
||||
|
||||
//returns ofPixels which contain the color differences between the two images. Is overloaded to include comparison with values written in to file names for some analyses
|
||||
virtual ofPixels calculateListOfZValues(ofImage image1, ofImage image2, int whichComparison);
|
||||
virtual ofPixels calculateListOfZValues(ofImage image1, ofImage image2, int whichComparison, int colourValue);
|
||||
|
||||
//uses the returned pixels from make3DZmap to make a mesh of points whose Z positions are set by the brightness values in ofPixels - ofPixels is being used as a convenient container for a bunch of z coordinates
|
||||
virtual void setMeshFromPixels(ofPixels somePixels, ofImage currentSecondImage, ofMesh * someMesh);
|
||||
//HELPER FUNCTIONS
|
||||
|
||||
//this is purely for debug/viewing purposes and loads old images from middlesborough test
|
||||
virtual vector<string> getListOfImageFilePaths(string location, string whichAnalysis);
|
||||
|
||||
//splits up the filename and returns the recorded value eg brightness
|
||||
//EG FILENAME : DIFF_NOISE_7_85.7322.jpg RETURNS : 85.7322
|
||||
virtual int getRecordedValueFromFileName(string str);
|
||||
|
||||
static vector<ofMesh>meshes;
|
||||
|
||||
|
||||
public:
|
||||
string _name;
|
||||
@ -53,18 +76,22 @@ public:
|
||||
|
||||
protected:
|
||||
int _cam_w, _cam_h;
|
||||
string _whole_file_path_analysis, _whole_file_path_synthesis;
|
||||
vector<string> _saved_filenames_analysis;
|
||||
vector<string> _saved_filenames_synthesis;
|
||||
string _whole_file_path;
|
||||
vector<string> _saved_filenames;
|
||||
|
||||
int _state;
|
||||
|
||||
//int _run_cnt;
|
||||
|
||||
float DELTA_T_SAVE;
|
||||
int NUM_PHASE;
|
||||
int NUM_RUN;
|
||||
int NUM_SAVE_PER_RUN;
|
||||
|
||||
//added Tom S 19/2/12
|
||||
//each mesh in the vector is a seperate 3D point cloud which is coloured with pixel data and shifted in the z plane according to the specified type of colour difference eg red value or hue
|
||||
//make this vector were static
|
||||
//how fast to move from one mesh to the next
|
||||
float speed;
|
||||
//the index (inside the vector of meshes) of the current mesh being displayed
|
||||
float whichMesh;
|
||||
friend class AnalysisAdaptor;
|
||||
};
|
||||
@ -21,15 +21,12 @@ public:
|
||||
|
||||
void start()
|
||||
{
|
||||
_stopping = false;
|
||||
_runnable = new RunnableAdapter<AbstractAnalysis>(*_analysis, &AbstractAnalysis::do_synthesize);
|
||||
_worker.start(*_runnable);
|
||||
}
|
||||
|
||||
void stop()
|
||||
{
|
||||
if(_stopping) return;
|
||||
_stopping = true;
|
||||
_analysis->_state = STATE_STOP;
|
||||
_worker.join();
|
||||
}
|
||||
@ -38,6 +35,5 @@ protected:
|
||||
AbstractAnalysis* _analysis;
|
||||
Thread _worker; //
|
||||
RunnableAdapter<AbstractAnalysis>* _runnable;
|
||||
bool _stopping;
|
||||
};
|
||||
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "CamNoiseAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -13,50 +18,16 @@ using Poco::Thread;
|
||||
|
||||
void CamNoiseAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
DELTA_T_SAVE = 200;
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 1;
|
||||
NUM_SAVE_PER_RUN = 100;
|
||||
|
||||
NUM_RUN = 5;
|
||||
|
||||
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
|
||||
// or 5 times per second = every 200 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
create_dir();
|
||||
|
||||
_frame_cnt = 0;
|
||||
_run_cnt = 0;
|
||||
_synth_save_cnt = 0;
|
||||
|
||||
_frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
|
||||
c = 0;
|
||||
|
||||
int anim_time = 10; // 10 seconds
|
||||
_anim_cnt_max = anim_time*ofGetFrameRate(); // e.g.: 30 frames per second = 150 frames
|
||||
|
||||
//create_dir();
|
||||
|
||||
_show_image = false;
|
||||
_image_shown = false;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -64,118 +35,91 @@ void CamNoiseAnalysis::acquire()
|
||||
{
|
||||
|
||||
Timer* save_timer;
|
||||
|
||||
TimerCallback<CamNoiseAnalysis> save_callback(*this, &CamNoiseAnalysis::save_cb);
|
||||
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_run_cnt++;
|
||||
_RUN_DONE = false;
|
||||
create_dir();
|
||||
|
||||
// RUN ROUTINE
|
||||
// for(int i = 0; i < NUM_RUN; i++) {
|
||||
// _run_cnt = i;
|
||||
//cout << "RUN NUM = " << i;
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
_run_cnt = i;
|
||||
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
void CamNoiseAnalysis::synthesise()
|
||||
{
|
||||
//cout << "CamNoiseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
//if you want to see what this looks like with real data ignore the new filenames and load teh old ones.
|
||||
bool debug=true;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
//cout << "CamNoiseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//cout << "LOADED image1!!!" << endl;
|
||||
//if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
|
||||
cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
|
||||
|
||||
cvGrayImage1 = cvColorImage1;
|
||||
//cvGrayImage2 = cvColorImage2;
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
//cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
//cvGrayDiff1.erode();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
//cvGrayDiff1.blur(5);
|
||||
//cvGrayDiff1.dilate();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
|
||||
cvGrayImage1.threshold(255.0*i/_saved_filenames_analysis.size()); //random threshold for the moment
|
||||
cvGrayImage1.blur(10);
|
||||
cvGrayImage1.contrastStretch();
|
||||
cvGrayImage1.blur(10);
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_CamNoiseAnalysis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
//ofSaveImage(cvGrayDiff1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
|
||||
//}
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
cout<<"setting mesh"<<endl;
|
||||
int _recorded_hue_value=getRecordedValueFromFileName(_saved_filenames[i]);
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_HUE,_recorded_hue_value), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
}
|
||||
|
||||
void CamNoiseAnalysis::display_results(){
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<CamNoiseAnalysis> display_results_callback(*this, &CamNoiseAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=300;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
}
|
||||
|
||||
void CamNoiseAnalysis::displayresults()
|
||||
{
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
display_results_timer->stop();
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
//cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -196,48 +140,44 @@ void CamNoiseAnalysis::draw()
|
||||
ofColor aColour;
|
||||
|
||||
int _fade_in_frames = _frame_cnt_max/10;
|
||||
float _number_of_grey_levels=5;
|
||||
float _number_of_grey_levels=10;
|
||||
|
||||
float _frames_per_level = _frame_cnt_max / _number_of_grey_levels;
|
||||
ofColor someColor;
|
||||
|
||||
/*
|
||||
if (_frame_cnt < _fade_in_frames) {
|
||||
aColour.set(255, 255, 255, ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255));
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
//cout << "FADE IN STROBE TIME " << endl;
|
||||
}
|
||||
*/
|
||||
//if (_frame_cnt >= _fade_in_frames && _frame_cnt < (_frame_cnt_max)){
|
||||
|
||||
if (_frame_cnt >= _fade_in_frames && _frame_cnt < (_frame_cnt_max-_fade_in_frames)){
|
||||
|
||||
|
||||
for(int i=1;i<_number_of_grey_levels;i++){
|
||||
if ( _frame_cnt >= _frames_per_level*(i-1) && +_frame_cnt < _frames_per_level * (i+1) ) {
|
||||
for(int i=0;i<_number_of_grey_levels;i++){
|
||||
if (_frame_cnt>= _frames_per_level *( i-1) && +_frame_cnt < _frames_per_level * (i) ) {
|
||||
//set colour to current grey level
|
||||
c=255-( 255.0 * ( i /_number_of_grey_levels));
|
||||
//cout << "c: " << c << endl;
|
||||
someColor.set(c);
|
||||
}
|
||||
|
||||
ofSetColor(someColor);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
}
|
||||
|
||||
//}
|
||||
/*
|
||||
}
|
||||
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt < _frame_cnt_max) {
|
||||
aColour.set(0, 0, 0, ofMap(_frame_cnt-(_frame_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255));
|
||||
aColour.set(0, 0, 0, 255-ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255));
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
// cout << "FADE OUT STROBE TIME " << endl;
|
||||
}
|
||||
*/
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
|
||||
} else {
|
||||
// _state = STATE_SYNTHESISING;
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
@ -249,118 +189,37 @@ void CamNoiseAnalysis::draw()
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
//cout << "CamNoiseAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
//cout << "CamNoiseAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
//cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
//cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
_RUN_DONE = true;
|
||||
//_state = STATE_DISPLAY_RESULTS;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
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
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
// display results of the synthesis
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
cout<<whichMesh<<" size of meshes "<<meshes.size()<<endl;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -373,20 +232,16 @@ 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";
|
||||
saveimage(file_name);
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
//if(_save_cnt >= NUM_SAVE_PER_RUN)
|
||||
// _RUN_DONE = true;
|
||||
|
||||
}
|
||||
void CamNoiseAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
@ -9,9 +9,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
|
||||
class CamNoiseAnalysis : public AbstractAnalysis
|
||||
{
|
||||
public:
|
||||
@ -23,41 +20,17 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
bool _RUN_DONE;
|
||||
int _run_cnt, _save_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _results_cnt, _results_cnt_max;
|
||||
|
||||
int _run_cnt, _save_cnt, _synth_save_cnt,_anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
@ -1,3 +1,35 @@
|
||||
/*
|
||||
- copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
|
||||
- all rights reserved.
|
||||
|
||||
+ redistribution and use in source and binary forms, with or without
|
||||
+ modification, are permitted provided that the following conditions
|
||||
+ are met:
|
||||
+ > redistributions of source code must retain the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer.
|
||||
+ > redistributions in binary form must reproduce the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer in
|
||||
+ the documentation and/or other materials provided with the
|
||||
+ distribution.
|
||||
|
||||
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
+ AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
||||
+ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
+ SUCH DAMAGE.
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "ColorMultiAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -10,211 +42,135 @@ using Poco::TimerCallback;
|
||||
using Poco::Thread;
|
||||
|
||||
|
||||
|
||||
void ColorMultiAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
DELTA_T_SAVE = 100;//150; // the right number is about 300
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 1;
|
||||
NUM_SAVE_PER_RUN = 100;//;
|
||||
|
||||
NUM_RUN = 5;
|
||||
|
||||
int acq_run_time = 35;
|
||||
|
||||
DELTA_T_SAVE = 1*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
|
||||
// or 10 times per second = every 100 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
|
||||
//create_dir();
|
||||
|
||||
create_dir();
|
||||
_frame_cnt = 0;
|
||||
_run_cnt = 0;
|
||||
_synth_save_cnt = 0;
|
||||
_fade_cnt=0;
|
||||
_frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
|
||||
c = 0;
|
||||
|
||||
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;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
void ColorMultiAnalysis::acquire()
|
||||
{
|
||||
|
||||
Timer* save_timer;
|
||||
|
||||
TimerCallback<ColorMultiAnalysis> save_callback(*this, &ColorMultiAnalysis::save_cb);
|
||||
|
||||
_run_cnt++;
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_RUN_DONE = false;
|
||||
create_dir();
|
||||
|
||||
// RUN ROUTINE
|
||||
//for(int i = 0; i < NUM_RUN; i++) {
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
// _run_cnt = i;
|
||||
_run_cnt = i;
|
||||
|
||||
//cout << "RUN NUM = " << i;
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
}
|
||||
|
||||
//}
|
||||
}
|
||||
|
||||
void ColorMultiAnalysis::synthesise()
|
||||
{
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
//cout << "ColorMultiAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "ColorMultiAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//cout << "LOADED image1!!!" << endl;
|
||||
//if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
|
||||
//cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
//cvGrayImage1 = cvColorImage1;
|
||||
//cvGrayImage2 = cvColorImage2;
|
||||
|
||||
//cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
//cvGrayDiff1.erode();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
//cvGrayDiff1.blur(5);
|
||||
//cvGrayDiff1.dilate();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
|
||||
cvColorImage1.contrastStretch();
|
||||
cvColorImage1.blur(5);
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.dilate();
|
||||
cvColorImage1.blur(5);
|
||||
cvColorImage1.dilate();
|
||||
cvColorImage1.dilate();
|
||||
cvColorImage1.dilate();
|
||||
cvColorImage1.dilate();
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvColorImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
|
||||
// }
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[0]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
cout<<"setting mesh"<<endl;
|
||||
meshes.push_back(ofMesh());
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_HUE), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
void ColorMultiAnalysis::display_results(){
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<ColorMultiAnalysis> display_results_callback(*this, &ColorMultiAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=500;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
display_results_timer->stop();
|
||||
|
||||
}
|
||||
|
||||
void ColorMultiAnalysis::displayresults()
|
||||
{
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
//cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void ColorMultiAnalysis::draw()
|
||||
{
|
||||
|
||||
switch (_state) {
|
||||
case STATE_ACQUIRING:
|
||||
{
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
if (_frame_cnt < _frame_cnt_max)
|
||||
{
|
||||
|
||||
|
||||
int _fade_in_frames = _frame_cnt_max/50;
|
||||
ofColor aColor;
|
||||
|
||||
if (_frame_cnt < _fade_in_frames) {
|
||||
|
||||
ofColor aColor;
|
||||
|
||||
aColor.setHsb(c, ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255), ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255));
|
||||
|
||||
ofSetColor(aColor);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
//cout << "FADING IN..." << endl;
|
||||
cout << "FADING IN..." << endl;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (_frame_cnt >= _fade_in_frames && _frame_cnt < _frame_cnt_max-_fade_in_frames){
|
||||
|
||||
ofColor aColor;
|
||||
aColor.setHsb(c, 255, 255);
|
||||
ofSetColor(aColor);
|
||||
|
||||
@ -224,26 +180,28 @@ void ColorMultiAnalysis::draw()
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
}
|
||||
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt <= _frame_cnt_max) {
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt < _frame_cnt_max) {
|
||||
|
||||
aColor.set(c, c, c, 255-int(ofMap(_frame_cnt-(_frame_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255)));
|
||||
ofColor aColor;
|
||||
|
||||
//aColor.setHsb(c, 255-ofMap(_fade_cnt- (_frame_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255), 255-(ofMap(_fade_cnt-(_frame_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255)));
|
||||
aColor.setHsb(c, 255-ofMap(_fade_cnt, 0, _fade_in_frames, 0, 255), 255-ofMap(_fade_cnt, 0, _fade_in_frames, 0, 255));
|
||||
|
||||
ofSetColor(aColor);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
//cout << "FADING OUT..." << endl;
|
||||
|
||||
_fade_cnt++;
|
||||
cout << "FADING OUT..." << endl;
|
||||
|
||||
}
|
||||
|
||||
|
||||
} else {
|
||||
//_state = STATE_SYNTHESISING;
|
||||
|
||||
_RUN_DONE = true;
|
||||
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
@ -251,116 +209,31 @@ void ColorMultiAnalysis::draw()
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
//cout << "ColorMultiAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
//cout << "ColorMultiAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
//cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
//cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
_state = STATE_DISPLAY_RESULTS;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
//image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -375,24 +248,19 @@ void ColorMultiAnalysis::draw()
|
||||
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";
|
||||
// cout << "COLORMULTIANALYSIS::saving...\n";
|
||||
|
||||
string file_name = ofToString(_save_cnt,2)+"_"+ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
saveimage(file_name);
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
|
||||
_save_cnt++;
|
||||
|
||||
}
|
||||
|
||||
void ColorMultiAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -4,9 +4,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
|
||||
class ColorMultiAnalysis : public AbstractAnalysis
|
||||
{
|
||||
public:
|
||||
@ -18,41 +15,15 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
bool _RUN_DONE;
|
||||
|
||||
int _run_cnt, _save_cnt, _fade_cnt, _synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
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;
|
||||
|
||||
int _run_cnt, _save_cnt, _fade_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _results_cnt, _results_cnt_max;
|
||||
};
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "ColorSingleAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -13,54 +18,20 @@ using Poco::Thread;
|
||||
|
||||
void ColorSingleAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
DELTA_T_SAVE = 100;//300;
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 1;
|
||||
NUM_SAVE_PER_RUN = 100;
|
||||
|
||||
NUM_RUN = 5;
|
||||
|
||||
int acq_run_time = 25; // 20 seconds of acquiring per run
|
||||
|
||||
DELTA_T_SAVE = 1*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
|
||||
// or 10 times per second = every 100 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
|
||||
//create_dir();
|
||||
|
||||
_run_cnt = 0;
|
||||
create_dir();
|
||||
_frame_cnt = 0;
|
||||
_synth_save_cnt = 0;
|
||||
c = 0;
|
||||
|
||||
int anim_time = 10; // 10 seconds
|
||||
_anim_cnt_max = anim_time*ofGetFrameRate(); // e.g.: 30 frames per second = 150 frames
|
||||
|
||||
_frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
|
||||
r = 0;
|
||||
g = 0;
|
||||
b = 0;
|
||||
|
||||
_fade_cnt=0;
|
||||
fileNameTag = "";
|
||||
|
||||
_show_image = false;
|
||||
_image_shown = false;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
@ -71,127 +42,94 @@ void ColorSingleAnalysis::acquire()
|
||||
|
||||
TimerCallback<ColorSingleAnalysis> save_callback(*this, &ColorSingleAnalysis::save_cb);
|
||||
|
||||
_run_cnt++;
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_RUN_DONE = false;
|
||||
create_dir();
|
||||
|
||||
// RUN ROUTINE
|
||||
//for(int i = 0; i < NUM_RUN; i++) {
|
||||
// _run_cnt = i;
|
||||
//cout << "RUN NUM = " << i;
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
_run_cnt = i;
|
||||
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
void ColorSingleAnalysis::synthesise()
|
||||
{
|
||||
// _saved_filenames has all the file names of all the saved images
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
//cout << "ColorSingleAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "ColorSingleAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//cout << "LOADED image1!!!" << endl;
|
||||
//if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
|
||||
//cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
//cvGrayImage1 = cvColorImage1;
|
||||
//cvGrayImage2 = cvColorImage2;
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
|
||||
//cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
//cvGrayDiff1.erode();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
//cvGrayDiff1.blur(5);
|
||||
//cvGrayDiff1.dilate();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
|
||||
cvColorImage1.contrastStretch();
|
||||
cvColorImage1.blur(5);
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.dilate();
|
||||
cvColorImage1.blur(5);
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.erode();
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_ColorSingleAnalysis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvColorImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
|
||||
// }
|
||||
if(i<_saved_filenames.size()/3){
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_RED), image2, &meshes[index]);
|
||||
}
|
||||
if(i>=_saved_filenames.size()/3 && i<2* _saved_filenames.size()/3){
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_GREEN), image2, &meshes[index]);
|
||||
}
|
||||
if(i>= 2* _saved_filenames.size()/3 && i<_saved_filenames.size()){
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_BLUE), image2, &meshes[index]);
|
||||
}
|
||||
index++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
void ColorSingleAnalysis::display_results(){
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<ColorSingleAnalysis> display_results_callback(*this, &ColorSingleAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=500;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
}
|
||||
|
||||
void ColorSingleAnalysis::displayresults()
|
||||
{
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
//cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
display_results_timer->stop();
|
||||
|
||||
}
|
||||
|
||||
|
||||
void ColorSingleAnalysis::draw()
|
||||
{
|
||||
|
||||
@ -241,8 +179,8 @@ void ColorSingleAnalysis::draw()
|
||||
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt < _frame_cnt_max){
|
||||
|
||||
int fade = ofMap(_fade_cnt, 0, _fade_in_frames, 0, 255);
|
||||
ofSetColor(0, 0, 255-fade);
|
||||
ofSetColor(0, 0, 255-ofMap(_fade_cnt, 0, _fade_in_frames, 0, 255));
|
||||
cout << "255-ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255)"<< 255-ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255) << endl;
|
||||
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
_fade_cnt++;
|
||||
@ -250,7 +188,6 @@ void ColorSingleAnalysis::draw()
|
||||
}
|
||||
|
||||
} else {
|
||||
//_state = STATE_SYNTHESISING;
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
@ -262,119 +199,32 @@ void ColorSingleAnalysis::draw()
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
//cout << "ColorSingleAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
// cout << "ColorSingleAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
//cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
//cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
_RUN_DONE = true;
|
||||
//_state = STATE_DISPLAY_RESULTS;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
//image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
|
||||
default:
|
||||
@ -386,24 +236,22 @@ void ColorSingleAnalysis::draw()
|
||||
// this runs at save_cb timer rate = DELTA_T_SAVE
|
||||
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";
|
||||
saveimage(file_name);
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
_save_cnt++;
|
||||
|
||||
//if(_save_cnt >= NUM_SAVE_PER_RUN)
|
||||
// _RUN_DONE = true;
|
||||
|
||||
}
|
||||
void ColorSingleAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -9,9 +9,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
|
||||
class ColorSingleAnalysis : public AbstractAnalysis
|
||||
{
|
||||
public:
|
||||
@ -23,43 +20,16 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
bool _RUN_DONE;
|
||||
string fileNameTag;
|
||||
float r,g,b;
|
||||
|
||||
int _run_cnt, _save_cnt, _fade_cnt, _synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
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;
|
||||
|
||||
int _run_cnt, _save_cnt, _fade_cnt;
|
||||
float r,g,b, _frame_cnt, _frame_cnt_max , _results_cnt, _results_cnt_max;
|
||||
};
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "DiffNoiseAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -13,183 +18,109 @@ using Poco::Thread;
|
||||
|
||||
void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
DELTA_T_SAVE = 600; // right number is about 450
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 1;
|
||||
NUM_SAVE_PER_RUN = 50;
|
||||
|
||||
NUM_RUN = 5;
|
||||
|
||||
int acq_run_time = 20; // 20 seconds of acquiring per run
|
||||
|
||||
DELTA_T_SAVE = 1*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
|
||||
// or 10 times per second = every 100 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
|
||||
//create_dir();
|
||||
|
||||
_run_cnt = 0;
|
||||
create_dir();
|
||||
_fade_cnt=0;
|
||||
_frame_cnt = 0;
|
||||
_synth_save_cnt = 0;
|
||||
_frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
|
||||
c = 0;
|
||||
|
||||
int anim_time = 10; // 10 seconds
|
||||
_anim_cnt_max = anim_time*ofGetFrameRate(); // e.g.: 30 frames per second = 150 frames
|
||||
|
||||
_show_image = false;
|
||||
_image_shown = false;
|
||||
|
||||
//for an ofxOpenCv.h image i would like to use..."
|
||||
//image3.allocate(RefractiveIndex::_vid_w, RefractiveIndex::_vid_h);
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
void DiffNoiseAnalysis::acquire()
|
||||
{
|
||||
|
||||
Timer* save_timer;
|
||||
|
||||
TimerCallback<DiffNoiseAnalysis> save_callback(*this, &DiffNoiseAnalysis::save_cb);
|
||||
|
||||
_run_cnt++;
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_RUN_DONE = false;
|
||||
create_dir();
|
||||
|
||||
// RUN ROUTINE
|
||||
//for(int i = 0; i < NUM_RUN; i++) {
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
// _run_cnt = i;
|
||||
//cout << "RUN NUM = " << i;
|
||||
_run_cnt = i;
|
||||
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
//}
|
||||
}
|
||||
}
|
||||
|
||||
void DiffNoiseAnalysis::synthesise()
|
||||
{
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
//cout << "DiffNoiseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "DiffNoiseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//cout << "LOADED image1!!!" << endl;
|
||||
//if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
|
||||
//cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
|
||||
|
||||
//cvGrayImage1 = cvColorImage1;
|
||||
//cvGrayImage2 = cvColorImage2;
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
//cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
//cvGrayDiff1.erode();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
//cvGrayDiff1.blur(5);
|
||||
//cvGrayDiff1.dilate();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
|
||||
cvColorImage1.contrastStretch();
|
||||
cvColorImage1.invert();
|
||||
cvColorImage1.blur(5);
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.blur(5);
|
||||
cvColorImage1.erode();
|
||||
cvColorImage1.contrastStretch();
|
||||
|
||||
//////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_DiffNoiseAnalysis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvColorImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
|
||||
// }
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
cout<<"setting mesh"<<endl;
|
||||
int _recorded_brightness_value=getRecordedValueFromFileName(_saved_filenames[i]);
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_HUE,_recorded_brightness_value), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
}
|
||||
|
||||
void DiffNoiseAnalysis::display_results(){
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<DiffNoiseAnalysis> display_results_callback(*this, &DiffNoiseAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=300;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
}
|
||||
display_results_timer->stop();
|
||||
|
||||
void DiffNoiseAnalysis::displayresults()
|
||||
{
|
||||
}// this runs at frame rate = 33 ms for 30 FPS
|
||||
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
//cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
// this runs at frame rate = 33 ms for 30 FPS
|
||||
void DiffNoiseAnalysis::draw()
|
||||
{
|
||||
switch (_state) {
|
||||
@ -218,12 +149,12 @@ void DiffNoiseAnalysis::draw()
|
||||
}
|
||||
}
|
||||
|
||||
//cout << "FADING IN..." << endl;
|
||||
cout << "FADING IN..." << endl;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (_frame_cnt >= _fade_in_frames && _frame_cnt <= (_frame_cnt_max-_fade_in_frames)){
|
||||
if (_frame_cnt >= _fade_in_frames && _frame_cnt < (_frame_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=1; i < ofGetHeight() ; i=i+rectSize)
|
||||
{
|
||||
@ -239,27 +170,29 @@ void DiffNoiseAnalysis::draw()
|
||||
}
|
||||
|
||||
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt <= _frame_cnt_max) {
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt < _frame_cnt_max) {
|
||||
|
||||
for (int i=1; i < ofGetHeight() ; i=i+rectSize)
|
||||
{
|
||||
for (int j=1; j < ofGetWidth(); j=j+rectSize)
|
||||
{
|
||||
c = ofRandom(0,255);
|
||||
aColour.set(c, c, c, 255-ofMap(_frame_cnt-(_frame_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255));
|
||||
aColour.set(c, c, c, 255-ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255));
|
||||
ofSetColor(aColour);
|
||||
ofRect(j, i, rectSize, rectSize);
|
||||
}
|
||||
}
|
||||
|
||||
//_fade_cnt++;
|
||||
//cout << "FADING OUT..." << endl;
|
||||
_fade_cnt++;
|
||||
cout << "FADING OUT..." << endl;
|
||||
|
||||
}
|
||||
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
} else {
|
||||
// _state = STATE_SYNTHESISING;
|
||||
|
||||
_RUN_DONE = true;
|
||||
|
||||
}
|
||||
@ -272,146 +205,73 @@ void DiffNoiseAnalysis::draw()
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
//cout << "DiffNoiseAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
//cout << "DiffNoiseAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
//cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
//cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
|
||||
_RUN_DONE = true;
|
||||
//_state = STATE_DISPLAY_RESULTS;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
//image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
// display results of the synthesis
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
cout<<whichMesh<<" size of meshes "<<meshes.size()<<endl;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
|
||||
}
|
||||
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// this runs at save_cb timer rate = DELTA_T_SAVE
|
||||
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;
|
||||
}
|
||||
float rand10 = ofRandom(0,10);
|
||||
|
||||
//cout << "DiffNoiseAnalysis::saving...\n";
|
||||
if (rand10 > 5.0) {
|
||||
|
||||
cout << "DiffNoiseAnalysis::saving...\n";
|
||||
cout << "c_last... " << c << endl;
|
||||
cout<<"rand10... " <<rand10<<endl;
|
||||
|
||||
string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
saveimage(file_name);
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
}
|
||||
|
||||
_save_cnt++;
|
||||
|
||||
//if(_save_cnt >= NUM_SAVE_PER_RUN)
|
||||
// _RUN_DONE = true;
|
||||
|
||||
}
|
||||
void DiffNoiseAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -9,9 +9,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
|
||||
class DiffNoiseAnalysis : public AbstractAnalysis
|
||||
{
|
||||
public:
|
||||
@ -23,40 +20,16 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
bool _RUN_DONE;
|
||||
int _run_cnt, _save_cnt, _fade_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _results_cnt, _results_cnt_max;
|
||||
|
||||
int _run_cnt, _save_cnt, _fade_cnt, _synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "IResponseAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -10,51 +15,19 @@ using Poco::Timer;
|
||||
using Poco::TimerCallback;
|
||||
using Poco::Thread;
|
||||
|
||||
|
||||
|
||||
void IResponseAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
DELTA_T_SAVE = 100;
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 1;
|
||||
NUM_SAVE_PER_RUN = 100;
|
||||
|
||||
NUM_RUN = 5;
|
||||
|
||||
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
|
||||
// or 10 times per second = every 100 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
|
||||
//create_dir();
|
||||
_synth_save_cnt = 0;
|
||||
_run_cnt = 0;
|
||||
create_dir();
|
||||
_frame_cnt = 0;
|
||||
_frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
|
||||
c = 0;
|
||||
|
||||
int anim_time = 10; // 10 seconds
|
||||
_anim_cnt_max = anim_time*ofGetFrameRate(); // e.g.: 30 frames per second = 150 frames
|
||||
|
||||
_show_image = false;
|
||||
_image_shown = false;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -62,120 +35,94 @@ void IResponseAnalysis::acquire()
|
||||
{
|
||||
|
||||
Timer* save_timer;
|
||||
|
||||
TimerCallback<IResponseAnalysis> save_callback(*this, &IResponseAnalysis::save_cb);
|
||||
|
||||
_run_cnt++;
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_RUN_DONE = false;
|
||||
create_dir();
|
||||
|
||||
// RUN ROUTINE
|
||||
//for(int i = 0; i < NUM_RUN; i++) {
|
||||
//_run_cnt = i;
|
||||
//cout << "RUN NUM = " << i;
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
_run_cnt = i;
|
||||
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
//}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void IResponseAnalysis::synthesise()
|
||||
{
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//cout << "LOADED image1!!!" << endl;
|
||||
if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
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();
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_IResponseSynthesis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvGrayDiff1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
cout<<"setting mesh"<<endl;
|
||||
int _recorded_brightness_value=getRecordedValueFromFileName(_saved_filenames[i]);
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_BRIGHTNESS,_recorded_brightness_value), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
void IResponseAnalysis::display_results(){
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<IResponseAnalysis> display_results_callback(*this, &IResponseAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=300;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
display_results_timer->stop();
|
||||
|
||||
}
|
||||
|
||||
|
||||
void IResponseAnalysis::displayresults()
|
||||
{
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
//cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// this runs at frame rate = 33 ms for 30 FPS
|
||||
void IResponseAnalysis::draw()
|
||||
{
|
||||
@ -184,18 +131,9 @@ void IResponseAnalysis::draw()
|
||||
|
||||
case STATE_ACQUIRING:
|
||||
{
|
||||
ofEnableAlphaBlending();
|
||||
ofColor aColour;
|
||||
int _fade_in_frames = _frame_cnt_max/10;
|
||||
//cout<< "_fade_in_frames" << _fade_in_frames<< endl;
|
||||
|
||||
if (_frame_cnt < _fade_in_frames) {
|
||||
|
||||
aColour.set(255, 255, 255, ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255));
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
}
|
||||
/// *** TODO *** ///
|
||||
// still need to deal with latency frames here - i.e.: there are frames
|
||||
/// *** TODO *** ///
|
||||
|
||||
if (_frame_cnt < _frame_cnt_max)
|
||||
{
|
||||
@ -203,18 +141,9 @@ void IResponseAnalysis::draw()
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
c = 255.0 * (_frame_cnt_max*_frame_cnt_max - _frame_cnt*_frame_cnt)/(_frame_cnt_max*_frame_cnt_max);
|
||||
} else {
|
||||
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt < _frame_cnt_max) {
|
||||
aColour.set(0, 0, 0, ofMap(_frame_cnt-(_frame_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255));
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
// cout << "FADE OUT STROBE TIME " << endl;
|
||||
}
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
_frame_cnt++;
|
||||
|
||||
break;
|
||||
@ -222,120 +151,38 @@ void IResponseAnalysis::draw()
|
||||
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
// cout << "IResponse = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
//cout << "IResponse STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
//cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
//cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
|
||||
_RUN_DONE = true;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
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
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
cout<<whichMesh<<" size of meshes "<<meshes.size()<<endl;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
@ -345,21 +192,21 @@ void IResponseAnalysis::draw()
|
||||
// this runs at save_cb timer rate = DELTA_T_SAVE
|
||||
void IResponseAnalysis::save_cb(Timer& timer)
|
||||
{
|
||||
//cout << "IResponseAnalysis::saving...\n";
|
||||
//cout << "c_last... " << c << endl;
|
||||
string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
saveimage(file_name);
|
||||
|
||||
_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;
|
||||
//if(_save_cnt >= NUM_SAVE_PER_RUN)
|
||||
// _RUN_DONE = true;
|
||||
}
|
||||
void IResponseAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
//cout << "IResponseAnalysis::saving...\n";
|
||||
|
||||
string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
}
|
||||
|
||||
@ -9,8 +9,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
class IResponseAnalysis : public AbstractAnalysis
|
||||
{
|
||||
public:
|
||||
@ -22,40 +20,17 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
bool _RUN_DONE;
|
||||
int _run_cnt, _save_cnt, _synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
int _run_cnt, _save_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _results_cnt, _results_cnt_max;
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "RelaxRateAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -13,162 +18,112 @@ using Poco::Thread;
|
||||
|
||||
void RelaxRateAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
NUM_RUN = 5;
|
||||
DELTA_T_SAVE = 130;
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 3;
|
||||
NUM_SAVE_PER_RUN = 100;
|
||||
|
||||
int acq_run_time = 20; // 20 seconds of acquiring per run
|
||||
create_dir();
|
||||
|
||||
DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
|
||||
// or 10 times per second = every 100 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
|
||||
//create_dir();
|
||||
|
||||
_run_cnt = 0;
|
||||
_level = 0;
|
||||
_flip = 1;
|
||||
_frame_cnt = 0;
|
||||
_frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
|
||||
c = 0;
|
||||
_synth_save_cnt = 0;
|
||||
|
||||
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;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
|
||||
void RelaxRateAnalysis::acquire()
|
||||
{
|
||||
|
||||
Timer* save_timer;
|
||||
|
||||
TimerCallback<RelaxRateAnalysis> save_callback(*this, &RelaxRateAnalysis::save_cb);
|
||||
|
||||
_run_cnt++;
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_RUN_DONE = false;
|
||||
|
||||
create_dir();
|
||||
|
||||
// RUN ROUTINE
|
||||
//for(int i = 0; i < NUM_RUN; i++) {
|
||||
//_run_cnt = i;
|
||||
//cout << "RUN NUM = " << i;
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
_run_cnt = i;
|
||||
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void RelaxRateAnalysis::synthesise()
|
||||
{
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
/*
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
//cout << "IResponseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//cout << "LOADED image1!!!" << endl;
|
||||
if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
|
||||
cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
|
||||
|
||||
cvGrayImage1 = cvColorImage1;
|
||||
cvGrayImage2 = cvColorImage2;
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
cvGrayDiff1.erode();
|
||||
cvGrayDiff1.contrastStretch();
|
||||
cvGrayDiff1.blur(5);
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_RelaxRateAnalysis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvGrayDiff1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
}
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
cout<<"setting mesh"<<endl;
|
||||
int _recorded_brightness_value=getRecordedValueFromFileName(_saved_filenames[i]);
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_BRIGHTNESS,_recorded_brightness_value), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
}
|
||||
void RelaxRateAnalysis::display_results(){
|
||||
|
||||
/*
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<RelaxRateAnalysis> display_results_callback(*this, &RelaxRateAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=300;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
}
|
||||
|
||||
void RelaxRateAnalysis::displayresults()
|
||||
{
|
||||
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
//cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
|
||||
display_results_timer->stop();
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
@ -201,12 +156,13 @@ void RelaxRateAnalysis::draw()
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
cout << "RELAXRATE RUN COMPLETED" << endl;
|
||||
//_state = STATE_SYNTHESISING;
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
//cout << "_frame_cnt:" << _frame_cnt << endl;
|
||||
cout << "_frame_cnt:" << _frame_cnt << endl;
|
||||
|
||||
break;
|
||||
}
|
||||
@ -214,146 +170,67 @@ void RelaxRateAnalysis::draw()
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
//cout << "RelaxRateAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
//cout << "ShadowScapesAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
//cout << "ShadowScapesAnalysis STATE_SYNTHESIZING = MIDDLE OF ANIMATION...\n";
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
cout << "_anim_cnt = " << _anim_cnt << endl;
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
//cout << "ShadowScapesAnalysis STATE_SYNTHESIZING = FADE OUT OF ANIMATION...\n";
|
||||
|
||||
//cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
//cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
//cout << "c_anim = " << c_anim << endl;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
_RUN_DONE = true;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
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
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
// display results of the synthesis
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
cout<<whichMesh<<" size of meshes "<<meshes.size()<<endl;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
|
||||
}
|
||||
*/
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
// this runs at save_cb timer rate = DELTA_T_SAVE
|
||||
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";
|
||||
|
||||
//cout << "c_last... " << c << endl;
|
||||
string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
saveimage(file_name);
|
||||
|
||||
_save_cnt++;
|
||||
|
||||
|
||||
//if(_save_cnt >= NUM_SAVE_PER_RUN)
|
||||
// _RUN_DONE = true;
|
||||
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
}
|
||||
void RelaxRateAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,3 +1,7 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
@ -5,7 +9,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
class RelaxRateAnalysis : public AbstractAnalysis
|
||||
{
|
||||
@ -18,42 +21,17 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
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;
|
||||
|
||||
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;
|
||||
int _run_cnt, _save_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _results_cnt, _results_cnt_max;
|
||||
|
||||
};
|
||||
|
||||
@ -1,3 +1,35 @@
|
||||
/*
|
||||
- copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
|
||||
- all rights reserved.
|
||||
|
||||
+ redistribution and use in source and binary forms, with or without
|
||||
+ modification, are permitted provided that the following conditions
|
||||
+ are met:
|
||||
+ > redistributions of source code must retain the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer.
|
||||
+ > redistributions in binary form must reproduce the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer in
|
||||
+ the documentation and/or other materials provided with the
|
||||
+ distribution.
|
||||
|
||||
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
+ AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
||||
+ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
+ SUCH DAMAGE.
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "ShadowScapesAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -5,8 +37,6 @@
|
||||
#include "Poco/Thread.h"
|
||||
#include "RefractiveIndex.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
using Poco::Timer;
|
||||
using Poco::TimerCallback;
|
||||
using Poco::Thread;
|
||||
@ -16,214 +46,121 @@ using Poco::Thread;
|
||||
|
||||
void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
NUM_RUN = 5;
|
||||
|
||||
int acq_run_time = 15; // 10 seconds of acquiring per run
|
||||
|
||||
int screenSpan;
|
||||
if (_dir == V) screenSpan = ofGetHeight();
|
||||
if (_dir == H) screenSpan = ofGetWidth();
|
||||
if (_dir == D) screenSpan = ofGetHeight();
|
||||
|
||||
_step = (screenSpan/acq_run_time)/(ofGetFrameRate());
|
||||
// pixel per frame = (pixels / sec) / (frame / sec)
|
||||
|
||||
// 40 pixels per second should give us a 20 second scan at 800 pixels wide
|
||||
|
||||
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
|
||||
|
||||
//create_dir(); // this makes both synth and analysis folder structures
|
||||
DELTA_T_SAVE = 100;
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 1;
|
||||
NUM_SAVE_PER_RUN = 100;
|
||||
|
||||
create_dir();
|
||||
_speed = 900.0; // 900.0 is the correct number
|
||||
_scanLineWidth = 100.0;
|
||||
_run_cnt = 0;
|
||||
_save_cnt = 0;
|
||||
_synth_save_cnt = 0;
|
||||
|
||||
int anim_time = 10; // 10 seconds
|
||||
_anim_cnt_max = anim_time*ofGetFrameRate(); // e.g.: 30 frames per second = 150 frames
|
||||
|
||||
_show_image = false;
|
||||
_image_shown = false;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
void ShadowScapesAnalysis::acquire()
|
||||
{
|
||||
int w;
|
||||
if (_dir == V) w = ofGetHeight();
|
||||
if (_dir == H) w = ofGetWidth();
|
||||
if (_dir == D) w = ofGetHeight();
|
||||
|
||||
_step = ((w/_speed) * 1000.0) / 500.0;
|
||||
_line = 0;
|
||||
|
||||
// RUN ROUTINE
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
Timer save_timer(0, DELTA_T_SAVE);
|
||||
TimerCallback<ShadowScapesAnalysis> save_callback(*this, &ShadowScapesAnalysis::save_cb);
|
||||
|
||||
_run_cnt++;
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_line = 0;
|
||||
_RUN_DONE = false;
|
||||
|
||||
create_dir();
|
||||
|
||||
//cout << "RUN NUM = " << i;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
save_timer.start(save_callback);
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer.stop();
|
||||
|
||||
//}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
void ShadowScapesAnalysis::synthesise()
|
||||
{
|
||||
//cout << "ShadowScapesAnalysis::saving synthesis...\n";
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
// cout << "ShadowScapesAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
// cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
///////////////////////// 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);
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
cvGrayImage1 = cvColorImage1;
|
||||
cvGrayImage2 = cvColorImage2;
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
|
||||
cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
cvGrayDiff1.erode();
|
||||
cvGrayDiff1.contrastStretch();
|
||||
cvGrayDiff1.blur(5);
|
||||
cvGrayDiff1.dilate();
|
||||
cvGrayDiff1.contrastStretch();
|
||||
string fnamei = _saved_filenames[i];
|
||||
string fnameii = _saved_filenames[i + 1];
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
bool l1 = image1.loadImage(_saved_filenames[i]);
|
||||
bool l2 = image2.loadImage(_saved_filenames[i+1]);
|
||||
|
||||
if(_dir == H) {
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_H_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
cout<<"setting mesh"<<endl;
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_BRIGHTNESS), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
|
||||
if(_dir == V) {
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_V_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
image1.clear();
|
||||
image2.clear();
|
||||
}
|
||||
|
||||
if(_dir == D) {
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_D_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
}
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvGrayDiff1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
void ShadowScapesAnalysis::display_results(){
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
Timer* display_results_timer;
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
TimerCallback<ShadowScapesAnalysis> display_results_callback(*this, &ShadowScapesAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=300;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
}
|
||||
|
||||
|
||||
void ShadowScapesAnalysis::displayresults()
|
||||
{
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
// cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// 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;
|
||||
display_results_timer->stop();
|
||||
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
|
||||
// the animation draw - and the output draw
|
||||
void ShadowScapesAnalysis::draw()
|
||||
{
|
||||
@ -294,22 +231,24 @@ void ShadowScapesAnalysis::draw()
|
||||
}
|
||||
|
||||
|
||||
if(_dir == V && int(_line) >= (ofGetHeight()+4*_scanLineWidth)){
|
||||
//cout << "VERTICAL IS DONE - _line >= (ofGetHeight()+4*_scanLineWidth) is TRUE" << endl;
|
||||
_RUN_DONE = true;
|
||||
|
||||
if(_dir == V && int(_line) >= (ofGetHeight()+4*_scanLineWidth)){
|
||||
cout << "VERTICAL IS DONE - _line >= (ofGetHeight()+4*_scanLineWidth) is TRUE" << endl;
|
||||
//_state = STATE_SYNTHESISING;
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
if(_dir == H && int(_line) >= (ofGetWidth()+4*_scanLineWidth)) {
|
||||
|
||||
//cout << "HORIZONTAL IS DONE - _line >= (ofGetWidth()+4*_scanLineWidth)) is TRUE" << endl;
|
||||
//_state = STATE_SYNTHESISING;
|
||||
_RUN_DONE = true;
|
||||
|
||||
}
|
||||
|
||||
if(_dir == D && int(_line) >= (1.5*ofGetHeight()+4*_scanLineWidth)) {
|
||||
//cout << "DIAGONAL IS DONE - _line >= (1.5*ofGetHeight()+4*_scanLineWidth)) is TRUE" << endl;
|
||||
|
||||
//_state = STATE_SYNTHESISING;
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
@ -318,141 +257,35 @@ void ShadowScapesAnalysis::draw()
|
||||
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// cout << "ShadowScapesAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
// cout << "ShadowScapesAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
_RUN_DONE = true;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
// cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
//cvGrayDiff1.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
|
||||
// THE OLD SHIT
|
||||
/*
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
ofSetColor(255, 255, 255, 200);
|
||||
image3.setFromPixels(image1.getPixels(),image1.width,image1.height, OF_IMAGE_COLOR);
|
||||
image4.setFromPixels(image2.getPixels(),image2.width,image2.height, OF_IMAGE_COLOR);
|
||||
|
||||
cvColorImage1.setFromPixels(image3.getPixels(), image3.width, image3.height);
|
||||
cvColorImage2.setFromPixels(image4.getPixels(), image4.width, image4.height);
|
||||
|
||||
cvGrayImage1 = cvColorImage1;
|
||||
cvGrayImage2 = cvColorImage2;
|
||||
|
||||
cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
cvGrayDiff1.contrastStretch();
|
||||
cvGrayDiff1.dilate();
|
||||
|
||||
cvGrayDiff1.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
*/
|
||||
|
||||
//image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
}
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
// display results of the synthesis
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
cout<<whichMesh<<" size of meshes "<<meshes.size()<<endl;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
@ -466,19 +299,15 @@ void ShadowScapesAnalysis::draw()
|
||||
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";
|
||||
|
||||
cout << "ShadowScapesAnalysis::saving...\n";
|
||||
string file_name;
|
||||
|
||||
if(_dir == H) {
|
||||
@ -493,8 +322,15 @@ void ShadowScapesAnalysis::save_cb(Timer& timer)
|
||||
file_name = ofToString(_save_cnt, 2)+"_D_"+ofToString(_line, 2)+"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
}
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
saveimage(file_name);
|
||||
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
_save_cnt++;
|
||||
|
||||
}
|
||||
void ShadowScapesAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,4 +1,34 @@
|
||||
/* */
|
||||
/*
|
||||
- copyright (c) 2011 Copenhagen Institute of Interaction Design (CIID)
|
||||
- all rights reserved.
|
||||
|
||||
+ redistribution and use in source and binary forms, with or without
|
||||
+ modification, are permitted provided that the following conditions
|
||||
+ are met:
|
||||
+ > redistributions of source code must retain the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer.
|
||||
+ > redistributions in binary form must reproduce the above copyright
|
||||
+ notice, this list of conditions and the following disclaimer in
|
||||
+ the documentation and/or other materials provided with the
|
||||
+ distribution.
|
||||
|
||||
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
+ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
+ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
||||
+ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
||||
+ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||||
+ BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||||
+ OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||||
+ AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
||||
+ OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
||||
+ OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
+ SUCH DAMAGE.
|
||||
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
@ -6,8 +36,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
enum shadow_type {
|
||||
H, V, D,
|
||||
};
|
||||
@ -24,11 +52,11 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
@ -38,32 +66,7 @@ protected:
|
||||
float _scanLineWidth; // pix per second
|
||||
float _step;
|
||||
shadow_type _dir;
|
||||
int _run_cnt, _save_cnt, _synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
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;
|
||||
int _run_cnt, _save_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _results_cnt, _results_cnt_max;
|
||||
|
||||
};
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "ShapeFromShadingAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -10,65 +15,43 @@ using Poco::Timer;
|
||||
using Poco::TimerCallback;
|
||||
using Poco::Thread;
|
||||
|
||||
|
||||
void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
NUM_RUN = 5;
|
||||
DELTA_T_SAVE = 300;
|
||||
NUM_PHASE = 1;
|
||||
NUM_RUN = 1;
|
||||
NUM_SAVE_PER_RUN = 100;
|
||||
|
||||
int acq_run_time = 20; // 20 seconds of acquiring per run
|
||||
create_dir();
|
||||
|
||||
DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
|
||||
// or 10 times per second = every 100 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
|
||||
//create_dir();
|
||||
_synth_save_cnt = 0;
|
||||
_run_cnt = 0;
|
||||
_level = 0;
|
||||
_flip = 1;
|
||||
_frame_cnt = 0;
|
||||
|
||||
_frame_cnt_max = ofGetFrameRate() * ((DELTA_T_SAVE * NUM_SAVE_PER_RUN) / 1000);
|
||||
c = 0;
|
||||
|
||||
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;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
void ShapeFromShadingAnalysis::acquire()
|
||||
{
|
||||
|
||||
Timer* save_timer;
|
||||
|
||||
TimerCallback<ShapeFromShadingAnalysis> save_callback(*this, &ShapeFromShadingAnalysis::save_cb);
|
||||
|
||||
_run_cnt++;
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0, _synth_save_cnt = 0;
|
||||
_RUN_DONE = false;
|
||||
create_dir();
|
||||
// RUN ROUTINE
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
_run_cnt = i;
|
||||
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
_animation_cnt1 = 0;
|
||||
_animation_cnt2 = 0;
|
||||
_animation_cnt3 = 0;
|
||||
@ -87,108 +70,76 @@ void ShapeFromShadingAnalysis::acquire()
|
||||
_animation_cnt16 = 0;
|
||||
_animation_reset = false; // coundn't get this to work - so using seperate counters - shitty!
|
||||
|
||||
// RUN ROUTINE
|
||||
//for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
// _run_cnt = i;
|
||||
|
||||
//cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
|
||||
save_timer->start(save_callback);
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
// }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void ShapeFromShadingAnalysis::synthesise()
|
||||
{
|
||||
// cout << "ShapeFromShadingAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
// cout << "ShapeFromShadingAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
// cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
// cout << "LOADED image1!!!" << endl;
|
||||
if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
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();
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_ShapeFromShadingSynthesis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvGrayDiff1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
cout<<"setting mesh"<<endl;
|
||||
int _recorded_brightness_value=getRecordedValueFromFileName(_saved_filenames[i]);
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_BRIGHTNESS,_recorded_brightness_value), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
void ShapeFromShadingAnalysis::display_results(){
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<ShapeFromShadingAnalysis> display_results_callback(*this, &ShapeFromShadingAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=300;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
}
|
||||
display_results_timer->stop();
|
||||
|
||||
void ShapeFromShadingAnalysis::displayresults()
|
||||
{
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
// cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// this runs at frame rate = 33 ms for 30 FPS
|
||||
@ -203,10 +154,23 @@ void ShapeFromShadingAnalysis::draw()
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
|
||||
int _quarter_frame_cnt_max = _frame_cnt_max/4;
|
||||
int _half_frame_cnt_max = _frame_cnt_max/2;
|
||||
int _threequarters_frame_cnt_max = 3*_frame_cnt_max/4;
|
||||
|
||||
//TODO: put in CROSS FADES, ETC§E
|
||||
|
||||
/*
|
||||
if (_animation_reset == true)
|
||||
{
|
||||
_animation_cnt1 = 0;
|
||||
_animation_cnt2 = 0;
|
||||
_animation_cnt3 = 0;
|
||||
_animation_cnt4 = 0;
|
||||
}
|
||||
*/
|
||||
|
||||
if(_frame_cnt < _quarter_frame_cnt_max) {
|
||||
|
||||
quad = "QUAD1";
|
||||
@ -347,6 +311,10 @@ void ShapeFromShadingAnalysis::draw()
|
||||
_animation_cnt12++;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -398,10 +366,6 @@ void ShapeFromShadingAnalysis::draw()
|
||||
}
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
} else {
|
||||
//_state = STATE_SYNTHESISING;
|
||||
_frame_cnt = 0;
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
@ -413,117 +377,33 @@ void ShapeFromShadingAnalysis::draw()
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
// cout << "RelaxRateAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
//cout << "ShadowScapesAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
//cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
//cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
_RUN_DONE = true;
|
||||
//_state = STATE_DISPLAY_RESULTS;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
// cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
// cout << "_show_image...\n" << endl;
|
||||
|
||||
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
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
cout<<whichMesh<<" size of meshes "<<meshes.size()<<endl;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
@ -537,22 +417,23 @@ void ShapeFromShadingAnalysis::draw()
|
||||
// this runs at save_cb timer rate = DELTA_T_SAVE
|
||||
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";
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
saveimage(file_name);
|
||||
|
||||
_save_cnt++;
|
||||
|
||||
//if(_save_cnt >= NUM_SAVE_PER_RUN)
|
||||
// _RUN_DONE = true;
|
||||
|
||||
}
|
||||
void ShapeFromShadingAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -9,8 +9,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
|
||||
class ShapeFromShadingAnalysis : public AbstractAnalysis
|
||||
{
|
||||
@ -23,16 +21,18 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
string quad;
|
||||
bool _RUN_DONE;
|
||||
float _flip, _level;
|
||||
int _run_cnt, _save_cnt;
|
||||
int _animation_cnt1;
|
||||
int _animation_cnt2;
|
||||
int _animation_cnt3;
|
||||
@ -50,32 +50,6 @@ protected:
|
||||
int _animation_cnt15;
|
||||
int _animation_cnt16;
|
||||
int _animation_reset; // this reset part didn't get working - so using 16 different counters! yay!
|
||||
float c, _frame_cnt, _frame_cnt_max, _results_cnt, _results_cnt_max;
|
||||
|
||||
int _run_cnt, _save_cnt, _synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
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;
|
||||
};
|
||||
|
||||
@ -1,3 +1,8 @@
|
||||
/*
|
||||
~ author: dviid
|
||||
~ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "StrobeAnalysis.h"
|
||||
#include "ofMain.h"
|
||||
|
||||
@ -12,49 +17,20 @@ using Poco::Thread;
|
||||
|
||||
void StrobeAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
NUM_RUN = 5;
|
||||
DELTA_T_SAVE = 100;
|
||||
NUM_RUN = 1;
|
||||
|
||||
int acq_run_time = 25; // 20 seconds of acquiring per run
|
||||
|
||||
DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 100 files
|
||||
// or 5 times per second = every 200 ms
|
||||
|
||||
_frame_cnt_max = acq_run_time*ofGetFrameRate(); // e.g.: 30 frames per second * 20 seconds = 600 frames
|
||||
|
||||
_strobe_interval = 1750; //every 1 seconds, or every thirty frames 30 frames
|
||||
_strobe_cnt = 0;
|
||||
_strobe_cnt_max = 20; // 40 x 500 ms = 20000 ms = 20 seconds run time
|
||||
_strobe_interval = 1000; //every 0.5seconds = 15 frames
|
||||
_frame_cnt_max = _strobe_cnt_max * _strobe_interval * ofGetFrameRate()/1000;
|
||||
|
||||
// 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();
|
||||
_synth_save_cnt = 0;
|
||||
_run_cnt = 0;
|
||||
|
||||
int anim_time = 5; // 5 seconds for the animation
|
||||
_anim_cnt_max = anim_time*ofGetFrameRate(); // e.g.: 30 frames per second = 150 frames
|
||||
|
||||
_show_image = false;
|
||||
_image_shown = false;
|
||||
|
||||
// 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
|
||||
|
||||
// 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;
|
||||
|
||||
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);
|
||||
//or 20 times, every one second...
|
||||
_save_cnt_max = _strobe_cnt_max*_strobe_interval/DELTA_T_SAVE;
|
||||
|
||||
create_dir();
|
||||
}
|
||||
|
||||
|
||||
@ -62,124 +38,94 @@ void StrobeAnalysis::acquire()
|
||||
{
|
||||
|
||||
Timer* save_timer;
|
||||
|
||||
TimerCallback<StrobeAnalysis> save_callback(*this, &StrobeAnalysis::save_cb);
|
||||
|
||||
_frame_cnt = 0; _save_cnt = 0; _anim_cnt = 0; _strobe_cnt = 0, _synth_save_cnt = 0;
|
||||
_run_cnt++;
|
||||
_RUN_DONE = false;
|
||||
create_dir();
|
||||
|
||||
// RUN ROUTINE
|
||||
//for(int i = 0; i < NUM_RUN; i++) {
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
//_run_cnt = i;
|
||||
_run_cnt = i;
|
||||
_save_cnt = 0;
|
||||
_frame_cnt = 0;
|
||||
|
||||
//cout << "RUN NUM = " << i;
|
||||
cout << "RUN NUM = " << i;
|
||||
|
||||
save_timer = new Timer(0, DELTA_T_SAVE); // timing interval for saving files
|
||||
save_timer->start(save_callback);
|
||||
_RUN_DONE = false;
|
||||
_frame_cnt = 0; _save_cnt = 0;
|
||||
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
|
||||
//}
|
||||
}
|
||||
}
|
||||
|
||||
void StrobeAnalysis::synthesise()
|
||||
{
|
||||
// cout << "StrobeAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//incrementer to whichMesh
|
||||
speed=0.2;
|
||||
//whichMesh is the index in the vector of meshes
|
||||
whichMesh=0;
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
int index=0;
|
||||
float iterator=1;
|
||||
bool debug=false;
|
||||
if(debug){
|
||||
_saved_filenames.clear();
|
||||
_saved_filenames=getListOfImageFilePaths("MIDDLESBOROUGH", _name);
|
||||
|
||||
// cout << "StrobeAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
// cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
//couldn't load image
|
||||
// cout << "didn't load image" << endl;
|
||||
//hack to limit number of meshes.
|
||||
if(_saved_filenames.size()>100){
|
||||
iterator= _saved_filenames.size() /100;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
// cout << "LOADED image1!!!" << endl;
|
||||
//if(image5.loadImage(_saved_filenames_analysis[i+1])){
|
||||
}
|
||||
//clear vector so we don't add to it on successive runs
|
||||
meshes.clear();
|
||||
|
||||
///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
|
||||
for(float i=0;i<_saved_filenames.size()-1;i+=iterator){
|
||||
|
||||
cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
|
||||
cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
|
||||
|
||||
cvGrayImage1 = cvColorImage1;
|
||||
//cvGrayImage2 = cvColorImage2;
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
|
||||
//cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
|
||||
//cvGrayDiff1.erode();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
//cvGrayDiff1.blur(5);
|
||||
//cvGrayDiff1.dilate();
|
||||
//cvGrayDiff1.contrastStretch();
|
||||
|
||||
cvGrayImage1.contrastStretch();
|
||||
cvGrayImage1.blur(10);
|
||||
cvGrayImage1.dilate();
|
||||
|
||||
/////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
|
||||
string file_name;
|
||||
|
||||
file_name = ofToString(_synth_save_cnt, 2)+"_StrobeAnalysis_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
//image4.setFromPixels(cvColorImage1.getPixelsRef(),image3.width, image3.height, OF_IMAGE_COLOR);
|
||||
|
||||
ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
//ofSaveImage(cvGrayDiff1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
|
||||
_synth_save_cnt++;
|
||||
|
||||
//}
|
||||
//there is a known issue with using loadImage inside classes in other directories. the fix is to call setUseTExture(false)
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(false);
|
||||
//some of the textures are not loading correctly so only make mesh if both the images load
|
||||
if(image1.loadImage(_saved_filenames[i]) && image2.loadImage(_saved_filenames[i+1])){
|
||||
meshes.push_back(ofMesh());
|
||||
cout<<"setting mesh"<<endl;
|
||||
int _recorded_brightness_value=getRecordedValueFromFileName(_saved_filenames[i]);
|
||||
setMeshFromPixels( calculateListOfZValues(image1,image2, COMPARE_BRIGHTNESS,_recorded_brightness_value), image2, &meshes[index]);
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
}
|
||||
|
||||
void StrobeAnalysis::display_results(){
|
||||
|
||||
Timer* display_results_timer;
|
||||
|
||||
TimerCallback<StrobeAnalysis> display_results_callback(*this, &StrobeAnalysis::display_results_cb);
|
||||
// display results of the synthesis
|
||||
|
||||
display_results_timer = new Timer(0, 20); // timing interval for saving files
|
||||
display_results_timer->start(display_results_callback);
|
||||
_RUN_DONE = false;
|
||||
_results_cnt=0;
|
||||
_results_cnt_max=300;
|
||||
|
||||
while(!_RUN_DONE)
|
||||
Thread::sleep(3);
|
||||
}
|
||||
|
||||
void StrobeAnalysis::displayresults()
|
||||
{
|
||||
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
// cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//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;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
display_results_timer->stop();
|
||||
|
||||
}
|
||||
|
||||
|
||||
// this runs at frame rate = 33 ms for 30 FPS
|
||||
void StrobeAnalysis::draw()
|
||||
{
|
||||
@ -193,7 +139,7 @@ void StrobeAnalysis::draw()
|
||||
ofEnableAlphaBlending();
|
||||
ofColor aColour;
|
||||
int _fade_in_frames = _frame_cnt_max/10;
|
||||
// cout<< "_fade_in_frames" << _fade_in_frames<< endl;
|
||||
cout<< "_fade_in_frames" << _fade_in_frames<< endl;
|
||||
|
||||
if (_frame_cnt < _fade_in_frames) {
|
||||
|
||||
@ -211,13 +157,13 @@ void StrobeAnalysis::draw()
|
||||
//cout << "frame_cnt % 15: " << _frame_cnt%15 << endl;
|
||||
//cout << "MAIN STROBE TIME " << endl;
|
||||
|
||||
if (int(_frame_cnt)%int(ofGetFrameRate()*_strobe_interval/1000) < (ofGetFrameRate()*_strobe_interval/1000)/2)
|
||||
if (_frame_cnt%int(ofGetFrameRate()*_strobe_interval/1000) < (ofGetFrameRate()*_strobe_interval/1000)/2)
|
||||
{
|
||||
ofSetColor(255, 255, 255);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
_strobe_cnt++;
|
||||
_strobe_on = 1;
|
||||
} else if (int(_frame_cnt)%int(ofGetFrameRate()*_strobe_interval/1000) >= (ofGetFrameRate()*_strobe_interval/1000)/2)
|
||||
} else if (_frame_cnt%int(ofGetFrameRate()*_strobe_interval/1000) >= (ofGetFrameRate()*_strobe_interval/1000)/2)
|
||||
{
|
||||
ofSetColor(0, 0, 0);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
@ -227,7 +173,7 @@ void StrobeAnalysis::draw()
|
||||
}
|
||||
|
||||
if (_frame_cnt >= (_frame_cnt_max-_fade_in_frames) && _frame_cnt < _frame_cnt_max) {
|
||||
aColour.set(255, 255, 255, 255-ofMap(_frame_cnt-(_frame_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255));
|
||||
aColour.set(255, 255, 255, 255-ofMap(_frame_cnt, 0, _fade_in_frames, 0, 255));
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, ofGetWidth(), ofGetHeight());
|
||||
// cout << "FADE OUT STROBE TIME " << endl;
|
||||
@ -235,7 +181,6 @@ void StrobeAnalysis::draw()
|
||||
|
||||
ofDisableAlphaBlending();
|
||||
} else {
|
||||
//_state = STATE_SYNTHESISING;
|
||||
_RUN_DONE = true;
|
||||
}
|
||||
|
||||
@ -247,117 +192,33 @@ void StrobeAnalysis::draw()
|
||||
case STATE_SYNTHESISING:
|
||||
{
|
||||
// display animation of something while the synthesis in on-going...
|
||||
|
||||
// cout << "StrobeAnalysis = STATE_SYNTHESISING...\n";
|
||||
|
||||
// display animation of something while the synthesis in on-going...
|
||||
ofEnableAlphaBlending();
|
||||
ofSetRectMode(OF_RECTMODE_CENTER);
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
|
||||
if(_anim_cnt < _anim_cnt_max){
|
||||
|
||||
ofColor aColour;
|
||||
int rectSizeW = ofGetWidth()/4;
|
||||
int rectSizeH = ofGetHeight()/4;
|
||||
int _fade_in_frames = _anim_cnt_max/2;
|
||||
|
||||
int c_anim = 10;
|
||||
int fade;
|
||||
|
||||
//ofRotate(ofMap(_anim_cnt/2.0, 0, _anim_cnt_max, 0, 360));
|
||||
|
||||
if (_anim_cnt < _fade_in_frames) {
|
||||
// cout << "StrobeAnalysis STATE_SYNTHESIZING = FADING IN ANIMATION...\n";
|
||||
|
||||
fade = ofMap(_anim_cnt, 0, _fade_in_frames, 0, 255);
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 0+17*i;
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, fade);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt >= _fade_in_frames && _anim_cnt <= (_anim_cnt_max-_fade_in_frames)){
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
c_anim = 255;
|
||||
aColour.set(c_anim, c_anim, c_anim, 255);
|
||||
ofSetColor(aColour);
|
||||
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
}
|
||||
|
||||
if (_anim_cnt > (_anim_cnt_max-_fade_in_frames) && _anim_cnt <= _anim_cnt_max) {
|
||||
|
||||
// cout << "_anim_cnt = " << _anim_cnt-(_anim_cnt_max-_fade_in_frames) << endl;
|
||||
fade = ofMap(_anim_cnt-(_anim_cnt_max-_fade_in_frames), 0, _fade_in_frames, 0, 255);
|
||||
// cout << "fade down = " << fade << endl;
|
||||
|
||||
for (int i=0; i <= 15; i++){
|
||||
|
||||
c_anim = (17*i);
|
||||
|
||||
aColour.set(c_anim, c_anim, c_anim, 255-fade);
|
||||
ofSetColor(aColour);
|
||||
ofRect(0, 0, rectSizeW+10*i, rectSizeH+10*i);
|
||||
ofRect(0, 0, rectSizeW-10*i, rectSizeH-10*i);
|
||||
}
|
||||
|
||||
}
|
||||
_anim_cnt++;
|
||||
|
||||
} else {
|
||||
_RUN_DONE = true;
|
||||
//_state = STATE_DISPLAY_RESULTS;
|
||||
_anim_cnt=0;
|
||||
}
|
||||
ofPopMatrix();
|
||||
ofSetRectMode(OF_RECTMODE_CORNER);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
// cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
// cout << "_show_image...\n" << endl;
|
||||
|
||||
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
|
||||
_RUN_DONE = true;
|
||||
int imageWidth=640;
|
||||
int imageHeight =480;
|
||||
ofPushMatrix();
|
||||
ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
|
||||
ofRotateY(_results_cnt*0.3);
|
||||
//ofRotateX(90);
|
||||
//ofRotateZ(whichMesh);
|
||||
ofTranslate(-ofGetWidth()/2, -ofGetHeight()/2),-400;
|
||||
ofTranslate((ofGetWidth()/2)-(imageWidth/2),0,0 );
|
||||
|
||||
meshes[whichMesh].drawVertices();
|
||||
ofPopMatrix();
|
||||
whichMesh+=speed;
|
||||
cout<<whichMesh<<" size of meshes "<<meshes.size()<<endl;
|
||||
if(whichMesh>meshes.size() -1 || whichMesh<0){
|
||||
speed*=-1;
|
||||
whichMesh+=speed;
|
||||
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -370,22 +231,27 @@ void StrobeAnalysis::draw()
|
||||
// this runs at save_cb timer rate = DELTA_T_SAVE
|
||||
void StrobeAnalysis::save_cb(Timer& timer)
|
||||
{
|
||||
string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(_strobe_on) +"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
saveimage(file_name);
|
||||
|
||||
_save_cnt++;
|
||||
|
||||
RefractiveIndex::_vidGrabber.grabFrame(); // get a new frame from the camera
|
||||
cout << "_save_cnt" << _save_cnt << endl;
|
||||
|
||||
if (RefractiveIndex::_vidGrabber.isFrameNew())
|
||||
{
|
||||
RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
cout << "_save_cnt_max" << _save_cnt_max << endl;
|
||||
|
||||
//cout << "StrobeAnalysis::saving...\n";
|
||||
|
||||
string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(_strobe_on) +"_"+ofToString(_run_cnt,2)+".jpg";
|
||||
|
||||
ofSaveImage(RefractiveIndex::_pixels, _whole_file_path_analysis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
|
||||
_saved_filenames_analysis.push_back(_whole_file_path_analysis+"/"+file_name);
|
||||
//TODO: something fucked here with my calc of _save_cnt_max - new structure should fix it?
|
||||
//if(_save_cnt >= _save_cnt_max-10) {
|
||||
// _RUN_DONE = true;
|
||||
//}
|
||||
|
||||
}
|
||||
|
||||
void StrobeAnalysis::display_results_cb(Timer& timer){
|
||||
_results_cnt++;
|
||||
if (_results_cnt>_results_cnt_max) {
|
||||
_RUN_DONE=true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -9,8 +9,6 @@
|
||||
|
||||
#include "Poco/Timer.h"
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
|
||||
|
||||
class StrobeAnalysis : public AbstractAnalysis
|
||||
{
|
||||
@ -23,46 +21,21 @@ public:
|
||||
void setup(int camWidth, int camHeight);
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
|
||||
void display_results();
|
||||
void draw();
|
||||
|
||||
void save_cb(Poco::Timer& timer);
|
||||
void display_results_cb(Poco::Timer& timer);
|
||||
|
||||
protected:
|
||||
|
||||
bool _RUN_DONE;
|
||||
int _strobe_cnt, _strobe_cnt_max;
|
||||
int _strobe_cnt, _run_cnt, _strobe_cnt_max;
|
||||
int _save_cnt;
|
||||
|
||||
int _frame_cnt, _frame_cnt_max, _save_cnt_max ;
|
||||
float _results_cnt, _results_cnt_max;
|
||||
|
||||
int _strobe_interval;
|
||||
bool _strobe_on;
|
||||
|
||||
int _run_cnt, _save_cnt,_synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user