/home/fwph/code/wurde/modules/visionModule/Operators/ImageWriter.cpp

Go to the documentation of this file.

#include "ImageWriter.H"
#include <Logger.H>
#include <string>
#include <opencv/cv.h>
#include <opencv/highgui.h>

using namespace std;
using namespace WURDE;
using namespace WURDEVision;

ImageWriter::ImageWriter(std::string name) : VisionOperator(name) {

}

void ImageWriter::initOperator() {
       // Potentially add two image saving threads here so that this operator doesn't
       // hold things up too badly.

       t1state=STATE_RUN;
       t2state=STATE_RUN;
       t3state=STATE_RUN;

       m_newt1image=false;
       m_newt2image=false;
       m_newt3image=false;

       m_t1image=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 3);
       m_t2image=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 3);
       m_t3image=cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 3);

       pthread_create(&thread1,NULL,runImageWriterThread1,(void *)this);
       pthread_create(&thread2,NULL,runImageWriterThread2,(void *)this);
       pthread_create(&thread3,NULL,runImageWriterThread3,(void *)this);

       if(g_globalConfiguration.haveModuleOption(m_name,"imageDir")){
              m_imageDir=g_globalConfiguration.getModuleOption(m_name,"imageDir");
       }else{
              m_imageDir=g_globalConfiguration.getDataDirectory();
       }

       if(g_globalConfiguration.haveModuleOption(m_name,"imagePrefix")){
              m_imagePrefix=g_globalConfiguration.getModuleOption(m_name,"imagePrefix");
       }else{
              m_imagePrefix=m_name;
       }

       m_state=STATE_RUN;
       m_format=FORMAT_CHAR_111_RGB;
       m_stereo=false;
       next=1;
}

void ImageWriter::runOperator(WURDEImage mImage) {
       
       if(next==1){
              if(!m_newt1image){                
                     g_debug("Checkpoint 1");     
                     if(m_t1image->width!=mImage.second->width||
                        m_t1image->height!=mImage.second->height){
                            m_t1image=NULL;
                            m_t1image=cvCreateImage(cvSize(mImage.second->width, mImage.second->height), IPL_DEPTH_8U, 3);
                     }

                     t1time=mImage.first;
                     // memcpy(m_t1image->imageData,mImage.second->imageData,3*mImage.second->height*mImage.second->width);
                     cvConvertImage(mImage.second,m_t1image,CV_CVTIMG_SWAP_RB);
                     next=2;

                     m_newt1image=true;
              }
       }else if (next==2){
              if(!m_newt2image){
                     if(m_t2image->width!=mImage.second->width||
                        m_t2image->height!=mImage.second->height){
                            //                      cvReleaseImage(&m_t2image);
                            m_t2image=NULL;
                            m_t2image=cvCreateImage(cvSize(mImage.second->width, mImage.second->height), IPL_DEPTH_8U, 3);
                     }
                     t2time=mImage.first;
                     //memcpy(m_t2image->imageData,mImage.second->imageData,3*mImage.second->height*mImage.second->width);
                     cvConvertImage(mImage.second,m_t2image,CV_CVTIMG_SWAP_RB);
                     next=3;
                     m_newt2image=true;
              }
       }else{
              if(!m_newt3image){
                     if(m_t3image->width!=mImage.second->width||
                        m_t3image->height!=mImage.second->height){
                            //                      cvReleaseImage(&m_t3image);
                            m_t3image=NULL;
                            m_t3image=cvCreateImage(cvSize(mImage.second->width, mImage.second->height), IPL_DEPTH_8U, 3);
                     }
                     
                     t3time=mImage.first;
                     cvConvertImage(mImage.second,m_t3image,CV_CVTIMG_SWAP_RB);
                     //              memcpy(m_t3image->imageData,mImage.second->imageData,3*mImage.second->height*mImage.second->width);
                     next=1;
                     m_newt3image=true;
              }
       }

}

void ImageWriter::quitOperator() {
       t1state=STATE_QUIT;
       t2state=STATE_QUIT;
       t3state=STATE_QUIT;

       pthread_join(thread1,NULL);
       pthread_join(thread2,NULL);
       pthread_join(thread3,NULL);

       
       cvReleaseImage(&m_t1image);
       cvReleaseImage(&m_t2image);
       cvReleaseImage(&m_t3image);

       m_t1image=NULL;
       m_t2image=NULL;
       m_t3image=NULL;
}

void ImageWriter::fileWriterThread1(){
       while(t1state==STATE_RUN){
              if(m_newt1image){
                     std::stringstream filename;
                     filename.setf(ios_base::showpoint);
                     filename.setf(ios_base::fixed,ios_base::floatfield);
                     double stamp;
                     stamp=t1time.getSeconds()+t1time.getUSeconds()/1000000.0;
                     
                     filename << m_imageDir << "/" << m_imagePrefix << "-" << stamp << ".ppm";
                     g_debug("Thread 1 writing..");
                     cvSaveImage((filename.str()).c_str(),m_t1image);

                     m_newt1image=false;
              }
              usleep(50000);
       }
}

void ImageWriter::fileWriterThread2(){
       while(t1state==STATE_RUN){
              if(m_newt2image){
                     std::stringstream filename;
                     filename.setf(ios_base::showpoint);
                     filename.setf(ios_base::fixed,ios_base::floatfield);
                     double stamp;
                     stamp=t2time.getSeconds()+t2time.getUSeconds()/1000000.0;
                     filename << m_imageDir << "/" << m_imagePrefix << "-" << stamp << ".ppm";
                     g_debug("Thread 2 writing..");
                     cvSaveImage((filename.str()).c_str(),m_t2image);
                     
                     m_newt2image=false;
              }
              usleep(50000);
       }
}

void ImageWriter::fileWriterThread3(){
       while(t1state==STATE_RUN){
              if(m_newt3image){
                     std::stringstream filename;
                     filename.setf(ios_base::showpoint);
                     filename.setf(ios_base::fixed,ios_base::floatfield);
                     double stamp;
                     stamp=t3time.getSeconds()+t3time.getUSeconds()/1000000.0;
                     
                     filename << m_imageDir << "/" << m_imagePrefix << "-" << stamp << ".ppm";
                     g_debug("Thread 3 writing..");
                     cvSaveImage((filename.str()).c_str(),m_t3image) ;

                     m_newt3image=false;
              
}             usleep(50000);
       }
}

extern "C" {
       void *runImageWriterThread1(void *ptr){
              ImageWriter *theObject=(ImageWriter *)ptr;
              
              theObject->fileWriterThread1();
              pthread_exit(NULL);
       }

       void *runImageWriterThread2(void *ptr){
              ImageWriter *theObject=(ImageWriter *)ptr;
              
              theObject->fileWriterThread2();
              pthread_exit(NULL);
       }
       
       void *runImageWriterThread3(void *ptr){
              ImageWriter *theObject=(ImageWriter *)ptr;
              
              theObject->fileWriterThread3();
              pthread_exit(NULL);
       }

       VisionOperator *ImageWriter_factory(std::string name) {
              return new ImageWriter(name);
       }
       
       class ImageWriterProxy { 
       public:
              ImageWriterProxy(){
                     operatorFactory["ImageWriter"] = ImageWriter_factory;
              }
       };
       
       ImageWriterProxy p_imagewriter;
}

---