PylonColorConverter.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/PylonColorConverter.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 <ICLCore/ImgBase.h>
#include <ICLCore/Img.h>
#include <ICLUtils/Mutex.h>
#include <ICLIO/PylonUtils.h>
#include <ICLCore/BayerConverter.h>

namespace icl {
  namespace io{
    namespace pylon {
  
      class ColorConverter{
        public:
          virtual ~ColorConverter() {}
          virtual void initBuffers(ConvBuffers* b) = 0;
          virtual void convert(const void *imgBuffer, ConvBuffers* b) = 0;
      };
  
      class PylonColorConverter {
        public:
        PylonColorConverter();
        ~PylonColorConverter();
  
        void resetConversion(int width, int height, int pixel_size_bits,
                             long buffer_size, Pylon::PixelType pixel_type,
                             std::string pixel_type_name);

        icl::core::ImgBase* convert(const void *imgBuffer, ConvBuffers* b);
  
        private:
        utils::Mutex m_Mutex;
        ColorConverter* m_Converter;

        std::string m_ErrorMessage;
  
        void freeAll();
        void initConversion();
        void getInfo();
        void setConversionRGB();
        void setConversionRGBPacked();
        void setConversionMono();
      };
  
      class Mono8uToMono8u : public ColorConverter{
        public:
          Mono8uToMono8u(int width, int height);
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          int m_Width;
          int m_Height;
      };
  
      class Mono16sToMono16s : public ColorConverter{
        public:
          Mono16sToMono16s(int width, int height);
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          int m_Width;
          int m_Height;
      };
  
      class MonoToMono8u : public ColorConverter{
        public:
          MonoToMono8u(int width, int height, Pylon::PixelType pixel_type,
                       int pixel_size_bits, long buffer_size);
          ~MonoToMono8u();
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          int m_Width;
          int m_Height;
          Pylon::PixelType m_PixelType;
          int m_PixelSize;
          long m_BufferSize;
          Pylon::CPixelFormatConverter* m_ColorConverter;
          Pylon::SImageFormat* m_InputFormat;
          Pylon::SOutputImageFormat* m_OutputFormat;
      };
  

      class Rgb8uToRgb8u : public ColorConverter{
        public:
          Rgb8uToRgb8u(int width, int height);
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          int m_Width;
          int m_Height;
      };
  
      class PylonColorToRgb : public ColorConverter{
        public:
          PylonColorToRgb(int width, int height, Pylon::PixelType pixel_type,
                       int pixel_size_bits, long buffer_size);
          ~PylonColorToRgb();
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          int m_Width;
          int m_Height;
          Pylon::PixelType m_PixelType;
          int m_PixelSize;
          long m_BufferSize;
          Pylon::CPixelFormatConverter* m_ColorConverter;
          Pylon::SImageFormat* m_InputFormat;
          Pylon::SOutputImageFormat* m_OutputFormat;
      };
  
      class BayerToRgb8Icl : public ColorConverter{
        public:
        BayerToRgb8Icl(core::BayerConverter::bayerConverterMethod method,
                       core::BayerConverter::bayerPattern pattern,
                       utils::Size s);
          ~BayerToRgb8Icl();
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          core::BayerConverter m_Conv;
          std::vector<icl8u*> m_Channels;
          utils::Size m_Size;
      };
  
  #ifdef HAVE_IPP

      class Yuv422ToRgb8Icl : public ColorConverter{
        public:
          Yuv422ToRgb8Icl(int width, int height);
          ~Yuv422ToRgb8Icl();
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          utils::Size m_Size;
          icl8u* m_ConvBuffer;
      };
  
      class Yuv422YUYVToRgb8Icl : public ColorConverter{
        public:
          Yuv422YUYVToRgb8Icl(int width, int height);
          ~Yuv422YUYVToRgb8Icl();
          void initBuffers(ConvBuffers* b);
          void convert(const void *imgBuffer, ConvBuffers* b);
        private:
          utils::Size m_Size;
          icl8u* m_ConvBuffer;
      };
  #endif
  
    } //namespace
  } // namespace io
} //namespace