PylonUtils.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLIO/src/ICLIO/PylonUtils.h                           **
** Module : ICLIO                                                  **
** Authors: Viktor Richter                                         **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.GPL  **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLIO/PylonIncludes.h>
#include <ICLUtils/Mutex.h>
#include <ICLUtils/Exception.h>
#include <ICLCore/CoreFunctions.h>
#include <ICLCore/ImgBase.h>
#include <ICLCore/Img.h>

namespace icl {
  namespace io{
    namespace pylon {
  
      template <typename T>
      class PylonGrabberBuffer {
        private:
          T *m_pBuffer;
          Pylon::StreamBufferHandle m_hBuffer;
  
        public:
          PylonGrabberBuffer(size_t size) : m_pBuffer(NULL) {
            m_pBuffer = new T[size];
            if (!m_pBuffer)
              throw utils::ICLException("Not enough memory to allocate image buffer");
          }
          ~PylonGrabberBuffer(){
            if (m_pBuffer)
              delete[] m_pBuffer;
            }
          T* getBufferPointer(void) {
            return m_pBuffer;
          }
          Pylon::StreamBufferHandle getBufferHandle(void) {
            return m_hBuffer;
          }
          void setBufferHandle(Pylon::StreamBufferHandle hBuffer) {
            m_hBuffer = hBuffer;
          }
      };
  
      template <typename T>
      class TsBuffer {
        public:
          T* m_Buffer;
          uint64_t m_Timestamp;
          size_t m_Size;
  
          TsBuffer(size_t size)  : m_Timestamp(0), m_Size(size){
            m_Buffer = new T[m_Size];
            if (!m_Buffer)
              throw utils::ICLException("Not enough memory to allocate image buffer");
          }
          ~TsBuffer(){
            if (m_Buffer){
              delete[] m_Buffer;
            }
          }

          void copy(void* buffer){
            T* tmp = (T*) buffer;
            core::copy(tmp, tmp + m_Size, m_Buffer);
          }
      };
  
      class ConvBuffers {
        public:
          ConvBuffers();
          ~ConvBuffers();
          void free();
          icl::core::ImgBase* m_Image;
          icl8u* m_ImageBuff;
          icl16s* m_ImageBuff16;
          icl::core::Img8u* m_ImageRGBA;
          std::vector<icl8u*>* m_Channels;
          std::vector<icl16s*>* m_Channels16;
          bool m_Reset;
      };
  

      class ConcGrabberBuffer {
        public:
          ConcGrabberBuffer();
          ~ConcGrabberBuffer();
  

          ConvBuffers* getNextReadBuffer();

          ConvBuffers* getNextWriteBuffer();
          void setReset();
          bool newAvailable();
  
        private:
          ConvBuffers*  m_Buffers[3];
          utils::Mutex m_Mutex;
          int m_Write;
          int m_Next;
          int m_Read;
          bool m_Avail;
      };
  

      struct PylonAutoEnv{
        public:
          PylonAutoEnv();
          ~PylonAutoEnv();

          static bool initPylonEnv();

          static bool termPylonEnv();
      };
  

      struct Interruptable{
          virtual ~Interruptable() {}
          virtual void acquisitionStart() = 0;
          virtual void acquisitionStop() = 0;
          virtual void grabbingStart() = 0;
          virtual void grabbingStop() = 0;
      };
  

      struct AcquisitionInterruptor{
        private:
          Interruptable* m_Interu;
  
        public:

          AcquisitionInterruptor(Interruptable* i, bool mock=false);
          ~AcquisitionInterruptor();
      };
  

      struct GrabbingInterruptor{
      private:
        Interruptable* m_Interu;
  
      public:

        GrabbingInterruptor(Interruptable* i, bool mock=false);
        ~GrabbingInterruptor();
      };
  
      void printHelp();
      Pylon::CDeviceInfo getDeviceFromArgs(std::string args) throw(utils::ICLException);
      int channelFromArgs(std::string args);

      Pylon::DeviceInfoList_t
      getPylonDeviceList(Pylon::DeviceInfoList_t* filter=NULL);
  
    } //namespace pylon
  } // namespace io
} //namespace icl