camera.impl.hpp

#include <sstream>
#include "/usr/local/include/nt2/nt2.hh"

using namespace std;
using namespace cimg_library; 
using namespace nt2;
//using namespace nt2::fml; 



template<class T, size_t N>
Camera<T,N>::Camera( /*const string filexml, */Param* param )
  :d(NULL), cS(NULL), t(NULL)
{
  CamParam* cam= new CamParam("doc.xml");
  c = cam->getStruct();
  delete cam;
  
  if( param->getType() == IP )
    {
      mFreq  = param->freq;
      PTZ    = param->PTZ ;
    }

  // dataGrabber de 3 elements
  d = new dataGrabber<T,N>(param, &c) ;

  if(PTZ)
    {
      cmd="NULL";
      cS = new cmdSender(&cmd, param, &c, &mMut);
      t  = new boost::thread(*cS);
    }

  std::cout <<  "Bufferisation de l'affichage en cours ..." << std::endl;
  while(d->isready()!= true);  // Pour que les buffers se remplissent
  std::cout <<  " Termine !" <<  std::endl;
}


template<class T, size_t N>
Camera<T,N>::~Camera()
{
  stop();
}


template<class T, size_t N>
void Camera<T,N>::affiche()
{ 
  if(PTZ)
    affiche_PTZ();
  else
    affiche_nPTZ();
}


template<class T, size_t N>
void Camera<T,N>::affiche_PTZ()
{
  jpeg = new JpegDecompressor;
  
  buffer_t img=getNextFrame();
  jpeg->decompress((unsigned char*)&img[0], img.size());
  
  const size_t width  = jpeg->getWidth();
  const size_t height = jpeg->getHeight();
  const size_t x1 = width/3;
  const size_t x2 = 2*(width/3);
  const size_t y1 = height/2; 
  
  // Construction de l'objet image avec une image d'initialisation
  cimg_library::CImg<unsigned char> image(jpeg->getImage(), width, height, 1, 3);
  
  // Construction de la fenetre d'affichage
  cimg_library::CImgDisplay main_disp(image,"Flux video");
  
  // Tant que le fenetre d'affichage n'est pas fermee
  while(!main_disp.is_closed)
    {
      while(!(main_disp.button) && !(main_disp.is_closed))
        {
          // Affichage de la nouvelle image dans la fenetre
          main_disp.display(getNextImg(image, img, width, height));
          
          tempo(1); 
        }
      
      send_cmd(main_disp, x1, x2, y1); 
      
      tempo(1);
      
    }
  
  delete jpeg;
}


template<class T, size_t N>
void Camera<T,N>::send_cmd(cimg_library::CImgDisplay & main_disp, const size_t x1, const size_t x2, const size_t y1)
{
  if(main_disp.button != 0)
    {
      std::stringstream cameramove; 
      
      // Clic avec le bouton du milieu --> Deplacement ou centrage sur la zone cliqué
      if(main_disp.button&4)
        {
          if(c.cmd_center!="NULL")
            cameramove << c.cmd_center << "=" << main_disp.mouse_x << "," << main_disp.mouse_y;
          
          else
            {
              if((size_t)main_disp.mouse_x < x1)
                cameramove <<  c.cmd_left;
              
              else
                if((size_t)main_disp.mouse_x >  x2)
                  cameramove << c.cmd_right;
              
                else
                  if ( ((size_t)main_disp.mouse_x >=  x1 && (size_t)main_disp.mouse_x <=  x2) && (size_t)main_disp.mouse_y <  y1)
                    cameramove << c.cmd_up;
              
                  else
                    cameramove << c.cmd_down;
            } 
        }
      else
        if(main_disp.button&1) // Clic avec le bouton gauche --> Zoom IN
          cameramove << c.cmd_zoomin.c_str();
      
        else
          if(main_disp.button&2) // Clic avec le bouton droit --> Zoom OUT
            cameramove << c.cmd_zoomout.c_str(); 
      
      
      main_disp.button = 0;
      
      sendReqFormat(cameramove.str());
    }
}




template<class T, size_t N>
void Camera<T,N>::affiche_nPTZ()
{
  jpeg = new JpegDecompressor;
  
  buffer_t img=getNextFrame();
  jpeg->decompress((unsigned char*)&img[0], img.size());
  
  const size_t width  = jpeg->getWidth();
  const size_t height = jpeg->getHeight(); 
  
  // Construction de l'objet image avec une image d'initialisation
  cimg_library::CImg<unsigned char> image(jpeg->getImage(),width, height,1,3);
  
  // Construction de la fenetre d'affichage
  cimg_library::CImgDisplay main_disp(image,"Flux video");

  while(!main_disp.is_closed)
    { 
      // Affichage de la nouvelle image dans la fenetre
      main_disp.display(getNextImg(image, img, width, height));
      
      tempo(1);
    }
  
  delete jpeg;
}


template<class T, size_t N>
buffer_t Camera<T,N>::getNextFrame()
{
  return d->getData();
}


template<class T, size_t N>
cimg_library::CImg<unsigned char>& Camera<T,N>::getNextImg(cimg_library::CImg<unsigned char> &image, buffer_t &img,  const size_t width,  const size_t height)
{
  img=getNextFrame();
  jpeg->decompress((unsigned char*)&img[0], img.size());
  
  // Chargement de l'image
  image.assign(jpeg->getImage(),jpeg->getWidth(),jpeg->getHeight(),1,3);
  return image;
}


template<class T, size_t N>
std::list<buffer_t> Camera<T,N>::snapshot(unsigned int nb, unsigned int dt)
{
  std::list<buffer_t>  l;   // La liste contenant les images
  
  // Tant que le nb d'images demande n'est pas atteint
  for ( unsigned int i=1; i<=nb ; i++ )
    {
      // Si un laps de temps entre 2 images est demande
      if( dt!=0 )
        tempo(dt); // Attente de dt milli-secondes
      
      // Ajout de l'image dans la liste
      l.push_back(getNextFrame());
    }
  
  // Renvoi de la liste
  return l;
}


template<class T, size_t N>
void Camera<T,N>::recSnap(unsigned int nb, unsigned int dt)
{
  std::list<buffer_t>       l    ;       // Liste pour les images demandees
  std::list<std::string>    name ;       // Liste pour les noms de fichiers
  std::string               fname;       // Pour le nom de fichier courant
  buffer_t                  b    ;       // Pour l'image courante
  FILE*                     fp   ;       // Pour le flux d'ecriture
  
  name.resize(nb);       // Resize de la liste des noms de fichiers
  l.resize(nb);          // Resize de la liste des buffers
  l=snapshot(nb,dt);     // Recuperation de la liste des images


  // GENRATION DES NOMS DE FICHIERS
  // Tant que le nb d'images demande n'est pas atteint
  for (unsigned int cpt=1; cpt<=nb ; cpt++)
    {
      // Creation du nom de fichier a ecrire (snap(num_incremente).jpg)
      std::stringstream filename;
      filename << "snap";
      filename.width(4);
      filename.fill('0');
      filename << cpt; 
      filename << ".jpg";


      // Rajout du nom dans la liste des noms
      name.push_back(filename.str());
    }

  // ECRITURE DES IMAGES SUR LE DISQUE
  // Tant qu'il reste des images a traiter
  while(nb--!=0)
    {
      // Recuperation du nom de fichier courant
      fname.clear();
      fname=name.back();
      name.pop_back();

      // Recuperation du buffer courant
      b.clear();
      b=l.back();
      l.pop_back();

      std::cout << "Writing " << fname.c_str() << std::endl;

      // Ouverture du fichier en eriture
      fp = fopen (fname.c_str(), "wb");

      // Ecriture des caracteres  dans le fichier
      fwrite(&b[0], b.size(), 1, fp );

      // Fermeture du fichier
      fclose(fp);
    }
}


template<class T, size_t N>
void Camera<T,N>::sendReqFormat(const std::string & command)
{
  // Tant qu'il n'y a pas de requête à envoyer
  while(cmd!="NULL")
    tempo(((1000/mFreq)/2)+1); // On dort la moitie de la frequence +1

  boost::mutex::scoped_lock lock(mMut);
  cmd=command;
}


template<class T, size_t N>
void Camera<T,N>::sendReq(const std::string & command)
{
  // Des vectors pour ranger les commandes et arguments
  std::vector<std::string> v_cmd;
  std::vector<std::string> v_arg;

  // typedef pour alléger l'ecriture
  typedef boost::tokenizer<boost::char_separator<char> > my_tok;

  // Separateur --> ";"
  boost::char_separator<char> sep( ";" );

  // Construction du tokenizer
  my_tok tok( command, sep );

  // Iterer la sequence de tokens
  for (my_tok::const_iterator i = tok.begin(); i != tok.end(); i++)
    {
      // On insere les commandes les unes a la suite des autres
      v_cmd.push_back(*i);
      i++;

      // Si l'argument est NULL, il est remplace par 1 (valeur a envoyer a la
      // camera si la commande ne prend pas d'argument)
      if(*i=="NULL")
        v_arg.push_back("1");
      else
        v_arg.push_back(*i);
    }

  // Il faut autant de commandes que d'arguments
  if (v_arg.size()!=v_cmd.size())
    {
      std::cerr << "Pas assez d'arguments pour envoyer la requete !!!" << std::endl;
      return;
    }

  // Pour stocker la requete
  std::stringstream ss;

  // Des iterators sur nos vectors
  std::vector<std::string>::const_iterator it_cmd = v_cmd.begin();
  std::vector<std::string>::const_iterator it_arg = v_arg.begin();

  // Tant qu'il y a des commandes à envoyer
  for( ; it_cmd != v_cmd.end(); it_cmd++, it_arg++)
    {
      // Si ce n'est pas la premiere commande, il faut rajouter &
      if(v_cmd.size()>1 && it_cmd != v_cmd.begin())
        ss << "&";
      ss << *it_cmd << "=" << *it_arg;
    }

  // Tant quil n'y a deja une commande en attente, on attend qu'elle soit envoyée
  while(cmd!="NULL")
    tempo(((1000/mFreq)/2)+1); // On dort la moitie de la frequence +1

  boost::mutex::scoped_lock lock(mMut);
  cmd=ss.str();
}


template<class T, size_t N>
void Camera<T,N>::clearLog()
{
  clearLog("cam.log");
}


template<class T, size_t N>
void Camera<T,N>::stop()
{
  //Si le datagrabber existe ...
  if(d)
    delete d;   // Delete du dataGrabber


  if (PTZ)
    {
      if (cS)
        {
          cS->stop(); // Arret du thread cmdSender
          tempo(1000/mFreq+1);
          delete cS;  // Delete du cmdSender
        }


      if (t)
        {
          delete t;
        }
    }

}

---