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.LGPL **
** 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 <ICLUtils/CompatMacros.h>
#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:
          ICLIO_API ConvBuffers();
          ICLIO_API ~ConvBuffers();
          ICLIO_API 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:
          ICLIO_API ConcGrabberBuffer();
          ICLIO_API ~ConcGrabberBuffer();


          ICLIO_API ConvBuffers* getNextReadBuffer();

          ICLIO_API ConvBuffers* getNextWriteBuffer();
          ICLIO_API void setReset();
          ICLIO_API 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:
          ICLIO_API PylonAutoEnv();
          ICLIO_API ~PylonAutoEnv();

          ICLIO_API static bool initPylonEnv();

          ICLIO_API 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:

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


      struct GrabbingInterruptor{
      private:
        Interruptable* m_Interu;

      public:

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

      ICLIO_API void printHelp();
      ICLIO_API Pylon::CDeviceInfo getDeviceFromArgs(std::string args);
      ICLIO_API int channelFromArgs(std::string args);

      ICLIO_API Pylon::DeviceInfoList_t
      getPylonDeviceList(Pylon::DeviceInfoList_t* filter=NULL);

    } //namespace pylon
  } // namespace io
} //namespace icl