Cimage_grab.h

Go to the documentation of this file.

/**********************************************************************
 * Copyright (C) 2012, The YaDICs Project Developers. 
 * See the COPYRIGHT file at the top-level directory of this distribution ./COPYRIGHT.
 * See ./COPYING file for copying and redistribution conditions.
 * 
 * This file is part of YaDICs.
 * YaDICs is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * YaDICs is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with YaDICs.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * Information about how to use the software are provided at http://yadic.univ-lille1.fr/
 **********************************************************************/


#ifndef CIMAGE_GRAB
#define CIMAGE_GRAB

//--------------------------XIMEA---------------------------------
#include "../XIMEA/examples/xiSample/stdafx.h"
#include "../XIMEA/include/xiApi.h"
#include "../XIMEA/include/xiExt.h"
#define FORMAT XI_MONO8
//--------------------------XIMEA---------------------------------

#include "Cimage_file.h"

template<typename Timg> 
class Cimage_grab: public Cimage_file<Timg>
{
  
  public:
    
    CImgList<double> m_time;
    CImg<unsigned char> m_cam_get;//unsigned char for mono8
    
    int m_image_exposure, m_frame;
    int m_image_width, m_image_height, m_offset_x, m_offset_y;
    float m_fps;
    
    XI_IMG m_image;
    HANDLE m_xiH;

    
    Cimage_grab() : Cimage_file<Timg>()
    {// constructor
     
      this->class_name = "Image : grab";
      
    }
    
    ~Cimage_grab()
    {//destructor
    
      if (m_xiH)
      {
        xiStopAcquisition(m_xiH);
        xiCloseDevice(m_xiH);
      }
      
    }
    
    
    
    virtual void load_paths(CParameterNetCDF &fp)
    {// attributes from cdl
    
      Cimage_file<Timg>::load_paths(fp);
    
      int error(1);
      
      //-------------------------------------
      m_frame = 0;
      std::string att_name = "exposure";
      error = fp.loadAttribute(att_name,m_image_exposure);
      att_name = "offset_x";
      error = fp.loadAttribute(att_name,m_offset_x);//X position of the cropped window left upper corner
      att_name = "offset_y";
      error = fp.loadAttribute(att_name,m_offset_y);//Y position of the cropped window left upper corner
      att_name = "width";
      error = fp.loadAttribute(att_name,m_image_width);//img width
      att_name = "height";
      error = fp.loadAttribute(att_name,m_image_height);//img height
      att_name = "fps";
      error = fp.loadAttribute(att_name,m_fps);//frame per second
      //-------------------------------------
      
      if (open_device(m_xiH, m_image))
      {//if device is openned
        
        //set and start acquisition
        error = set_device(m_xiH, m_image_exposure, m_offset_x, m_offset_y, m_image_width, m_image_height, m_fps);
        
        //assign CImg buffer for capture
        m_cam_get.assign(m_image_width, m_image_height, 1, 1, 0);
        //assgin Image couple for correlation
        this->m_img.assign(this->m_dim_image, m_image_width, m_image_height, 1, 1, 0);
        m_time.assign(3,this->m_dim_sample,1,1,1,0);//frame number, frame time, capture frequency from the latest image
        //define space dimensions
        this->m_dim = 2;

      }
      else
      {
        printf("Warning : device no opened");
      }

    }
    
    int open_device(HANDLE &xiH, XI_IMG &image)
    {//open device
    
      image.size = sizeof(XI_IMG);
      image.bp = NULL;
      image.bp_size = 0;
      
      //init
      xiH = NULL;
      int error = 1;
      
      DWORD dwNumberOfDevices = 0;// Get number of camera devices
      DWORD m_get_delay = 10000;//timeOut
      
      if (!xiGetNumberDevices(&dwNumberOfDevices))
      {
        printf("number of devices detected : %i",dwNumberOfDevices);
        // Retrieving a handle to the camera device 
        xiOpenDevice(0, &xiH);
      }
      else
      {
        printf("xiGetNumberDevices (no camera found)");
        error = 0;
      }
      
      return error;
      
    }

    int set_device(HANDLE &xiH, int &exposure, int &offset_x, int &offset_y, int &width, int &height, float &fps)
    {//set and start
    
      int error(0), tmpW(0), tmpH(0);
      float min_fps(0), max_fps(0);
      
      xiSetParamInt(xiH, XI_PRM_EXPOSURE, exposure);//set exposure

      xiGetParamInt( xiH, XI_PRM_WIDTH, &tmpW);//get full image width
      xiGetParamInt( xiH, XI_PRM_HEIGHT, &tmpH);//get full image height
      printf("\nFullFrame resolution -> [%i, %i]\n",tmpW, tmpH);
      

      xiSetParamInt( xiH, XI_PRM_OFFSET_X, offset_x);//set offset_y (must be even)
      xiSetParamInt( xiH, XI_PRM_OFFSET_Y, offset_y);//set offset_y (must be even)
      xiSetParamInt( xiH, XI_PRM_WIDTH, width);//set image_width (must be divisible by 4)
      xiSetParamInt( xiH, XI_PRM_HEIGHT, height);//set image_height (must be even)
      
      xiGetParamInt( xiH, XI_PRM_WIDTH, &width);//get effective image width
      xiGetParamInt( xiH, XI_PRM_HEIGHT, &height);//get effective image height

      printf("\nCaptured image -> offset [%i, %i] - dimensions [%i, %i]\n", offset_x, offset_y, width, height);
      
      xiSetParamInt( xiH, XI_PRM_BUFFERS_QUEUE_SIZE, 2);//only one image within camera buffer (Pb with XI_PRM_RECENT_FRAME = 1)
      
      xiSetParamInt( xiH, XI_PRM_IMAGE_DATA_FORMAT, FORMAT);//data format
      
      if(fps)
      {//trigger
      
        std::cerr<<"Information: use internal trigger.\n";
      
        xiGetParamFloat( xiH, XI_PRM_FRAMERATE XI_PRM_INFO_MIN, &min_fps);//detect mini fps for such exposure
        xiGetParamFloat( xiH, XI_PRM_FRAMERATE XI_PRM_INFO_MAX, &max_fps);//detect maxi fps for such exposure
      
        if (fps>max_fps or fps<min_fps)
        {//over the appropriate range
          printf("Warning ! : required fps isn't in the appropriate range, its value will be set to (min_fps + max_fps)/2\n");
          fps = (min_fps + max_fps)/2;
        }
      
        xiSetParamFloat( xiH, XI_PRM_FRAMERATE, fps);//set fps (must be in [min_fps, max_fps]
        xiGetParamFloat( xiH, XI_PRM_FRAMERATE, &fps);
      
        printf("\nFPS settings [min: %f, max: %f, current: %f]\n", min_fps, max_fps, fps);

      }
      else
      {
        
        std::cerr<<"Information: use external trigger.\n";
        xiSetParamInt( xiH, XI_PRM_TRG_SOURCE, XI_TRG_EDGE_RISING);
        xiSetParamInt( xiH, XI_PRM_GPI_SELECTOR, 1);
        xiSetParamInt( xiH, XI_PRM_GPI_MODE, XI_GPI_TRIGGER);
        
      }
      
      xiStartAcquisition(xiH);//start acquisition
      
      return error;
      
    }
    
    void grab(HANDLE &xiH, XI_IMG &image, CImg<unsigned char> &buffer, CImgList<double> &time, int const &bframe, int &frame)
    {//grab one frame and stores it within buffer[bframe]
    
      int lastFrame = -1;

      do
      {//while the frame number doesn't change

        xiGetImage(xiH, 10000, &image);

        //condition
        if(frame){lastFrame = time[0][frame-1];}
        
      }
      while ( image.nframe == lastFrame );

      memcpy( buffer.data(), image.bp, image.width*image.height);

      //copy data information
      time[0][frame] = image.nframe;//get frame number
      time[1][frame] = (double)image.tsSec + (double)image.tsUSec/1e6;//get time
      if (!frame){time[2][frame] = 1.0/(time[1][frame]-time[1][frame-1]);}else{time[2][frame] = 1.0/time[1][frame];}//get effective freq

      printf("image : %i, frame %f, at time %f, with a frequency of %f\n",bframe, m_time[0][frame], m_time[1][frame], m_time[2][frame]);

      
    }
    
    virtual void load_images(CImg<char> &list, std::string &dir, const int &sample)
    {// load images from paths
    

      for (int bframe = 0; bframe<this->m_dim_image; bframe++)
      {// for the number of frame to correlate

        grab(m_xiH, m_image, m_cam_get, m_time, bframe, m_frame);
        
        //copy data within m_img
        this->m_img[bframe] = m_cam_get;

        m_frame++;
        
      }

    }

 
};

#endif